cascade-ai 0.5.1 → 0.9.7

package/dist/index.js

@@ -4,21 +4,22 @@ import { glob } from 'glob';
 import Anthropic from '@anthropic-ai/sdk';
 import OpenAI, { AzureOpenAI } from 'openai';
 import { GoogleGenAI, HarmBlockThreshold, HarmCategory } from '@google/genai';
-import axios2 from 'axios';
-import fs3 from 'fs/promises';
-import path16 from 'path';
+import fs4 from 'fs/promises';
+import path18 from 'path';
+import os4 from 'os';
 import * as ignoreFactory from 'ignore';
 import ignoreFactory__default from 'ignore';
 import { exec, execFile, execSync } from 'child_process';
 import { promisify } from 'util';
-import fs15 from 'fs';
+import fs17 from 'fs';
 import { simpleGit } from 'simple-git';
 import PDFDocument from 'pdfkit';
+import dns from 'dns/promises';
+import net from 'net';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { z } from 'zod';
-import os3 from 'os';
-import { createContext, runInContext } from 'vm';
+import { Worker } from 'worker_threads';
 import Database from 'better-sqlite3';
 import { createServer } from 'http';
 import { fileURLToPath } from 'url';
@@ -70,13 +71,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var keytar_default;
 var init_keytar = __esm({
   "node_modules/keytar/build/Release/keytar.node"() {
-    keytar_default = "./keytar-F4YAPN53.node";
+    keytar_default = "./keytar-VMICNFEJ.node";
   }
 });
 
-// node-file:F:\Softwares\Github Softwares\Cascade-AI\node_modules\keytar\build\Release\keytar.node
+// node-file:/home/runner/work/Cascade-AI/Cascade-AI/node_modules/keytar/build/Release/keytar.node
 var require_keytar = __commonJS({
-  "node-file:F:\\Softwares\\Github Softwares\\Cascade-AI\\node_modules\\keytar\\build\\Release\\keytar.node"(exports$1, module) {
+  "node-file:/home/runner/work/Cascade-AI/Cascade-AI/node_modules/keytar/build/Release/keytar.node"(exports, module) {
     init_keytar();
     try {
       module.exports = __require(keytar_default);
@@ -87,7 +88,7 @@ var require_keytar = __commonJS({
 
 // node_modules/keytar/lib/keytar.js
 var require_keytar2 = __commonJS({
-  "node_modules/keytar/lib/keytar.js"(exports$1, module) {
+  "node_modules/keytar/lib/keytar.js"(exports, module) {
     var keytar = require_keytar();
     function checkRequired(val, name) {
       if (!val || val.length <= 0) {
@@ -124,7 +125,7 @@ var require_keytar2 = __commonJS({
 });
 
 // src/constants.ts
-var CASCADE_VERSION = "0.5.1";
+var CASCADE_VERSION = "0.9.6";
 var CASCADE_CONFIG_DIR = ".cascade";
 var CASCADE_MD_FILE = "CASCADE.md";
 var CASCADE_IGNORE_FILE = ".cascadeignore";
@@ -292,7 +293,7 @@ var MODELS = {
     isLocal: false
   },
   "gemini-2.5-pro": {
-    id: "gemini-2.5-pro-preview-05-06",
+    id: "gemini-2.5-pro",
     name: "Gemini 2.5 Pro",
     provider: "gemini",
     contextWindow: 1e6,
@@ -304,7 +305,7 @@ var MODELS = {
     isLocal: false
   },
   "gemini-2.5-flash": {
-    id: "gemini-2.5-flash-preview-04-17",
+    id: "gemini-2.5-flash",
     name: "Gemini 2.5 Flash",
     provider: "gemini",
     contextWindow: 1e6,
@@ -369,6 +370,9 @@ var MODELS = {
     minSizeB: 7
   }
 };
+for (const _m of Object.values(MODELS)) {
+  if (_m.supportsToolUse === void 0) _m.supportsToolUse = !_m.isLocal;
+}
 var T1_MODEL_PRIORITY = [
   "claude-opus-4",
   "claude-sonnet-4",
@@ -428,12 +432,15 @@ var TOOL_NAMES = {
   PDF_CREATE: "pdf_create",
   RUN_CODE: "run_code",
   PEER_MESSAGE: "peer_message",
-  WEB_SEARCH: "web_search"
+  WEB_SEARCH: "web_search",
+  REQUEST_WORKERS: "request_workers"
 };
 var DEFAULT_APPROVAL_REQUIRED = [
   TOOL_NAMES.SHELL,
   TOOL_NAMES.FILE_DELETE,
   TOOL_NAMES.FILE_WRITE,
+  TOOL_NAMES.FILE_EDIT,
+  TOOL_NAMES.GIT,
   TOOL_NAMES.BROWSER,
   TOOL_NAMES.GITHUB,
   "pdf_create",
@@ -480,9 +487,16 @@ var AnthropicProvider = class extends BaseProvider {
   client;
   constructor(config, model) {
     super(config, model);
-    this.client = new Anthropic({
-      apiKey: config.apiKey
-    });
+    if (config.authToken) {
+      this.client = new Anthropic({
+        authToken: config.authToken,
+        defaultHeaders: { "anthropic-beta": "oauth-2025-04-20" }
+      });
+    } else {
+      this.client = new Anthropic({
+        apiKey: config.apiKey
+      });
+    }
   }
   async generate(options) {
     const chunks = [];
@@ -505,7 +519,7 @@ var AnthropicProvider = class extends BaseProvider {
       system: options.systemPrompt,
       messages,
       tools: tools?.length ? tools : void 0
-    });
+    }, { signal: options.signal });
     let isThinking = false;
     for await (const event of stream) {
       if (event.type === "content_block_delta") {
@@ -592,7 +606,7 @@ var AnthropicProvider = class extends BaseProvider {
   }
   async isAvailable() {
     try {
-      return !!this.config.apiKey;
+      return !!(this.config.apiKey || this.config.authToken);
     } catch {
       return false;
     }
@@ -693,7 +707,7 @@ var OpenAIProvider = class extends BaseProvider {
     };
     let stream;
     try {
-      stream = await this.client.chat.completions.create(params);
+      stream = await this.client.chat.completions.create(params, { signal: options.signal });
     } catch (err) {
       if (err.message && err.message.includes("max_completion_tokens")) {
         const fallbackParams = { ...params };
@@ -702,7 +716,7 @@ var OpenAIProvider = class extends BaseProvider {
         if (this.model.id.includes("o1") || this.model.id.includes("o3")) {
           fallbackParams.temperature = 1;
         }
-        stream = await this.client.chat.completions.create(fallbackParams);
+        stream = await this.client.chat.completions.create(fallbackParams, { signal: options.signal });
       } else {
         throw err;
       }
@@ -916,7 +930,8 @@ var GeminiProvider = class extends BaseProvider {
           { category: HarmCategory.HARM_CATEGORY_HARASSMENT, threshold: HarmBlockThreshold.BLOCK_NONE },
           { category: HarmCategory.HARM_CATEGORY_HATE_SPEECH, threshold: HarmBlockThreshold.BLOCK_NONE }
         ],
-        tools: options.tools?.length ? [{ functionDeclarations: options.tools.map(this.convertTool) }] : void 0
+        tools: options.tools?.length ? [{ functionDeclarations: options.tools.map(this.convertTool) }] : void 0,
+        abortSignal: options.signal
       }
     });
     let fullContent = "";
@@ -1118,6 +1133,8 @@ var GeminiProvider = class extends BaseProvider {
     };
   }
 };
+
+// src/providers/ollama.ts
 var TOOL_CAPABLE_FAMILIES = [
   "llama3.1",
   "llama3.2",
@@ -1154,9 +1171,10 @@ var OllamaProvider = class extends BaseProvider {
         parameters: t.inputSchema
       }
     }));
-    const response = await axios2.post(
-      `${this.baseUrl}/api/chat`,
-      {
+    const response = await fetch(`${this.baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
         model: this.model.id,
         messages,
         stream: true,
@@ -1165,61 +1183,43 @@ var OllamaProvider = class extends BaseProvider {
           num_predict: options.maxTokens ?? this.model.maxOutputTokens,
           temperature: options.temperature ?? 0.7
         }
-      },
-      { responseType: "stream" }
-    );
+      }),
+      signal: options.signal
+    });
+    if (!response.ok || !response.body) {
+      throw new Error(`Ollama chat request failed: ${response.status} ${response.statusText}`);
+    }
     let fullContent = "";
     let inputTokens = 0;
     let outputTokens = 0;
     const pendingToolCalls = [];
-    await new Promise((resolve, reject) => {
-      let buffer = "";
-      response.data.on("data", (chunk) => {
-        buffer += chunk.toString();
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          try {
-            const parsed = JSON.parse(line);
-            if (parsed.message?.content) {
-              fullContent += parsed.message.content;
-              onChunk({ text: parsed.message.content, finishReason: null });
-            }
-            if (parsed.message?.tool_calls?.length) {
-              pendingToolCalls.push(...parsed.message.tool_calls);
-            }
-            if (parsed.done) {
-              inputTokens = parsed.prompt_eval_count ?? 0;
-              outputTokens = parsed.eval_count ?? 0;
-            }
-          } catch {
-          }
+    const handleLine = (line) => {
+      if (!line.trim()) return;
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed.message?.content) {
+          fullContent += parsed.message.content;
+          onChunk({ text: parsed.message.content, finishReason: null });
         }
-      });
-      response.data.on("end", () => {
-        const tail = buffer.trim();
-        if (tail) {
-          try {
-            const parsed = JSON.parse(tail);
-            if (parsed.message?.content) {
-              fullContent += parsed.message.content;
-              onChunk({ text: parsed.message.content, finishReason: null });
-            }
-            if (parsed.message?.tool_calls?.length) {
-              pendingToolCalls.push(...parsed.message.tool_calls);
-            }
-            if (parsed.done) {
-              inputTokens = parsed.prompt_eval_count ?? inputTokens;
-              outputTokens = parsed.eval_count ?? outputTokens;
-            }
-          } catch {
-          }
+        if (parsed.message?.tool_calls?.length) {
+          pendingToolCalls.push(...parsed.message.tool_calls);
         }
-        resolve();
-      });
-      response.data.on("error", reject);
-    });
+        if (parsed.done) {
+          inputTokens = parsed.prompt_eval_count ?? inputTokens;
+          outputTokens = parsed.eval_count ?? outputTokens;
+        }
+      } catch {
+      }
+    };
+    let buffer = "";
+    const decoder = new TextDecoder();
+    for await (const chunk of response.body) {
+      buffer += decoder.decode(chunk, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) handleLine(line);
+    }
+    handleLine(buffer);
     const toolCalls = pendingToolCalls.map((tc, i) => {
       let input;
       if (typeof tc.function.arguments === "string") {
@@ -1251,9 +1251,11 @@ var OllamaProvider = class extends BaseProvider {
   }
   async listModels() {
     try {
-      const response = await axios2.get(`${this.baseUrl}/api/tags`);
+      const response = await fetch(`${this.baseUrl}/api/tags`);
+      if (!response.ok) return [];
+      const data = await response.json();
       const supportedKeywords = ["llama3", "llama2", "gemma", "mistral", "mixtral", "qwen", "phi3", "codellama", "deepseek", "llava", "starcoder", "stable-code", "nomic-embed"];
-      return response.data.models.filter((m) => {
+      return data.models.filter((m) => {
         const name = m.name.toLowerCase();
         return supportedKeywords.some((k) => name.includes(k));
       }).map((m) => ({
@@ -1275,11 +1277,15 @@ var OllamaProvider = class extends BaseProvider {
     }
   }
   async isAvailable() {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), 2e3);
     try {
-      await axios2.get(`${this.baseUrl}/api/tags`, { timeout: 2e3 });
-      return true;
+      const response = await fetch(`${this.baseUrl}/api/tags`, { signal: ac.signal });
+      return response.ok;
     } catch {
       return false;
+    } finally {
+      clearTimeout(timer);
     }
   }
   convertMessages(messages, systemPrompt) {
@@ -1382,6 +1388,19 @@ var ModelSelector = class {
   addDynamicModel(model) {
     this.availableModels.set(model.id, model);
   }
+  /**
+   * Permanently drop a model from the available set for this session. Used by
+   * the router's 404 / "model not found" self-heal so a dead id is never
+   * selected again after it fails once.
+   */
+  removeModel(id) {
+    this.availableModels.delete(id);
+  }
+  /** Look up an available model by exact id (post-discovery/pricing lookups). */
+  getModelById(id) {
+    const m = this.availableModels.get(id);
+    return m && this.availableProviders.has(m.provider) ? m : void 0;
+  }
   getAvailableModelsForProvider(provider) {
     const models = /* @__PURE__ */ new Map();
     for (const model of this.availableModels.values()) {
@@ -1398,6 +1417,7 @@ var ModelSelector = class {
         model = this.resolveDynamicModel(overrideModelId);
       }
       if (model && this.availableProviders.has(model.provider)) return model;
+      return null;
     }
     if (requireVision) {
       return this.selectVisionModel();
@@ -1460,6 +1480,14 @@ var ModelSelector = class {
         candidates.push(model);
       }
     }
+    const localOnly = this.availableProviders.size > 0 && Array.from(this.availableProviders).every((p) => p === "ollama");
+    if (localOnly) {
+      for (const model of this.availableModels.values()) {
+        if (model.isLocal && this.availableProviders.has(model.provider) && !candidates.some((c) => c.id === model.id)) {
+          candidates.push(model);
+        }
+      }
+    }
     return candidates;
   }
   isProviderAvailable(provider) {
@@ -1864,6 +1892,267 @@ var ModelProfiler = class {
   }
 };
 
+// src/core/router/savings.ts
+var NO_SAVINGS = { savedUsd: 0, savedPct: 0, counterfactualUsd: 0 };
+function computeDelegationSavings(stats, t1Model) {
+  if (!t1Model) return NO_SAVINGS;
+  let counterfactualUsd = 0;
+  const tiers = /* @__PURE__ */ new Set([
+    ...Object.keys(stats.inputTokensByTier),
+    ...Object.keys(stats.outputTokensByTier)
+  ]);
+  for (const tier of tiers) {
+    counterfactualUsd += calculateCost(
+      stats.inputTokensByTier[tier] ?? 0,
+      stats.outputTokensByTier[tier] ?? 0,
+      t1Model
+    );
+  }
+  const savedUsd = counterfactualUsd - stats.totalCostUsd;
+  if (!(savedUsd > 0) || counterfactualUsd <= 0) {
+    return { ...NO_SAVINGS, counterfactualUsd: Math.max(0, counterfactualUsd) };
+  }
+  return {
+    savedUsd,
+    savedPct: Math.round(savedUsd / counterfactualUsd * 1e3) / 10,
+    counterfactualUsd
+  };
+}
+var DEFAULT_SNAPSHOT_URL = "https://raw.githubusercontent.com/Varun-SV/Cascade-AI/main/src/core/router/benchmark-data.json";
+var OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
+var FETCH_TIMEOUT_MS = 8e3;
+var DEFAULT_CACHE_FILE = path18.join(os4.homedir(), GLOBAL_CONFIG_DIR, "benchmarks-cache.json");
+function normalizeModelId(id) {
+  let s = id.toLowerCase();
+  const slash = s.lastIndexOf("/");
+  if (slash !== -1) s = s.slice(slash + 1);
+  s = s.replace(/-preview(?:-\d{2}-\d{2})?$/, "");
+  s = s.replace(/-\d{8}$/, "");
+  s = s.replace(/[:@].*$/, "");
+  return s;
+}
+var LiveDataProvider = class {
+  snapshot = null;
+  prices = /* @__PURE__ */ new Map();
+  source = "bundled";
+  fetchedAt = 0;
+  loaded = false;
+  refreshing = null;
+  opts;
+  constructor(opts = {}) {
+    this.opts = {
+      live: opts.live ?? true,
+      pricingLive: opts.pricingLive ?? true,
+      refreshHours: opts.refreshHours ?? 24,
+      cacheFile: opts.cacheFile ?? DEFAULT_CACHE_FILE,
+      sourceUrl: opts.sourceUrl
+    };
+  }
+  /** Load cached data from disk (cheap, no network). Safe to call repeatedly. */
+  async load() {
+    if (this.loaded) return;
+    this.loaded = true;
+    try {
+      const raw = await fs4.readFile(this.opts.cacheFile, "utf-8");
+      const cache = JSON.parse(raw);
+      if (cache.snapshot?.families) {
+        this.snapshot = cache.snapshot;
+        this.source = "cache";
+      }
+      if (cache.prices) {
+        for (const [id, p] of Object.entries(cache.prices)) this.prices.set(id, p);
+      }
+      this.fetchedAt = cache.fetchedAt ?? 0;
+    } catch {
+    }
+  }
+  /**
+   * Refresh from the network if the cache is older than the TTL. Coalesces
+   * concurrent callers and never throws — failures keep last-known-good data.
+   */
+  async refresh(force = false) {
+    if (this.refreshing) return this.refreshing;
+    this.refreshing = this.doRefresh(force).finally(() => {
+      this.refreshing = null;
+    });
+    return this.refreshing;
+  }
+  async doRefresh(force) {
+    await this.load();
+    const ttlMs = this.opts.refreshHours * 36e5;
+    const fresh = ttlMs > 0 && Date.now() - this.fetchedAt < ttlMs;
+    if (!force && fresh && this.source !== "bundled") return;
+    const [snap, prices] = await Promise.all([
+      this.opts.live ? this.fetchSnapshot() : Promise.resolve(null),
+      this.opts.pricingLive ? this.fetchPrices() : Promise.resolve(null)
+    ]);
+    let changed = false;
+    if (snap) {
+      this.snapshot = snap;
+      this.source = "live";
+      changed = true;
+    }
+    if (prices && prices.size > 0) {
+      this.prices = prices;
+      changed = true;
+    }
+    if (changed) {
+      this.fetchedAt = Date.now();
+      await this.saveCache();
+    }
+  }
+  async fetchSnapshot() {
+    const url = this.opts.sourceUrl ?? DEFAULT_SNAPSHOT_URL;
+    try {
+      const resp = await withTimeout(fetch(url), FETCH_TIMEOUT_MS, "benchmark fetch timed out");
+      if (!resp.ok) return null;
+      const data = await resp.json();
+      if (!data || typeof data !== "object" || !data.families || typeof data.families !== "object") {
+        return null;
+      }
+      return data;
+    } catch {
+      return null;
+    }
+  }
+  async fetchPrices() {
+    try {
+      const resp = await withTimeout(fetch(OPENROUTER_MODELS_URL), FETCH_TIMEOUT_MS, "pricing fetch timed out");
+      if (!resp.ok) return null;
+      const data = await resp.json();
+      if (!Array.isArray(data?.data)) return null;
+      const out = /* @__PURE__ */ new Map();
+      for (const m of data.data) {
+        if (!m?.id || !m.pricing) continue;
+        const input = Number(m.pricing.prompt) * 1e3;
+        const output = Number(m.pricing.completion) * 1e3;
+        if (!Number.isFinite(input) || !Number.isFinite(output)) continue;
+        out.set(normalizeModelId(m.id), { input, output });
+      }
+      return out;
+    } catch {
+      return null;
+    }
+  }
+  async saveCache() {
+    try {
+      await fs4.mkdir(path18.dirname(this.opts.cacheFile), { recursive: true });
+      const cache = {
+        fetchedAt: this.fetchedAt,
+        snapshot: this.snapshot ?? void 0,
+        prices: Object.fromEntries(this.prices)
+      };
+      await fs4.writeFile(this.opts.cacheFile, JSON.stringify(cache, null, 2), "utf-8");
+    } catch {
+    }
+  }
+  /** Quality profile for a model family, or null when we have no live/cached data. */
+  getQualityProfile(family) {
+    return this.snapshot?.families?.[family] ?? null;
+  }
+  /** Current per-1k price for a model id, or null when unknown. */
+  getLivePrice(modelId) {
+    return this.prices.get(normalizeModelId(modelId)) ?? null;
+  }
+  /**
+   * Returns a price-corrected copy of each model when live pricing is known,
+   * leaving the original untouched (so the shared catalog is never mutated).
+   */
+  applyLivePricing(models) {
+    return models.map((m) => {
+      const p = this.getLivePrice(m.id);
+      if (!p) return m;
+      return { ...m, inputCostPer1kTokens: p.input, outputCostPer1kTokens: p.output };
+    });
+  }
+  /** Where the active quality data came from — for /why and `cascade models`. */
+  getDataSource() {
+    return this.source;
+  }
+  getGeneratedAt() {
+    return this.snapshot?.generatedAt ?? null;
+  }
+  hasLivePricing() {
+    return this.prices.size > 0;
+  }
+};
+
+// src/core/router/benchmarks.ts
+var liveProvider = null;
+function setBenchmarkLiveProvider(provider) {
+  liveProvider = provider;
+}
+var FAMILY_BENCHMARKS = {
+  // Anthropic — strongest at coding and agentic tool-use.
+  "claude-opus": { code: 95, analysis: 92, creative: 90, data: 88 },
+  "claude-sonnet": { code: 93, analysis: 88, creative: 87, data: 85 },
+  "claude-haiku": { code: 80, analysis: 75, creative: 76, data: 72 },
+  // OpenAI — strong all-round, particularly creative/writing.
+  "gpt-4.1": { code: 90, analysis: 89, creative: 91, data: 87 },
+  "gpt-4.1-mini": { code: 82, analysis: 80, creative: 83, data: 79 },
+  "gpt-4.1-nano": { code: 70, analysis: 68, creative: 72, data: 66 },
+  "gpt-4o": { code: 86, analysis: 85, creative: 90, data: 84 },
+  "gpt-4o-mini": { code: 76, analysis: 74, creative: 80, data: 72 },
+  // Google — strongest at analysis/data and long-context.
+  "gemini-2.5-pro": { code: 90, analysis: 93, creative: 86, data: 92 },
+  "gemini-2.5-flash": { code: 82, analysis: 83, creative: 80, data: 82 },
+  "gemini-1.5-pro": { code: 82, analysis: 84, creative: 82, data: 85 },
+  "gemini-2.0-flash": { code: 79, analysis: 80, creative: 79, data: 80 },
+  "gemini-flash-lite": { code: 68, analysis: 68, creative: 70, data: 68 },
+  // Local (Ollama) — lower absolute scores; the ordering is what matters when a
+  // tier is restricted to local-only models.
+  "deepseek": { code: 80, analysis: 72, creative: 68, data: 74 },
+  "qwen": { code: 78, analysis: 73, creative: 72, data: 74 },
+  "codellama": { code: 76, analysis: 60, creative: 55, data: 60 },
+  "llama-70b": { code: 74, analysis: 72, creative: 73, data: 70 },
+  "mistral": { code: 62, analysis: 64, creative: 66, data: 60 },
+  "gemma": { code: 58, analysis: 60, creative: 62, data: 57 },
+  "llama-small": { code: 55, analysis: 56, creative: 60, data: 54 }
+};
+var FAMILY_MATCHERS = [
+  [/opus/i, "claude-opus"],
+  [/sonnet/i, "claude-sonnet"],
+  [/haiku/i, "claude-haiku"],
+  [/gpt-?4\.1-nano/i, "gpt-4.1-nano"],
+  [/gpt-?4\.1-mini/i, "gpt-4.1-mini"],
+  [/gpt-?4\.1/i, "gpt-4.1"],
+  [/gpt-?4o-mini/i, "gpt-4o-mini"],
+  [/gpt-?4o/i, "gpt-4o"],
+  [/gemini-?2\.5-pro/i, "gemini-2.5-pro"],
+  [/gemini-?2\.5-flash/i, "gemini-2.5-flash"],
+  [/gemini-?1\.5-pro/i, "gemini-1.5-pro"],
+  [/gemini-?2\.0-flash-lite/i, "gemini-flash-lite"],
+  [/gemini-?2\.0-flash/i, "gemini-2.0-flash"],
+  [/codellama|code-llama|starcoder|stable-code/i, "codellama"],
+  [/deepseek/i, "deepseek"],
+  [/qwen/i, "qwen"],
+  [/llama.?3.*70b|llama3:70b|llama-3-70b/i, "llama-70b"],
+  [/llama/i, "llama-small"],
+  [/mistral|mixtral/i, "mistral"],
+  [/gemma/i, "gemma"]
+];
+function resolveFamily(model) {
+  const hay = `${model.id} ${model.name}`;
+  for (const [re, fam] of FAMILY_MATCHERS) {
+    if (re.test(hay)) return fam;
+  }
+  return null;
+}
+function benchmarkScore01(model, taskType) {
+  const fam = resolveFamily(model);
+  if (!fam) return 0.5;
+  const profile = liveProvider?.getQualityProfile(fam) ?? FAMILY_BENCHMARKS[fam];
+  if (!profile) return 0.5;
+  let score;
+  if (taskType === "mixed") {
+    const vals = Object.values(profile).filter((v) => typeof v === "number");
+    score = vals.length ? vals.reduce((a, b) => a + b, 0) / vals.length : 50;
+  } else {
+    score = profile[taskType] ?? 50;
+  }
+  return Math.max(0, Math.min(1, score / 100));
+}
+
 // src/core/router/index.ts
 var CascadeRouter = class _CascadeRouter extends EventEmitter {
   selector;
@@ -1882,6 +2171,12 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
   tierModels = /* @__PURE__ */ new Map();
   config;
   sessionCostUsd = 0;
+  // Per-run accounting for the hard per-task cap. Reset by beginRun() at the
+  // start of every `cascade run`, independent of the session-wide budget.
+  runTokens = 0;
+  runCostUsd = 0;
+  runBudgetExceeded = false;
+  runBudgetExceededReason;
   /**
    * Budget state machine — guards against two concurrent `generate()` calls
    * each firing the warning or both slipping past the hard cap. All
@@ -1892,6 +2187,12 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
   budgetExceededReason;
   tpmLimiter;
   localQueue;
+  taskAnalyzer;
+  liveData;
+  /** Snapshot of configured/default tier models, taken before Cascade Auto overrides them. */
+  originalTierModels;
+  /** The current run's abort signal — injected into every provider call so a cancel aborts in-flight requests. */
+  runSignal;
   /** Thrown when the configured budget is exceeded. */
   static BudgetExceededError = class extends Error {
     constructor(msg) {
@@ -1918,10 +2219,17 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
       if (!override) continue;
       const model = this.selector.selectForTier(tier, override);
       if (!model) {
-        throw new Error(`Configured model "${override}" for ${tier} could not be loaded. Check provider availability and exact model name.`);
-      }
-      if (model.id !== override && `${model.provider}:${model.id}` !== override) {
-        throw new Error(`Configured model "${override}" for ${tier} resolved to "${model.id}". Use the exact provider model ID or prefix the provider (e.g. gemini:${override}).`);
+        const knownProviders = ["anthropic", "openai", "gemini", "azure", "openai-compatible", "ollama"];
+        const hasProviderPrefix = override.includes(":") && knownProviders.some((p) => override.startsWith(p + ":"));
+        if (hasProviderPrefix) {
+          const provider = override.split(":")[0];
+          throw new Error(
+            `Configured model "${override}" for ${tier} cannot be used: provider '${provider}' is not available or unreachable. Check that the provider is running and accessible.`
+          );
+        }
+        throw new Error(
+          `Configured model "${override}" for ${tier} could not be loaded. Check provider availability and exact model name.`
+        );
       }
       this.tierModels.set(tier, model);
       this.ensureProvider(model, config.providers);
@@ -1946,19 +2254,93 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
     profiler.profileAll(allModels).catch(() => {
     });
   }
+  /**
+   * Cascade Auto live data: discover/validate real model ids from each cloud
+   * provider, then fetch current public quality scores + per-token prices and
+   * apply the prices to the available-model set. Best-effort and safe to run in
+   * the background — any failure leaves the bundled catalog/benchmarks in effect.
+   */
+  async refreshLiveData() {
+    const benchCfg = this.config.benchmarks ?? {};
+    if (!this.liveData) {
+      this.liveData = new LiveDataProvider({
+        live: benchCfg.live,
+        pricingLive: benchCfg.pricingLive,
+        refreshHours: benchCfg.refreshHours,
+        sourceUrl: benchCfg.sourceUrl
+      });
+      setBenchmarkLiveProvider(this.liveData);
+    }
+    await this.discoverProviderModels();
+    await this.liveData.refresh().catch(() => {
+    });
+    this.applyLivePricing();
+  }
+  /** Returns the live-data provider once refreshLiveData has run (UX/insight). */
+  getLiveData() {
+    return this.liveData;
+  }
+  /**
+   * Query each available cloud provider's live model list and register the
+   * results. Confirms catalog ids still exist and surfaces newly released
+   * models without a package upgrade. Mirrors discoverOllamaModels.
+   */
+  async discoverProviderModels() {
+    const cloud = ["anthropic", "openai", "gemini", "azure", "openai-compatible"];
+    const tasks = cloud.map(async (type) => {
+      if (!this.selector.isProviderAvailable(type)) return;
+      const seed = this.getAnyModelForProvider(type);
+      if (!seed) return;
+      const cfg = this.config.providers.find((p) => p.type === type) ?? { type };
+      try {
+        const provider = this.createProvider(cfg, seed);
+        if (typeof provider.listModels !== "function") return;
+        const models = await provider.listModels();
+        for (const m of models) this.selector.addDynamicModel(m);
+      } catch {
+      }
+    });
+    await Promise.allSettled(tasks);
+  }
+  /**
+   * Replace available models with live-priced copies and refresh the already
+   * resolved tier models so shared-tier cost accounting uses current prices.
+   */
+  applyLivePricing() {
+    if (!this.liveData?.hasLivePricing()) return;
+    const updated = this.liveData.applyLivePricing(this.selector.getAllAvailableModels());
+    for (const m of updated) this.selector.addDynamicModel(m);
+    for (const tier of ["T1", "T2", "T3"]) {
+      const cur = this.tierModels.get(tier);
+      if (!cur) continue;
+      const fresh = this.selector.getModelById(cur.id);
+      if (fresh) this.tierModels.set(tier, fresh);
+    }
+  }
   async generate(tier, options, onChunk, requireVision = false) {
     if (this.budgetState === "exceeded") {
       throw new _CascadeRouter.BudgetExceededError(
         this.budgetExceededReason ?? "Session budget exceeded."
       );
     }
+    if (this.runBudgetExceeded) {
+      throw new _CascadeRouter.BudgetExceededError(
+        this.runBudgetExceededReason ?? "Per-task budget exceeded."
+      );
+    }
     const limits = this.config?.tierLimits;
     const tierKey = tier.toLowerCase();
     const tierMaxTokens = limits?.[`${tierKey}MaxTokens`];
     if (tierMaxTokens && (!options.maxTokens || options.maxTokens > tierMaxTokens)) {
       options = { ...options, maxTokens: tierMaxTokens };
     }
-    const model = requireVision ? this.selector.selectVisionModel() : this.tierModels.get(tier);
+    if (this.runSignal && !options.signal) {
+      options = { ...options, signal: this.runSignal };
+    }
+    if (options.model && !requireVision) {
+      this.ensureProvider(options.model, this.config.providers);
+    }
+    const model = requireVision ? this.selector.selectVisionModel() : options.model ?? this.tierModels.get(tier);
     if (!model) throw new Error(`No model available for tier ${tier}`);
     const provider = this.getProvider(model);
     if (!provider) throw new Error(`No provider for model ${model.id}`);
@@ -1987,16 +2369,33 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
           `Local model ${model.id} inference timed out after ${inferenceTimeoutMs}ms`
         );
       } else if (useStream && onChunk) {
+        const cloudTimeoutMs = this.config.cloudInferenceTimeoutMs ?? 12e4;
         try {
-          result = await provider.generateStream(options, (chunk) => {
-            const text = typeof chunk?.text === "string" ? chunk.text : "";
-            if (text) onChunk({ ...chunk, text });
-          });
-        } catch {
-          result = await provider.generate(options);
+          result = await withTimeout(
+            provider.generateStream(options, (chunk) => {
+              const text = typeof chunk?.text === "string" ? chunk.text : "";
+              if (text) onChunk({ ...chunk, text });
+            }),
+            cloudTimeoutMs,
+            `Model ${model.id} stream timed out after ${cloudTimeoutMs}ms`
+          );
+        } catch (streamErr) {
+          if (streamErr instanceof Error && streamErr.name === "AbortError" || this.runSignal?.aborted || options.signal?.aborted) {
+            throw streamErr;
+          }
+          result = await withTimeout(
+            provider.generate(options),
+            cloudTimeoutMs,
+            `Model ${model.id} inference timed out after ${cloudTimeoutMs}ms`
+          );
         }
       } else {
-        result = await provider.generate(options);
+        const cloudTimeoutMs = this.config.cloudInferenceTimeoutMs ?? 12e4;
+        result = await withTimeout(
+          provider.generate(options),
+          cloudTimeoutMs,
+          `Model ${model.id} inference timed out after ${cloudTimeoutMs}ms`
+        );
       }
       const correctedCost = calculateCost(
         result.usage.inputTokens,
@@ -2017,6 +2416,9 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
       this.failover.recordSuccess(model.provider);
       return result;
     } catch (err) {
+      if (err instanceof Error && err.name === "AbortError" || this.runSignal?.aborted || options.signal?.aborted) {
+        throw new CascadeCancelledError("Run cancelled");
+      }
       const errMsg = err instanceof Error ? err.message : String(err);
       if (this.isRateLimitError(errMsg)) {
         this.failover.recordFailure(model.provider, "rate_limit");
@@ -2024,11 +2426,35 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
         if (fallback) {
           this.tierModels.set(tier, fallback);
           this.ensureProvider(fallback, this.config.providers);
+          this.emit("failover", {
+            tier,
+            from: `${model.provider}:${model.id}`,
+            to: `${fallback.provider}:${fallback.id}`,
+            reason: "rate limit"
+          });
           releaseLocalSlot?.();
           releaseLocalSlot = void 0;
           return this.generate(tier, options, onChunk, requireVision);
         }
       }
+      if (isModelNotFoundError(errMsg)) {
+        this.selector.removeModel(model.id);
+        const next = this.selector.selectForTier(tier);
+        if (next && next.id !== model.id) {
+          this.tierModels.set(tier, next);
+          this.ensureProvider(next, this.config.providers);
+          this.emit("failover", {
+            tier,
+            from: `${model.provider}:${model.id}`,
+            to: `${next.provider}:${next.id}`,
+            reason: "model not found"
+          });
+          releaseLocalSlot?.();
+          releaseLocalSlot = void 0;
+          const retryOpts = options.model && options.model.id === model.id ? { ...options, model: void 0 } : options;
+          return this.generate(tier, retryOpts, onChunk, requireVision);
+        }
+      }
       throw err;
     } finally {
       releaseLocalSlot?.();
@@ -2037,18 +2463,74 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
   getModelForTier(tier) {
     return this.tierModels.get(tier);
   }
+  /** Reflection settings for workers (config.reflection). Off unless enabled. */
+  getReflectionConfig() {
+    const r = this.config?.reflection;
+    return { enabled: r?.enabled === true, maxRounds: r?.maxRounds ?? 1 };
+  }
+  /** T3→T2 reinforcement settings (config.reinforcements). Off unless enabled. */
+  getReinforcementsConfig() {
+    const r = this.config?.reinforcements;
+    return { enabled: r?.enabled === true, maxPerSection: r?.maxPerSection ?? 4 };
+  }
+  /**
+   * Resolved T3 wave execution mode. 'auto' becomes 'sequential' when the T3
+   * tier resolves to a LOCAL model (the single-GPU queue serializes anyway, so
+   * running them in parallel just thrashes it), and 'parallel' for cloud.
+   */
+  getT3ExecutionMode() {
+    const mode = this.config?.t3Execution ?? "auto";
+    if (mode === "parallel" || mode === "sequential") return mode;
+    return this.tierModels.get("T3")?.isLocal ? "sequential" : "parallel";
+  }
   /**
    * Cascade Auto: temporarily override the model for a tier.
    * Used by TaskAnalyzer to inject task-optimal models before execution.
    * The override is valid for the current task only — restored by restoreTierModels().
    */
   overrideTierModel(tier, model) {
+    if (!this.originalTierModels) {
+      this.originalTierModels = new Map(this.tierModels);
+    }
     this.tierModels.set(tier, model);
     this.ensureProvider(model, this.config.providers);
   }
+  /**
+   * Restore tier models to the configured/default baseline captured before the
+   * first Cascade Auto override. Called at the end of each run so `/why`, the
+   * status bar, and the next run reflect the configured models, not stale picks.
+   */
+  restoreTierModels() {
+    if (this.originalTierModels) {
+      this.tierModels = new Map(this.originalTierModels);
+      this.originalTierModels = void 0;
+    }
+  }
+  /** Set (or clear) the current run's abort signal for instant cancellation. */
+  setRunSignal(signal) {
+    this.runSignal = signal;
+  }
   getSelector() {
     return this.selector;
   }
+  /** Wire the Cascade Auto task analyzer used for per-subtask model routing. */
+  setTaskAnalyzer(analyzer) {
+    this.taskAnalyzer = analyzer;
+  }
+  /**
+   * Cascade Auto per-subtask routing: pick the benchmark-best model for a
+   * specific subtask's text, scoped to the tier's eligible candidates. Returns
+   * null when Cascade Auto is off (callers then use the shared tier model).
+   * Pure heuristic — no extra LLM call.
+   */
+  async selectModelForSubtask(tier, text) {
+    if (!this.config?.cascadeAuto || !this.taskAnalyzer || !text.trim()) return null;
+    try {
+      return await this.taskAnalyzer.selectModel(text, tier, this.selector);
+    } catch {
+      return null;
+    }
+  }
   getStats() {
     return {
       totalTokens: this.stats.totalTokens,
@@ -2061,6 +2543,14 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
       outputTokensByTier: { ...this.stats.outputTokensByTier }
     };
   }
+  /**
+   * What did delegation save? Compares actual spend against the
+   * counterfactual of every call running on the T1 model. This is the
+   * number only a tiered hierarchy can show.
+   */
+  getDelegationSavings() {
+    return computeDelegationSavings(this.stats, this.tierModels.get("T1"));
+  }
   /**
    * Returns a human-readable cost summary broken down by tier.
    * Example: { T1: "$0.0120 (2 calls, 1500 tokens)", T2: "$0.0043 (6 calls, 4200 tokens)", ... }
@@ -2119,6 +2609,11 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
    * Sets (or clears) a runtime session budget cap (USD).
    * Pass null to remove the cap.
    */
+  /** Raise/set the per-task token cap at runtime (used by /continue resume). */
+  setMaxTokensPerRun(maxTokens) {
+    if (!this.config) return;
+    this.config = { ...this.config, budget: { ...this.config.budget, maxTokensPerRun: maxTokens } };
+  }
   setSessionBudget(usd) {
     if (!this.config) return;
     if (!this.config.budget) {
@@ -2221,7 +2716,39 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
     this.stats.tokensByTier[tier] = (this.stats.tokensByTier[tier] ?? 0) + usage.totalTokens;
     this.stats.inputTokensByTier[tier] = (this.stats.inputTokensByTier[tier] ?? 0) + usage.inputTokens;
     this.stats.outputTokensByTier[tier] = (this.stats.outputTokensByTier[tier] ?? 0) + usage.outputTokens;
+    this.runTokens += usage.totalTokens;
+    this.runCostUsd += usage.estimatedCostUsd;
     this.updateBudgetState();
+    this.enforceRunBudget();
+  }
+  /**
+   * Resets per-run accounting at the start of each `cascade run`. Session
+   * totals and a session-wide budget halt are deliberately preserved; only the
+   * per-task ceiling is cleared so the next task starts with a fresh allowance.
+   */
+  beginRun() {
+    this.runTokens = 0;
+    this.runCostUsd = 0;
+    this.runBudgetExceeded = false;
+    this.runBudgetExceededReason = void 0;
+  }
+  /**
+   * Enforce the hard per-task ceiling. Once tripped, the flag makes every
+   * subsequent (and concurrent) generate() call in this run fail fast.
+   */
+  enforceRunBudget() {
+    if (this.runBudgetExceeded) return;
+    const budget = this.config?.budget;
+    const maxTokens = budget?.maxTokensPerRun;
+    const maxCost = budget?.maxCostPerRunUsd;
+    const overTokens = maxTokens != null && this.runTokens >= maxTokens;
+    const overCost = maxCost != null && this.runCostUsd >= maxCost;
+    if (!overTokens && !overCost) return;
+    const reason = overTokens ? `Per-task token cap of ${maxTokens.toLocaleString()} reached (used ${this.runTokens.toLocaleString()}). Stopping this run to avoid runaway cost \u2014 raise budget.maxTokensPerRun for larger jobs.` : `Per-task cost cap of $${maxCost.toFixed(4)} reached (spent $${this.runCostUsd.toFixed(4)}). Stopping this run to avoid runaway cost.`;
+    this.runBudgetExceeded = true;
+    this.runBudgetExceededReason = reason;
+    this.emit("budget:exceeded", { reason, spentUsd: this.sessionCostUsd });
+    throw new _CascadeRouter.BudgetExceededError(reason);
   }
   /**
    * Single point of truth for budget state transitions. Called after each
@@ -2271,6 +2798,9 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
     return /rate.?limit|429|too.?many.?requests|quota/i.test(msg);
   }
 };
+function isModelNotFoundError(msg) {
+  return /not[_\s]?found|404|does not exist|no such model|unknown model|invalid model|model_not_found|not supported for generatecontent|is not supported for/i.test(msg);
+}
 var BaseTier = class extends EventEmitter {
   id;
   role;
@@ -2553,60 +3083,95 @@ var AuditLogger = class {
 
 // src/tools/text-tool-parser.ts
 var TOOL_CALL_RE = /<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/g;
-var JSON_BLOCK_RE = /```json\s*([\s\S]*?)\s*```/g;
-var FUNCTION_OBJ_RE = /\{\s*"function"\s*:\s*\{[^}]*"name"\s*:[^}]*\}\s*\}/g;
+var JSON_BLOCK_RE = /```(?:json|tool_call|tool)?\s*([\s\S]*?)```/g;
 function parseTextToolCalls(text) {
-  const results = tryXmlBlocks(text);
-  if (results.length > 0) return results;
-  const jsonBlockResults = tryJsonCodeBlocks(text);
-  if (jsonBlockResults.length > 0) return jsonBlockResults;
-  return tryFunctionCallObjects(text);
+  const xml = collect(text, TOOL_CALL_RE);
+  if (xml.length > 0) return xml;
+  const fenced = collect(text, JSON_BLOCK_RE);
+  if (fenced.length > 0) return fenced;
+  return tryBareObjects(text);
 }
-function tryXmlBlocks(text) {
+function collect(text, re) {
   const results = [];
   let match;
-  TOOL_CALL_RE.lastIndex = 0;
-  while ((match = TOOL_CALL_RE.exec(text)) !== null) {
-    try {
-      const raw = JSON.parse(match[1]);
-      if (typeof raw.name !== "string") continue;
-      const input = typeof raw.input === "object" && raw.input !== null ? raw.input : {};
-      results.push({ name: raw.name, input });
-    } catch {
-    }
+  re.lastIndex = 0;
+  while ((match = re.exec(text)) !== null) {
+    const body = (match[1] ?? "").trim();
+    const parsed = parseJsonLoose(body);
+    const call = coerceCall(parsed);
+    if (call) results.push(call);
   }
   return results;
 }
-function tryJsonCodeBlocks(text) {
+function tryBareObjects(text) {
   const results = [];
-  let match;
-  JSON_BLOCK_RE.lastIndex = 0;
-  while ((match = JSON_BLOCK_RE.exec(text)) !== null) {
-    try {
-      const raw = JSON.parse(match[1]);
-      if (typeof raw.name !== "string") continue;
-      const input = typeof raw.input === "object" && raw.input !== null ? raw.input : {};
-      results.push({ name: raw.name, input });
-    } catch {
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] !== "{") continue;
+    let depth = 0;
+    let inStr = false;
+    let esc = false;
+    let end = -1;
+    for (let j = i; j < text.length; j++) {
+      const c = text[j];
+      if (esc) {
+        esc = false;
+        continue;
+      }
+      if (c === "\\") {
+        esc = true;
+        continue;
+      }
+      if (c === '"') {
+        inStr = !inStr;
+        continue;
+      }
+      if (inStr) continue;
+      if (c === "{") depth++;
+      else if (c === "}") {
+        depth--;
+        if (depth === 0) {
+          end = j;
+          break;
+        }
+      }
     }
+    if (end === -1) break;
+    const candidate = text.slice(i, end + 1);
+    if (/['"]name['"]\s*:/.test(candidate) && /['"](?:input|arguments)['"]\s*:/.test(candidate)) {
+      const call = coerceCall(parseJsonLoose(candidate));
+      if (call) results.push(call);
+    }
+    i = end;
   }
   return results;
 }
-function tryFunctionCallObjects(text) {
-  const results = [];
-  let match;
-  FUNCTION_OBJ_RE.lastIndex = 0;
-  while ((match = FUNCTION_OBJ_RE.exec(text)) !== null) {
+function parseJsonLoose(raw) {
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
     try {
-      const raw = JSON.parse(match[0]);
-      const fn = raw.function;
-      if (!fn || typeof fn.name !== "string") continue;
-      const input = typeof fn.arguments === "object" && fn.arguments !== null ? fn.arguments : {};
-      results.push({ name: fn.name, input });
+      return JSON.parse(raw.replace(/'/g, '"'));
     } catch {
+      return null;
     }
   }
-  return results;
+}
+function coerceCall(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const obj = raw;
+  const fn = obj.function && typeof obj.function === "object" ? obj.function : null;
+  const name = typeof obj.name === "string" ? obj.name : fn && typeof fn.name === "string" ? fn.name : null;
+  if (!name) return null;
+  const rawInput = obj.input ?? obj.arguments ?? (fn ? fn.input ?? fn.arguments : void 0);
+  let input = {};
+  if (rawInput && typeof rawInput === "object") {
+    input = rawInput;
+  } else if (typeof rawInput === "string") {
+    const parsed = parseJsonLoose(rawInput);
+    if (parsed && typeof parsed === "object") input = parsed;
+  }
+  return { name, input };
 }
 function toToolCall(parsed, index) {
   return {
@@ -2617,32 +3182,59 @@ function toToolCall(parsed, index) {
 }
 function buildTextToolSystemPrompt(tools) {
   const toolDefs = tools.map((t) => {
-    const props = t.inputSchema?.properties ?? {};
-    const paramLines = Object.entries(props).map(([k, v]) => `    "${k}": "<${v.description ?? k}>"`);
-    return `\u2022 ${t.name}: ${t.description}
-  Input: {${paramLines.length ? "\n" + paramLines.join(",\n") + "\n  " : ""}}`;
+    const schema = t.inputSchema ?? {};
+    const props = schema.properties && typeof schema.properties === "object" ? schema.properties : {};
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    const paramLines = Object.entries(props).map(([k, v]) => {
+      const type = typeof v.type === "string" ? v.type : "any";
+      const desc = typeof v.description === "string" ? v.description : k;
+      const req = required.includes(k) ? " [required]" : "";
+      const enumVals = Array.isArray(v.enum) ? ` (one of: ${v.enum.map((e) => JSON.stringify(e)).join(", ")})` : "";
+      return `    - ${k} (${type})${req}: ${desc}${enumVals}`;
+    });
+    return `\u2022 ${t.name} \u2014 ${t.description}${paramLines.length ? "\n" + paramLines.join("\n") : "\n    (no parameters)"}`;
   }).join("\n");
   return `
 TOOL USE INSTRUCTIONS:
-You do not have native tool-use capability. To call a tool, write a <tool_call> block:
+You do not have native tool-use capability. To call a tool, output a single <tool_call> block containing JSON with the tool name and its input arguments:
 
 <tool_call>
-{"name": "<tool_name>", "input": {<parameters>}}
+{"name": "<tool_name>", "input": { ...arguments... }}
 </tool_call>
 
+Rules:
+- Use exactly the parameter names shown below and include every [required] parameter.
+- For parameters that list "one of", use one of those values verbatim.
+- Emit valid JSON with double quotes. Call only ONE tool at a time, then wait for the result.
+
 Available tools:
 ${toolDefs}
 
 EXAMPLE \u2014 calling the "shell" tool to list files:
 <tool_call>
-{"name": "shell", "input": {"command": "ls -la /workspace"}}
+{"name": "shell", "input": {"command": "ls -la"}}
 </tool_call>
 
-You will then receive a user message with the result, then continue your work.
-Only call one tool at a time. When you have enough information, provide your final answer.`;
+When you have enough information, stop calling tools and write your final answer.`;
 }
 
 // src/core/tiers/t3-worker.ts
+var CriticalToolError = class extends Error {
+  constructor(message, toolName) {
+    super(message);
+    this.toolName = toolName;
+    this.name = "CriticalToolError";
+  }
+  toolName;
+};
+var WorkerStallError = class extends Error {
+  constructor(message, partialOutput) {
+    super(message);
+    this.partialOutput = partialOutput;
+    this.name = "WorkerStallError";
+  }
+  partialOutput;
+};
 var T3_SYSTEM_PROMPT = `You are a T3 Worker agent in the Cascade AI system. Your job is to execute a specific subtask completely and accurately.
 
 Rules:
@@ -2664,6 +3256,10 @@ var T3Worker = class extends BaseTier {
   store;
   audit;
   tools = [];
+  /** 0 = top-level worker (may request reinforcements); 1 = a spawned reinforcement (may not). */
+  reinforcementDepth = 0;
+  /** Sibling-worker requests this worker made via request_workers (T3→T2). */
+  pendingReinforcements = [];
   /** @deprecated — kept only as fallback when no escalator is attached */
   sessionApprovals = /* @__PURE__ */ new Map();
   peerBus;
@@ -2676,10 +3272,22 @@ var T3Worker = class extends BaseTier {
       this.log(`Peer message from ${msg.fromId}: ${msg.type}`);
       this.receivePeerSync(msg.fromId, msg.payload);
     });
+    this.peerBus.on("broadcast", (msg) => {
+      const payload = msg?.payload;
+      if (payload?.type === "TOOL_CREATED" && payload.spec && this.toolCreator) {
+        this.toolCreator.registerSpec(payload.spec);
+        this.tools = this.toolRegistry.getToolDefinitions();
+        this.log(`Registered peer tool "${payload.spec.name}" from broadcast.`);
+      }
+    });
   }
   setPermissionEscalator(escalator) {
     this.permissionEscalator = escalator;
   }
+  /** Marks this worker as a spawned reinforcement (depth 1 — cannot request more). */
+  markAsReinforcement() {
+    this.reinforcementDepth = 1;
+  }
   setToolCreator(creator) {
     this.toolCreator = creator;
   }
@@ -2700,6 +3308,31 @@ var T3Worker = class extends BaseTier {
     this.setLabel(assignment.subtaskTitle);
     this.setStatus("ACTIVE");
     this.tools = this.toolRegistry.getToolDefinitions();
+    if (this.reinforcementDepth === 0 && this.router.getReinforcementsConfig?.()?.enabled) {
+      this.tools = [...this.tools, {
+        name: "request_workers",
+        description: "Ask your manager to spawn additional sibling workers for sub-problems you discover are too large or parallelizable to finish alone. Use sparingly \u2014 only when the work genuinely needs to fan out.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            subtasks: {
+              type: "array",
+              description: "New sibling subtasks for your manager to spawn.",
+              items: {
+                type: "object",
+                properties: {
+                  title: { type: "string" },
+                  description: { type: "string" },
+                  expectedOutput: { type: "string" }
+                },
+                required: ["title", "description"]
+              }
+            }
+          },
+          required: ["subtasks"]
+        }
+      }];
+    }
     if (assignment.dependsOn?.length && this.peerBus) {
       this.sendStatusUpdate({
         progressPct: 0,
@@ -2800,12 +3433,31 @@ Now execute your subtask using this context where relevant.`
           return this.buildResult("ESCALATED", output, { checksRun, passed, failed }, issues, correctionAttempts);
         }
       }
+      const reflectCfg = this.router.getReflectionConfig?.() ?? { enabled: false, maxRounds: 1 };
+      if (reflectCfg.enabled) {
+        this.sendStatusUpdate({ progressPct: 85, currentAction: "Reflecting on output", status: "IN_PROGRESS" });
+        output = await this.reflectAndImprove(assignment, output, reflectCfg.maxRounds);
+      }
       this.setStatus("COMPLETED", output);
       this.sendStatusUpdate({ progressPct: 100, currentAction: "Subtask complete", status: "IN_PROGRESS", output });
       this.peerBus?.publish(this.id, assignment.subtaskId, output, "COMPLETED");
       return this.buildResult("COMPLETED", output, { checksRun, passed, failed }, issues, correctionAttempts);
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
+      if (err instanceof WorkerStallError) {
+        issues.push(`Stalled: ${errMsg}`);
+        const finalOutput2 = err.partialOutput || output || errMsg;
+        this.setStatus("FAILED", finalOutput2);
+        this.peerBus?.publish(this.id, assignment.subtaskId, finalOutput2, "FAILED");
+        return this.buildResult("ESCALATED", finalOutput2, { checksRun, passed, failed }, issues, correctionAttempts);
+      }
+      if (err instanceof CriticalToolError) {
+        issues.push(`[CRITICAL_TOOL_ERROR] ${err.toolName}: ${errMsg}`);
+        const finalOutput2 = output || `Tool "${err.toolName}" failed unrecoverably: ${errMsg}`;
+        this.setStatus("FAILED", finalOutput2);
+        this.peerBus?.publish(this.id, assignment.subtaskId, finalOutput2, "FAILED");
+        return this.buildResult("ESCALATED", finalOutput2, { checksRun, passed, failed }, issues, correctionAttempts);
+      }
       issues.push(`Execution error: ${errMsg}`);
       const finalOutput = output || errMsg;
       this.setStatus("FAILED", finalOutput);
@@ -2843,8 +3495,17 @@ Now execute your subtask using this context where relevant.`
     const MAX_ITERATIONS = 15;
     const requiresArtifact = this.requiresArtifact();
     tools = [...tools];
-    const t3Model = this.router.getModelForTier("T3");
-    const useTextTools = t3Model?.supportsToolUse === false && tools.length > 0;
+    let subtaskModel;
+    try {
+      const subtaskText = `${this.assignment?.subtaskTitle ?? ""} ${this.assignment?.description ?? ""} ${this.assignment?.expectedOutput ?? ""}`;
+      subtaskModel = await this.router.selectModelForSubtask("T3", subtaskText) ?? void 0;
+      if (subtaskModel) {
+        this.log(`Cascade Auto: routing this subtask to ${subtaskModel.provider}:${subtaskModel.id}`);
+      }
+    } catch {
+    }
+    const effectiveModel = subtaskModel ?? this.router.getModelForTier("T3");
+    const useTextTools = effectiveModel?.supportsToolUse === false && tools.length > 0;
     const textToolSuffix = useTextTools ? buildTextToolSystemPrompt(tools) : "";
     while (iterations < MAX_ITERATIONS) {
       iterations++;
@@ -2856,7 +3517,8 @@ Now execute your subtask using this context where relevant.`
 HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
         // Don't pass tools array when model can't use them natively
         tools: useTextTools ? void 0 : tools.length ? tools : void 0,
-        maxTokens: 4096
+        maxTokens: 4096,
+        ...subtaskModel ? { model: subtaskModel } : {}
       };
       const result = await this.router.generate(
         "T3",
@@ -2880,10 +3542,17 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
           }
           stalledArtifactIterations += 1;
           if (stalledArtifactIterations >= 2) {
+            const partial = result.content || "";
             if (stalledArtifactIterations === 2) {
-              throw new Error(`Worker stalled waiting for artifact creation. Requesting dynamic tool generation from T2 Manager for: ${this.assignment?.subtaskTitle ?? "unknown task"}`);
+              throw new WorkerStallError(
+                `Worker stalled waiting for artifact creation. Requesting dynamic tool generation from T2 Manager for: ${this.assignment?.subtaskTitle ?? "unknown task"}`,
+                partial
+              );
             }
-            throw new Error("Artifact-producing task stalled without creating or verifying the required files");
+            throw new WorkerStallError(
+              "Artifact-producing task stalled without creating or verifying the required files",
+              partial
+            );
           }
           await this.context.addMessage({
             role: "user",
@@ -2920,7 +3589,41 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
       toolCalls: allToolCalls
     };
   }
+  /**
+   * Lightweight argument check against the tool's JSON Schema: required fields
+   * present and enum values in range. Not a full validator — just the two
+   * failure modes weak models hit most. Returns an error message, or null if OK.
+   */
+  validateToolInput(tc) {
+    const def = this.tools.find((t) => t.name === tc.name);
+    const schema = def?.inputSchema;
+    if (!schema) return null;
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    const missing = required.filter((k) => tc.input[k] === void 0 || tc.input[k] === null || tc.input[k] === "");
+    if (missing.length) {
+      return `Tool error: missing required parameter(s) for "${tc.name}": ${missing.join(", ")}. Expected: ${JSON.stringify(schema)}. Supply them and call the tool again.`;
+    }
+    if (schema.properties) {
+      for (const [k, prop] of Object.entries(schema.properties)) {
+        const allowed = Array.isArray(prop?.enum) ? prop.enum : null;
+        if (allowed && tc.input[k] !== void 0 && !allowed.includes(tc.input[k])) {
+          return `Tool error: invalid value for "${k}" in "${tc.name}": ${JSON.stringify(tc.input[k])}. Must be one of ${JSON.stringify(allowed)}.`;
+        }
+      }
+    }
+    return null;
+  }
   async executeTool(tc) {
+    if (tc.name === "request_workers") {
+      const msg = this.recordReinforcements(tc.input);
+      this.emit("tool:result", { id: tc.id, tierId: this.id, toolName: tc.name, output: msg, durationMs: 0 });
+      return msg;
+    }
+    const validationError = this.validateToolInput(tc);
+    if (validationError) {
+      this.emit("tool:result", { id: tc.id, tierId: this.id, toolName: tc.name, error: validationError, durationMs: 0 });
+      return validationError;
+    }
     const needsApproval = this.toolRegistry.requiresApproval(tc.name);
     if (needsApproval) {
       if (this.permissionEscalator) {
@@ -2941,7 +3644,14 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
           const wasApproved = this.sessionApprovals.get(tc.name);
           if (!wasApproved) return `Tool ${tc.name} was denied by user.`;
         } else {
+          const LEGACY_APPROVAL_TIMEOUT_MS = 6e5;
           const legacyDecision = await new Promise((resolve) => {
+            const eventName = `tool:approval-response:${this.id}-${tc.id}`;
+            const timer = setTimeout(() => {
+              this.removeAllListeners(eventName);
+              resolve({ approved: false });
+            }, LEGACY_APPROVAL_TIMEOUT_MS);
+            timer.unref?.();
             this.emit("tool:approval-request", {
               id: `${this.id}-${tc.id}`,
               tierId: this.id,
@@ -2950,7 +3660,10 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
               description: `T3 (${this.assignment?.subtaskTitle}) wants to run "${tc.name}"`,
               isDangerous: this.toolRegistry.isDangerous(tc.name)
             });
-            this.once(`tool:approval-response:${this.id}-${tc.id}`, resolve);
+            this.once(eventName, (d) => {
+              clearTimeout(timer);
+              resolve(d);
+            });
           });
           if (legacyDecision.always) this.sessionApprovals.set(tc.name, legacyDecision.approved);
           if (!legacyDecision.approved) return `Tool ${tc.name} was denied by user.`;
@@ -2969,8 +3682,8 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
         tierId: this.id,
         sessionId: this.taskId,
         requireApproval: false,
-        saveSnapshot: async (path17, content) => {
-          this.store?.addFileSnapshot(this.taskId, path17, content);
+        saveSnapshot: async (path19, content) => {
+          this.store?.addFileSnapshot(this.taskId, path19, content);
         },
         sendPeerSync: (to, syncType, content) => {
           this.peerBus?.send(this.id, to, syncType, this.assignment?.subtaskId ?? "", content);
@@ -2994,7 +3707,10 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
       const durationMs = Date.now() - toolStartMs;
       const errMsg = err instanceof Error ? err.message : String(err);
       this.emit("tool:result", { id: tc.id, tierId: this.id, toolName: tc.name, error: errMsg, durationMs });
-      return `Tool error: ${errMsg}`;
+      if (/\b(429|rate.?limit|authentication|api.?key|forbidden|401|403)\b/i.test(errMsg)) {
+        throw new CriticalToolError(errMsg, tc.name);
+      }
+      return await this.adaptiveFallback(tc, `Tool error: ${errMsg}`);
     }
   }
   /**
@@ -3072,6 +3788,11 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
    */
   async coordinateFileIntents(assignment) {
     if (!this.peerBus) return;
+    const haystack = `${assignment.description}
+${assignment.expectedOutput}`;
+    if (!/\b(create|write|save|generate|produce|output|edit|update|modify|append|overwrite|rewrite)\b/i.test(haystack)) {
+      return;
+    }
     const plannedFiles = this.extractArtifactPaths(assignment);
     if (!plannedFiles.length) return;
     this.peerBus.broadcast(this.id, {
@@ -3082,16 +3803,22 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
     await new Promise((r) => setTimeout(r, 500));
     const sortedFiles = [...plannedFiles].sort();
     for (const filePath of sortedFiles) {
-      if (this.peerBus.isFileLocked(filePath)) {
-        this.log(`[T3] Waiting for file lock: ${filePath}`);
-        this.sendStatusUpdate({
-          progressPct: 5,
-          currentAction: `Waiting for peer to finish editing: ${filePath}`,
-          status: "IN_PROGRESS"
+      try {
+        if (this.peerBus.isFileLocked(filePath)) {
+          this.log(`[T3] Waiting for file lock: ${filePath}`);
+          this.sendStatusUpdate({
+            progressPct: 5,
+            currentAction: `Waiting for peer to finish editing: ${filePath}`,
+            status: "IN_PROGRESS"
+          });
+          await this.peerBus.waitForFileRelease(filePath, 1e4).catch(() => {
+          });
+        }
+        await this.peerBus.lockFile(this.id, filePath, 1e4).catch(() => {
         });
-        await this.peerBus.waitForFileRelease(filePath);
+      } catch (err) {
+        this.log(`[T3] Lock coordination skipped for ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
       }
-      await this.peerBus.lockFile(this.id, filePath);
     }
     const origPublish = this.peerBus.publish.bind(this.peerBus);
     const bus = this.peerBus;
@@ -3122,13 +3849,13 @@ ${assignment.expectedOutput}`;
     const artifactPaths = this.extractArtifactPaths(assignment);
     if (!artifactPaths.length) return { ok: true, issues: [] };
     const issues = [];
-    const { exec: exec3 } = await import('child_process');
+    const { exec: exec2 } = await import('child_process');
     const { promisify: promisify4 } = await import('util');
-    const execAsync2 = promisify4(exec3);
+    const execAsync2 = promisify4(exec2);
     for (const artifactPath of artifactPaths) {
-      const absolutePath = path16.resolve(process.cwd(), artifactPath);
+      const absolutePath = path18.resolve(process.cwd(), artifactPath);
       try {
-        const stat = await fs3.stat(absolutePath);
+        const stat = await fs4.stat(absolutePath);
         if (!stat.isFile()) {
           issues.push(`Expected artifact is not a file: ${artifactPath}`);
           continue;
@@ -3138,7 +3865,7 @@ ${assignment.expectedOutput}`;
           continue;
         }
         if (!/\.pdf$/i.test(artifactPath)) {
-          const content = await fs3.readFile(absolutePath, "utf-8");
+          const content = await fs4.readFile(absolutePath, "utf-8");
           if (!content.trim()) {
             issues.push(`Artifact content is empty: ${artifactPath}`);
             continue;
@@ -3147,7 +3874,7 @@ ${assignment.expectedOutput}`;
           issues.push(`PDF artifact looks too small to be valid: ${artifactPath}`);
           continue;
         }
-        const ext = path16.extname(absolutePath).toLowerCase();
+        const ext = path18.extname(absolutePath).toLowerCase();
         try {
           if (ext === ".ts" || ext === ".tsx") {
             await execAsync2(`npx tsc --noEmit ${absolutePath}`, { timeout: 1e4 });
@@ -3169,6 +3896,61 @@ ${stdout}`);
     }
     return { ok: issues.length === 0, issues };
   }
+  /**
+   * Reflection / self-critique: critique the output against the broader GOAL
+   * (not just the subtask spec the self-test checks) and revise once if it falls
+   * short. Two cheap calls per round — a JSON verdict, then a rewrite only if
+   * needed. Best-effort: any parse/error just keeps the current output.
+   */
+  async reflectAndImprove(assignment, output, maxRounds) {
+    const sys = this.systemPromptOverride + (this.hierarchyContext ? `
+
+HIERARCHY CONTEXT: ${this.hierarchyContext}` : "");
+    let current = output;
+    for (let round = 0; round < Math.max(1, maxRounds); round++) {
+      try {
+        const verdict = await this.router.generate("T3", {
+          messages: [{
+            role: "user",
+            content: `Does this output FULLY achieve the goal \u2014 not just the literal task, but the intent behind it?
+
+Goal / expected: ${assignment.expectedOutput}
+Subtask: ${assignment.description}
+
+Output:
+${current}
+
+Reply with ONLY JSON: {"sufficient": true|false, "notes": "what is weak or missing if not sufficient"}`
+          }],
+          systemPrompt: sys,
+          maxTokens: 400
+        });
+        const parsed = JSON.parse(/\{[\s\S]*\}/.exec(verdict.content)?.[0] ?? "{}");
+        if (parsed.sufficient !== false) break;
+        const improved = await this.router.generate("T3", {
+          messages: [{
+            role: "user",
+            content: `Improve the following so it fully achieves the goal. Address specifically: ${parsed.notes ?? "gaps vs the goal"}.
+Output ONLY the improved result \u2014 no preamble, no commentary.
+
+Goal / expected: ${assignment.expectedOutput}
+
+Current output:
+${current}`
+          }],
+          systemPrompt: sys,
+          maxTokens: 4096
+        });
+        const next = (improved.content ?? "").trim();
+        if (!next) break;
+        current = next;
+        this.log("Reflection: revised output for better goal alignment.");
+      } catch {
+        break;
+      }
+    }
+    return current;
+  }
   async selfTest(assignment, output) {
     const prompt = `Self-test this output against the assignment requirements.
 
@@ -3243,6 +4025,35 @@ ${assignment.constraints.map((c) => `- ${c}`).join("\n")}
 
 Begin execution now.`;
   }
+  /**
+   * Records a request_workers call (T3→T2 reinforcement). Capped at
+   * maxPerSection; reinforcement workers (depth 1) cannot request more.
+   */
+  recordReinforcements(input) {
+    if (this.reinforcementDepth !== 0) {
+      return "request_workers is unavailable to reinforcement workers \u2014 complete your assigned subtask.";
+    }
+    const max = this.router.getReinforcementsConfig?.()?.maxPerSection ?? 4;
+    const raw = Array.isArray(input.subtasks) ? input.subtasks : [];
+    let added = 0;
+    for (const s of raw) {
+      if (this.pendingReinforcements.length >= max) break;
+      const o = s;
+      if (typeof o?.title !== "string" || typeof o?.description !== "string") continue;
+      this.pendingReinforcements.push({
+        subtaskId: `reinf-${this.id}-${this.pendingReinforcements.length + 1}`,
+        subtaskTitle: o.title,
+        description: o.description,
+        expectedOutput: typeof o.expectedOutput === "string" ? o.expectedOutput : o.title,
+        constraints: [],
+        peerT3Ids: [],
+        parentT2: this.parentId ?? "root",
+        dependsOn: []
+      });
+      added++;
+    }
+    return added > 0 ? `Requested ${added} reinforcement worker(s) from your manager; they will run in parallel. Focus on your own part \u2014 do not redo their work.` : "No valid reinforcement subtasks (each needs a title and description), or the per-section limit was reached.";
+  }
   buildResult(status, output, testResults, issues, correctionAttempts) {
     return {
       subtaskId: this.assignment?.subtaskId ?? "",
@@ -3251,7 +4062,8 @@ Begin execution now.`;
       testResults,
       issues,
       peerSyncsUsed: this.peerSyncBuffer.map((m) => m.fromId),
-      correctionAttempts
+      correctionAttempts,
+      reinforcements: this.pendingReinforcements.length ? this.pendingReinforcements : void 0
     };
   }
   isFileOperation(toolName) {
@@ -3270,6 +4082,17 @@ var PeerBus = class extends EventEmitter {
   /** Called when any peer message or broadcast is sent — used for dashboard visibility. */
   onPeerMessage;
   sessionId = "";
+  /** Surface coordination traffic (locks, barriers) to the visibility hook. */
+  emitCoordination(fromId, text) {
+    this.onPeerMessage?.({
+      fromId,
+      toId: void 0,
+      syncType: "COORDINATION",
+      payload: text,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionId: this.sessionId
+    });
+  }
   register(peerId) {
     this.members.add(peerId);
   }
@@ -3406,8 +4229,10 @@ var PeerBus = class extends EventEmitter {
     const existing = this.fileLocks.get(filePath);
     if (!existing) {
       this.fileLocks.set(filePath, { holderId: tierId, lockedAt: (/* @__PURE__ */ new Date()).toISOString(), waiters: [] });
+      this.emitCoordination(tierId, `\u{1F512} locked ${filePath}`);
       return;
     }
+    this.emitCoordination(tierId, `\u23F3 waiting for ${filePath} (held by ${existing.holderId})`);
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         reject(new Error(`File lock timeout for ${filePath} (held by ${existing.holderId})`));
@@ -3415,6 +4240,7 @@ var PeerBus = class extends EventEmitter {
       existing.waiters.push(() => {
         clearTimeout(timer);
         this.fileLocks.set(filePath, { holderId: tierId, lockedAt: (/* @__PURE__ */ new Date()).toISOString(), waiters: [] });
+        this.emitCoordination(tierId, `\u{1F512} locked ${filePath}`);
         resolve();
       });
     });
@@ -3425,6 +4251,7 @@ var PeerBus = class extends EventEmitter {
   releaseFile(tierId, filePath) {
     const lock = this.fileLocks.get(filePath);
     if (!lock || lock.holderId !== tierId) return;
+    this.emitCoordination(tierId, `\u{1F513} released ${filePath}`);
     const nextWaiter = lock.waiters.shift();
     if (nextWaiter) {
       nextWaiter();
@@ -3504,6 +4331,7 @@ var PeerBus = class extends EventEmitter {
     }
     const bar = this.barriers.get(barrierName);
     bar.arrived.add(peerId);
+    this.emitCoordination(peerId, `\u22A8 barrier "${barrierName}" (${bar.arrived.size}/${bar.total})`);
     if (bar.arrived.size >= bar.total) {
       this.emit(`barrier:${barrierName}`);
       return;
@@ -3536,6 +4364,7 @@ var T2Manager = class extends BaseTier {
   router;
   toolRegistry;
   assignment;
+  sectionModel;
   t3Workers = /* @__PURE__ */ new Map();
   escalations = [];
   peerSyncBuffer = [];
@@ -3545,6 +4374,8 @@ var T2Manager = class extends BaseTier {
   t2PeerBus;
   permissionEscalator;
   toolCreator;
+  /** Optional boardroom gate (Moderate / root-T2 runs) — pauses after decomposition. */
+  planApprovalCallback;
   /** AbortController for the current T3 wave — aborted on cancel-and-respawn */
   waveAbortController = null;
   setPeerBus(bus) {
@@ -3582,6 +4413,10 @@ var T2Manager = class extends BaseTier {
   setToolCreator(creator) {
     this.toolCreator = creator;
   }
+  /** Boardroom gate for Moderate (root-T2) runs: pause after decomposition. */
+  setPlanApprovalCallback(cb) {
+    this.planApprovalCallback = cb;
+  }
   /**
    * Phase 1 of T2 peer discussion: broadcast this section's plan so sibling T2s
    * and T1 can detect overlaps and coordinate execution order.
@@ -3635,9 +4470,39 @@ var T2Manager = class extends BaseTier {
       status: "IN_PROGRESS"
     });
     this.log(`T2 managing section: ${assignment.sectionTitle}`);
+    this.sectionModel = void 0;
+    try {
+      const sectionText = `${assignment.sectionTitle} ${assignment.description} ${assignment.expectedOutput}`;
+      this.sectionModel = await this.router.selectModelForSubtask("T2", sectionText) ?? void 0;
+      if (this.sectionModel) {
+        this.log(`Cascade Auto: routing this section to ${this.sectionModel.provider}:${this.sectionModel.id}`);
+      }
+    } catch {
+    }
     try {
       this.throwIfCancelled();
-      const subtasks = assignment.t3Subtasks.length > 0 ? assignment.t3Subtasks : await this.decomposeSection(assignment);
+      let subtasks = assignment.t3Subtasks.length > 0 ? assignment.t3Subtasks : await this.decomposeSection(assignment);
+      if (this.planApprovalCallback) {
+        const decision = await this.planApprovalCallback(subtasks, assignment.sectionTitle);
+        if (!decision.approved) {
+          const output = "Plan rejected \u2014 nothing was executed.";
+          this.setStatus("COMPLETED", output);
+          this.sendStatusUpdate({ progressPct: 100, currentAction: "Plan rejected by user", status: "IN_PROGRESS", output });
+          return { sectionId: assignment.sectionId, sectionTitle: assignment.sectionTitle, status: "COMPLETED", t3Results: [], sectionSummary: output, issues: [] };
+        }
+        if (decision.keepSubtaskIds?.length) {
+          const keep = new Set(decision.keepSubtaskIds);
+          subtasks = subtasks.filter((s) => keep.has(s.subtaskId));
+        }
+        if (decision.note?.trim()) {
+          subtasks = await this.decomposeSection({
+            ...assignment,
+            description: `${assignment.description}
+
+Guidance (must be followed): ${decision.note}`
+          });
+        }
+      }
       this.sendStatusUpdate({
         progressPct: 20,
         currentAction: `Dispatching ${subtasks.length} T3 workers`,
@@ -3711,7 +4576,8 @@ Return ONLY the JSON array.`;
       systemPrompt: this.systemPromptOverride + T2_SYSTEM_PROMPT + (this.hierarchyContext ? `
 
 HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
-      maxTokens: 2e3
+      maxTokens: 2e3,
+      ...this.sectionModel ? { model: this.sectionModel } : {}
     });
     try {
       const jsonMatch = /\[[\s\S]*\]/.exec(result.content);
@@ -3815,6 +4681,8 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
     let remaining = new Set(sanitizedAssignments.map((a) => a.subtaskId));
     let wave = 0;
     let respawnBudget = 1;
+    const reinforceCfg = this.router.getReinforcementsConfig?.() ?? { enabled: false, maxPerSection: 4 };
+    let reinforcementsAdded = 0;
     while (remaining.size > 0) {
       const runnableIds = [...remaining].filter((id) => (inDegree.get(id) ?? 0) === 0);
       if (runnableIds.length === 0) {
@@ -3839,15 +4707,27 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
       const waveSignal = AbortSignal.any(
         [this.signal, this.waveAbortController.signal].filter(Boolean)
       );
-      const waveResults = await Promise.allSettled(
-        runnableIds.map(async (id) => {
-          const assignment = sanitizedAssignments.find((a) => a.subtaskId === id);
-          const worker = workerMap.get(id);
-          const result = await worker.execute(assignment, taskId, waveSignal);
-          resultMap.set(id, result);
-          return result;
-        })
-      );
+      const runOne = async (id) => {
+        const assignment = sanitizedAssignments.find((a) => a.subtaskId === id);
+        const worker = workerMap.get(id);
+        const result = await worker.execute(assignment, taskId, waveSignal);
+        resultMap.set(id, result);
+        return result;
+      };
+      let waveResults;
+      if (this.router.getT3ExecutionMode?.() === "sequential") {
+        this.log(`Wave ${wave}: running ${runnableIds.length} subtask(s) sequentially (local tier)`);
+        waveResults = [];
+        for (const id of runnableIds) {
+          try {
+            waveResults.push({ status: "fulfilled", value: await runOne(id) });
+          } catch (reason) {
+            waveResults.push({ status: "rejected", reason });
+          }
+        }
+      } else {
+        waveResults = await Promise.allSettled(runnableIds.map(runOne));
+      }
       const escalatedToolIdx = respawnBudget > 0 ? waveResults.findIndex(
         (r) => r.status === "fulfilled" && r.value.status === "ESCALATED" && r.value.issues.some((iss) => iss.includes("dynamic tool generation"))
       ) : -1;
@@ -3875,6 +4755,8 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
 [SYSTEM]: Dynamic tool "${toolName}" is now available \u2014 use it to complete your task.`;
             }
           }
+          const spec = this.toolCreator.getSpec(toolName);
+          if (spec) this.t3PeerBus.broadcast(this.id, { type: "TOOL_CREATED", spec });
         }
         for (const id of runnableIds) {
           this.t3PeerBus.clearOutput(id);
@@ -3920,6 +4802,35 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
           inDegree.set(dependent, Math.max(0, (inDegree.get(dependent) ?? 0) - 1));
         }
       }
+      if (reinforceCfg.enabled && reinforcementsAdded < reinforceCfg.maxPerSection) {
+        let addedThisWave = 0;
+        for (const id of runnableIds) {
+          for (const req of resultMap.get(id)?.reinforcements ?? []) {
+            if (reinforcementsAdded >= reinforceCfg.maxPerSection) break;
+            reinforcementsAdded++;
+            addedThisWave++;
+            const assignment = {
+              ...req,
+              subtaskId: `reinf-${this.id}-${reinforcementsAdded}`,
+              dependsOn: [],
+              peerT3Ids: []
+            };
+            sanitizedAssignments.push(assignment);
+            adj.set(assignment.subtaskId, /* @__PURE__ */ new Set());
+            inDegree.set(assignment.subtaskId, 0);
+            remaining.add(assignment.subtaskId);
+            const fresh = this.buildWorkerMap([assignment], taskId);
+            for (const [k, v] of fresh) {
+              v.markAsReinforcement();
+              workerMap.set(k, v);
+            }
+            this.log(`Reinforcement: spawned worker "${assignment.subtaskTitle}" (requested by ${id})`);
+          }
+        }
+        if (addedThisWave > 0) {
+          this.sendStatusUpdate({ progressPct: 55, currentAction: `Added ${addedThisWave} reinforcement worker(s)`, status: "IN_PROGRESS" });
+        }
+      }
     }
     return [...resultMap.values()];
   }
@@ -4029,7 +4940,8 @@ NEW OUTPUTS TO INTEGRATE:
           systemPrompt: this.systemPromptOverride + "You are a T2 Manager. Summarize the work of your T3 workers succinctly." + (this.hierarchyContext ? `
 
 HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
-          maxTokens: 500
+          maxTokens: 500,
+          ...this.sectionModel ? { model: this.sectionModel } : {}
         });
         currentSummary = result.content;
       } catch (err) {
@@ -4078,7 +4990,8 @@ Reply with exactly one word: YES, NO, or UNSURE.`;
 
 HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
         maxTokens: 10,
-        temperature: 0
+        temperature: 0,
+        ...this.sectionModel ? { model: this.sectionModel } : {}
       });
       const answer = result.content.trim().toUpperCase();
       if (answer.includes("YES")) {
@@ -4186,6 +5099,7 @@ var T1Administrator = class extends BaseTier {
   taskGoal = "";
   peerMessageCallback;
   peerMessageSessionId = "";
+  planApprovalCallback;
   constructor(router, toolRegistry, config) {
     super("T1", "T1");
     this.router = router;
@@ -4212,6 +5126,17 @@ var T1Administrator = class extends BaseTier {
     this.t2PeerBus.onPeerMessage = cb;
     this.t2PeerBus.sessionId = sessionId;
   }
+  /**
+   * Install a "boardroom" gate: called with T1's plan BEFORE any T2 manager
+   * spawns. When unset, plans proceed immediately (headless/SDK unchanged).
+   */
+  setPlanApprovalCallback(cb) {
+    this.planApprovalCallback = cb;
+  }
+  /** Decompose a prompt into a plan WITHOUT executing it (powers /plan preview). */
+  async previewPlan(prompt) {
+    return this.decomposeTask(prompt);
+  }
   async execute(userPrompt, images, systemContext, signal) {
     this.signal = signal;
     this.taskId = randomUUID();
@@ -4230,29 +5155,72 @@ var T1Administrator = class extends BaseTier {
       enrichedPrompt = await this.analyzeImages(userPrompt, images);
     }
     this.throwIfCancelled();
-    const plan = await this.decomposeTask(enrichedPrompt, systemContext);
-    this.sendStatusUpdate({
-      progressPct: 10,
-      currentAction: `Plan ready: ${plan.complexity} \u2192 ${plan.sections.length} sections`,
-      status: "IN_PROGRESS"
-    });
-    this.emit("plan", { taskId: this.taskId, plan });
-    this.throwIfCancelled();
+    let plan = await this.decomposeTask(enrichedPrompt, systemContext);
+    this.sendStatusUpdate({
+      progressPct: 10,
+      currentAction: `Plan ready: ${plan.complexity} \u2192 ${plan.sections.length} sections`,
+      status: "IN_PROGRESS"
+    });
+    this.emit("plan", { taskId: this.taskId, plan });
+    if (this.planApprovalCallback) {
+      const maxRounds = this.config.planReview?.maxRevisionRounds ?? 5;
+      const reviewer = this.config.planReview?.autoReviewer === true;
+      let round = 0;
+      for (; ; ) {
+        const critique = reviewer ? await this.reviewPlan(plan, enrichedPrompt) ?? void 0 : void 0;
+        this.sendStatusUpdate({
+          progressPct: 10,
+          currentAction: "Boardroom: waiting for plan approval",
+          status: "IN_PROGRESS"
+        });
+        const decision = await this.planApprovalCallback(plan, { critique });
+        if (!decision.approved) {
+          const output2 = "Plan rejected in the boardroom \u2014 nothing was executed. Rephrase the request or adjust the plan with a new prompt.";
+          this.setStatus("COMPLETED", output2);
+          this.sendStatusUpdate({ progressPct: 100, currentAction: "Plan rejected by user", status: "IN_PROGRESS", output: output2 });
+          return { output: output2, t2Results: [], taskId: this.taskId, complexity: plan.complexity };
+        }
+        if (decision.editedPlan?.sections?.length) {
+          plan = decision.editedPlan;
+          try {
+            this.validatePlan(plan);
+          } catch {
+          }
+          this.emit("plan", { taskId: this.taskId, plan });
+        }
+        if (decision.note?.trim() && round < maxRounds) {
+          round++;
+          this.log(`Boardroom note \u2014 re-planning (round ${round}/${maxRounds}): ${decision.note}`);
+          plan = await this.decomposeTask(
+            `${enrichedPrompt}
+
+Board guidance (must be followed in the plan): ${decision.note}`,
+            systemContext
+          );
+          this.emit("plan", { taskId: this.taskId, plan });
+          continue;
+        }
+        break;
+      }
+    }
+    this.throwIfCancelled();
     let allT2Results = await this.dispatchT2Managers(plan.sections);
     let pass = 1;
-    const MAX_REPLAN_PASSES = 2;
-    while (pass <= MAX_REPLAN_PASSES) {
+    const maxReplanPasses = this.config.maxReplanPasses ?? 2;
+    const okCount = (rs) => rs.filter((r) => r.status === "COMPLETED" || r.status === "PARTIAL").length;
+    while (pass <= maxReplanPasses) {
       const reviewResult = await this.reviewT2Outputs(enrichedPrompt, plan, allT2Results);
       if (reviewResult.approved) {
         this.log("T1 Review passed.");
         break;
       }
-      this.log(`T1 Review rejected outputs. Replanning (Pass ${pass}). Reason: ${reviewResult.reason}`);
+      this.log(`T1 Review rejected outputs. Replanning (Pass ${pass}/${maxReplanPasses}). Reason: ${reviewResult.reason}`);
       this.sendStatusUpdate({
         progressPct: 80 + pass * 5,
         currentAction: `Review failed: ${reviewResult.reason}. Replanning...`,
         status: "IN_PROGRESS"
       });
+      const okBefore = okCount(allT2Results);
       const correctionPlan = await this.decomposeTask(`The previous execution plan failed to fully satisfy the original goal or encountered errors.
 Review reason: ${reviewResult.reason}
 
@@ -4261,6 +5229,10 @@ Original goal: ${enrichedPrompt}
 Create a CORRECTION PLAN that contains only the new sections needed to fix the issues. Do not repeat successful sections.`);
       const correctionResults = await this.dispatchT2Managers(correctionPlan.sections);
       allT2Results = [...allT2Results, ...correctionResults];
+      if (okCount(allT2Results) <= okBefore) {
+        this.log("T1 Review: corrective pass made no net progress \u2014 stopping early with the best partial result.");
+        break;
+      }
       pass++;
     }
     this.sendStatusUpdate({
@@ -4329,6 +5301,34 @@ If no, reply with "REJECTED: [Detailed reason explaining exactly what is missing
 
 [Image context: ${result.content}]`;
   }
+  /**
+   * Automated reviewer pass: a single T1 critique of the plan before the user
+   * sees it (planReview.autoReviewer). Best-effort — returns null on any error
+   * so it never blocks the approval gate.
+   */
+  async reviewPlan(plan, goal) {
+    try {
+      const sections = plan.sections.map((s, i) => `${i + 1}. ${s.sectionTitle} \u2014 ${s.description} (${s.t3Subtasks?.length ?? 0} subtasks${s.dependsOn?.length ? `, depends on: ${s.dependsOn.join(", ")}` : ""})`).join("\n");
+      const prompt = `You are a senior engineer reviewing an execution plan BEFORE it runs.
+
+GOAL:
+${goal}
+
+PLAN (${plan.complexity}, ${plan.sections.length} sections):
+${sections}
+
+In 3-5 terse bullets, flag the most important RISKS, GAPS, or over-/under-decomposition the operator should weigh before approving. If the plan is sound, say so in one line. Output plain-text bullets only - no preamble.`;
+      const result = await this.router.generate("T1", {
+        messages: [{ role: "user", content: prompt }],
+        systemPrompt: "You are a concise, critical plan reviewer. Be specific and brief.",
+        maxTokens: 400
+      });
+      const text = (result.content ?? "").trim();
+      return text.length ? text : null;
+    } catch {
+      return null;
+    }
+  }
   async decomposeTask(prompt, systemContext) {
     const contextSection = systemContext ? `
 Project context:
@@ -4628,7 +5628,14 @@ Leave dependsOn empty for sections that can run immediately in parallel.`;
   async compileFinalOutput(originalPrompt, plan, t2Results) {
     const completedSections = t2Results.filter((r) => r.status !== "FAILED");
     if (!completedSections.length) {
-      return "Task failed \u2014 all sections encountered errors. Please check the escalation log.";
+      const allIssues = t2Results.flatMap((r) => r.t3Results.flatMap((t) => t.issues));
+      const critical = allIssues.find((i) => i.includes("[CRITICAL_TOOL_ERROR]"));
+      const stalled = allIssues.find((i) => /^Stalled:/.test(i));
+      const topReason = critical ?? stalled ?? allIssues[0] ?? "no specific reason recorded";
+      const sectionWord = t2Results.length === 1 ? "section" : "sections";
+      return `Task failed \u2014 ${topReason}
+
+All ${t2Results.length} ${sectionWord} encountered errors. Run \`/logs\` for details.`;
     }
     const sectionsText = completedSections.map((r) => `**${r.sectionTitle}**
 ${r.sectionSummary}
@@ -4748,7 +5755,7 @@ var ShellTool = class extends BaseTool {
     const timeout = input["timeout"] ?? 3e4;
     this.validateCommand(command);
     try {
-      const { stdout, stderr } = await execAsync(command, { cwd, timeout });
+      const { stdout, stderr } = await execAsync(command, { cwd, timeout, windowsHide: true });
       const out = [stdout, stderr].filter(Boolean).join("\n").trim();
       return out || "(no output)";
     } catch (err) {
@@ -4762,11 +5769,14 @@ ${[e.stdout, e.stderr].filter(Boolean).join("\n").trim()}`;
   }
   validateCommand(command) {
     const builtinDangerous = [
-      /rm\s+-rf\s+\//,
-      />\s*\/dev\/sda/,
-      /mkfs\./,
-      /dd\s+if=.*of=\/dev\//,
-      /chmod\s+777\s+\//
+      /\brm\s+(?:-\w+\s+)*-\w*[rf]\w*[rf]\w*\s+(?:\/|~|\$HOME)(?:\s|$)/,
+      // rm -rf / , rm -fr ~
+      />\s*\/dev\/[sh]d[a-z]/,
+      /\bmkfs[.\s]/,
+      /\bdd\s+.*\bof=\/dev\/[sh]d[a-z]/,
+      /\bchmod\s+(?:-\w+\s+)*-?R?\s*777\s+\//,
+      /:\(\)\s*\{\s*:\s*\|\s*:?\s*&\s*\}\s*;/
+      // fork bomb :(){ :|:& };:
     ];
     for (const pattern of builtinDangerous) {
       if (pattern.test(command)) {
@@ -4805,16 +5815,16 @@ function resolveInWorkspace(workspaceRoot, input) {
   if (typeof input !== "string" || input.length === 0) {
     throw new WorkspaceSandboxError(String(input), workspaceRoot);
   }
-  const root = path16.resolve(workspaceRoot);
-  const abs = path16.isAbsolute(input) ? path16.resolve(input) : path16.resolve(root, input);
-  const rel = path16.relative(root, abs);
-  if (rel === "" || rel === ".") ; else if (rel.startsWith("..") || path16.isAbsolute(rel)) {
+  const root = path18.resolve(workspaceRoot);
+  const abs = path18.isAbsolute(input) ? path18.resolve(input) : path18.resolve(root, input);
+  const rel = path18.relative(root, abs);
+  if (rel === "" || rel === ".") ; else if (rel.startsWith("..") || path18.isAbsolute(rel)) {
     throw new WorkspaceSandboxError(input, root);
   }
   try {
-    const real = fs15.realpathSync(abs);
-    const realRel = path16.relative(root, real);
-    if (realRel !== "" && realRel !== "." && (realRel.startsWith("..") || path16.isAbsolute(realRel))) {
+    const real = fs17.realpathSync(abs);
+    const realRel = path18.relative(root, real);
+    if (realRel !== "" && realRel !== "." && (realRel.startsWith("..") || path18.isAbsolute(realRel))) {
       throw new WorkspaceSandboxError(input, root);
     }
   } catch (e) {
@@ -4841,7 +5851,7 @@ var FileReadTool = class extends BaseTool {
     const absPath = resolveInWorkspace(this.workspaceRoot, filePath);
     const offset = input["offset"] ?? 1;
     const limit = input["limit"];
-    const content = await fs3.readFile(absPath, "utf-8");
+    const content = await fs4.readFile(absPath, "utf-8");
     const lines = content.split("\n");
     const start = Math.max(0, offset - 1);
     const end = limit ? start + limit : lines.length;
@@ -4870,13 +5880,13 @@ var FileWriteTool = class extends BaseTool {
     const content = input["content"];
     if (options.saveSnapshot) {
       try {
-        const oldContent = await fs3.readFile(absPath, "utf-8");
+        const oldContent = await fs4.readFile(absPath, "utf-8");
         await options.saveSnapshot(absPath, oldContent);
       } catch {
       }
     }
-    await fs3.mkdir(path16.dirname(absPath), { recursive: true });
-    await fs3.writeFile(absPath, content, "utf-8");
+    await fs4.mkdir(path18.dirname(absPath), { recursive: true });
+    await fs4.writeFile(absPath, content, "utf-8");
     return `Written ${content.length} characters to ${filePath}`;
   }
 };
@@ -4902,7 +5912,7 @@ var FileEditTool = class extends BaseTool {
     const oldString = input["old_string"];
     const newString = input["new_string"];
     const replaceAll = input["replace_all"] ?? false;
-    const rawContent = await fs3.readFile(absPath, "utf-8");
+    const rawContent = await fs4.readFile(absPath, "utf-8");
     if (options.saveSnapshot) {
       await options.saveSnapshot(absPath, rawContent);
     }
@@ -4914,7 +5924,7 @@ var FileEditTool = class extends BaseTool {
       );
     }
     const updated = replaceAll ? content.split(normalizedOld).join(newString) : content.replace(normalizedOld, newString);
-    await fs3.writeFile(absPath, updated, "utf-8");
+    await fs4.writeFile(absPath, updated, "utf-8");
     const count = replaceAll ? content.split(normalizedOld).length - 1 : 1;
     return `Replaced ${count} occurrence(s) in ${filePath}`;
   }
@@ -4937,12 +5947,12 @@ var FileDeleteTool = class extends BaseTool {
     const absPath = resolveInWorkspace(this.workspaceRoot, filePath);
     if (options.saveSnapshot) {
       try {
-        const oldContent = await fs3.readFile(absPath, "utf-8");
+        const oldContent = await fs4.readFile(absPath, "utf-8");
         await options.saveSnapshot(absPath, oldContent);
       } catch {
       }
     }
-    await fs3.rm(absPath, { recursive: false });
+    await fs4.rm(absPath, { recursive: false });
     return `Deleted ${filePath}`;
   }
 };
@@ -4959,7 +5969,7 @@ var FileListTool = class extends BaseTool {
   async execute(input, _options) {
     const inputPath = input["path"] || ".";
     const absPath = resolveInWorkspace(this.workspaceRoot, inputPath);
-    const entries = await fs3.readdir(absPath, { withFileTypes: true });
+    const entries = await fs4.readdir(absPath, { withFileTypes: true });
     return entries.map((e) => `${e.isDirectory() ? "[DIR] " : "      "}${e.name}`).join("\n") || "(empty directory)";
   }
 };
@@ -5052,6 +6062,8 @@ var GitTool = class extends BaseTool {
     return lines.join("\n") || "Working tree clean";
   }
 };
+
+// src/tools/github.ts
 var GitHubTool = class extends BaseTool {
   name = "github";
   description = "Interact with GitHub or GitLab: create PRs, list issues, comment on issues.";
@@ -5076,6 +6088,34 @@ var GitHubTool = class extends BaseTool {
   isDangerous() {
     return true;
   }
+  // ── fetch helpers (replace axios) ──────────────
+  async request(url, init) {
+    const res = await fetch(url, init);
+    const text = await res.text();
+    let data;
+    try {
+      data = text ? JSON.parse(text) : void 0;
+    } catch {
+      data = text;
+    }
+    if (!res.ok) {
+      const err = new Error(`HTTP ${res.status}`);
+      err.status = res.status;
+      err.data = data;
+      throw err;
+    }
+    return data;
+  }
+  apiGet(url, headers) {
+    return this.request(url, { headers });
+  }
+  apiPost(url, body, headers) {
+    return this.request(url, {
+      method: "POST",
+      headers: { ...headers, "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  }
   async execute(input, _options) {
     const platform = input["platform"] ?? "github";
     const operation = input["operation"];
@@ -5098,10 +6138,10 @@ var GitHubTool = class extends BaseTool {
       }
       return await this.executeGitLab(operation, repo, token, input);
     } catch (err) {
-      const axiosErr = err;
-      if (axiosErr?.response?.status) {
-        const status = axiosErr.response.status;
-        const msg = axiosErr.response.data?.message ?? "";
+      const httpErr = err;
+      if (httpErr?.status) {
+        const status = httpErr.status;
+        const msg = httpErr.data?.message ?? "";
         switch (status) {
           case 401:
             return `Authentication failed: Your ${platform} token is invalid or expired. Check your token and try again.`;
@@ -5114,10 +6154,10 @@ var GitHubTool = class extends BaseTool {
           case 429:
             return `Rate limited by ${platform}. Please wait a moment before trying again.`;
           default:
-            return `${platform} API error (${status}): ${msg || (axiosErr.message ?? "Unknown error")}`;
+            return `${platform} API error (${status}): ${msg || (httpErr.message ?? "Unknown error")}`;
         }
       }
-      return `${platform} request failed: ${axiosErr.message ?? String(err)}`;
+      return `${platform} request failed: ${httpErr.message ?? String(err)}`;
     }
   }
   async executeGitHub(operation, repo, token, input) {
@@ -5128,35 +6168,35 @@ var GitHubTool = class extends BaseTool {
     const base = `https://api.github.com/repos/${repo}`;
     switch (operation) {
       case "list_issues": {
-        const response = await axios2.get(`${base}/issues`, { headers });
-        return response.data.map((i) => `#${i.number} [${i.state}] ${i.title}`).join("\n");
+        const data = await this.apiGet(`${base}/issues`, headers);
+        return data.map((i) => `#${i.number} [${i.state}] ${i.title}`).join("\n");
       }
       case "list_prs": {
-        const response = await axios2.get(`${base}/pulls`, { headers });
-        return response.data.map((p) => `#${p.number} [${p.state}] ${p.title} (${p.head.ref} \u2192 ${p.base.ref})`).join("\n");
+        const data = await this.apiGet(`${base}/pulls`, headers);
+        return data.map((p) => `#${p.number} [${p.state}] ${p.title} (${p.head.ref} \u2192 ${p.base.ref})`).join("\n");
       }
       case "create_pr": {
-        const response = await axios2.post(`${base}/pulls`, {
+        const data = await this.apiPost(`${base}/pulls`, {
           title: input["title"],
           body: input["body"] ?? "",
           head: input["head"],
           base: input["base"] ?? "main"
-        }, { headers });
-        return `Created PR #${response.data.number}: ${response.data.html_url}`;
+        }, headers);
+        return `Created PR #${data.number}: ${data.html_url}`;
       }
       case "comment_issue": {
         const num = input["issue_number"];
-        await axios2.post(`${base}/issues/${num}/comments`, { body: input["body"] }, { headers });
+        await this.apiPost(`${base}/issues/${num}/comments`, { body: input["body"] }, headers);
         return `Comment added to #${num}`;
       }
       case "get_pr": {
         const num = input["issue_number"];
-        const response = await axios2.get(`${base}/pulls/${num}`, { headers });
-        return `PR #${num}: ${response.data.title}
-State: ${response.data.state}
-${response.data.html_url}
+        const data = await this.apiGet(`${base}/pulls/${num}`, headers);
+        return `PR #${num}: ${data.title}
+State: ${data.state}
+${data.html_url}
 
-${response.data.body}`;
+${data.body}`;
       }
       default:
         throw new Error(`Unknown GitHub operation: ${operation}`);
@@ -5168,35 +6208,35 @@ ${response.data.body}`;
     const base = `https://gitlab.com/api/v4/projects/${encodedRepo}`;
     switch (operation) {
       case "list_issues": {
-        const response = await axios2.get(`${base}/issues`, { headers });
-        return response.data.map((i) => `#${i.iid} [${i.state}] ${i.title}`).join("\n");
+        const data = await this.apiGet(`${base}/issues`, headers);
+        return data.map((i) => `#${i.iid} [${i.state}] ${i.title}`).join("\n");
       }
       case "create_pr": {
-        const response = await axios2.post(`${base}/merge_requests`, {
+        const data = await this.apiPost(`${base}/merge_requests`, {
           title: input["title"],
           description: input["body"] ?? "",
           source_branch: input["head"],
           target_branch: input["base"] ?? "main"
-        }, { headers });
-        return `Created MR !${response.data.iid}: ${response.data.web_url}`;
+        }, headers);
+        return `Created MR !${data.iid}: ${data.web_url}`;
       }
       case "list_prs": {
-        const response = await axios2.get(`${base}/merge_requests`, { headers });
-        return response.data.map((p) => `!${p.iid} [${p.state}] ${p.title} (${p.source_branch} \u2192 ${p.target_branch})`).join("\n");
+        const data = await this.apiGet(`${base}/merge_requests`, headers);
+        return data.map((p) => `!${p.iid} [${p.state}] ${p.title} (${p.source_branch} \u2192 ${p.target_branch})`).join("\n");
       }
       case "comment_issue": {
         const num = input["issue_number"];
-        await axios2.post(`${base}/issues/${num}/notes`, { body: input["body"] }, { headers });
+        await this.apiPost(`${base}/issues/${num}/notes`, { body: input["body"] }, headers);
         return `Comment added to #${num}`;
       }
       case "get_pr": {
         const num = input["issue_number"];
-        const response = await axios2.get(`${base}/merge_requests/${num}`, { headers });
-        return `MR !${num}: ${response.data.title}
-State: ${response.data.state}
-${response.data.web_url}
+        const data = await this.apiGet(`${base}/merge_requests/${num}`, headers);
+        return `MR !${num}: ${data.title}
+State: ${data.state}
+${data.web_url}
 
-${response.data.description}`;
+${data.description}`;
       }
       default:
         throw new Error(`GitLab operation not supported: ${operation}`);
@@ -5342,8 +6382,8 @@ var ImageAnalyzeTool = class extends BaseTool {
   }
 };
 async function fileToImageAttachment(filePath) {
-  const data = await fs3.readFile(filePath);
-  const ext = path16.extname(filePath).toLowerCase();
+  const data = await fs4.readFile(filePath);
+  const ext = path18.extname(filePath).toLowerCase();
   const mimeMap = {
     ".jpg": "image/jpeg",
     ".jpeg": "image/jpeg",
@@ -5377,14 +6417,14 @@ var PDFCreateTool = class extends BaseTool {
     const filePath = input["path"];
     const content = input["content"];
     const title = input["title"];
-    const dir = path16.dirname(filePath);
-    if (!fs15.existsSync(dir)) {
-      fs15.mkdirSync(dir, { recursive: true });
+    const dir = path18.dirname(filePath);
+    if (!fs17.existsSync(dir)) {
+      fs17.mkdirSync(dir, { recursive: true });
     }
     return new Promise((resolve, reject) => {
       try {
         const doc = new PDFDocument({ margin: 50 });
-        const stream = fs15.createWriteStream(filePath);
+        const stream = fs17.createWriteStream(filePath);
         doc.pipe(stream);
         if (title) {
           doc.info["Title"] = title;
@@ -5462,24 +6502,22 @@ var CodeInterpreterTool = class extends BaseTool {
       }
       cmdPrefix = NODE_CMD;
     }
-    const tmpDir = path16.join(process.cwd(), ".cascade", "tmp");
-    if (!fs15.existsSync(tmpDir)) {
-      fs15.mkdirSync(tmpDir, { recursive: true });
+    const tmpDir = path18.join(this.workspaceRoot, ".cascade", "tmp");
+    if (!fs17.existsSync(tmpDir)) {
+      fs17.mkdirSync(tmpDir, { recursive: true });
     }
     const extension = language === "python" ? "py" : "js";
     const fileName = `intp_${randomUUID().slice(0, 8)}.${extension}`;
-    const filePath = path16.join(tmpDir, fileName);
-    fs15.writeFileSync(filePath, code, "utf-8");
-    const quotedPath = `"${filePath}"`;
-    const quotedArgs = args.map((a) => `"${a}"`).join(" ");
-    const fullCmd = `${cmdPrefix} ${quotedPath}${quotedArgs ? " " + quotedArgs : ""}`;
+    const filePath = path18.join(tmpDir, fileName);
+    fs17.writeFileSync(filePath, code, "utf-8");
+    const execArgs = [filePath, ...args];
     return new Promise((resolve) => {
       const startMs = Date.now();
-      exec(fullCmd, { cwd: process.cwd(), timeout: 3e4 }, (error, stdout, stderr) => {
+      execFile(cmdPrefix, execArgs, { cwd: this.workspaceRoot, timeout: 3e4 }, (error, stdout, stderr) => {
         const duration = Date.now() - startMs;
         try {
-          if (fs15.existsSync(filePath)) {
-            fs15.unlinkSync(filePath);
+          if (fs17.existsSync(filePath)) {
+            fs17.unlinkSync(filePath);
           }
         } catch (cleanupErr) {
           console.error(`Failed to cleanup interpreter script ${filePath}:`, cleanupErr);
@@ -5758,7 +6796,7 @@ var GlobTool = class extends BaseTool {
   };
   async execute(input, _options) {
     const pattern = input["pattern"];
-    const searchPath = input["path"] ? path16.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
+    const searchPath = input["path"] ? path18.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
     const matches = await glob(pattern, {
       cwd: searchPath,
       ignore: ["node_modules/**", ".git/**", "dist/**", "build/**"],
@@ -5771,7 +6809,7 @@ var GlobTool = class extends BaseTool {
     const withMtime = await Promise.all(
       matches.map(async (rel) => {
         try {
-          const stat = await fs3.stat(path16.join(searchPath, rel));
+          const stat = await fs4.stat(path18.join(searchPath, rel));
           return { rel, mtime: stat.mtimeMs };
         } catch {
           return { rel, mtime: 0 };
@@ -5820,7 +6858,7 @@ var GrepTool = class extends BaseTool {
   };
   async execute(input, _options) {
     const pattern = input["pattern"];
-    const searchPath = input["path"] ? path16.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
+    const searchPath = input["path"] ? path18.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
     const globPattern = input["glob"];
     const outputMode = input["output_mode"] ?? "content";
     const context = input["context"] ?? 0;
@@ -5874,15 +6912,15 @@ var GrepTool = class extends BaseTool {
         nodir: true
       });
     } catch {
-      files = [path16.relative(searchPath, searchPath) || "."];
+      files = [path18.relative(searchPath, searchPath) || "."];
     }
     const results = [];
     let totalCount = 0;
     for (const rel of files) {
-      const abs = path16.join(searchPath, rel);
+      const abs = path18.join(searchPath, rel);
       let content;
       try {
-        content = await fs3.readFile(abs, "utf-8");
+        content = await fs4.readFile(abs, "utf-8");
       } catch {
         continue;
       }
@@ -5920,6 +6958,92 @@ Total: ${totalCount} matches`);
     return results.join("\n");
   }
 };
+var SsrfBlockedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SsrfBlockedError";
+  }
+};
+var ALLOWED_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+var MAX_REDIRECTS = 5;
+function allowLocal() {
+  return process.env["CASCADE_ALLOW_LOCAL_FETCH"] === "1";
+}
+function isPrivateAddress(ip) {
+  const type = net.isIP(ip);
+  if (type === 4) return isPrivateIPv4(ip);
+  if (type === 6) return isPrivateIPv6(ip);
+  return true;
+}
+function isPrivateIPv4(ip) {
+  const parts = ip.split(".").map((p) => Number(p));
+  if (parts.length !== 4 || parts.some((p) => Number.isNaN(p) || p < 0 || p > 255)) return true;
+  const [a, b] = parts;
+  if (a === 0) return true;
+  if (a === 10) return true;
+  if (a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a >= 224) return true;
+  return false;
+}
+function isPrivateIPv6(ip) {
+  const lower = ip.toLowerCase().replace(/^\[|\]$/g, "");
+  if (lower === "::1" || lower === "::") return true;
+  if (lower.startsWith("fe80")) return true;
+  if (lower.startsWith("fc") || lower.startsWith("fd")) return true;
+  const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(lower);
+  if (mapped) return isPrivateIPv4(mapped[1]);
+  return false;
+}
+async function assertPublicUrl(rawUrl) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    throw new SsrfBlockedError(`Invalid URL: ${rawUrl}`);
+  }
+  if (!ALLOWED_PROTOCOLS.has(url.protocol)) {
+    throw new SsrfBlockedError(`Blocked URL scheme "${url.protocol}" \u2014 only http and https are allowed.`);
+  }
+  if (allowLocal()) return url;
+  const host = url.hostname.replace(/^\[|\]$/g, "");
+  if (net.isIP(host)) {
+    if (isPrivateAddress(host)) {
+      throw new SsrfBlockedError(`Blocked request to non-public address ${host}.`);
+    }
+    return url;
+  }
+  if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local")) {
+    throw new SsrfBlockedError(`Blocked request to local hostname "${host}".`);
+  }
+  let addresses;
+  try {
+    const records = await dns.lookup(host, { all: true });
+    addresses = records.map((r) => r.address);
+  } catch {
+    throw new SsrfBlockedError(`Could not resolve host "${host}".`);
+  }
+  if (addresses.length === 0 || addresses.some((addr) => isPrivateAddress(addr))) {
+    throw new SsrfBlockedError(`Blocked request to "${host}" \u2014 resolves to a non-public address.`);
+  }
+  return url;
+}
+async function safeFetch(rawUrl, init = {}) {
+  let currentUrl = (await assertPublicUrl(rawUrl)).toString();
+  for (let i = 0; i <= MAX_REDIRECTS; i++) {
+    const resp = await fetch(currentUrl, { ...init, redirect: "manual" });
+    if (resp.status < 300 || resp.status >= 400) return resp;
+    const location = resp.headers.get("location");
+    if (!location) return resp;
+    const next = new URL(location, currentUrl);
+    await assertPublicUrl(next.toString());
+    currentUrl = next.toString();
+  }
+  throw new SsrfBlockedError(`Too many redirects (>${MAX_REDIRECTS}).`);
+}
 
 // src/tools/web-fetch.ts
 var MAX_CHARS = 5e4;
@@ -5953,15 +7077,17 @@ var WebFetchTool = class extends BaseTool {
     const url = input["url"];
     let resp;
     try {
-      resp = await fetch(url, {
+      resp = await safeFetch(url, {
         headers: {
           "User-Agent": "Cascade-AI/1.0 WebFetchTool",
           Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,text/plain;q=0.8,*/*;q=0.5"
         },
-        signal: AbortSignal.timeout(TIMEOUT_MS),
-        redirect: "follow"
+        signal: AbortSignal.timeout(TIMEOUT_MS)
       });
     } catch (err) {
+      if (err instanceof SsrfBlockedError) {
+        return `Refused to fetch ${url}: ${err.message}`;
+      }
       return `Failed to fetch ${url}: ${err instanceof Error ? err.message : String(err)}`;
     }
     if (!resp.ok) {
@@ -6153,10 +7279,10 @@ var ToolRegistry = class extends EventEmitter {
   }
   isIgnored(filePath) {
     if (!filePath) return false;
-    const abs = path16.resolve(this.workspaceRoot, filePath);
-    const rel = path16.relative(this.workspaceRoot, abs);
-    if (!rel || rel.startsWith("..") || path16.isAbsolute(rel)) return true;
-    const posixRel = rel.split(path16.sep).join("/");
+    const abs = path18.resolve(this.workspaceRoot, filePath);
+    const rel = path18.relative(this.workspaceRoot, abs);
+    if (!rel || rel.startsWith("..") || path18.isAbsolute(rel)) return true;
+    const posixRel = rel.split(path18.sep).join("/");
     return this.ignoreMatcher.ignores(posixRel);
   }
 };
@@ -6180,9 +7306,11 @@ var McpClient = class _McpClient {
   tools = /* @__PURE__ */ new Map();
   trustedServers;
   approvalCallback;
+  onWarn;
   constructor(options = {}) {
     this.trustedServers = new Set(options.trustedServers ?? []);
     this.approvalCallback = options.approvalCallback;
+    this.onWarn = options.onWarn ?? ((message) => console.warn(message));
   }
   async connect(server) {
     if (!this.trustedServers.has(server.name)) {
@@ -6211,7 +7339,7 @@ var McpClient = class _McpClient {
     for (const tool of toolsResult.tools) {
       for (const existing of this.tools.values()) {
         if (existing.name === tool.name && existing.serverName !== server.name) {
-          console.warn(
+          this.onWarn(
             `[mcp] Tool "${tool.name}" is exposed by both "${existing.serverName}" and "${server.name}". Cascade disambiguates internally via mcp::<server>::<tool>.`
           );
           break;
@@ -6291,6 +7419,19 @@ var PermissionEscalator = class extends EventEmitter {
   t1Evaluator;
   /** Pending user-decision resolvers keyed by request ID */
   pendingUserDecisions = /* @__PURE__ */ new Map();
+  /** ms to wait for a user approval decision before denying for safety. */
+  approvalTimeoutMs;
+  /** Autonomous mode (autonomy: 'auto'): non-dangerous tools auto-approve. */
+  autonomous;
+  constructor(approvalTimeoutMs = 6e5, autonomous = false) {
+    super();
+    this.approvalTimeoutMs = approvalTimeoutMs;
+    this.autonomous = autonomous;
+  }
+  /** Toggle autonomous auto-approval at runtime (e.g. from /auto). */
+  setAutonomous(on) {
+    this.autonomous = on;
+  }
   setT2Evaluator(evaluator) {
     this.t2Evaluator = evaluator;
   }
@@ -6303,7 +7444,7 @@ var PermissionEscalator = class extends EventEmitter {
    */
   async requestPermission(req) {
     const cacheKey = `${req.parentT2Id}:${req.toolName}`;
-    if (this.sessionCache.has(cacheKey)) {
+    if (!req.forceReprompt && this.sessionCache.has(cacheKey)) {
       return {
         requestId: req.id,
         approved: this.sessionCache.get(cacheKey),
@@ -6323,6 +7464,15 @@ var PermissionEscalator = class extends EventEmitter {
       this.sessionCache.set(cacheKey, true);
       return decision;
     }
+    if (this.autonomous && !req.isDangerous) {
+      return {
+        requestId: req.id,
+        approved: true,
+        always: false,
+        decidedBy: "T1",
+        reasoning: "Autonomous mode \u2014 non-dangerous tool auto-approved"
+      };
+    }
     if (this.t2Evaluator) {
       try {
         const t2Decision = await this.t2Evaluator(req);
@@ -6363,13 +7513,28 @@ var PermissionEscalator = class extends EventEmitter {
   }
   waitForUserDecision(req) {
     return new Promise((resolve) => {
+      let timer;
       const wrappedResolver = (decision) => {
+        if (timer) clearTimeout(timer);
         if (decision.always) {
           this.sessionCache.set(`${req.parentT2Id}:${req.toolName}`, decision.approved);
         }
         resolve(decision);
       };
       this.pendingUserDecisions.set(req.id, wrappedResolver);
+      if (this.approvalTimeoutMs > 0 && Number.isFinite(this.approvalTimeoutMs)) {
+        timer = setTimeout(() => {
+          if (this.pendingUserDecisions.delete(req.id)) {
+            resolve({
+              requestId: req.id,
+              approved: false,
+              decidedBy: "USER",
+              reasoning: `Approval timed out after ${this.approvalTimeoutMs}ms \u2014 denied for safety`
+            });
+          }
+        }, this.approvalTimeoutMs);
+        timer.unref?.();
+      }
       this.emit("permission:user-required", req);
     });
   }
@@ -6387,11 +7552,14 @@ var PermissionEscalator = class extends EventEmitter {
 };
 var ProviderConfigSchema = z.object({
   type: z.enum(["anthropic", "openai", "gemini", "azure", "openai-compatible", "ollama"]),
+  label: z.string().optional(),
   apiKey: z.string().optional(),
   baseUrl: z.string().url().optional(),
   deploymentName: z.string().optional(),
   apiVersion: z.string().optional(),
-  model: z.string().optional()
+  model: z.string().optional(),
+  authToken: z.string().optional(),
+  credentialSource: z.string().optional()
 });
 var ModelOverridesSchema = z.object({
   t1: z.string().optional(),
@@ -6421,10 +7589,12 @@ var ToolsConfigSchema = z.object({
   requireApprovalFor: z.array(z.string()).default([]),
   browserEnabled: z.boolean().default(false),
   mcpServers: z.array(McpServerConfigSchema).optional(),
+  mcpTrusted: z.array(z.string()).optional(),
   /** Web search backends — at least one should be configured for best results */
   webSearch: WebSearchConfigSchema.optional()
 });
 var HookDefinitionSchema = z.object({
+  name: z.string().optional(),
   command: z.string(),
   tools: z.array(z.string()).optional(),
   timeout: z.number().optional()
@@ -6437,6 +7607,13 @@ var HooksConfigSchema = z.object({
 });
 var DashboardConfigSchema = z.object({
   port: z.number().default(4891),
+  /**
+   * Interface to bind the dashboard HTTP/WebSocket server to. Defaults to
+   * loopback so the dashboard — which exposes /api/run (arbitrary task
+   * execution) and config mutation — is never reachable from the network
+   * unless the operator explicitly opts in (e.g. "0.0.0.0" for team mode).
+   */
+  host: z.string().default("127.0.0.1"),
   auth: z.boolean().default(true),
   teamMode: z.enum(["single", "multi"]).default("single"),
   secret: z.string().optional()
@@ -6459,6 +7636,15 @@ var TierLimitsSchema = z.object({
 var BudgetConfigSchema = z.object({
   dailyBudgetUsd: z.number().optional(),
   sessionBudgetUsd: z.number().optional(),
+  /**
+   * Hard per-task token ceiling. A single `cascade run` is stopped once its
+   * combined token usage crosses this, so a mis-routed trivial task can never
+   * fan out into a runaway multi-agent burn. Resets every run. Raise it for
+   * genuinely large jobs. Defaults to 200k.
+   */
+  maxTokensPerRun: z.number().int().positive().default(2e5),
+  /** Optional hard per-task cost ceiling (USD). Unset = only the token cap applies. */
+  maxCostPerRunUsd: z.number().positive().optional(),
   warnAtPct: z.number().default(80)
 });
 var WorkspaceConfigSchema = z.object({
@@ -6487,6 +7673,32 @@ var CascadeConfigSchema = z.object({
    * Heuristic-first with AI inference fallback (adds ~0–500ms per task).
    */
   cascadeAuto: z.boolean().default(false),
+  /**
+   * Cascade Auto trade-off bias when picking a model for a task:
+   *   - 'balanced' (default): quality × cost-efficiency — cheap models win
+   *     trivial tasks, strong models win hard ones.
+   *   - 'quality': pick the highest-benchmark model; cost only breaks ties.
+   *   - 'cost': pick the cheapest model that clears a per-task quality floor.
+   */
+  autoBias: z.enum(["balanced", "quality", "cost"]).default("balanced"),
+  /**
+   * Public-benchmark data source for Cascade Auto. All fields have safe
+   * defaults so zero config "just works" — live data is fetched in the
+   * background and the bundled snapshot is used until it arrives (or offline).
+   */
+  benchmarks: z.object({
+    /** Fetch current quality scores from a public source. Default: true. */
+    live: z.boolean().default(true),
+    /** How long a fetched snapshot stays fresh before re-fetching (hours). */
+    refreshHours: z.number().min(0).default(24),
+    /**
+     * Override the quality-benchmark source URL (must return the snapshot
+     * JSON shape). When unset, the maintained GitHub-raw snapshot is used.
+     */
+    sourceUrl: z.string().url().optional(),
+    /** Fetch current per-token prices from OpenRouter (free, no key). */
+    pricingLive: z.boolean().default(true)
+  }).default({}),
   /**
    * Runtime Tool Creation: when true, T3 workers can generate and register new tools
    * at runtime via the ToolCreator when no existing tool can handle a required operation.
@@ -6494,6 +7706,13 @@ var CascadeConfigSchema = z.object({
    * HTTP calls from generated tools require approval.
    */
   enableToolCreation: z.boolean().default(true),
+  /**
+   * Persist runtime-generated tools to .cascade/dynamic-tools.json and reload them
+   * on startup for cross-run dedup. Reloaded (and peer-received) tools are always
+   * treated as UNTRUSTED — their dangerous actions re-escalate. Set false to disable
+   * persistence entirely.
+   */
+  persistDynamicTools: z.boolean().default(true),
   /**
    * External plugin paths or npm package names to load at startup.
    * Each entry must export a default ToolPlugin object.
@@ -6510,7 +7729,89 @@ var CascadeConfigSchema = z.object({
    * Timeout in milliseconds for a single local model inference call.
    * Local models can take minutes for large parameter counts. Default: 5 minutes.
    */
-  localInferenceTimeoutMs: z.number().int().min(1e3).default(3e5)
+  localInferenceTimeoutMs: z.number().int().min(1e3).default(3e5),
+  /**
+   * Timeout (ms) for a single cloud LLM call (streaming or not). Guards against
+   * a stalled provider stream hanging the whole run with no output. On timeout
+   * the call errors and the worker escalates. Default: 2 minutes.
+   */
+  cloudInferenceTimeoutMs: z.number().int().min(1e3).default(12e4),
+  /**
+   * Timeout (ms) for a tool-approval decision. If no decision arrives in time the
+   * request is DENIED (never auto-approved) so the run continues rather than
+   * hanging on an unanswered prompt. Default: 10 minutes.
+   */
+  approvalTimeoutMs: z.number().int().min(1e3).default(6e5),
+  /**
+   * Boardroom plan approval: pause after the plan is produced so the user can
+   * review the org chart (sections, workers, estimated cost) before any worker
+   * spawns. Scope:
+   *   'never'   — never pause (default; no behavior change).
+   *   'complex' — pause Complex runs only ('always' is kept as an alias).
+   *   'all'     — pause Moderate and Complex runs.
+   * Headless/SDK consumers without a listener auto-approve, so pausing is safe
+   * outside the TUI.
+   */
+  planApproval: z.enum(["never", "complex", "all", "always"]).default("never"),
+  /**
+   * Plan-review behaviour for the boardroom gate:
+   *   autoReviewer      — a reviewer model critiques the plan (gaps/risks/cost)
+   *                       before you see it, and the critique is shown in the dialog.
+   *   editable          — allow editing the plan (drop sections) in the dialog.
+   *   maxRevisionRounds — how many steering-note → re-plan → re-ask rounds the
+   *                       boardroom allows before proceeding with the last plan.
+   */
+  planReview: z.object({
+    autoReviewer: z.boolean().default(false),
+    editable: z.boolean().default(true),
+    maxRevisionRounds: z.number().int().min(1).max(20).default(5)
+  }).default({}),
+  /**
+   * Autonomy level. 'manual' (default): plan + tool approvals prompt as usual.
+   * 'auto': hands-off — the plan gate auto-approves and the escalator
+   * auto-approves NON-dangerous tools, while dangerous tools still escalate and
+   * budget caps remain the hard stop. Toggle at runtime with /auto.
+   */
+  autonomy: z.enum(["manual", "auto"]).default("manual"),
+  /**
+   * Max corrective re-plan passes T1's reviewer runs before returning the best
+   * partial result. The run also stops early when a pass makes no net progress.
+   */
+  maxReplanPasses: z.number().int().min(0).max(10).default(2),
+  /**
+   * Reflection / self-critique. When enabled, after a worker's pass/fail self-test
+   * succeeds it runs a goal-alignment critique and revises once if the output is
+   * weak against the broader goal (not just the subtask spec). Off by default — it
+   * adds an LLM call per worker.
+   */
+  reflection: z.object({
+    enabled: z.boolean().default(false),
+    maxRounds: z.number().int().min(1).max(3).default(1)
+  }).default({}),
+  /**
+   * T3 worker execution within a dependency wave:
+   *   'auto' (default) — sequential when the T3 tier is a LOCAL model (a single
+   *     GPU serializes anyway, so parallel just thrashes the queue), parallel for
+   *     cloud models.
+   *   'parallel' / 'sequential' — force it.
+   */
+  t3Execution: z.enum(["auto", "parallel", "sequential"]).default("auto"),
+  /**
+   * T3→T2 reinforcement: when enabled, a worker that discovers its subtask should
+   * fan out can call the `request_workers` tool to have its T2 manager spawn
+   * sibling workers for the new pieces (no 4th tier; bounded). Off by default.
+   */
+  reinforcements: z.object({
+    enabled: z.boolean().default(false),
+    maxPerSection: z.number().int().min(1).max(20).default(4)
+  }).default({}),
+  /**
+   * Render the TUI in the terminal's alternate screen buffer (like vim).
+   * Flicker-proof and restores the shell on exit, but native scrollback is
+   * unavailable — history scrolls in-app with PgUp/PgDn. Also enabled per
+   * session with the --alt-screen flag. Default: off.
+   */
+  altScreen: z.boolean().default(false)
 });
 
 // src/config/validate.ts
@@ -6648,14 +7949,20 @@ var TASK_TYPE_TAGS = {
 };
 var TaskAnalyzer = class {
   tracker;
+  bias;
   lastProfile = null;
   lastSelectedModels = /* @__PURE__ */ new Map();
-  constructor(tracker) {
+  constructor(tracker, bias = "balanced") {
     this.tracker = tracker;
+    this.bias = bias;
   }
   setTracker(tracker) {
     this.tracker = tracker;
   }
+  /** Change the cost/quality bias at runtime (e.g. when config reloads). */
+  setBias(bias) {
+    this.bias = bias;
+  }
   /** Returns the TaskProfile from the most recent analyze() call — used for outcome recording. */
   getLastProfile() {
     return this.lastProfile;
@@ -6715,7 +8022,16 @@ 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);
-    return perf * costEff * match;
+    const benchmark = 0.3 + 0.7 * benchmarkScore01(model, profile.type);
+    switch (this.bias) {
+      case "quality":
+        return perf * match * benchmark ** 2 * (0.85 + 0.15 * costEff);
+      case "cost":
+        return perf * match * costEff ** 1.5 * Math.sqrt(benchmark);
+      case "balanced":
+      default:
+        return perf * costEff * match * benchmark;
+    }
   }
   costEfficiency(model, complexity) {
     if (this.tracker) return this.tracker.costEfficiencyScore(model, complexity);
@@ -6735,7 +8051,7 @@ var TaskAnalyzer = class {
     analysisCache.clear();
   }
 };
-var DEFAULT_STATS_FILE = path16.join(os3.homedir(), ".cascade", "model-perf.json");
+var DEFAULT_STATS_FILE = path18.join(os4.homedir(), ".cascade", "model-perf.json");
 var ModelPerformanceTracker = class {
   stats = /* @__PURE__ */ new Map();
   statsFile;
@@ -6747,7 +8063,7 @@ var ModelPerformanceTracker = class {
     if (this.loaded) return;
     this.loaded = true;
     try {
-      const raw = await fs3.readFile(this.statsFile, "utf-8");
+      const raw = await fs4.readFile(this.statsFile, "utf-8");
       const parsed = JSON.parse(raw);
       for (const [key, stat] of Object.entries(parsed)) {
         this.stats.set(key, stat);
@@ -6757,10 +8073,10 @@ var ModelPerformanceTracker = class {
   }
   async save() {
     try {
-      await fs3.mkdir(path16.dirname(this.statsFile), { recursive: true });
+      await fs4.mkdir(path18.dirname(this.statsFile), { recursive: true });
       const obj = {};
       for (const [key, stat] of this.stats) obj[key] = stat;
-      await fs3.writeFile(this.statsFile, JSON.stringify(obj, null, 2), "utf-8");
+      await fs4.writeFile(this.statsFile, JSON.stringify(obj, null, 2), "utf-8");
     } catch {
     }
   }
@@ -6808,6 +8124,96 @@ var ModelPerformanceTracker = class {
     return Math.max(0.1, 1 - normalised * complexityWeight);
   }
 };
+var DYNAMIC_TOOLS_FILE = "dynamic-tools.json";
+function normalizeToolSchema(schema) {
+  if (schema && schema["type"] === "object" && typeof schema["properties"] === "object") {
+    return schema;
+  }
+  const properties = schema && typeof schema === "object" ? schema : {};
+  return {
+    type: "object",
+    properties,
+    required: Object.keys(properties)
+  };
+}
+function capabilityKey(text) {
+  return Array.from(
+    new Set((text.toLowerCase().match(/[a-z0-9]+/g) ?? []).filter((w) => w.length > 2))
+  ).sort().join(" ");
+}
+var DYNAMIC_TOOL_TIMEOUT_MS = 15e3;
+var DYNAMIC_FETCH_MAX = 1e6;
+var HARNESS_SRC = `
+const { parentPort, workerData } = require('node:worker_threads');
+const { executeCode, input } = workerData;
+let nextId = 0;
+const pending = new Map();
+function bridge(kind, payload) {
+  return new Promise((resolve, reject) => {
+    const id = nextId++;
+    pending.set(id, { resolve, reject });
+    parentPort.postMessage(Object.assign({ kind, id }, payload));
+  });
+}
+parentPort.on('message', (msg) => {
+  const p = pending.get(msg.id);
+  if (!p) return;
+  pending.delete(msg.id);
+  if (msg.error !== undefined) p.reject(new Error(msg.error));
+  else p.resolve(msg.value);
+});
+const callTool = (name, toolInput) => bridge('callTool', { name: name, input: toolInput });
+const fetch = async (url, init) => {
+  const safeInit = init && typeof init === 'object'
+    ? { method: init.method, headers: init.headers, body: typeof init.body === 'string' ? init.body : undefined }
+    : undefined;
+  const r = await bridge('fetch', { url: url, init: safeInit });
+  return {
+    ok: r.ok, status: r.status, statusText: r.statusText,
+    headers: { get: (k) => (String(k).toLowerCase() === 'content-type' ? r.contentType : null) },
+    text: async () => r.body,
+    json: async () => JSON.parse(r.body),
+  };
+};
+(async () => {
+  const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+  const fn = new AsyncFunction('input', 'callTool', 'fetch', 'console', executeCode);
+  return await fn(input, callTool, fetch, { log() {}, error() {} });
+})()
+  .then((r) => parentPort.postMessage({ kind: 'result', value: String(r == null ? '' : r) }))
+  .catch((e) => parentPort.postMessage({ kind: 'result', value: 'Tool error: ' + (e && e.message ? e.message : String(e)) }));
+`;
+function isExecutableToolCode(code) {
+  try {
+    const AsyncFunction = Object.getPrototypeOf(async function() {
+    }).constructor;
+    new AsyncFunction("input", "callTool", "fetch", "console", code);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function bridgeFetch(url, init) {
+  try {
+    const i = init && typeof init === "object" ? init : {};
+    const resp = await safeFetch(url, {
+      method: typeof i["method"] === "string" ? i["method"] : void 0,
+      headers: i["headers"],
+      body: typeof i["body"] === "string" ? i["body"] : void 0
+    });
+    const contentType = resp.headers.get("content-type") ?? "";
+    let body = "";
+    try {
+      body = await resp.text();
+    } catch {
+      body = "";
+    }
+    if (body.length > DYNAMIC_FETCH_MAX) body = body.slice(0, DYNAMIC_FETCH_MAX);
+    return { ok: resp.ok, status: resp.status, statusText: resp.statusText, contentType, body };
+  } catch (err) {
+    return { __error: err instanceof Error ? err.message : String(err) };
+  }
+}
 var DynamicTool = class extends BaseTool {
   name;
   description;
@@ -6815,8 +8221,12 @@ var DynamicTool = class extends BaseTool {
   executeCode;
   _isDangerous;
   registry;
-  escalator;
-  constructor(spec, registry, escalator) {
+  /** Resolve the CURRENT escalator at call time — covers tools registered before
+   *  the per-run escalator was wired (persisted at init, received from a peer). */
+  getEscalator;
+  /** Untrusted = loaded from disk / a peer; its dangerous calls always re-prompt. */
+  trusted;
+  constructor(spec, registry, getEscalator, trusted) {
     super();
     this.name = spec.name;
     this.description = spec.description;
@@ -6824,32 +8234,35 @@ var DynamicTool = class extends BaseTool {
     this.executeCode = spec.executeCode;
     this._isDangerous = spec.isDangerous;
     this.registry = registry;
-    this.escalator = escalator;
+    this.getEscalator = getEscalator;
+    this.trusted = trusted;
   }
   isDangerous() {
     return this._isDangerous;
   }
   async execute(input, options) {
     const registry = this.registry;
-    const escalator = this.escalator;
     const callTool = async (toolName, toolInput) => {
       if (!registry.hasTool(toolName)) return `Tool not found: ${toolName}`;
       if (registry.isDangerous(toolName)) {
-        if (escalator) {
-          const req = {
-            id: `dynamic-${this.name}-${toolName}-${Date.now()}`,
-            requestedBy: `dynamic_tool:${this.name}`,
-            parentT2Id: options.tierId,
-            toolName,
-            input: toolInput,
-            isDangerous: true,
-            subtaskContext: `Dynamic tool "${this.name}" requesting access to "${toolName}"`,
-            sectionContext: `Dynamic tool "${this.name}"`
-          };
-          const decision = await escalator.requestPermission(req);
-          if (!decision.approved) {
-            return `Permission denied for ${toolName} (decided by ${decision.decidedBy}).`;
-          }
+        const escalator = this.getEscalator();
+        if (!escalator) {
+          return `Permission denied for "${toolName}": dynamic tool "${this.name}" has no approver available (default-deny).`;
+        }
+        const req = {
+          id: `dynamic-${this.name}-${toolName}-${Date.now()}`,
+          requestedBy: `dynamic_tool:${this.name}`,
+          parentT2Id: options.tierId,
+          toolName,
+          input: toolInput,
+          isDangerous: true,
+          subtaskContext: `Dynamic tool "${this.name}" (${this.trusted ? "trusted" : "UNTRUSTED"}) requesting access to "${toolName}"`,
+          sectionContext: `Dynamic tool "${this.name}"`,
+          forceReprompt: !this.trusted
+        };
+        const decision = await escalator.requestPermission(req);
+        if (!decision.approved) {
+          return `Permission denied for ${toolName} (decided by ${decision.decidedBy}).`;
         }
       }
       try {
@@ -6859,41 +8272,52 @@ var DynamicTool = class extends BaseTool {
         return `Error calling ${toolName}: ${err instanceof Error ? err.message : String(err)}`;
       }
     };
-    const sandbox = {
-      input,
-      fetch: globalThis.fetch,
-      callTool,
-      JSON,
-      Math,
-      Date,
-      console: { log: () => {
-      }, error: () => {
-      } },
-      setTimeout,
-      clearTimeout,
-      Promise,
-      Error,
-      String,
-      Number,
-      Boolean,
-      Array,
-      Object,
-      result: void 0
-    };
-    const context = createContext(sandbox);
-    const wrapped = `(async () => { ${this.executeCode} })().then(r => { result = String(r ?? ''); }).catch(e => { result = 'Tool error: ' + e.message; });`;
-    try {
-      const promise = runInContext(wrapped, context, {
-        timeout: 15e3,
-        breakOnSigint: true,
-        filename: `dynamic_tool_${this.name}.js`,
-        displayErrors: true
+    return this.runInWorker(input, callTool);
+  }
+  /** 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) => {
+      let settled = false;
+      const worker = new Worker(HARNESS_SRC, {
+        eval: true,
+        workerData: { executeCode: this.executeCode, input },
+        resourceLimits: { maxOldGenerationSizeMb: 128 }
       });
-      await promise;
-      return sandbox["result"] ?? "";
-    } catch (err) {
-      return `Dynamic tool error: ${err instanceof Error ? err.message : String(err)}`;
-    }
+      const finish = (value) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        void worker.terminate();
+        resolve(value);
+      };
+      const timer = setTimeout(
+        () => finish(`Dynamic tool "${this.name}" timed out after ${timeoutMs}ms and was terminated.`),
+        timeoutMs
+      );
+      timer.unref?.();
+      worker.on("message", (msg) => {
+        if (msg?.kind === "result") {
+          finish(typeof msg.value === "string" ? msg.value : String(msg.value ?? ""));
+        } else if (msg?.kind === "callTool") {
+          void (async () => {
+            const value = await callTool(String(msg.name), msg.input ?? {});
+            if (!settled) worker.postMessage({ id: msg.id, value });
+          })();
+        } else if (msg?.kind === "fetch") {
+          void (async () => {
+            const r = await bridgeFetch(String(msg.url), msg.init);
+            if (settled) return;
+            if ("__error" in r) worker.postMessage({ id: msg.id, error: r.__error });
+            else worker.postMessage({ id: msg.id, value: r });
+          })();
+        }
+      });
+      worker.on("error", (err) => finish(`Dynamic tool error: ${err instanceof Error ? err.message : String(err)}`));
+      worker.on("exit", (code) => {
+        if (code !== 0) finish(`Dynamic tool "${this.name}" exited unexpectedly (code ${code}).`);
+      });
+    });
   }
 };
 var TOOL_CREATOR_PROMPT = `You are a tool-generation assistant for the Cascade AI system.
@@ -6926,52 +8350,153 @@ var ToolCreator = class {
   router;
   registry;
   escalator;
-  createdTools = /* @__PURE__ */ new Set();
-  constructor(router, registry) {
+  workspacePath;
+  /** When false, persisted tools are neither loaded nor written. */
+  persistEnabled;
+  logger;
+  /** name → spec, for persistence, broadcast, and re-registration. */
+  specs = /* @__PURE__ */ new Map();
+  /** capability fingerprint → tool name, so the same need isn't re-generated. */
+  capabilityIndex = /* @__PURE__ */ new Map();
+  constructor(router, registry, workspacePath, persistEnabled = true) {
     this.router = router;
     this.registry = registry;
+    this.workspacePath = workspacePath;
+    this.persistEnabled = persistEnabled;
   }
   setPermissionEscalator(escalator) {
     this.escalator = escalator;
   }
+  /** Route diagnostics through the host (Cascade) so they survive the Ink TUI. */
+  setLogger(fn) {
+    this.logger = fn;
+  }
+  /** Returns the stored spec for a created tool (for peer broadcast). */
+  getSpec(name) {
+    return this.specs.get(name);
+  }
+  log(msg) {
+    if (this.logger) this.logger(msg);
+  }
   /**
    * Generate a new tool from a description and register it with the ToolRegistry.
-   * The generated tool has access to all registered cascade tools via callTool().
-   * Returns the tool name if successful, null if generation failed.
+   * Returns the tool name on success, or null on failure (with a logged reason —
+   * failures are no longer swallowed silently). Reuses an existing tool when the
+   * same capability has already been created (dedup) so peers/runs don't
+   * regenerate identical tools.
    */
   async createTool(description, context) {
+    const key = capabilityKey(`${description} ${context}`);
+    const existing = this.capabilityIndex.get(key);
+    if (existing && this.registry.hasTool(existing)) {
+      this.log(`[tool-creator] Reusing existing tool "${existing}" for: ${description.slice(0, 80)}`);
+      return existing;
+    }
     const prompt = `${TOOL_CREATOR_PROMPT}
 
 Task context: ${context.slice(0, 200)}
 Required capability: ${description.slice(0, 300)}`;
+    let spec = null;
+    for (let attempt = 1; attempt <= 2 && !spec; attempt++) {
+      try {
+        const result = await this.router.generate("T3", {
+          messages: [{ role: "user", content: prompt }],
+          maxTokens: 800
+        });
+        const jsonMatch = /\{[\s\S]*\}/.exec(result.content);
+        if (!jsonMatch) {
+          this.log(`[tool-creator] Attempt ${attempt}: model returned no JSON object.`);
+          continue;
+        }
+        const parsed = JSON.parse(jsonMatch[0]);
+        if (!parsed.name || !parsed.description || !parsed.executeCode || !parsed.inputSchema) {
+          this.log(`[tool-creator] Attempt ${attempt}: spec missing required fields (name/description/executeCode/inputSchema).`);
+          continue;
+        }
+        spec = parsed;
+      } catch (err) {
+        this.log(`[tool-creator] Attempt ${attempt} failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    if (!spec) {
+      this.log(`[tool-creator] Could not generate a tool for: ${description.slice(0, 80)}`);
+      return null;
+    }
+    spec.inputSchema = normalizeToolSchema(spec.inputSchema);
+    if (this.specs.has(spec.name) || this.registry.hasTool(spec.name)) {
+      spec.name = `${spec.name}_${Date.now() % 1e4}`;
+    }
+    if (!isExecutableToolCode(spec.executeCode)) {
+      this.log(`[tool-creator] Generated code for "${spec.name}" has a syntax error \u2014 discarded.`);
+      return null;
+    }
+    this.registerSpec(spec, true);
+    this.capabilityIndex.set(key, spec.name);
+    this.log(`[tool-creator] Created tool "${spec.name}".`);
+    void this.persist();
+    return spec.name;
+  }
+  /**
+   * Register a spec (from createTool, disk, or a peer) into the registry.
+   * Idempotent — a name already present is skipped. `trusted` is set by the
+   * caller and never inherited from disk: createTool passes true; persisted and
+   * peer-broadcast specs pass false, so their dangerous actions always re-escalate.
+   * The DynamicTool resolves the escalator lazily (`() => this.escalator`) so a
+   * later setPermissionEscalator covers tools registered before the run wired it.
+   */
+  registerSpec(spec, trusted = false) {
+    spec.trusted = trusted;
+    if (this.registry.hasTool(spec.name)) {
+      this.specs.set(spec.name, spec);
+      return;
+    }
+    const tool = new DynamicTool(spec, this.registry, () => this.escalator, trusted);
+    this.registry.register(tool);
+    this.specs.set(spec.name, spec);
+    this.capabilityIndex.set(capabilityKey(`${spec.description}`), spec.name);
+  }
+  /** Load tools persisted by previous runs and register them — as UNTRUSTED, and
+   *  only after re-validating each spec (its source could have been tampered with
+   *  or authored during a prior prompt-injected run). Untrusted tools re-escalate
+   *  any dangerous action, so a silently-reloaded tool can't act without approval. */
+  async loadPersistedTools() {
+    if (!this.workspacePath || !this.persistEnabled) return;
+    const file = path18.join(this.workspacePath, ".cascade", DYNAMIC_TOOLS_FILE);
     try {
-      const result = await this.router.generate("T3", {
-        messages: [{ role: "user", content: prompt }],
-        maxTokens: 800
-      });
-      const jsonMatch = /\{[\s\S]*\}/.exec(result.content);
-      if (!jsonMatch) return null;
-      const spec = JSON.parse(jsonMatch[0]);
-      if (!spec.name || !spec.description || !spec.executeCode || !spec.inputSchema) return null;
-      if (this.createdTools.has(spec.name) || this.registry.hasTool(spec.name)) {
-        spec.name = `${spec.name}_${Date.now() % 1e4}`;
+      const raw = await fs4.readFile(file, "utf-8");
+      const specs = JSON.parse(raw);
+      if (!Array.isArray(specs)) return;
+      let loaded = 0;
+      let skipped = 0;
+      for (const spec of specs) {
+        if (!(spec?.name && spec.description && spec.executeCode && spec.inputSchema) || !isExecutableToolCode(spec.executeCode)) {
+          skipped++;
+          continue;
+        }
+        spec.inputSchema = normalizeToolSchema(spec.inputSchema);
+        this.registerSpec(spec, false);
+        loaded++;
       }
-      try {
-        new Function("input", "fetch", "callTool", spec.executeCode);
-      } catch {
-        return null;
+      if (loaded || skipped) {
+        this.log(`[tool-creator] Loaded ${loaded} persisted tool(s) as untrusted${skipped ? `, skipped ${skipped} invalid` : ""}.`);
       }
-      const tool = new DynamicTool(spec, this.registry, this.escalator);
-      this.registry.register(tool);
-      this.createdTools.add(spec.name);
-      return spec.name;
     } catch {
-      return null;
+    }
+  }
+  async persist() {
+    if (!this.workspacePath || !this.persistEnabled) return;
+    const dir = path18.join(this.workspacePath, ".cascade");
+    const file = path18.join(dir, DYNAMIC_TOOLS_FILE);
+    try {
+      await fs4.mkdir(dir, { recursive: true });
+      await fs4.writeFile(file, JSON.stringify(Array.from(this.specs.values()), null, 2), "utf-8");
+    } catch (err) {
+      this.log(`[tool-creator] Failed to persist tools: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
   /** Returns the names of all tools created in this session. */
   getCreatedTools() {
-    return Array.from(this.createdTools);
+    return Array.from(this.specs.keys());
   }
 };
 
@@ -6981,7 +8506,11 @@ var Cascade = class _Cascade extends EventEmitter {
   toolRegistry;
   mcpClient;
   config;
+  /** Orchestration decisions for the CURRENT run — cleared on each run(). */
+  decisionLog = [];
   initialized = false;
+  /** Last task that stopped at the budget cap — powers /continue (resumeRun). */
+  lastInterruptedRun;
   initPromise;
   store;
   audit;
@@ -6989,15 +8518,23 @@ var Cascade = class _Cascade extends EventEmitter {
   taskAnalyzer;
   perfTracker;
   toolCreator;
+  workspacePath;
   constructor(config, workspacePath, store) {
     super();
     this.config = validateConfig(config);
+    this.workspacePath = workspacePath;
     this.store = store;
     this.router = new CascadeRouter();
     this.mcpClient = new McpClient({
       trustedServers: this.config.tools.mcpTrusted,
       approvalCallback: async (server) => {
         return await this.requestMcpApproval(server);
+      },
+      // Route warnings through the event stream when anyone is listening —
+      // a raw console write while the TUI is live corrupts Ink's frame.
+      onWarn: (message) => {
+        if (this.listenerCount("log") > 0) this.emit("log", { level: "warn", message });
+        else console.warn(message);
       }
     });
     this.toolRegistry = new ToolRegistry(this.config.tools, workspacePath);
@@ -7007,11 +8544,15 @@ var Cascade = class _Cascade extends EventEmitter {
     if (this.config.cascadeAuto === true) {
       this.perfTracker = new ModelPerformanceTracker();
       void this.perfTracker.load();
-      this.taskAnalyzer = new TaskAnalyzer(this.perfTracker);
+      this.taskAnalyzer = new TaskAnalyzer(this.perfTracker, this.config.autoBias ?? "balanced");
+      this.router.setTaskAnalyzer(this.taskAnalyzer);
     }
     const cfg = this.config;
     if (cfg["enableToolCreation"] === true) {
-      this.toolCreator = new ToolCreator(this.router, this.toolRegistry);
+      this.toolCreator = new ToolCreator(this.router, this.toolRegistry, this.workspacePath, cfg["persistDynamicTools"] !== false);
+      this.toolCreator.setLogger((m) => {
+        if (this.listenerCount("log") > 0) this.emit("log", { level: "info", message: m });
+      });
     }
   }
   setStore(store) {
@@ -7042,6 +8583,17 @@ var Cascade = class _Cascade extends EventEmitter {
       this.emit("mcp:approval-required", { server });
     });
   }
+  recordDecision(kind, detail) {
+    this.decisionLog.push({ at: (/* @__PURE__ */ new Date()).toISOString(), kind, detail });
+  }
+  /**
+   * The orchestration decision trail for the most recent run: complexity
+   * verdict (and why), which model served each tier, failovers, and
+   * escalations. Powers the /why command.
+   */
+  getDecisionLog() {
+    return [...this.decisionLog];
+  }
   /** Resolve a pending MCP server approval from a REPL / dashboard listener. */
   resolveMcpApproval(serverName, approved) {
     const resolver = this.pendingMcpApprovals.get(serverName);
@@ -7050,6 +8602,125 @@ var Cascade = class _Cascade extends EventEmitter {
       resolver(approved);
     }
   }
+  // ── Boardroom plan approval ─────────────────────────────────────────
+  // Same gate pattern as MCP approvals, with the opposite default: plans
+  // are work the user asked for, so no listener (SDK/headless) or a
+  // timeout means PROCEED, not reject.
+  pendingPlanApproval;
+  async requestPlanApproval(plan, taskId, critique, summary) {
+    if (this.config.autonomy === "auto") {
+      return { approved: true };
+    }
+    if (this.listenerCount("plan:approval-required") === 0) {
+      return { approved: true };
+    }
+    const t2Count = plan.sections.length;
+    const t3Count = plan.sections.reduce((sum, s) => sum + (s.t3Subtasks?.length ?? 0), 0);
+    return await new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        if (this.pendingPlanApproval) {
+          this.pendingPlanApproval = void 0;
+          resolve({ approved: true });
+        }
+      }, 12e4);
+      this.pendingPlanApproval = (decision) => {
+        clearTimeout(timeout);
+        this.pendingPlanApproval = void 0;
+        resolve(decision);
+      };
+      this.emit("plan:approval-required", {
+        taskId,
+        plan,
+        t2Count,
+        t3Count,
+        estCostUsd: this.estimatePlanCost(plan),
+        critique,
+        summary
+      });
+    });
+  }
+  /**
+   * Resolve a pending boardroom plan approval from a REPL / dashboard listener.
+   * An optional `note` re-plans and re-asks; an optional `editedPlan` is applied
+   * directly (no re-decompose).
+   */
+  resolvePlanApproval(approved, note, editedPlan) {
+    this.pendingPlanApproval?.({ approved, note, editedPlan });
+  }
+  /**
+   * Autonomy control (used by the /auto command). 'auto' makes the next run
+   * hands-off: the plan gate auto-approves and non-dangerous tools auto-approve,
+   * while dangerous tools still escalate and budget caps remain the hard stop.
+   */
+  setAutonomy(mode) {
+    this.config = { ...this.config, autonomy: mode };
+  }
+  getAutonomy() {
+    return this.config.autonomy === "auto" ? "auto" : "manual";
+  }
+  /**
+   * Preview T1's decomposition for a prompt WITHOUT executing it (powers /plan).
+   * Idempotent init guard, so it works before the first run.
+   */
+  async previewPlan(prompt) {
+    await this.init();
+    const t1 = new T1Administrator(this.router, this.toolRegistry, this.config);
+    if (this.store) t1.setStore(this.store);
+    return t1.previewPlan(prompt);
+  }
+  /** True when a task stopped at the budget cap and can be resumed via /continue. */
+  hasResumableRun() {
+    return this.lastInterruptedRun != null;
+  }
+  /**
+   * Raise the per-run token budget for a resume and return the continuation
+   * prompt (or null when nothing is resumable). Consumes the interrupted-run
+   * state. The REPL submits the returned prompt through its normal flow so the
+   * resumed run renders like any other; `resumeRun` wraps this for SDK callers.
+   */
+  prepareResume(opts = {}) {
+    const last = this.lastInterruptedRun;
+    if (!last) return null;
+    this.lastInterruptedRun = void 0;
+    const raised = opts.maxTokens ?? Math.round((this.config.budget?.maxTokensPerRun ?? 2e5) * 2);
+    this.config = { ...this.config, budget: { ...this.config.budget, maxTokensPerRun: raised } };
+    this.router.setMaxTokensPerRun(raised);
+    return `Continue and FINISH this task. A previous attempt was interrupted before completion; any files already created are on disk \u2014 build on them, do NOT recreate them. Complete only the remaining work.
+
+Original task: ${last.prompt}` + (last.partialOutput ? `
+
+Partial result so far:
+${last.partialOutput}` : "");
+  }
+  /**
+   * Resume the last budget-capped task with a raised budget (SDK/headless).
+   * Returns null when there is nothing to resume.
+   */
+  async resumeRun(opts = {}) {
+    const prompt = this.prepareResume(opts);
+    if (!prompt) return null;
+    return this.run({ prompt });
+  }
+  /**
+   * Rough pre-execution cost estimate for a plan: ~3 T2 calls per section
+   * plus ~4 T3 calls per subtask at typical token volumes. A ballpark for
+   * the approval dialog, not an invoice — always label it "est."
+   */
+  estimatePlanCost(plan) {
+    const T2_CALLS_PER_SECTION = 3;
+    const T3_CALLS_PER_SUBTASK = 4;
+    const IN_TOKENS = 1500;
+    const OUT_TOKENS = 700;
+    const t2Model = this.router.getTierModel("T2");
+    const t3Model = this.router.getTierModel("T3");
+    let est = 0;
+    for (const section of plan.sections) {
+      if (t2Model) est += T2_CALLS_PER_SECTION * calculateCost(IN_TOKENS, OUT_TOKENS, t2Model);
+      const subtasks = section.t3Subtasks?.length ?? 1;
+      if (t3Model) est += subtasks * T3_CALLS_PER_SUBTASK * calculateCost(IN_TOKENS, OUT_TOKENS, t3Model);
+    }
+    return est;
+  }
   async init() {
     if (this.initialized) return;
     if (this.initPromise) return this.initPromise;
@@ -7058,6 +8729,9 @@ var Cascade = class _Cascade extends EventEmitter {
       this.router.on("budget:warning", (payload) => {
         this.emit("budget:warning", payload);
       });
+      this.router.on("failover", (e) => {
+        this.recordDecision("failover", `${e.tier} ${e.from} \u2192 ${e.to} (${e.reason})`);
+      });
       this.router.on("budget:exceeded", (payload) => {
         this.emit("budget:exceeded", payload);
         for (const [name, resolver] of this.pendingMcpApprovals) {
@@ -7095,7 +8769,12 @@ var Cascade = class _Cascade extends EventEmitter {
         this.router.profileModels(this.store).catch(() => {
         });
       }
+      if (this.config.cascadeAuto) {
+        this.router.refreshLiveData().catch(() => {
+        });
+      }
       this.initOptionalFeatures();
+      if (this.toolCreator) await this.toolCreator.loadPersistedTools();
       this.initialized = true;
     })();
     try {
@@ -7121,6 +8800,20 @@ var Cascade = class _Cascade extends EventEmitter {
     const wordCount = prompt.trim().split(/\s+/).length;
     return wordCount <= 12 && LOW_COMPLEXITY.some((re) => re.test(prompt.trim()));
   }
+  /**
+   * Read-only inquiries about existing content ("read / review / explain /
+   * summarize / analyze this file or codebase and tell me …") are single-agent
+   * work — one worker with file/grep tools answers directly, no T1→T2→T3 fan-out.
+   * They must NOT ask to create, build, implement, refactor, or save an artifact;
+   * those stay on the heavier classifier path. This keeps trivial "what does this
+   * do?" requests from being mis-routed into a multi-agent, multi-thousand-token run.
+   */
+  looksLikeReadOnlyInquiry(prompt) {
+    const p = prompt.trim();
+    const inquiry = /\b(?:read|review|explain|describe|summari[sz]e|analy[sz]e|assess|evaluate|inspect|examine|explore|go through|look at|tell me about|what (?:is|are|does|do)|is it|understand|novelty|novel idea)\b/i.test(p);
+    const producesArtifact = /\b(?:create|build|implement|generate|write|refactor|rewrite|add|fix|deploy|install|migrate|scaffold|set up|save (?:a|the)|report|\.(?:pdf|md|txt|json|csv|py|js|ts|tsx|jsx|html|docx?))\b/i.test(p);
+    return inquiry && !producesArtifact;
+  }
   // Cache glob scan results per workspace path to avoid repeated I/O.
   static globCache = /* @__PURE__ */ new Map();
   async countWorkspaceFiles(workspacePath) {
@@ -7140,9 +8833,22 @@ var Cascade = class _Cascade extends EventEmitter {
     }
   }
   async determineComplexity(prompt, workspacePath, conversationHistory = []) {
-    if (this.isCasualGreeting(prompt)) return "Simple";
-    if (this.looksLikeSimpleArtifactTask(prompt)) return "Simple";
-    if (this.looksLikeConversational(prompt)) return "Simple";
+    if (this.isCasualGreeting(prompt)) {
+      this.recordDecision("complexity", "Simple \u2014 heuristic: casual greeting (no classifier call)");
+      return "Simple";
+    }
+    if (this.looksLikeSimpleArtifactTask(prompt)) {
+      this.recordDecision("complexity", "Simple \u2014 heuristic: single-file artifact task (no classifier call)");
+      return "Simple";
+    }
+    if (this.looksLikeConversational(prompt)) {
+      this.recordDecision("complexity", "Simple \u2014 heuristic: short conversational message (no classifier call)");
+      return "Simple";
+    }
+    if (this.looksLikeReadOnlyInquiry(prompt)) {
+      this.recordDecision("complexity", "Simple \u2014 heuristic: read-only inquiry over existing content (single agent, no classifier call)");
+      return "Simple";
+    }
     let workspaceContext = "";
     try {
       const count = await this.countWorkspaceFiles(workspacePath);
@@ -7162,10 +8868,12 @@ Classification:
 Important rules:
 - Treat short follow-ups like "proceed", "continue", "do it", "yes" as referring to the recent context.
 - If the earlier context is complex, keep the inherited complexity unless the user clearly narrows scope.
+- Reading, explaining, summarizing, or analyzing existing files/code and answering a question \u2014 WITHOUT creating files or implementing changes \u2014 is "Simple" (single agent), never "Complex".
 - If the task asks for a simple single-file artifact like hello.txt, it is usually Moderate.
 - If the task asks for a saved report, PDF, implementation, or deeper verification workflow, it is at least Moderate and often Complex.
 
-Respond with exactly one word: Simple, Moderate, or Complex.`;
+Respond with the verdict word first, then a dash and a short reason (under 12 words).
+Format: <Simple|Moderate|Complex> \u2014 <reason>`;
     const recentHistory = conversationHistory.slice(-6);
     const contextBlock = recentHistory.map((message, index) => {
       const content = typeof message.content === "string" ? message.content : message.content.map((block) => block.type === "text" ? block.text : "[non-text]").join(" ");
@@ -7180,26 +8888,36 @@ ${prompt}` : prompt;
       const result = await this.router.generate("T1", {
         messages: [{ role: "user", content: routedPrompt }],
         systemPrompt: sysPrompt,
-        maxTokens: 8,
+        maxTokens: 40,
         temperature: 0
       });
-      const content = result.content.trim().toLowerCase();
-      if (content.includes("simple")) return "Simple";
-      if (content.includes("moderate")) return "Moderate";
-      return "Complex";
+      const content = result.content.trim();
+      const firstWord = (content.split(/[\s—–-]+/)[0] ?? "").toLowerCase();
+      const reason = content.replace(/^\S+\s*[—–-]*\s*/, "").trim();
+      const verdict = firstWord.includes("simple") ? "Simple" : firstWord.includes("moderate") ? "Moderate" : "Complex";
+      this.recordDecision("complexity", `${verdict} \u2014 classifier: ${reason || "no reason given"}`);
+      return verdict;
     } catch {
       const followUpPrompt = /^(proceed|continue|go ahead|do it|yes|yep|ok|okay|carry on)$/i.test(prompt.trim());
-      if (followUpPrompt && recentHistory.length > 0) return "Complex";
-      return "Complex";
+      if (followUpPrompt && recentHistory.length > 0) {
+        this.recordDecision("complexity", "Complex \u2014 classifier unavailable; short follow-up inherits prior context");
+        return "Complex";
+      }
+      this.recordDecision("complexity", "Moderate \u2014 classifier unavailable; defaulting to the mid-cost route");
+      return "Moderate";
     }
   }
   async run(options) {
     await this.init();
+    this.router.beginRun();
+    this.router.setRunSignal(options.signal);
     const startMs = Date.now();
     const taskId = randomUUID();
-    const escalator = new PermissionEscalator();
+    this.decisionLog = [];
+    const escalator = new PermissionEscalator(this.config.approvalTimeoutMs ?? 6e5, this.config.autonomy === "auto");
     escalator.on("permission:user-required", async (req) => {
       this.emit("permission:user-required", req);
+      this.recordDecision("escalation", `"${req.toolName}" by ${req.requestedBy} \u2014 T2 and T1 both unsure, escalated to user`);
       const enrichedRequest = {
         id: req.id,
         tierId: req.requestedBy,
@@ -7236,16 +8954,32 @@ ${prompt}` : prompt;
       toolCreationEnabled: this.config["enableToolCreation"] === true
     });
     this.emit("tier:root", { role: complexity === "Simple" ? "T3" : complexity === "Moderate" ? "T2" : "T1" });
+    const tiersInPlay = complexity === "Simple" ? ["T3"] : complexity === "Moderate" ? ["T2", "T3"] : ["T1", "T2", "T3"];
     if (this.taskAnalyzer) {
-      const tiers = complexity === "Simple" ? ["T3"] : complexity === "Moderate" ? ["T2", "T3"] : ["T1", "T2", "T3"];
-      await Promise.all(tiers.map(async (tier) => {
+      await Promise.all(tiersInPlay.map(async (tier) => {
+        const tierKey = tier.toLowerCase();
+        if (this.config.models?.[tierKey]) return;
         try {
           const model = await this.taskAnalyzer.selectModel(options.prompt, tier, this.router.getSelector());
-          if (model) this.router.overrideTierModel(tier, model);
+          if (model) {
+            this.router.overrideTierModel(tier, model);
+            const taskType = this.taskAnalyzer.getLastProfile()?.type ?? "mixed";
+            const bench = Math.round(benchmarkScore01(model, taskType) * 100);
+            const price = model.inputCostPer1kTokens === 0 && model.outputCostPer1kTokens === 0 ? "free" : `$${model.outputCostPer1kTokens.toFixed(4)}/1K out`;
+            const dataSrc = this.router.getLiveData()?.getDataSource() ?? "bundled";
+            this.recordDecision(
+              "model",
+              `${tier} \u2192 ${model.provider}:${model.id} \u2014 Cascade Auto: best value for ${taskType} (bench ${bench}/100, ${price}, data: ${dataSrc})`
+            );
+          }
         } catch {
         }
       }));
     }
+    this.recordDecision("model", tiersInPlay.map((tier) => {
+      const m = this.router.getTierModel(tier);
+      return m ? `${tier} ${m.provider}:${m.id}${m.isLocal ? " \u2302local" : ""}` : `${tier} (none)`;
+    }).join("  \xB7  "));
     const toolCreator = this.toolCreator;
     if (toolCreator) toolCreator.setPermissionEscalator(escalator);
     let finalOutput = "";
@@ -7327,6 +9061,25 @@ ${prompt}` : prompt;
         if (toolCreator) t2.setToolCreator(toolCreator);
         t2.setPeerMessageCallback((e) => this.emit("peer:message", e), options.sessionId ?? "");
         bindTierEvents(t2);
+        if (this.config.planApproval === "all") {
+          t2.setPlanApprovalCallback(async (subtasks) => {
+            const pseudoPlan = {
+              complexity: "Moderate",
+              reasoning: "",
+              sections: subtasks.map((st) => ({
+                sectionId: st.subtaskId,
+                sectionTitle: st.subtaskTitle,
+                description: st.description,
+                t3Subtasks: []
+              }))
+            };
+            const n = subtasks.length;
+            const summary = `${n} worker${n !== 1 ? "s" : ""} \xB7 1 root manager \xB7 est. $${this.estimatePlanCost(pseudoPlan).toFixed(4)}`;
+            const decision = await this.requestPlanApproval(pseudoPlan, taskId, void 0, summary);
+            const keepSubtaskIds = decision.editedPlan?.sections?.map((s) => s.sectionId).filter((id) => Boolean(id));
+            return { approved: decision.approved, note: decision.note, keepSubtaskIds };
+          });
+        }
         const assignment = {
           sectionId: taskId,
           sectionTitle: "Direct Task",
@@ -7358,17 +9111,33 @@ ${prompt}` : prompt;
         t1.setPeerMessageCallback((e) => this.emit("peer:message", e), options.sessionId ?? "");
         bindTierEvents(t1);
         t1.on("plan", (e) => this.emit("plan", e));
+        if (this.config.planApproval != null && this.config.planApproval !== "never") {
+          t1.setPlanApprovalCallback(async (plan, meta) => {
+            const decision = await this.requestPlanApproval(plan, taskId, meta?.critique);
+            this.recordDecision("escalation", decision.approved ? `Boardroom: plan approved (${plan.sections.length} sections)${decision.note ? " with a steering note" : ""}${decision.editedPlan ? " (edited)" : ""}` : "Boardroom: plan rejected \u2014 run stopped before any T2 spawned");
+            return decision;
+          });
+        }
         const result = await t1.execute(options.prompt, options.images, void 0, options.signal);
         finalOutput = result.output;
         t2Results = result.t2Results;
       }
     } catch (err) {
-      if (err instanceof CascadeCancelledError) {
+      if (err instanceof CascadeCancelledError || err instanceof Error && err.name === "AbortError" || options.signal?.aborted) {
         this.emit("run:cancelled", {
+          taskId,
+          reason: err instanceof Error ? err.message : "Task cancelled",
+          partialOutput: finalOutput || ""
+        });
+        runError = null;
+      } else if (err instanceof Error && err.name === "BudgetExceededError") {
+        this.emit("run:budget-exceeded", {
           taskId,
           reason: err.message,
           partialOutput: finalOutput || ""
         });
+        this.lastInterruptedRun = { prompt: options.prompt, partialOutput: finalOutput || "", taskId };
+        if (!finalOutput) finalOutput = `\u26A0 Stopped to avoid runaway cost: ${err.message}`;
         runError = null;
       } else {
         runError = err;
@@ -7379,6 +9148,8 @@ ${prompt}` : prompt;
         escalator.cancelAllPending();
       } catch {
       }
+      this.router.restoreTierModels();
+      this.router.setRunSignal(void 0);
       if (this.taskAnalyzer) {
         try {
           const stats2 = this.router.getStats();
@@ -7486,7 +9257,7 @@ var Keystore = class {
       const creds = await this.keytar.findCredentials(KEYTAR_SERVICE);
       this.cache = Object.fromEntries(creds.map((c) => [c.account, c.password]));
       this.backend = "keytar";
-      if (password && fs15.existsSync(this.storePath)) {
+      if (password && fs17.existsSync(this.storePath)) {
         try {
           const fileEntries = this.decryptFile(password);
           for (const [k, v] of Object.entries(fileEntries)) {
@@ -7505,7 +9276,7 @@ var Keystore = class {
         "Keystore unlock requires a password because the OS keychain (keytar) is not available on this system."
       );
     }
-    if (!fs15.existsSync(this.storePath)) {
+    if (!fs17.existsSync(this.storePath)) {
       const salt = crypto.randomBytes(SALT_LEN);
       this.masterKey = this.deriveKey(password, salt);
       this.writeWithSalt({}, salt);
@@ -7519,7 +9290,7 @@ var Keystore = class {
   }
   /** Synchronous legacy unlock kept for AES-only environments. */
   unlockSync(password) {
-    if (!fs15.existsSync(this.storePath)) {
+    if (!fs17.existsSync(this.storePath)) {
       const salt = crypto.randomBytes(SALT_LEN);
       this.masterKey = this.deriveKey(password, salt);
       this.writeWithSalt({}, salt);
@@ -7577,7 +9348,7 @@ var Keystore = class {
     }
   }
   decryptFile(password, knownSalt) {
-    if (!fs15.existsSync(this.storePath)) return {};
+    if (!fs17.existsSync(this.storePath)) return {};
     try {
       const { salt, ciphertext, iv, tag } = this.readRaw();
       const useSalt = knownSalt ?? salt;
@@ -7599,8 +9370,8 @@ var Keystore = class {
     const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
     const tag = cipher.getAuthTag();
     const out = Buffer.concat([raw.salt, iv, tag, ciphertext]);
-    fs15.mkdirSync(path16.dirname(this.storePath), { recursive: true });
-    fs15.writeFileSync(this.storePath, out, { mode: 384 });
+    fs17.mkdirSync(path18.dirname(this.storePath), { recursive: true });
+    fs17.writeFileSync(this.storePath, out, { mode: 384 });
   }
   writeWithSalt(data, salt) {
     if (!this.masterKey) throw new Error("writeWithSalt called before masterKey was set");
@@ -7610,11 +9381,11 @@ var Keystore = class {
     const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
     const tag = cipher.getAuthTag();
     const out = Buffer.concat([salt, iv, tag, ciphertext]);
-    fs15.mkdirSync(path16.dirname(this.storePath), { recursive: true });
-    fs15.writeFileSync(this.storePath, out, { mode: 384 });
+    fs17.mkdirSync(path18.dirname(this.storePath), { recursive: true });
+    fs17.writeFileSync(this.storePath, out, { mode: 384 });
   }
   readRaw() {
-    const buf = fs15.readFileSync(this.storePath);
+    const buf = fs17.readFileSync(this.storePath);
     let offset = 0;
     const salt = buf.subarray(offset, offset + SALT_LEN);
     offset += SALT_LEN;
@@ -7647,9 +9418,9 @@ var CascadeIgnore = class {
     ]);
   }
   async load(workspacePath) {
-    const filePath = path16.join(workspacePath, ".cascadeignore");
+    const filePath = path18.join(workspacePath, ".cascadeignore");
     try {
-      const content = await fs3.readFile(filePath, "utf-8");
+      const content = await fs4.readFile(filePath, "utf-8");
       const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
       this.ig.add(lines);
       this.loaded = true;
@@ -7658,7 +9429,7 @@ var CascadeIgnore = class {
   }
   isIgnored(filePath, workspacePath) {
     try {
-      const relative = workspacePath ? path16.relative(workspacePath, filePath) : filePath;
+      const relative = workspacePath ? path18.relative(workspacePath, filePath) : filePath;
       return this.ig.ignores(relative);
     } catch {
       return false;
@@ -7669,9 +9440,9 @@ var CascadeIgnore = class {
   }
 };
 async function loadCascadeMd(workspacePath) {
-  const filePath = path16.join(workspacePath, "CASCADE.md");
+  const filePath = path18.join(workspacePath, "CASCADE.md");
   try {
-    const raw = await fs3.readFile(filePath, "utf-8");
+    const raw = await fs4.readFile(filePath, "utf-8");
     return parseCascadeMd(raw);
   } catch {
     return null;
@@ -7700,7 +9471,7 @@ ${raw.trim()}`;
 var MemoryStore = class _MemoryStore {
   db;
   constructor(dbPath) {
-    fs15.mkdirSync(path16.dirname(dbPath), { recursive: true });
+    fs17.mkdirSync(path18.dirname(dbPath), { recursive: true });
     try {
       this.db = new Database(dbPath, { timeout: 5e3 });
       this.db.pragma("journal_mode = WAL");
@@ -8458,15 +10229,15 @@ var ConfigManager = class {
   globalDir;
   constructor(workspacePath = process.cwd()) {
     this.workspacePath = workspacePath;
-    this.globalDir = path16.join(os3.homedir(), GLOBAL_CONFIG_DIR);
+    this.globalDir = path18.join(os4.homedir(), GLOBAL_CONFIG_DIR);
   }
   async load() {
     this.config = await this.loadConfig();
     this.ignore = new CascadeIgnore();
     await this.ignore.load(this.workspacePath);
     this.cascadeMd = await loadCascadeMd(this.workspacePath);
-    this.keystore = new Keystore(path16.join(this.globalDir, GLOBAL_KEYSTORE_FILE));
-    this.store = new MemoryStore(path16.join(this.workspacePath, CASCADE_DB_FILE));
+    this.keystore = new Keystore(path18.join(this.globalDir, GLOBAL_KEYSTORE_FILE));
+    this.store = new MemoryStore(path18.join(this.workspacePath, CASCADE_DB_FILE));
     await this.injectEnvKeys();
     await this.ensureDefaultIdentity();
   }
@@ -8489,9 +10260,9 @@ var ConfigManager = class {
     return this.workspacePath;
   }
   async save() {
-    const configPath = path16.join(this.workspacePath, CASCADE_CONFIG_FILE);
-    await fs3.mkdir(path16.dirname(configPath), { recursive: true });
-    await fs3.writeFile(configPath, JSON.stringify(this.config, null, 2), "utf-8");
+    const configPath = path18.join(this.workspacePath, CASCADE_CONFIG_FILE);
+    await fs4.mkdir(path18.dirname(configPath), { recursive: true });
+    await fs4.writeFile(configPath, JSON.stringify(this.config, null, 2), "utf-8");
   }
   async updateConfig(updates) {
     this.config = validateConfig({ ...this.config, ...updates });
@@ -8514,9 +10285,9 @@ var ConfigManager = class {
     return configProvider?.apiKey;
   }
   async loadConfig() {
-    const configPath = path16.join(this.workspacePath, CASCADE_CONFIG_FILE);
+    const configPath = path18.join(this.workspacePath, CASCADE_CONFIG_FILE);
     try {
-      const raw = await fs3.readFile(configPath, "utf-8");
+      const raw = await fs4.readFile(configPath, "utf-8");
       return validateConfig(JSON.parse(raw));
     } catch (err) {
       if (err.code === "ENOENT") {
@@ -8595,12 +10366,13 @@ async function streamCascade(prompt, onToken, options = {}) {
     }
   });
 }
+var JWT_ALGORITHM = "HS256";
 function createToken(user, secret) {
-  return jwt.sign(user, secret, { expiresIn: "24h" });
+  return jwt.sign(user, secret, { expiresIn: "24h", algorithm: JWT_ALGORITHM });
 }
 function verifyToken(token, secret) {
   try {
-    return jwt.verify(token, secret);
+    return jwt.verify(token, secret, { algorithms: [JWT_ALGORITHM] });
   } catch {
     return null;
   }
@@ -8731,7 +10503,7 @@ var DashboardSocket = class {
     this.io.close();
   }
 };
-var __dirname$1 = path16.dirname(fileURLToPath(import.meta.url));
+var __dirname$1 = path18.dirname(fileURLToPath(import.meta.url));
 var DashboardServer = class {
   app;
   httpServer;
@@ -8742,12 +10514,14 @@ var DashboardServer = class {
   globalStore = null;
   broadcastTimer = null;
   port;
+  host;
   workspacePath;
   constructor(config, store, workspacePath = process.cwd()) {
     this.config = config;
     this.store = store;
     this.workspacePath = workspacePath;
     this.port = config.dashboard.port ?? DEFAULT_DASHBOARD_PORT;
+    this.host = config.dashboard.host ?? "127.0.0.1";
     this.dashboardSecret = this.resolveDashboardSecret();
     this.app = express();
     this.httpServer = createServer(this.app);
@@ -8760,10 +10534,19 @@ var DashboardServer = class {
     this.setupRoutes();
   }
   async start() {
+    const isLoopback = this.host === "127.0.0.1" || this.host === "::1" || this.host === "localhost";
+    if (!isLoopback) {
+      console.warn(
+        `\u26A0 Dashboard is binding to ${this.host}:${this.port} \u2014 reachable from the network. It exposes task execution (/api/run) and config endpoints. Ensure dashboard.auth is enabled and CASCADE_DASHBOARD_PASSWORD is set.`
+      );
+      if (!this.config.dashboard.auth) {
+        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) => {
       const onError = (err) => reject(err);
       this.httpServer.once("error", onError);
-      this.httpServer.listen(this.port, () => {
+      this.httpServer.listen(this.port, this.host, () => {
         this.httpServer.off("error", onError);
         resolve();
       });
@@ -8797,15 +10580,15 @@ var DashboardServer = class {
   resolveDashboardSecret() {
     const fromConfig = this.config.dashboard.secret ?? process.env["CASCADE_DASHBOARD_SECRET"];
     if (fromConfig) return fromConfig;
-    const secretPath = path16.join(this.workspacePath, CASCADE_DASHBOARD_SECRET_FILE);
+    const secretPath = path18.join(this.workspacePath, CASCADE_DASHBOARD_SECRET_FILE);
     try {
-      if (fs15.existsSync(secretPath)) {
-        const existing = fs15.readFileSync(secretPath, "utf-8").trim();
+      if (fs17.existsSync(secretPath)) {
+        const existing = fs17.readFileSync(secretPath, "utf-8").trim();
         if (existing.length >= 16) return existing;
       }
       const generated = randomUUID();
-      fs15.mkdirSync(path16.dirname(secretPath), { recursive: true });
-      fs15.writeFileSync(secretPath, generated, { encoding: "utf-8", mode: 384 });
+      fs17.mkdirSync(path18.dirname(secretPath), { recursive: true });
+      fs17.writeFileSync(secretPath, generated, { encoding: "utf-8", mode: 384 });
       if (this.config.dashboard.auth) {
         console.warn(
           `Dashboard auth enabled with no secret configured; persisted a generated secret to ${secretPath}. Set CASCADE_DASHBOARD_SECRET or config.dashboard.secret to override.`
@@ -8832,7 +10615,7 @@ var DashboardServer = class {
   // ── Setup ─────────────────────────────────────
   getGlobalStore() {
     if (!this.globalStore) {
-      const globalDbPath = path16.join(os3.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path18.join(os4.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       this.globalStore = new MemoryStore(globalDbPath);
     }
     return this.globalStore;
@@ -8893,12 +10676,12 @@ var DashboardServer = class {
     }
   }
   watchRuntimeChanges() {
-    const workspaceDbPath = path16.join(this.workspacePath, CASCADE_DB_FILE);
-    const globalDbPath = path16.join(os3.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+    const workspaceDbPath = path18.join(this.workspacePath, CASCADE_DB_FILE);
+    const globalDbPath = path18.join(os4.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
     const watchPaths = [workspaceDbPath, globalDbPath].filter((p, index, arr) => arr.indexOf(p) === index);
     for (const watchPath of watchPaths) {
-      if (!fs15.existsSync(watchPath)) continue;
-      fs15.watchFile(watchPath, { interval: 3e3 }, () => {
+      if (!fs17.existsSync(watchPath)) continue;
+      fs17.watchFile(watchPath, { interval: 3e3 }, () => {
         this.throttledBroadcast(watchPath === globalDbPath ? "global" : "workspace");
       });
     }
@@ -9028,7 +10811,7 @@ var DashboardServer = class {
       const sessionId = req.params.id;
       this.store.deleteSession(sessionId);
       this.store.deleteRuntimeSession(sessionId);
-      const globalDbPath = path16.join(os3.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path18.join(os4.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteRuntimeSession(sessionId);
@@ -9042,7 +10825,7 @@ var DashboardServer = class {
     });
     this.app.delete("/api/sessions", auth, (req, res) => {
       const body = req.body;
-      const globalDbPath = path16.join(os3.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path18.join(os4.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       if (body?.ids && Array.isArray(body.ids) && body.ids.length > 0) {
         const globalStore = new MemoryStore(globalDbPath);
         try {
@@ -9065,7 +10848,7 @@ var DashboardServer = class {
     });
     this.app.delete("/api/runtime", auth, (_req, res) => {
       this.store.deleteAllRuntimeNodes();
-      const globalDbPath = path16.join(os3.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path18.join(os4.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteAllRuntimeNodes();
@@ -9138,12 +10921,12 @@ var DashboardServer = class {
       if (body["tierLimits"]) this.config.tierLimits = { ...this.config.tierLimits, ...body["tierLimits"] };
       if (body["budget"]) this.config.budget = { ...this.config.budget, ...body["budget"] };
       try {
-        const configPath = path16.join(this.workspacePath, CASCADE_CONFIG_FILE);
-        const existing = fs15.existsSync(configPath) ? JSON.parse(fs15.readFileSync(configPath, "utf-8")) : {};
+        const configPath = path18.join(this.workspacePath, CASCADE_CONFIG_FILE);
+        const existing = fs17.existsSync(configPath) ? JSON.parse(fs17.readFileSync(configPath, "utf-8")) : {};
         const updated = { ...existing, tierLimits: this.config.tierLimits, budget: this.config.budget };
         const tmp = configPath + ".tmp";
-        fs15.writeFileSync(tmp, JSON.stringify(updated, null, 2), "utf-8");
-        fs15.renameSync(tmp, configPath);
+        fs17.writeFileSync(tmp, JSON.stringify(updated, null, 2), "utf-8");
+        fs17.renameSync(tmp, configPath);
         res.json({ ok: true });
       } catch (err) {
         res.status(500).json({ error: `Failed to save config: ${err instanceof Error ? err.message : String(err)}` });
@@ -9171,7 +10954,7 @@ var DashboardServer = class {
     this.app.get("/api/runtime", auth, (req, res) => {
       const scope = req.query["scope"] ?? "workspace";
       if (scope === "global") {
-        const globalDbPath = path16.join(os3.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+        const globalDbPath = path18.join(os4.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
         const globalStore = new MemoryStore(globalDbPath);
         try {
           res.json({
@@ -9244,13 +11027,13 @@ var DashboardServer = class {
         }))
       });
     });
-    const prodPath = path16.resolve(__dirname$1, "../web/dist");
-    const devPath = path16.resolve(__dirname$1, "../../web/dist");
-    const webDistPath = fs15.existsSync(prodPath) ? prodPath : devPath;
-    if (fs15.existsSync(webDistPath)) {
+    const prodPath = path18.resolve(__dirname$1, "../web/dist");
+    const devPath = path18.resolve(__dirname$1, "../../web/dist");
+    const webDistPath = fs17.existsSync(prodPath) ? prodPath : devPath;
+    if (fs17.existsSync(webDistPath)) {
       this.app.use(express.static(webDistPath));
       this.app.get("*", (_req, res) => {
-        res.sendFile(path16.join(webDistPath, "index.html"));
+        res.sendFile(path18.join(webDistPath, "index.html"));
       });
     } else {
       this.app.get("/", (_req, res) => {