cascade-ai 0.4.0 → 0.5.1

package/dist/index.js

@@ -5,20 +5,20 @@ import Anthropic from '@anthropic-ai/sdk';
 import OpenAI, { AzureOpenAI } from 'openai';
 import { GoogleGenAI, HarmBlockThreshold, HarmCategory } from '@google/genai';
 import axios2 from 'axios';
-import fs2 from 'fs/promises';
-import path13 from 'path';
+import fs3 from 'fs/promises';
+import path16 from 'path';
 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 { simpleGit } from 'simple-git';
-import fs11 from 'fs';
 import PDFDocument from 'pdfkit';
 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 os2 from 'os';
 import Database from 'better-sqlite3';
 import { createServer } from 'http';
 import { fileURLToPath } from 'url';
@@ -124,7 +124,7 @@ var require_keytar2 = __commonJS({
 });
 
 // src/constants.ts
-var CASCADE_VERSION = "0.4.0";
+var CASCADE_VERSION = "0.5.1";
 var CASCADE_CONFIG_DIR = ".cascade";
 var CASCADE_MD_FILE = "CASCADE.md";
 var CASCADE_IGNORE_FILE = ".cascadeignore";
@@ -1118,6 +1118,22 @@ var GeminiProvider = class extends BaseProvider {
     };
   }
 };
+var TOOL_CAPABLE_FAMILIES = [
+  "llama3.1",
+  "llama3.2",
+  "llama3.3",
+  "qwen2",
+  "qwen2.5",
+  "qwen3",
+  "mistral-nemo",
+  "mistral-small",
+  "command-r",
+  "firefunction"
+];
+function isToolCapable(modelName) {
+  const name = modelName.toLowerCase();
+  return TOOL_CAPABLE_FAMILIES.some((family) => name.includes(family));
+}
 var OllamaProvider = class extends BaseProvider {
   baseUrl;
   constructor(config, model) {
@@ -1130,12 +1146,21 @@ var OllamaProvider = class extends BaseProvider {
   }
   async generateStream(options, onChunk) {
     const messages = this.convertMessages(options.messages, options.systemPrompt);
+    const ollamaTools = options.tools?.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.inputSchema
+      }
+    }));
     const response = await axios2.post(
       `${this.baseUrl}/api/chat`,
       {
         model: this.model.id,
         messages,
         stream: true,
+        tools: ollamaTools?.length ? ollamaTools : void 0,
         options: {
           num_predict: options.maxTokens ?? this.model.maxOutputTokens,
           temperature: options.temperature ?? 0.7
@@ -1146,6 +1171,7 @@ var OllamaProvider = class extends BaseProvider {
     let fullContent = "";
     let inputTokens = 0;
     let outputTokens = 0;
+    const pendingToolCalls = [];
     await new Promise((resolve, reject) => {
       let buffer = "";
       response.data.on("data", (chunk) => {
@@ -1160,6 +1186,9 @@ var OllamaProvider = class extends BaseProvider {
               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;
@@ -1177,6 +1206,9 @@ var OllamaProvider = class extends BaseProvider {
               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;
@@ -1188,11 +1220,30 @@ var OllamaProvider = class extends BaseProvider {
       });
       response.data.on("error", reject);
     });
-    onChunk({ text: "", finishReason: "stop" });
+    const toolCalls = pendingToolCalls.map((tc, i) => {
+      let input;
+      if (typeof tc.function.arguments === "string") {
+        try {
+          input = JSON.parse(tc.function.arguments);
+        } catch {
+          input = { __rawArguments: tc.function.arguments };
+        }
+      } else {
+        input = tc.function.arguments;
+      }
+      return {
+        id: `ollama-tool-${Date.now()}-${i}`,
+        name: tc.function.name,
+        input
+      };
+    });
+    const finishReason = toolCalls.length ? "tool_use" : "stop";
+    onChunk({ text: "", finishReason });
     return {
       content: fullContent,
       usage: this.makeUsage(inputTokens, outputTokens),
-      finishReason: "stop"
+      toolCalls: toolCalls.length ? toolCalls : void 0,
+      finishReason
     };
   }
   async countTokens(text) {
@@ -1216,6 +1267,7 @@ var OllamaProvider = class extends BaseProvider {
         maxOutputTokens: 4e3,
         supportsStreaming: true,
         isLocal: true,
+        supportsToolUse: isToolCapable(m.name),
         minSizeB: this.parseSizeB(m.details?.parameter_size)
       }));
     } catch {
@@ -1238,6 +1290,26 @@ var OllamaProvider = class extends BaseProvider {
         result.push({ role: "system", content: typeof m.content === "string" ? m.content : "" });
         continue;
       }
+      if (m.role === "tool") {
+        result.push({
+          role: "tool",
+          content: typeof m.content === "string" ? m.content : JSON.stringify(m.content)
+        });
+        continue;
+      }
+      if (m.role === "assistant" && m.toolCalls?.length) {
+        result.push({
+          role: "assistant",
+          content: typeof m.content === "string" ? m.content : "",
+          tool_calls: m.toolCalls.map((tc) => ({
+            function: {
+              name: tc.name,
+              arguments: tc.input
+            }
+          }))
+        });
+        continue;
+      }
       if (typeof m.content === "string") {
         result.push({ role: m.role, content: m.content });
         continue;
@@ -1370,6 +1442,26 @@ var ModelSelector = class {
         return T3_MODEL_PRIORITY;
     }
   }
+  getAllAvailableModels() {
+    return Array.from(this.availableModels.values()).filter(
+      (m) => this.availableProviders.has(m.provider)
+    );
+  }
+  /**
+   * Returns all available models eligible for the given tier, ordered by the
+   * tier's priority chain. Use this as the candidate set for scored selection.
+   */
+  getCandidatesForTier(tier) {
+    const priority = this.getPriorityList(tier);
+    const candidates = [];
+    for (const key of priority) {
+      const model = this.availableModels.get(key);
+      if (model && this.availableProviders.has(model.provider)) {
+        candidates.push(model);
+      }
+    }
+    return candidates;
+  }
   isProviderAvailable(provider) {
     return this.availableProviders.has(provider);
   }
@@ -1575,11 +1667,203 @@ var TpmLimiter = class {
   }
 };
 
+// src/core/router/local-queue.ts
+var LocalRequestQueue = class {
+  maxConcurrent;
+  active = 0;
+  queue = [];
+  constructor(maxConcurrent = 1) {
+    this.maxConcurrent = Math.max(1, maxConcurrent);
+  }
+  /**
+   * Acquire a queue slot. Returns a `release` function that MUST be called
+   * when the inference call is done (even on error). Rejects if the slot
+   * cannot be acquired within `timeoutMs`.
+   */
+  async acquire(timeoutMs) {
+    if (this.active < this.maxConcurrent) {
+      this.active++;
+      return this.makeRelease();
+    }
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let timer;
+      const resolver = (release) => {
+        if (settled) return;
+        settled = true;
+        if (timer !== void 0) clearTimeout(timer);
+        resolve(release);
+      };
+      if (timeoutMs !== void 0 && timeoutMs > 0) {
+        timer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          const idx = this.queue.indexOf(resolver);
+          if (idx !== -1) this.queue.splice(idx, 1);
+          reject(new Error(
+            `Local model queue: timed out waiting for a free slot after ${timeoutMs}ms. Active: ${this.active}, Queued: ${this.queue.length}. Consider increasing localConcurrency or localInferenceTimeoutMs in your config.`
+          ));
+        }, timeoutMs);
+      }
+      this.queue.push(resolver);
+    });
+  }
+  /** Number of in-flight requests. */
+  get activeCount() {
+    return this.active;
+  }
+  /** Number of requests waiting for a slot. */
+  get queueDepth() {
+    return this.queue.length;
+  }
+  makeRelease() {
+    let called = false;
+    return () => {
+      if (called) return;
+      called = true;
+      this.active--;
+      const next = this.queue.shift();
+      if (next) {
+        this.active++;
+        next(this.makeRelease());
+      }
+    };
+  }
+};
+
 // src/utils/cost.ts
 function calculateCost(inputTokens, outputTokens, model) {
   return inputTokens / 1e3 * model.inputCostPer1kTokens + outputTokens / 1e3 * model.outputCostPer1kTokens;
 }
 
+// src/utils/retry.ts
+var CascadeCancelledError = class extends Error {
+  constructor(reason) {
+    super(reason ?? "Run was cancelled via AbortSignal");
+    this.name = "CascadeCancelledError";
+  }
+};
+var CascadeToolError = class extends Error {
+  /** A friendly message to show the user / T3 */
+  userMessage;
+  /** Whether this error class is retryable by default */
+  retryable;
+  constructor(userMessage, cause, retryable = false) {
+    const causeMsg = cause instanceof Error ? cause.message : String(cause);
+    super(`${userMessage}: ${causeMsg}`);
+    this.name = "CascadeToolError";
+    this.userMessage = userMessage;
+    this.retryable = retryable;
+  }
+};
+async function withTimeout(promise, timeoutMs, errorMessage = "Operation timed out") {
+  let timer;
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(errorMessage)),
+      timeoutMs
+    );
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+
+// src/core/router/model-profiler.ts
+var SKIP_PATTERN = /embed|dall-e|whisper|tts|vision|instruct-vision|rerank/i;
+var SPECIALIZATION_KEYWORDS = {
+  code: ["code", "coding", "programming", "developer", "software", "function", "debug", "typescript", "python", "javascript"],
+  analysis: ["analysis", "analytical", "reasoning", "logic", "research", "evaluate", "assess", "explain"],
+  creative: ["creative", "writing", "story", "poetry", "content", "blog", "essay", "narrative"],
+  data: ["data", "sql", "statistics", "chart", "csv", "json", "excel", "spreadsheet", "math", "mathematical"],
+  instruction: ["instruction", "instruction-following", "accurate", "precise", "factual"],
+  multilingual: ["multilingual", "language", "translation", "linguistic"],
+  long_context: ["long", "context", "document", "book", "summarize", "large"]
+};
+function extractSpecializations(description) {
+  const lower = description.toLowerCase();
+  const found = [];
+  for (const [key, terms] of Object.entries(SPECIALIZATION_KEYWORDS)) {
+    if (terms.some((t) => lower.includes(t))) {
+      found.push(key);
+    }
+  }
+  return found;
+}
+async function fetchOpenRouterModels() {
+  try {
+    const resp = await fetch("https://openrouter.ai/api/v1/models", {
+      headers: { "User-Agent": "Cascade-AI/0.4.0" },
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (!resp.ok) return [];
+    const data = await resp.json();
+    return data.data ?? [];
+  } catch {
+    return [];
+  }
+}
+async function queryModelDirectly(router, model) {
+  try {
+    const result = await router.generate("T3", {
+      messages: [{
+        role: "user",
+        content: 'What are your top 3 task specializations? Reply with valid JSON only: {"specializations": ["<area1>", "<area2>", "<area3>"]}'
+      }],
+      maxTokens: 60
+    });
+    const match = /\{[\s\S]*?\}/.exec(result.content);
+    if (!match) return [];
+    const parsed = JSON.parse(match[0]);
+    const specs = parsed.specializations;
+    if (!Array.isArray(specs)) return [];
+    return specs.filter((s) => typeof s === "string").slice(0, 5);
+  } catch {
+    return [];
+  }
+}
+var ModelProfiler = class {
+  store;
+  router;
+  constructor(store, router) {
+    this.store = store;
+    this.router = router;
+  }
+  /**
+   * Profile all models that haven't been profiled yet.
+   * Safe to call concurrently — SQLite upsert handles races.
+   */
+  async profileAll(models) {
+    const alreadyProfiled = new Set(this.store.getProfiledModelIds());
+    const toProfile = models.filter(
+      (m) => !alreadyProfiled.has(m.id) && !SKIP_PATTERN.test(m.id) && !SKIP_PATTERN.test(m.name)
+    );
+    if (toProfile.length === 0) return;
+    const openRouterModels = await fetchOpenRouterModels();
+    const orByNormalizedId = /* @__PURE__ */ new Map();
+    for (const m of openRouterModels) {
+      orByNormalizedId.set(m.id.toLowerCase(), m);
+      const short = m.id.split("/").pop();
+      if (short) orByNormalizedId.set(short.toLowerCase(), m);
+    }
+    await Promise.allSettled(
+      toProfile.map(async (model) => {
+        let specializations = [];
+        const orMatch = orByNormalizedId.get(model.id.toLowerCase()) ?? orByNormalizedId.get(model.id.split("/").pop()?.toLowerCase() ?? "");
+        if (orMatch?.description) {
+          specializations = extractSpecializations(orMatch.description);
+        }
+        if (specializations.length === 0 && this.router) {
+          specializations = await queryModelDirectly(this.router);
+        }
+        this.store.saveModelProfile(model.id, model.provider, specializations);
+      })
+    );
+  }
+};
+
 // src/core/router/index.ts
 var CascadeRouter = class _CascadeRouter extends EventEmitter {
   selector;
@@ -1607,6 +1891,7 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
   budgetState = "ok";
   budgetExceededReason;
   tpmLimiter;
+  localQueue;
   /** Thrown when the configured budget is exceeded. */
   static BudgetExceededError = class extends Error {
     constructor(msg) {
@@ -1623,6 +1908,7 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
     this.selector = new ModelSelector(availableProviders);
     this.failover = new FailoverManager(this.selector);
     this.tpmLimiter = new TpmLimiter(config.rateLimits?.providerTpm ?? {});
+    this.localQueue = new LocalRequestQueue(config.localConcurrency ?? 1);
     const ollamaCfg = config.providers.find((p) => p.type === "ollama");
     if (availableProviders.has("ollama")) {
       await this.discoverOllamaModels(ollamaCfg);
@@ -1649,6 +1935,17 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
       }
     }
   }
+  /**
+   * Run model specialization profiling in the background.
+   * Only profiles models that haven't been profiled yet (cache-first).
+   * No-op if store is not provided.
+   */
+  async profileModels(store) {
+    const allModels = this.selector.getAllAvailableModels();
+    const profiler = new ModelProfiler(store, this);
+    profiler.profileAll(allModels).catch(() => {
+    });
+  }
   async generate(tier, options, onChunk, requireVision = false) {
     if (this.budgetState === "exceeded") {
       throw new _CascadeRouter.BudgetExceededError(
@@ -1670,9 +1967,26 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
       await this.tpmLimiter.acquire(model.provider, estimatedTokens);
     }
     const useStream = Boolean(onChunk) && model.supportsStreaming && typeof provider.generateStream === "function";
+    let releaseLocalSlot;
+    if (model.isLocal) {
+      const inferenceTimeoutMs = this.config.localInferenceTimeoutMs ?? 3e5;
+      const queueWaitMs = Math.round(inferenceTimeoutMs / 2);
+      releaseLocalSlot = await this.localQueue.acquire(queueWaitMs);
+    }
     try {
       let result;
-      if (useStream && onChunk) {
+      if (model.isLocal) {
+        const inferenceTimeoutMs = this.config.localInferenceTimeoutMs ?? 3e5;
+        const inferencePromise = useStream && onChunk ? provider.generateStream(options, (chunk) => {
+          const text = typeof chunk?.text === "string" ? chunk.text : "";
+          if (text) onChunk({ ...chunk, text });
+        }) : provider.generate(options);
+        result = await withTimeout(
+          inferencePromise,
+          inferenceTimeoutMs,
+          `Local model ${model.id} inference timed out after ${inferenceTimeoutMs}ms`
+        );
+      } else if (useStream && onChunk) {
         try {
           result = await provider.generateStream(options, (chunk) => {
             const text = typeof chunk?.text === "string" ? chunk.text : "";
@@ -1710,10 +2024,14 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
         if (fallback) {
           this.tierModels.set(tier, fallback);
           this.ensureProvider(fallback, this.config.providers);
+          releaseLocalSlot?.();
+          releaseLocalSlot = void 0;
           return this.generate(tier, options, onChunk, requireVision);
         }
       }
       throw err;
+    } finally {
+      releaseLocalSlot?.();
     }
   }
   getModelForTier(tier) {
@@ -1953,29 +2271,6 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
     return /rate.?limit|429|too.?many.?requests|quota/i.test(msg);
   }
 };
-
-// src/utils/retry.ts
-var CascadeCancelledError = class extends Error {
-  constructor(reason) {
-    super(reason ?? "Run was cancelled via AbortSignal");
-    this.name = "CascadeCancelledError";
-  }
-};
-var CascadeToolError = class extends Error {
-  /** A friendly message to show the user / T3 */
-  userMessage;
-  /** Whether this error class is retryable by default */
-  retryable;
-  constructor(userMessage, cause, retryable = false) {
-    const causeMsg = cause instanceof Error ? cause.message : String(cause);
-    super(`${userMessage}: ${causeMsg}`);
-    this.name = "CascadeToolError";
-    this.userMessage = userMessage;
-    this.retryable = retryable;
-  }
-};
-
-// src/core/tiers/base.ts
 var BaseTier = class extends EventEmitter {
   id;
   role;
@@ -2256,6 +2551,97 @@ 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;
+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);
+}
+function tryXmlBlocks(text) {
+  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 {
+    }
+  }
+  return results;
+}
+function tryJsonCodeBlocks(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 {
+    }
+  }
+  return results;
+}
+function tryFunctionCallObjects(text) {
+  const results = [];
+  let match;
+  FUNCTION_OBJ_RE.lastIndex = 0;
+  while ((match = FUNCTION_OBJ_RE.exec(text)) !== null) {
+    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 });
+    } catch {
+    }
+  }
+  return results;
+}
+function toToolCall(parsed, index) {
+  return {
+    id: `text-tool-${Date.now()}-${index}`,
+    name: parsed.name,
+    input: parsed.input
+  };
+}
+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  " : ""}}`;
+  }).join("\n");
+  return `
+TOOL USE INSTRUCTIONS:
+You do not have native tool-use capability. To call a tool, write a <tool_call> block:
+
+<tool_call>
+{"name": "<tool_name>", "input": {<parameters>}}
+</tool_call>
+
+Available tools:
+${toolDefs}
+
+EXAMPLE \u2014 calling the "shell" tool to list files:
+<tool_call>
+{"name": "shell", "input": {"command": "ls -la /workspace"}}
+</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.`;
+}
+
 // src/core/tiers/t3-worker.ts
 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.
 
@@ -2457,6 +2843,9 @@ 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;
+    const textToolSuffix = useTextTools ? buildTextToolSystemPrompt(tools) : "";
     while (iterations < MAX_ITERATIONS) {
       iterations++;
       this.throwIfCancelled();
@@ -2464,8 +2853,9 @@ Now execute your subtask using this context where relevant.`
         messages: this.context.getMessages(),
         systemPrompt: this.systemPromptOverride + systemPrompt + (this.hierarchyContext ? `
 
-HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
-        tools: tools.length ? tools : void 0,
+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
       };
       const result = await this.router.generate(
@@ -2475,8 +2865,14 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
           this.emit("stream:token", { tierId: this.id, text: chunk.text });
         }
       );
-      await this.context.addMessage({ role: "assistant", content: result.content, toolCalls: result.toolCalls });
-      if (!result.toolCalls?.length) {
+      let effectiveToolCalls = result.toolCalls ?? [];
+      if (useTextTools && effectiveToolCalls.length === 0) {
+        const textCalls = parseTextToolCalls(result.content);
+        effectiveToolCalls = textCalls.map((tc, i) => toToolCall(tc, i));
+      }
+      const effectiveResult = { ...result, toolCalls: effectiveToolCalls };
+      await this.context.addMessage({ role: "assistant", content: result.content, toolCalls: effectiveToolCalls });
+      if (!effectiveResult.toolCalls?.length) {
         if (requiresArtifact) {
           const artifactCheck = await this.verifyArtifacts(this.assignment);
           if (artifactCheck.ok) {
@@ -2498,7 +2894,7 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
         return { output: result.content, toolCalls: allToolCalls };
       }
       stalledArtifactIterations = 0;
-      if (result.finishReason === "stop") {
+      if (effectiveResult.finishReason === "stop" && effectiveResult.toolCalls.length === 0) {
         if (requiresArtifact) {
           const artifactCheck = await this.verifyArtifacts(this.assignment);
           if (artifactCheck.ok) {
@@ -2508,7 +2904,7 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
           return { output: result.content, toolCalls: allToolCalls };
         }
       }
-      for (const tc of result.toolCalls) {
+      for (const tc of effectiveResult.toolCalls) {
         allToolCalls.push(tc);
         const toolResult = await this.executeTool(tc);
         await this.context.addMessage({
@@ -2566,13 +2962,15 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
       currentAction: `Using tool: ${tc.name}`,
       status: "IN_PROGRESS"
     });
+    this.emit("tool:call", { id: tc.id, tierId: this.id, toolName: tc.name, input: tc.input });
+    const toolStartMs = Date.now();
     try {
       const result = await this.toolRegistry.execute(tc.name, tc.input, {
         tierId: this.id,
         sessionId: this.taskId,
         requireApproval: false,
-        saveSnapshot: async (path14, content) => {
-          this.store?.addFileSnapshot(this.taskId, path14, content);
+        saveSnapshot: async (path17, content) => {
+          this.store?.addFileSnapshot(this.taskId, path17, content);
         },
         sendPeerSync: (to, syncType, content) => {
           this.peerBus?.send(this.id, to, syncType, this.assignment?.subtaskId ?? "", content);
@@ -2589,12 +2987,84 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
           this.audit.fileChange(this.id, tc.input["path"] ?? "unknown", tc.name);
         }
       }
-      this.emit("tool:result", { tierId: this.id, toolName: tc.name, result });
+      const durationMs = Date.now() - toolStartMs;
+      this.emit("tool:result", { id: tc.id, tierId: this.id, toolName: tc.name, output: typeof result === "string" ? result : JSON.stringify(result), durationMs });
       return typeof result === "string" ? result : JSON.stringify(result);
     } catch (err) {
-      return `Tool error: ${err instanceof Error ? err.message : String(err)}`;
+      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}`;
     }
   }
+  /**
+   * Adaptive fallback cascade — invoked when executeTool() fails.
+   * Strategy order:
+   *   1. Find a semantically similar registered tool and retry with same input
+   *   2. Synthesize a new tool via ToolCreator (if available) and run it
+   *   3. Return the original error so the agent loop can decide what to do next
+   */
+  async adaptiveFallback(tc, originalError) {
+    const altTool = this.findAlternativeTool(tc.name);
+    if (altTool) {
+      this.log(`Adaptive fallback: trying alternative tool "${altTool}" for failed "${tc.name}"`);
+      this.sendStatusUpdate({ progressPct: 50, currentAction: `Fallback: trying ${altTool}`, status: "IN_PROGRESS" });
+      try {
+        const result = await this.toolRegistry.execute(altTool, tc.input, {
+          tierId: this.id,
+          sessionId: this.taskId,
+          requireApproval: false
+        });
+        const str = typeof result === "string" ? result : JSON.stringify(result);
+        if (!str.startsWith("Tool error:") && !str.startsWith("Error:")) {
+          return `[Fallback via ${altTool}]: ${str}`;
+        }
+      } catch {
+      }
+    }
+    if (this.toolCreator) {
+      this.log(`Adaptive fallback: requesting dynamic tool synthesis for "${tc.name}"`);
+      this.sendStatusUpdate({ progressPct: 55, currentAction: `Synthesizing fallback tool for: ${tc.name}`, status: "IN_PROGRESS" });
+      try {
+        const newToolName = await this.toolCreator.createTool(
+          `Replacement for "${tc.name}" \u2014 original failed with: ${originalError.slice(0, 150)}`,
+          this.assignment?.subtaskTitle ?? tc.name
+        );
+        if (newToolName) {
+          this.log(`Adaptive fallback: synthesized "${newToolName}", retrying`);
+          const result = await this.toolRegistry.execute(newToolName, tc.input, {
+            tierId: this.id,
+            sessionId: this.taskId,
+            requireApproval: false
+          });
+          const str = typeof result === "string" ? result : JSON.stringify(result);
+          if (!str.startsWith("Tool error:")) return `[Synthesized ${newToolName}]: ${str}`;
+        }
+      } catch {
+      }
+    }
+    return originalError;
+  }
+  /**
+   * Find a registered tool whose name/description semantically overlaps with
+   * the failing tool. Returns the best candidate name, or null if none found.
+   */
+  findAlternativeTool(failedToolName) {
+    const failedKeywords = failedToolName.toLowerCase().split(/[_\-\s]+/);
+    const allTools = this.toolRegistry.getToolDefinitions();
+    let bestScore = 0;
+    let bestName = null;
+    for (const tool of allTools) {
+      if (tool.name === failedToolName) continue;
+      const toolWords = tool.name.toLowerCase().split(/[_\-\s]+/);
+      const score = failedKeywords.filter((k) => toolWords.includes(k)).length;
+      if (score > bestScore && score >= 1) {
+        bestScore = score;
+        bestName = tool.name;
+      }
+    }
+    return bestName;
+  }
   /**
    * Announce which files this T3 plans to edit, then acquire locks on them
    * before competing siblings can claim them. T3s working on different files
@@ -2653,12 +3123,12 @@ ${assignment.expectedOutput}`;
     if (!artifactPaths.length) return { ok: true, issues: [] };
     const issues = [];
     const { exec: exec3 } = await import('child_process');
-    const { promisify: promisify3 } = await import('util');
-    const execAsync2 = promisify3(exec3);
+    const { promisify: promisify4 } = await import('util');
+    const execAsync2 = promisify4(exec3);
     for (const artifactPath of artifactPaths) {
-      const absolutePath = path13.resolve(process.cwd(), artifactPath);
+      const absolutePath = path16.resolve(process.cwd(), artifactPath);
       try {
-        const stat = await fs2.stat(absolutePath);
+        const stat = await fs3.stat(absolutePath);
         if (!stat.isFile()) {
           issues.push(`Expected artifact is not a file: ${artifactPath}`);
           continue;
@@ -2668,7 +3138,7 @@ ${assignment.expectedOutput}`;
           continue;
         }
         if (!/\.pdf$/i.test(artifactPath)) {
-          const content = await fs2.readFile(absolutePath, "utf-8");
+          const content = await fs3.readFile(absolutePath, "utf-8");
           if (!content.trim()) {
             issues.push(`Artifact content is empty: ${artifactPath}`);
             continue;
@@ -2677,7 +3147,7 @@ ${assignment.expectedOutput}`;
           issues.push(`PDF artifact looks too small to be valid: ${artifactPath}`);
           continue;
         }
-        const ext = path13.extname(absolutePath).toLowerCase();
+        const ext = path16.extname(absolutePath).toLowerCase();
         try {
           if (ext === ".ts" || ext === ".tsx") {
             await execAsync2(`npx tsc --noEmit ${absolutePath}`, { timeout: 1e4 });
@@ -2795,6 +3265,11 @@ var PeerBus = class extends EventEmitter {
   barriers = /* @__PURE__ */ new Map();
   broadcastLog = [];
   fileLocks = /* @__PURE__ */ new Map();
+  /** subtaskIds whose T3 is being retried by T2 — dependents should re-wait rather than fail fast */
+  retryPending = /* @__PURE__ */ new Set();
+  /** Called when any peer message or broadcast is sent — used for dashboard visibility. */
+  onPeerMessage;
+  sessionId = "";
   register(peerId) {
     this.members.add(peerId);
   }
@@ -2816,11 +3291,33 @@ var PeerBus = class extends EventEmitter {
     this.waiters.delete(subtaskId);
   }
   /**
-   * Wait for a specific subtask's output — resolves immediately if already available
+   * Mark a subtask as retry-pending so dependents re-wait instead of failing fast
+   * when they see an ESCALATED status.
+   */
+  markRetryPending(subtaskId) {
+    this.retryPending.add(subtaskId);
+    this.outputs.delete(subtaskId);
+  }
+  /** Called by T2 after retry resolves (success or final failure). */
+  clearRetryPending(subtaskId) {
+    this.retryPending.delete(subtaskId);
+  }
+  /** Remove a single output entry so a respawned worker can republish without clearing prior-wave outputs. */
+  clearOutput(subtaskId) {
+    this.outputs.delete(subtaskId);
+    this.waiters.delete(subtaskId);
+    this.retryPending.delete(subtaskId);
+  }
+  isRetryPending(subtaskId) {
+    return this.retryPending.has(subtaskId);
+  }
+  /**
+   * Wait for a specific subtask's output — resolves immediately if already available.
+   * If the output is ESCALATED but a retry is pending, waits for the retry result.
    */
   waitFor(subtaskId, timeoutMs = 12e4) {
     const existing = this.outputs.get(subtaskId);
-    if (existing) return Promise.resolve(existing);
+    if (existing && !this.retryPending.has(subtaskId)) return Promise.resolve(existing);
     return new Promise((resolve, reject) => {
       const resolver = (output) => {
         clearTimeout(timer);
@@ -2851,6 +3348,7 @@ var PeerBus = class extends EventEmitter {
    * Also logs to broadcastLog so collect() can retrieve recent broadcasts.
    */
   broadcast(fromId, payload) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const msg = {
       fromId,
       toId: "*",
@@ -2858,10 +3356,18 @@ var PeerBus = class extends EventEmitter {
       subtaskId: "",
       syncType: "SHARE_OUTPUT",
       payload,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      timestamp
     };
-    this.broadcastLog.push({ fromId, payload, timestamp: msg.timestamp });
+    this.broadcastLog.push({ fromId, payload, timestamp });
     this.emit("broadcast", msg);
+    this.onPeerMessage?.({
+      fromId,
+      toId: void 0,
+      syncType: "SHARE_OUTPUT",
+      payload: typeof payload === "string" ? payload : JSON.stringify(payload),
+      timestamp,
+      sessionId: this.sessionId
+    });
   }
   /**
    * Collect all broadcast messages received within a time window.
@@ -2947,6 +3453,16 @@ var PeerBus = class extends EventEmitter {
   isFileLocked(filePath) {
     return this.fileLocks.has(filePath);
   }
+  /**
+   * Reset all runtime output/waiter state for a fresh T3 respawn wave.
+   * Preserves member registrations and barrier definitions.
+   */
+  reset() {
+    this.outputs.clear();
+    this.waiters.clear();
+    this.retryPending.clear();
+    this.broadcastLog = [];
+  }
   /**
    * Clear broadcast log — call between phases to avoid stale announcements.
    */
@@ -2957,6 +3473,7 @@ var PeerBus = class extends EventEmitter {
    * Send a targeted message to a specific peer
    */
   send(fromId, toId, syncType, subtaskId, payload) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const msg = {
       fromId,
       toId,
@@ -2964,10 +3481,18 @@ var PeerBus = class extends EventEmitter {
       subtaskId,
       syncType,
       payload,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      timestamp
     };
     this.emit(`message:${toId}`, msg);
     this.emit("message", msg);
+    this.onPeerMessage?.({
+      fromId,
+      toId,
+      syncType: syncType ?? "SHARE_OUTPUT",
+      payload: typeof payload === "string" ? payload : JSON.stringify(payload),
+      timestamp,
+      sessionId: this.sessionId
+    });
   }
   /**
    * Barrier — wait until N peers have all reached this point
@@ -3020,6 +3545,8 @@ var T2Manager = class extends BaseTier {
   t2PeerBus;
   permissionEscalator;
   toolCreator;
+  /** AbortController for the current T3 wave — aborted on cancel-and-respawn */
+  waveAbortController = null;
   setPeerBus(bus) {
     this.t2PeerBus = bus;
     this.t2PeerBus.register(this.id);
@@ -3028,6 +3555,14 @@ var T2Manager = class extends BaseTier {
       this.receivePeerSync(msg.fromId, msg.payload);
     });
   }
+  setPeerMessageCallback(cb, sessionId) {
+    this.t3PeerBus.onPeerMessage = cb;
+    this.t3PeerBus.sessionId = sessionId;
+    if (this.t2PeerBus) {
+      this.t2PeerBus.onPeerMessage = cb;
+      this.t2PeerBus.sessionId = sessionId;
+    }
+  }
   constructor(router, toolRegistry, parentId) {
     super("T2", void 0, parentId);
     this.router = router;
@@ -3195,6 +3730,26 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
       }];
     }
   }
+  buildWorkerMap(assignments, taskId) {
+    const workerMap = /* @__PURE__ */ new Map();
+    for (const a of assignments) {
+      const worker = new T3Worker(this.router, this.toolRegistry, this.id);
+      if (this.store) worker.setStore(this.store, taskId);
+      worker.setPeerBus(this.t3PeerBus);
+      if (this.permissionEscalator) worker.setPermissionEscalator(this.permissionEscalator);
+      if (this.toolCreator) worker.setToolCreator(this.toolCreator);
+      workerMap.set(a.subtaskId, worker);
+      this.t3Workers.set(a.subtaskId, worker);
+      worker.on("stream:token", (e) => this.emit("stream:token", e));
+      worker.on("log", (e) => this.emit("log", e));
+      worker.on("tier:status", (e) => this.emit("tier:status", e));
+      worker.on("tool:approval-request", (e) => this.emit("tool:approval-request", {
+        ...e,
+        __cascadeResponder: (decision) => worker.emit(`tool:approval-response:${e.id}`, decision)
+      }));
+    }
+    return workerMap;
+  }
   async executeSubtasks(subtasks, taskId) {
     const assignments = subtasks.map((s) => ({
       ...s,
@@ -3221,6 +3776,8 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
       worker.on("stream:token", (e) => this.emit("stream:token", e));
       worker.on("log", (e) => this.emit("log", e));
       worker.on("tier:status", (e) => this.emit("tier:status", e));
+      worker.on("tool:call", (e) => this.emit("tool:call", e));
+      worker.on("tool:result", (e) => this.emit("tool:result", e));
       worker.on("tool:approval-request", (e) => this.emit("tool:approval-request", {
         ...e,
         __cascadeResponder: (decision) => worker.emit(`tool:approval-response:${e.id}`, decision)
@@ -3257,6 +3814,7 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
     const sanitizedAssignments = this.breakCycles(assignments, adj, inDegree);
     let remaining = new Set(sanitizedAssignments.map((a) => a.subtaskId));
     let wave = 0;
+    let respawnBudget = 1;
     while (remaining.size > 0) {
       const runnableIds = [...remaining].filter((id) => (inDegree.get(id) ?? 0) === 0);
       if (runnableIds.length === 0) {
@@ -3277,15 +3835,62 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
         status: "IN_PROGRESS"
       });
       this.throwIfCancelled();
+      this.waveAbortController = new AbortController();
+      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, this.signal);
+          const result = await worker.execute(assignment, taskId, waveSignal);
           resultMap.set(id, result);
           return result;
         })
       );
+      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;
+      if (escalatedToolIdx !== -1 && this.toolCreator) {
+        respawnBudget--;
+        this.waveAbortController.abort();
+        const escalatedId = runnableIds[escalatedToolIdx];
+        const escalatedAssignment = sanitizedAssignments.find((a) => a.subtaskId === escalatedId);
+        this.log(`Wave ${wave}: tool escalation detected \u2014 synthesizing tool then respawning all ${runnableIds.length} worker(s)`);
+        this.sendStatusUpdate({
+          progressPct: 50,
+          currentAction: `Synthesizing dynamic tool for: ${escalatedAssignment.subtaskTitle}`,
+          status: "IN_PROGRESS"
+        });
+        const toolName = await this.toolCreator.createTool(
+          `Help complete: ${escalatedAssignment.subtaskTitle}`,
+          escalatedAssignment.description
+        );
+        if (toolName) {
+          this.log(`Tool "${toolName}" created \u2014 respawning wave ${wave} workers`);
+          for (const a of sanitizedAssignments) {
+            if (runnableIds.includes(a.subtaskId)) {
+              a.description += `
+
+[SYSTEM]: Dynamic tool "${toolName}" is now available \u2014 use it to complete your task.`;
+            }
+          }
+        }
+        for (const id of runnableIds) {
+          this.t3PeerBus.clearOutput(id);
+        }
+        const freshMap = this.buildWorkerMap(
+          sanitizedAssignments.filter((a) => runnableIds.includes(a.subtaskId)),
+          taskId
+        );
+        for (const [k, v] of freshMap) workerMap.set(k, v);
+        for (const id of runnableIds) {
+          remaining.add(id);
+          inDegree.set(id, 0);
+        }
+        wave--;
+        continue;
+      }
       for (let i = 0; i < runnableIds.length; i++) {
         const id = runnableIds[i];
         remaining.delete(id);
@@ -3293,61 +3898,22 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
         if (r.status === "rejected") {
           this.log(`T3 worker ${id} failed: ${r.reason instanceof Error ? r.reason.message : String(r.reason)} \u2014 retrying once`);
           const assignment = sanitizedAssignments.find((a) => a.subtaskId === id);
-          const retried = await this.retryT3(assignment, taskId);
-          resultMap.set(id, retried);
-        } else if (r.status === "fulfilled" && r.value.status === "ESCALATED" && r.value.issues.some((i2) => i2.includes("dynamic tool generation"))) {
-          const assignment = sanitizedAssignments.find((a) => a.subtaskId === id);
-          if (this.toolCreator) {
-            this.log(`T3 escalated for tool. T2 spawning Tool-Builder T3 for: ${assignment.subtaskTitle}`);
-            this.sendStatusUpdate({
-              progressPct: 50,
-              currentAction: `Spawning Tool-Builder T3 for: ${assignment.subtaskTitle}`,
-              status: "IN_PROGRESS"
+          try {
+            const retried = await this.retryT3(assignment, taskId);
+            resultMap.set(id, retried);
+          } catch (retryErr) {
+            const msg = retryErr instanceof Error ? retryErr.message : String(retryErr);
+            this.log(`T3 retry for ${id} threw before publishing \u2014 unblocking dependents with FAILED`);
+            this.t3PeerBus.publish(this.id, id, `Retry failed: ${msg}`, "FAILED");
+            resultMap.set(id, {
+              subtaskId: id,
+              status: "FAILED",
+              output: `Retry threw: ${msg}`,
+              testResults: { checksRun: [], passed: [], failed: [] },
+              issues: [msg],
+              peerSyncsUsed: [],
+              correctionAttempts: 1
             });
-            const toolName = await this.toolCreator.createTool(
-              `Help complete: ${assignment.subtaskTitle}`,
-              assignment.description
-            );
-            if (toolName) {
-              this.log(`T2 verifying new tool: ${toolName}`);
-              this.sendStatusUpdate({
-                progressPct: 60,
-                currentAction: `T2 Verifying new tool: ${toolName}`,
-                status: "IN_PROGRESS"
-              });
-              try {
-                const verifyResult = await this.router.generate("T2", {
-                  messages: [{ role: "user", content: `A new tool named "${toolName}" was just created dynamically to help with: ${assignment.description}. Based on its name and purpose, does this seem like a valid addition? Reply "VERIFIED" or "REJECTED".` }],
-                  systemPrompt: this.systemPromptOverride + "You are T2 Manager verifying a dynamic tool.",
-                  maxTokens: 50
-                });
-                if (!verifyResult.content.toUpperCase().includes("REJECTED")) {
-                  this.log(`T2 verification passed for ${toolName}. Restarting original T3.`);
-                  const retried = await this.retryT3({
-                    ...assignment,
-                    description: `${assignment.description}
-
-[SYSTEM NOTIFICATION]: A new dynamic tool "${toolName}" has been built and verified for you. Use it to complete your task.`
-                  }, taskId);
-                  resultMap.set(id, retried);
-                } else {
-                  this.log(`T2 rejected the dynamic tool: ${toolName}`);
-                  resultMap.set(id, r.value);
-                }
-              } catch {
-                const retried = await this.retryT3({
-                  ...assignment,
-                  description: `${assignment.description}
-
-[SYSTEM NOTIFICATION]: A new dynamic tool "${toolName}" has been built for you. Use it to complete your task.`
-                }, taskId);
-                resultMap.set(id, retried);
-              }
-            } else {
-              resultMap.set(id, r.value);
-            }
-          } else {
-            resultMap.set(id, r.value);
           }
         }
         for (const dependent of adj.get(id) ?? []) {
@@ -3618,6 +4184,8 @@ var T1Administrator = class extends BaseTier {
   toolCreator;
   /** Stored overall task goal — used when evaluating escalated permissions */
   taskGoal = "";
+  peerMessageCallback;
+  peerMessageSessionId = "";
   constructor(router, toolRegistry, config) {
     super("T1", "T1");
     this.router = router;
@@ -3638,6 +4206,12 @@ var T1Administrator = class extends BaseTier {
   setToolCreator(creator) {
     this.toolCreator = creator;
   }
+  setPeerMessageCallback(cb, sessionId) {
+    this.peerMessageCallback = cb;
+    this.peerMessageSessionId = sessionId;
+    this.t2PeerBus.onPeerMessage = cb;
+    this.t2PeerBus.sessionId = sessionId;
+  }
   async execute(userPrompt, images, systemContext, signal) {
     this.signal = signal;
     this.taskId = randomUUID();
@@ -3857,6 +4431,9 @@ Leave dependsOn empty for sections that can run immediately in parallel.`;
         manager.setStore(this.store);
       }
       manager.setPeerBus(this.t2PeerBus);
+      if (this.peerMessageCallback) {
+        manager.setPeerMessageCallback(this.peerMessageCallback, this.peerMessageSessionId);
+      }
       if (this.permissionEscalator) {
         manager.setPermissionEscalator(this.permissionEscalator);
       }
@@ -3867,6 +4444,8 @@ Leave dependsOn empty for sections that can run immediately in parallel.`;
       bind(manager, "stream:token", (e) => this.emit("stream:token", e));
       bind(manager, "log", (e) => this.emit("log", e));
       bind(manager, "tier:status", (e) => this.emit("tier:status", e));
+      bind(manager, "tool:call", (e) => this.emit("tool:call", e));
+      bind(manager, "tool:result", (e) => this.emit("tool:result", e));
       bind(manager, "tool:approval-request", (e) => this.emit("tool:approval-request", e));
       bind(manager, "message", (msg) => {
         if (msg.type === "PEER_SYNC") {
@@ -4226,13 +4805,21 @@ function resolveInWorkspace(workspaceRoot, input) {
   if (typeof input !== "string" || input.length === 0) {
     throw new WorkspaceSandboxError(String(input), workspaceRoot);
   }
-  const root = path13.resolve(workspaceRoot);
-  const abs = path13.isAbsolute(input) ? path13.resolve(input) : path13.resolve(root, input);
-  const rel = path13.relative(root, abs);
-  if (rel === "" || rel === ".") return abs;
-  if (rel.startsWith("..") || path13.isAbsolute(rel)) {
+  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)) {
     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))) {
+      throw new WorkspaceSandboxError(input, root);
+    }
+  } catch (e) {
+    if (e instanceof WorkspaceSandboxError) throw e;
+  }
   return abs;
 }
 
@@ -4254,7 +4841,7 @@ var FileReadTool = class extends BaseTool {
     const absPath = resolveInWorkspace(this.workspaceRoot, filePath);
     const offset = input["offset"] ?? 1;
     const limit = input["limit"];
-    const content = await fs2.readFile(absPath, "utf-8");
+    const content = await fs3.readFile(absPath, "utf-8");
     const lines = content.split("\n");
     const start = Math.max(0, offset - 1);
     const end = limit ? start + limit : lines.length;
@@ -4283,13 +4870,13 @@ var FileWriteTool = class extends BaseTool {
     const content = input["content"];
     if (options.saveSnapshot) {
       try {
-        const oldContent = await fs2.readFile(absPath, "utf-8");
+        const oldContent = await fs3.readFile(absPath, "utf-8");
         await options.saveSnapshot(absPath, oldContent);
       } catch {
       }
     }
-    await fs2.mkdir(path13.dirname(absPath), { recursive: true });
-    await fs2.writeFile(absPath, content, "utf-8");
+    await fs3.mkdir(path16.dirname(absPath), { recursive: true });
+    await fs3.writeFile(absPath, content, "utf-8");
     return `Written ${content.length} characters to ${filePath}`;
   }
 };
@@ -4315,7 +4902,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 fs2.readFile(absPath, "utf-8");
+    const rawContent = await fs3.readFile(absPath, "utf-8");
     if (options.saveSnapshot) {
       await options.saveSnapshot(absPath, rawContent);
     }
@@ -4327,7 +4914,7 @@ var FileEditTool = class extends BaseTool {
       );
     }
     const updated = replaceAll ? content.split(normalizedOld).join(newString) : content.replace(normalizedOld, newString);
-    await fs2.writeFile(absPath, updated, "utf-8");
+    await fs3.writeFile(absPath, updated, "utf-8");
     const count = replaceAll ? content.split(normalizedOld).length - 1 : 1;
     return `Replaced ${count} occurrence(s) in ${filePath}`;
   }
@@ -4350,12 +4937,12 @@ var FileDeleteTool = class extends BaseTool {
     const absPath = resolveInWorkspace(this.workspaceRoot, filePath);
     if (options.saveSnapshot) {
       try {
-        const oldContent = await fs2.readFile(absPath, "utf-8");
+        const oldContent = await fs3.readFile(absPath, "utf-8");
         await options.saveSnapshot(absPath, oldContent);
       } catch {
       }
     }
-    await fs2.rm(absPath, { recursive: false });
+    await fs3.rm(absPath, { recursive: false });
     return `Deleted ${filePath}`;
   }
 };
@@ -4372,7 +4959,7 @@ var FileListTool = class extends BaseTool {
   async execute(input, _options) {
     const inputPath = input["path"] || ".";
     const absPath = resolveInWorkspace(this.workspaceRoot, inputPath);
-    const entries = await fs2.readdir(absPath, { withFileTypes: true });
+    const entries = await fs3.readdir(absPath, { withFileTypes: true });
     return entries.map((e) => `${e.isDirectory() ? "[DIR] " : "      "}${e.name}`).join("\n") || "(empty directory)";
   }
 };
@@ -4755,8 +5342,8 @@ var ImageAnalyzeTool = class extends BaseTool {
   }
 };
 async function fileToImageAttachment(filePath) {
-  const data = await fs2.readFile(filePath);
-  const ext = path13.extname(filePath).toLowerCase();
+  const data = await fs3.readFile(filePath);
+  const ext = path16.extname(filePath).toLowerCase();
   const mimeMap = {
     ".jpg": "image/jpeg",
     ".jpeg": "image/jpeg",
@@ -4790,14 +5377,14 @@ var PDFCreateTool = class extends BaseTool {
     const filePath = input["path"];
     const content = input["content"];
     const title = input["title"];
-    const dir = path13.dirname(filePath);
-    if (!fs11.existsSync(dir)) {
-      fs11.mkdirSync(dir, { recursive: true });
+    const dir = path16.dirname(filePath);
+    if (!fs15.existsSync(dir)) {
+      fs15.mkdirSync(dir, { recursive: true });
     }
     return new Promise((resolve, reject) => {
       try {
         const doc = new PDFDocument({ margin: 50 });
-        const stream = fs11.createWriteStream(filePath);
+        const stream = fs15.createWriteStream(filePath);
         doc.pipe(stream);
         if (title) {
           doc.info["Title"] = title;
@@ -4875,14 +5462,14 @@ var CodeInterpreterTool = class extends BaseTool {
       }
       cmdPrefix = NODE_CMD;
     }
-    const tmpDir = path13.join(process.cwd(), ".cascade", "tmp");
-    if (!fs11.existsSync(tmpDir)) {
-      fs11.mkdirSync(tmpDir, { recursive: true });
+    const tmpDir = path16.join(process.cwd(), ".cascade", "tmp");
+    if (!fs15.existsSync(tmpDir)) {
+      fs15.mkdirSync(tmpDir, { recursive: true });
     }
     const extension = language === "python" ? "py" : "js";
     const fileName = `intp_${randomUUID().slice(0, 8)}.${extension}`;
-    const filePath = path13.join(tmpDir, fileName);
-    fs11.writeFileSync(filePath, code, "utf-8");
+    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 : ""}`;
@@ -4891,8 +5478,8 @@ var CodeInterpreterTool = class extends BaseTool {
       exec(fullCmd, { cwd: process.cwd(), timeout: 3e4 }, (error, stdout, stderr) => {
         const duration = Date.now() - startMs;
         try {
-          if (fs11.existsSync(filePath)) {
-            fs11.unlinkSync(filePath);
+          if (fs15.existsSync(filePath)) {
+            fs15.unlinkSync(filePath);
           }
         } catch (cleanupErr) {
           console.error(`Failed to cleanup interpreter script ${filePath}:`, cleanupErr);
@@ -5152,6 +5739,253 @@ var WebSearchTool = class extends BaseTool {
     return lines.join("\n");
   }
 };
+var GlobTool = class extends BaseTool {
+  name = "glob";
+  description = "Fast file pattern matching. Returns file paths matching a glob pattern, sorted by modification time. Use this to find files by name patterns.";
+  inputSchema = {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: 'Glob pattern to match files against, e.g. "**/*.ts", "src/**/*.tsx"'
+      },
+      path: {
+        type: "string",
+        description: "Directory to search in. Defaults to the workspace root."
+      }
+    },
+    required: ["pattern"]
+  };
+  async execute(input, _options) {
+    const pattern = input["pattern"];
+    const searchPath = input["path"] ? path16.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
+    const matches = await glob(pattern, {
+      cwd: searchPath,
+      ignore: ["node_modules/**", ".git/**", "dist/**", "build/**"],
+      nodir: true,
+      dot: false
+    });
+    if (matches.length === 0) {
+      return `No files matched pattern: ${pattern}`;
+    }
+    const withMtime = await Promise.all(
+      matches.map(async (rel) => {
+        try {
+          const stat = await fs3.stat(path16.join(searchPath, rel));
+          return { rel, mtime: stat.mtimeMs };
+        } catch {
+          return { rel, mtime: 0 };
+        }
+      })
+    );
+    withMtime.sort((a, b) => b.mtime - a.mtime);
+    const lines = withMtime.map((f) => f.rel);
+    return lines.join("\n");
+  }
+};
+var execFileAsync = promisify(execFile);
+var GrepTool = class extends BaseTool {
+  name = "grep";
+  description = "Search file contents using a regex pattern. Returns matching lines with file paths and line numbers. Tries ripgrep (rg) first, falls back to Node.js regex scan.";
+  inputSchema = {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: "Regular expression pattern to search for in file contents"
+      },
+      path: {
+        type: "string",
+        description: "File or directory to search in. Defaults to workspace root."
+      },
+      glob: {
+        type: "string",
+        description: 'Glob pattern to filter files, e.g. "*.ts", "**/*.tsx"'
+      },
+      output_mode: {
+        type: "string",
+        enum: ["content", "files_with_matches", "count"],
+        description: '"content" shows matching lines (default), "files_with_matches" shows file paths only, "count" shows match counts'
+      },
+      context: {
+        type: "number",
+        description: "Lines of context around each match (content mode only). Default: 0."
+      },
+      case_insensitive: {
+        type: "boolean",
+        description: "Case-insensitive search. Default: false."
+      }
+    },
+    required: ["pattern"]
+  };
+  async execute(input, _options) {
+    const pattern = input["pattern"];
+    const searchPath = input["path"] ? path16.resolve(this.workspaceRoot, input["path"]) : this.workspaceRoot;
+    const globPattern = input["glob"];
+    const outputMode = input["output_mode"] ?? "content";
+    const context = input["context"] ?? 0;
+    const caseInsensitive = input["case_insensitive"] ?? false;
+    try {
+      const result = await this.runRipgrep(
+        pattern,
+        searchPath,
+        globPattern,
+        outputMode,
+        context,
+        caseInsensitive
+      );
+      return result;
+    } catch {
+    }
+    return this.nodeScan(pattern, searchPath, globPattern, outputMode, context, caseInsensitive);
+  }
+  async runRipgrep(pattern, searchPath, globPattern, outputMode, context, caseInsensitive) {
+    const args = ["--no-heading"];
+    if (caseInsensitive) args.push("-i");
+    if (outputMode === "files_with_matches") args.push("-l");
+    else if (outputMode === "count") args.push("-c");
+    else {
+      args.push("-n");
+      if (context > 0) args.push(`-C${context}`);
+    }
+    if (globPattern) args.push("--glob", globPattern);
+    args.push("--", pattern, searchPath);
+    const { stdout } = await execFileAsync("rg", args, {
+      timeout: 15e3,
+      maxBuffer: 2 * 1024 * 1024
+    });
+    const trimmed = stdout.trim();
+    return trimmed || `No matches found for: ${pattern}`;
+  }
+  async nodeScan(pattern, searchPath, globPattern, outputMode, context, caseInsensitive) {
+    const flags = caseInsensitive ? "gi" : "g";
+    let regex;
+    try {
+      regex = new RegExp(pattern, flags);
+    } catch {
+      return `Invalid regex pattern: ${pattern}`;
+    }
+    const fileGlob = globPattern ?? "**/*";
+    let files;
+    try {
+      files = await glob(fileGlob, {
+        cwd: searchPath,
+        ignore: ["node_modules/**", ".git/**", "dist/**", "build/**"],
+        nodir: true
+      });
+    } catch {
+      files = [path16.relative(searchPath, searchPath) || "."];
+    }
+    const results = [];
+    let totalCount = 0;
+    for (const rel of files) {
+      const abs = path16.join(searchPath, rel);
+      let content;
+      try {
+        content = await fs3.readFile(abs, "utf-8");
+      } catch {
+        continue;
+      }
+      const lines = content.split("\n");
+      const matchingLines = [];
+      for (let i = 0; i < lines.length; i++) {
+        if (regex.test(lines[i])) matchingLines.push(i);
+        regex.lastIndex = 0;
+      }
+      if (matchingLines.length === 0) continue;
+      totalCount += matchingLines.length;
+      if (outputMode === "files_with_matches") {
+        results.push(rel);
+      } else if (outputMode === "count") {
+        results.push(`${rel}: ${matchingLines.length}`);
+      } else {
+        const shown = /* @__PURE__ */ new Set();
+        for (const lineIdx of matchingLines) {
+          const start = Math.max(0, lineIdx - context);
+          const end = Math.min(lines.length - 1, lineIdx + context);
+          for (let i = start; i <= end; i++) shown.add(i);
+        }
+        const sortedIdxs = [...shown].sort((a, b) => a - b);
+        for (const i of sortedIdxs) {
+          const marker = matchingLines.includes(i) ? ":" : "-";
+          results.push(`${rel}:${i + 1}${marker}${lines[i]}`);
+        }
+      }
+    }
+    if (results.length === 0) return `No matches found for: ${pattern}`;
+    if (outputMode === "count") {
+      results.push(`
+Total: ${totalCount} matches`);
+    }
+    return results.join("\n");
+  }
+};
+
+// src/tools/web-fetch.ts
+var MAX_CHARS = 5e4;
+var TIMEOUT_MS = 15e3;
+function stripHtml(html) {
+  let text = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<noscript[\s\S]*?<\/noscript>/gi, "");
+  text = text.replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<\/div>/gi, "\n").replace(/<\/h[1-6]>/gi, "\n").replace(/<\/li>/gi, "\n").replace(/<\/tr>/gi, "\n").replace(/<\/td>/gi, "	");
+  text = text.replace(/<[^>]+>/g, "");
+  text = text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/&#(\d+);/g, (_, n) => String.fromCharCode(Number(n)));
+  text = text.split("\n").map((l) => l.trim()).filter((l) => l.length > 0).join("\n");
+  return text;
+}
+var WebFetchTool = class extends BaseTool {
+  name = "web_fetch";
+  description = "Fetch a URL and return its content as plain text (HTML stripped). Use for reading documentation, web pages, or any URL. Limit: 50,000 characters.";
+  inputSchema = {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "The URL to fetch"
+      },
+      prompt: {
+        type: "string",
+        description: "Optional hint for what information to extract from the page (not used for filtering, just context)"
+      }
+    },
+    required: ["url"]
+  };
+  async execute(input, _options) {
+    const url = input["url"];
+    let resp;
+    try {
+      resp = await fetch(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"
+      });
+    } catch (err) {
+      return `Failed to fetch ${url}: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    if (!resp.ok) {
+      return `HTTP ${resp.status} ${resp.statusText} from ${url}`;
+    }
+    const contentType = resp.headers.get("content-type") ?? "";
+    let text;
+    try {
+      const raw = await resp.text();
+      text = contentType.includes("html") ? stripHtml(raw) : raw;
+    } catch (err) {
+      return `Failed to read response body: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    if (text.length > MAX_CHARS) {
+      text = text.slice(0, MAX_CHARS) + `
+
+[Content truncated at ${MAX_CHARS} characters]`;
+    }
+    return `URL: ${url}
+Content-Type: ${contentType}
+
+${text}`;
+  }
+};
 
 // src/tools/mcp.ts
 var McpToolWrapper = class extends BaseTool {
@@ -5177,7 +6011,7 @@ var McpToolWrapper = class extends BaseTool {
 
 // src/tools/registry.ts
 var ignore = ignoreFactory__default.default ?? ignoreFactory__default;
-var ToolRegistry = class {
+var ToolRegistry = class extends EventEmitter {
   tools = /* @__PURE__ */ new Map();
   config;
   ignoreMatcher = ignore();
@@ -5185,12 +6019,36 @@ var ToolRegistry = class {
   /** Loaded plugins, keyed by plugin name */
   plugins = /* @__PURE__ */ new Map();
   constructor(config, workspaceRoot = process.cwd()) {
+    super();
     this.config = config;
     this.workspaceRoot = workspaceRoot;
     this.registerDefaults();
   }
   register(tool) {
     this.tools.set(tool.name, tool);
+    this.emit("tool:added", tool.name);
+  }
+  /**
+   * Wait until a named tool is registered, resolving immediately if it already exists.
+   * T3 workers can call this after encountering a missing-tool error to resume
+   * automatically once T2 synthesizes the tool.
+   */
+  waitForTool(toolName, timeoutMs = 6e4) {
+    if (this.tools.has(toolName)) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.off("tool:added", handler);
+        reject(new Error(`Timeout waiting for tool: ${toolName}`));
+      }, timeoutMs);
+      const handler = (name) => {
+        if (name === toolName) {
+          clearTimeout(timer);
+          this.off("tool:added", handler);
+          resolve();
+        }
+      };
+      this.on("tool:added", handler);
+    });
   }
   /**
    * Register a ToolPlugin, loading all its tools into the registry.
@@ -5275,7 +6133,10 @@ var ToolRegistry = class {
       new PDFCreateTool(),
       new CodeInterpreterTool(),
       new PeerCommunicationTool(),
-      new WebSearchTool(this.config.webSearch)
+      new WebSearchTool(this.config.webSearch),
+      new GlobTool(),
+      new GrepTool(),
+      new WebFetchTool()
     ];
     for (const tool of tools) {
       tool.setWorkspaceRoot(this.workspaceRoot);
@@ -5292,10 +6153,10 @@ var ToolRegistry = class {
   }
   isIgnored(filePath) {
     if (!filePath) return false;
-    const abs = path13.resolve(this.workspaceRoot, filePath);
-    const rel = path13.relative(this.workspaceRoot, abs);
-    if (!rel || rel.startsWith("..") || path13.isAbsolute(rel)) return true;
-    const posixRel = rel.split(path13.sep).join("/");
+    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("/");
     return this.ignoreMatcher.ignores(posixRel);
   }
 };
@@ -5632,7 +6493,24 @@ var CascadeConfigSchema = z.object({
    * Generated tools are session-scoped and sandboxed in node:vm.
    * HTTP calls from generated tools require approval.
    */
-  enableToolCreation: z.boolean().default(false)
+  enableToolCreation: z.boolean().default(true),
+  /**
+   * External plugin paths or npm package names to load at startup.
+   * Each entry must export a default ToolPlugin object.
+   * Example: ["./plugins/my-tool.js", "cascade-plugin-slack"]
+   */
+  plugins: z.array(z.string()).default([]),
+  /**
+   * Maximum number of concurrent inference requests to any local model provider
+   * (e.g. Ollama). Defaults to 1 to prevent GPU memory pressure when multiple
+   * T3 workers run in parallel on a single-GPU machine.
+   */
+  localConcurrency: z.number().int().min(1).default(1),
+  /**
+   * 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)
 });
 
 // src/config/validate.ts
@@ -5760,139 +6638,237 @@ function heuristicAnalyze(prompt) {
   const estimatedTokens = wordCount * 5;
   return { type, complexity, requiresReasoning, requiresVision, estimatedTokens, confidence };
 }
-function selectModelFromProfile(profile, tier, selector) {
-  if (profile.requiresVision) {
-    return selector.selectVisionModel();
-  }
-  if (tier === "T1") {
-    if (profile.complexity >= 4) {
-      return selector.selectForTier("T1");
-    } else {
-      return selector.selectForTier("T2");
-    }
-  }
-  if (tier === "T2") {
-    if (profile.type === "code" || profile.type === "data") {
-      return selector.selectForTier("T2");
-    } else if (profile.complexity <= 2) {
-      return selector.selectForTier("T3");
-    }
-    return selector.selectForTier("T2");
-  }
-  if (tier === "T3") {
-    if (profile.complexity >= 4 || profile.requiresReasoning) {
-      return selector.selectForTier("T2");
-    } else if (profile.type === "creative") {
-      return selector.selectForTier("T2");
-    } else {
-      return selector.selectForTier("T3");
-    }
-  }
-  return selector.selectForTier(tier);
-}
 var analysisCache = /* @__PURE__ */ new Map();
+var TASK_TYPE_TAGS = {
+  code: ["code", "instruction"],
+  analysis: ["analysis", "instruction"],
+  creative: ["creative", "multilingual"],
+  data: ["data", "code"],
+  mixed: []
+};
 var TaskAnalyzer = class {
-  router;
-  constructor(router) {
-    this.router = router;
+  tracker;
+  lastProfile = null;
+  lastSelectedModels = /* @__PURE__ */ new Map();
+  constructor(tracker) {
+    this.tracker = tracker;
+  }
+  setTracker(tracker) {
+    this.tracker = tracker;
+  }
+  /** Returns the TaskProfile from the most recent analyze() call — used for outcome recording. */
+  getLastProfile() {
+    return this.lastProfile;
   }
   /**
-   * Analyze a prompt and return a TaskProfile.
-   * Uses heuristics first; falls back to AI inference if confidence is low.
+   * Analyze a prompt and return a TaskProfile using pure heuristics.
+   * Low confidence prompts fall back to a conservative mixed/moderate profile.
    */
   async analyze(prompt) {
     const cacheKey = prompt.slice(0, 200);
     const cached = analysisCache.get(cacheKey);
-    if (cached) return cached;
-    const heuristic = heuristicAnalyze(prompt);
-    if (heuristic.confidence < 0.7 && this.router) {
-      try {
-        const aiProfile = await this.aiInference(prompt);
-        const merged = {
-          type: aiProfile.type,
-          complexity: aiProfile.complexity,
-          requiresReasoning: aiProfile.requiresReasoning,
-          requiresVision: heuristic.requiresVision || aiProfile.requiresVision,
-          estimatedTokens: heuristic.estimatedTokens,
-          confidence: 0.9
-          // AI-backed
-        };
-        analysisCache.set(cacheKey, merged);
-        return merged;
-      } catch {
-      }
+    if (cached) {
+      this.lastProfile = cached;
+      return cached;
     }
-    analysisCache.set(cacheKey, heuristic);
-    return heuristic;
+    const profile = heuristicAnalyze(prompt);
+    analysisCache.set(cacheKey, profile);
+    this.lastProfile = profile;
+    return profile;
   }
   /**
-   * Select the optimal model for a given tier based on task analysis.
+   * Select the optimal model for a given tier.
+   * Scores tier-eligible models using cost efficiency + historical performance.
+   * Falls back to the priority-list default when no candidates have history.
    */
   async selectModel(prompt, tier, selector) {
     const profile = await this.analyze(prompt);
-    return selectModelFromProfile(profile, tier, selector);
+    if (profile.requiresVision) {
+      return selector.selectVisionModel();
+    }
+    const candidates = selector.getCandidatesForTier(tier);
+    if (candidates.length === 0) return selector.selectForTier(tier);
+    const scored = candidates.map((m) => ({
+      model: m,
+      score: this.scoreModel(m, profile)
+    }));
+    scored.sort((a, b) => b.score - a.score);
+    const best = scored[0]?.model ?? selector.selectForTier(tier);
+    if (best) this.lastSelectedModels.set(tier, best);
+    return best;
   }
-  async aiInference(prompt) {
-    if (!this.router) throw new Error("No router for AI inference");
-    const inferencePrompt = `Analyze this task and return ONLY a JSON object \u2014 no other text.
-
-Task: "${prompt.slice(0, 300)}"
-
-Return: { "type": "code"|"analysis"|"creative"|"data"|"mixed", "complexity": 1-5, "requiresReasoning": true|false, "requiresVision": true|false }
-
-Where complexity: 1=trivial, 2=simple, 3=moderate, 4=complex, 5=research-grade.`;
-    const result = await this.router.generate("T3", {
-      messages: [{ role: "user", content: inferencePrompt }],
-      maxTokens: 80
-    });
-    const jsonMatch = /\{[\s\S]*?\}/.exec(result.content);
-    if (!jsonMatch) throw new Error("No JSON in AI inference response");
-    const parsed = JSON.parse(jsonMatch[0]);
-    const validTypes = ["code", "analysis", "creative", "data", "mixed"];
-    const type = validTypes.includes(parsed.type) ? parsed.type : "mixed";
-    const complexity = Math.max(1, Math.min(5, Math.round(parsed.complexity)));
-    return {
-      type,
-      complexity,
-      requiresReasoning: Boolean(parsed.requiresReasoning),
-      requiresVision: Boolean(parsed.requiresVision),
-      estimatedTokens: 0,
-      confidence: 0.9
-    };
+  /**
+   * Record the outcome of a completed run across all tiers that were selected
+   * during this session and persist stats to disk.
+   */
+  recordRunOutcome(outcome, costByTier) {
+    if (!this.tracker || !this.lastProfile) return;
+    const taskType = this.lastProfile.type;
+    for (const [tier, model] of this.lastSelectedModels) {
+      const cost = costByTier[tier] ?? 0;
+      this.tracker.record(model.id, taskType, outcome, 0, cost);
+    }
+    this.lastSelectedModels.clear();
+    void this.tracker.save();
+  }
+  scoreModel(model, profile) {
+    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;
+  }
+  costEfficiency(model, complexity) {
+    if (this.tracker) return this.tracker.costEfficiencyScore(model, complexity);
+    const blended = model.inputCostPer1kTokens + model.outputCostPer1kTokens * 2;
+    const normalised = Math.min(1, blended / 0.05);
+    const complexityWeight = (6 - complexity) / 5;
+    return Math.max(0.1, 1 - normalised * complexityWeight);
+  }
+  taskMatchScore(model, profile) {
+    const expected = TASK_TYPE_TAGS[profile.type];
+    if (!model.specializations?.length || expected.length === 0) return 1;
+    const matches = expected.filter((tag) => model.specializations.includes(tag)).length;
+    return matches > 0 ? 1 + matches / expected.length * 0.3 : 0.8;
   }
   /** Clear the analysis cache (call between sessions). */
   static clearCache() {
     analysisCache.clear();
   }
 };
+var DEFAULT_STATS_FILE = path16.join(os3.homedir(), ".cascade", "model-perf.json");
+var ModelPerformanceTracker = class {
+  stats = /* @__PURE__ */ new Map();
+  statsFile;
+  loaded = false;
+  constructor(statsFile = DEFAULT_STATS_FILE) {
+    this.statsFile = statsFile;
+  }
+  async load() {
+    if (this.loaded) return;
+    this.loaded = true;
+    try {
+      const raw = await fs3.readFile(this.statsFile, "utf-8");
+      const parsed = JSON.parse(raw);
+      for (const [key, stat] of Object.entries(parsed)) {
+        this.stats.set(key, stat);
+      }
+    } catch {
+    }
+  }
+  async save() {
+    try {
+      await fs3.mkdir(path16.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");
+    } catch {
+    }
+  }
+  record(modelId, taskType, outcome, retries = 0, costUsd = 0) {
+    const key = `${modelId}:${taskType}`;
+    const s = this.stats.get(key) ?? {
+      successCount: 0,
+      failureCount: 0,
+      totalRetries: 0,
+      totalCostUsd: 0,
+      sampleCount: 0
+    };
+    this.stats.set(key, {
+      successCount: s.successCount + (outcome === "success" ? 1 : 0),
+      failureCount: s.failureCount + (outcome === "failure" ? 1 : 0),
+      totalRetries: s.totalRetries + retries,
+      totalCostUsd: s.totalCostUsd + costUsd,
+      sampleCount: s.sampleCount + 1
+    });
+  }
+  /**
+   * Returns 0.05–1.0; defaults to 0.5 (neutral prior) when no history exists.
+   * High retry counts penalise the score.
+   */
+  performanceScore(modelId, taskType) {
+    const key = `${modelId}:${taskType}`;
+    const s = this.stats.get(key);
+    if (!s || s.sampleCount === 0) return 0.5;
+    const successRate = s.successCount / s.sampleCount;
+    const avgRetries = s.totalRetries / s.sampleCount;
+    const retryPenalty = Math.min(0.4, avgRetries / 3);
+    return Math.max(0.05, successRate * (1 - retryPenalty));
+  }
+  /**
+   * Returns 0.1–1.0. Cheaper models score higher, with the penalty scaled
+   * down for complex tasks (where capability matters more than cost).
+   *
+   * blended cost = input + 2 × output (output tokens are typically pricier).
+   * normalised over $0.05 blended as the "expensive" ceiling.
+   */
+  costEfficiencyScore(model, complexity) {
+    const blended = model.inputCostPer1kTokens + model.outputCostPer1kTokens * 2;
+    const normalised = Math.min(1, blended / 0.05);
+    const complexityWeight = (6 - complexity) / 5;
+    return Math.max(0.1, 1 - normalised * complexityWeight);
+  }
+};
 var DynamicTool = class extends BaseTool {
   name;
   description;
   inputSchema;
   executeCode;
   _isDangerous;
-  constructor(spec) {
+  registry;
+  escalator;
+  constructor(spec, registry, escalator) {
     super();
     this.name = spec.name;
     this.description = spec.description;
     this.inputSchema = spec.inputSchema;
     this.executeCode = spec.executeCode;
     this._isDangerous = spec.isDangerous;
+    this.registry = registry;
+    this.escalator = escalator;
   }
   isDangerous() {
     return this._isDangerous;
   }
-  async execute(input, _options) {
+  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}).`;
+          }
+        }
+      }
+      try {
+        const result = await registry.execute(toolName, toolInput, options);
+        return typeof result === "string" ? result : JSON.stringify(result);
+      } catch (err) {
+        return `Error calling ${toolName}: ${err instanceof Error ? err.message : String(err)}`;
+      }
+    };
     const sandbox = {
       input,
       fetch: globalThis.fetch,
+      callTool,
       JSON,
       Math,
       Date,
       console: { log: () => {
       }, error: () => {
       } },
-      // Silenced
       setTimeout,
       clearTimeout,
       Promise,
@@ -5925,29 +6901,42 @@ Generate a minimal, safe JavaScript tool function for the described operation.
 
 Rules:
 - Return ONLY a JSON object with these fields: name, description, inputSchema, executeCode, isDangerous
-- executeCode is a self-contained JavaScript function body that:
-  - Receives: input (object), fetch (if HTTP needed)
+- executeCode is a self-contained JavaScript async function body that:
+  - Receives: input (object), fetch (for HTTP), callTool(toolName, input) (to call any registered cascade tool)
   - Returns: a string result
-  - Uses no require(), no fs, no process \u2014 only fetch, JSON, Math, Date, String, Number, Array, Object
+  - For file operations, prefer: await callTool('file_read', { path: input.path })
+  - For shell commands, prefer: await callTool('shell', { command: 'ls -la' })
+  - For pure computation / HTTP: use fetch or built-ins (JSON, Math, Date, String, Number, Array, Object)
   - Must complete in under 15 seconds
-- isDangerous should be true only if the tool makes write operations or external HTTP calls
+- isDangerous: true if the tool calls dangerous cascade tools (shell, file_write, file_delete, git) or makes HTTP calls that write data
 - name must be snake_case, start with "dynamic_", max 40 chars
 - description must be \u2264 120 chars
 
-Example executeCode for an HTTP tool:
-"const res = await fetch(input.url); const text = await res.text(); return text.slice(0, 2000);"
+Example for a file-summary tool:
+{
+  "name": "dynamic_summarize_file",
+  "description": "Read a file and return a one-paragraph summary",
+  "inputSchema": { "path": { "type": "string", "description": "File path to summarize" } },
+  "executeCode": "const content = await callTool('file_read', { path: input.path }); return content.slice(0, 500);",
+  "isDangerous": false
+}
 
 Return ONLY valid JSON \u2014 no other text.`;
 var ToolCreator = class {
   router;
   registry;
+  escalator;
   createdTools = /* @__PURE__ */ new Set();
   constructor(router, registry) {
     this.router = router;
     this.registry = registry;
   }
+  setPermissionEscalator(escalator) {
+    this.escalator = escalator;
+  }
   /**
    * 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.
    */
   async createTool(description, context) {
@@ -5958,26 +6947,21 @@ Required capability: ${description.slice(0, 300)}`;
     try {
       const result = await this.router.generate("T3", {
         messages: [{ role: "user", content: prompt }],
-        maxTokens: 600
+        maxTokens: 800
       });
       const jsonMatch = /\{[\s\S]*\}/.exec(result.content);
-      if (!jsonMatch) {
-        return null;
-      }
+      if (!jsonMatch) return null;
       const spec = JSON.parse(jsonMatch[0]);
-      if (!spec.name || !spec.description || !spec.executeCode || !spec.inputSchema) {
-        return null;
-      }
+      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}`;
       }
       try {
-        createContext({ input: {}, fetch: globalThis.fetch });
-        new Function("input", "fetch", spec.executeCode);
-      } catch (err) {
+        new Function("input", "fetch", "callTool", spec.executeCode);
+      } catch {
         return null;
       }
-      const tool = new DynamicTool(spec);
+      const tool = new DynamicTool(spec, this.registry, this.escalator);
       this.registry.register(tool);
       this.createdTools.add(spec.name);
       return spec.name;
@@ -5985,16 +6969,14 @@ Required capability: ${description.slice(0, 300)}`;
       return null;
     }
   }
-  /**
-   * Returns the names of all tools created in this session.
-   */
+  /** Returns the names of all tools created in this session. */
   getCreatedTools() {
     return Array.from(this.createdTools);
   }
 };
 
 // src/core/cascade.ts
-var Cascade = class extends EventEmitter {
+var Cascade = class _Cascade extends EventEmitter {
   router;
   toolRegistry;
   mcpClient;
@@ -6005,6 +6987,7 @@ var Cascade = class extends EventEmitter {
   audit;
   telemetry;
   taskAnalyzer;
+  perfTracker;
   toolCreator;
   constructor(config, workspacePath, store) {
     super();
@@ -6021,10 +7004,12 @@ var Cascade = class extends EventEmitter {
     this.telemetry = config.telemetry?.enabled ? new Telemetry(config.telemetry, config.telemetry.distinctId ?? "anonymous") : noopTelemetry;
   }
   initOptionalFeatures() {
-    const cfg = this.config;
-    if (cfg["cascadeAuto"] === true) {
-      this.taskAnalyzer = new TaskAnalyzer(this.router);
+    if (this.config.cascadeAuto === true) {
+      this.perfTracker = new ModelPerformanceTracker();
+      void this.perfTracker.load();
+      this.taskAnalyzer = new TaskAnalyzer(this.perfTracker);
     }
+    const cfg = this.config;
     if (cfg["enableToolCreation"] === true) {
       this.toolCreator = new ToolCreator(this.router, this.toolRegistry);
     }
@@ -6090,6 +7075,26 @@ var Cascade = class extends EventEmitter {
           }
         }
       }
+      const pluginPaths = this.config["plugins"];
+      if (pluginPaths?.length) {
+        for (const pluginPath of pluginPaths) {
+          try {
+            const mod = await import(pluginPath);
+            const plugin = mod.default ?? mod;
+            if (plugin && Array.isArray(plugin.tools)) {
+              this.toolRegistry.registerPlugin(plugin);
+            } else {
+              console.warn(`[cascade] Plugin "${pluginPath}" does not export a valid ToolPlugin.`);
+            }
+          } catch (err) {
+            console.warn(`[cascade] Failed to load plugin "${pluginPath}":`, err);
+          }
+        }
+      }
+      if (this.config.cascadeAuto && this.store) {
+        this.router.profileModels(this.store).catch(() => {
+        });
+      }
       this.initOptionalFeatures();
       this.initialized = true;
     })();
@@ -6107,21 +7112,41 @@ var Cascade = class extends EventEmitter {
   looksLikeSimpleArtifactTask(prompt) {
     return /create .*\.(txt|md|json|csv)\b/i.test(prompt) && !/(research|compare|thorough|pdf|report|analy[sz]e|architecture|multi-agent)/i.test(prompt);
   }
-  async determineComplexity(prompt, workspacePath, conversationHistory = []) {
-    if (this.isCasualGreeting(prompt)) {
-      return "Simple";
-    }
-    if (this.looksLikeSimpleArtifactTask(prompt)) {
-      return "Simple";
-    }
-    let workspaceContext = "";
+  looksLikeConversational(prompt) {
+    const LOW_COMPLEXITY = [
+      /^(?:hi|hello|hey|thanks|thank you|ok|okay|yes|no|sure|got it|sounds good)\b/i,
+      /^(?:what is|what are|list|show me|tell me|who is|where is|when is|how do i)\b/i,
+      /\b(?:simple|quick|brief|small|single|one-line|typo|rename)\b/i
+    ];
+    const wordCount = prompt.trim().split(/\s+/).length;
+    return wordCount <= 12 && LOW_COMPLEXITY.some((re) => re.test(prompt.trim()));
+  }
+  // Cache glob scan results per workspace path to avoid repeated I/O.
+  static globCache = /* @__PURE__ */ new Map();
+  async countWorkspaceFiles(workspacePath) {
+    const now = Date.now();
+    const cached = _Cascade.globCache.get(workspacePath);
+    if (cached && cached.expiresAt > now) return cached.count;
     try {
       const files = await glob("**/*.*", {
         cwd: workspacePath,
         ignore: ["node_modules/**", ".git/**", "dist/**", "build/**"],
         nodir: true
       });
-      workspaceContext = `Workspace Scout: Found ~${files.length} source files in the project.`;
+      _Cascade.globCache.set(workspacePath, { count: files.length, expiresAt: now + 3e4 });
+      return files.length;
+    } catch {
+      return 0;
+    }
+  }
+  async determineComplexity(prompt, workspacePath, conversationHistory = []) {
+    if (this.isCasualGreeting(prompt)) return "Simple";
+    if (this.looksLikeSimpleArtifactTask(prompt)) return "Simple";
+    if (this.looksLikeConversational(prompt)) return "Simple";
+    let workspaceContext = "";
+    try {
+      const count = await this.countWorkspaceFiles(workspacePath);
+      workspaceContext = `Workspace Scout: Found ~${count} source files in the project.`;
     } catch {
       workspaceContext = "Workspace Scout: Could not scan workspace.";
     }
@@ -6207,7 +7232,7 @@ ${prompt}` : prompt;
     this.telemetry.capture("cascade:session_start", {
       complexity,
       providerCount: this.config.providers.length,
-      cascadeAutoEnabled: this.config["cascadeAuto"] === true,
+      cascadeAutoEnabled: this.config.cascadeAuto === true,
       toolCreationEnabled: this.config["enableToolCreation"] === true
     });
     this.emit("tier:root", { role: complexity === "Simple" ? "T3" : complexity === "Moderate" ? "T2" : "T1" });
@@ -6222,6 +7247,7 @@ ${prompt}` : prompt;
       }));
     }
     const toolCreator = this.toolCreator;
+    if (toolCreator) toolCreator.setPermissionEscalator(escalator);
     let finalOutput = "";
     let t2Results = [];
     let runError = null;
@@ -6243,6 +7269,8 @@ ${prompt}` : prompt;
       });
       tier.on("log", (e) => this.emit("log", e));
       tier.on("tier:status", (e) => this.emit("tier:status", e));
+      tier.on("tool:call", (e) => this.emit("tool:call", e));
+      tier.on("tool:result", (e) => this.emit("tool:result", e));
       tier.on("tool:approval-request", async (request) => {
         this.emit("tool:approval-request", request);
         let decision = { approved: false };
@@ -6297,6 +7325,7 @@ ${prompt}` : prompt;
         }
         t2.setPermissionEscalator(escalator);
         if (toolCreator) t2.setToolCreator(toolCreator);
+        t2.setPeerMessageCallback((e) => this.emit("peer:message", e), options.sessionId ?? "");
         bindTierEvents(t2);
         const assignment = {
           sectionId: taskId,
@@ -6326,6 +7355,7 @@ ${prompt}` : prompt;
         }
         t1.setPermissionEscalator(escalator);
         if (toolCreator) t1.setToolCreator(toolCreator);
+        t1.setPeerMessageCallback((e) => this.emit("peer:message", e), options.sessionId ?? "");
         bindTierEvents(t1);
         t1.on("plan", (e) => this.emit("plan", e));
         const result = await t1.execute(options.prompt, options.images, void 0, options.signal);
@@ -6349,6 +7379,13 @@ ${prompt}` : prompt;
         escalator.cancelAllPending();
       } catch {
       }
+      if (this.taskAnalyzer) {
+        try {
+          const stats2 = this.router.getStats();
+          this.taskAnalyzer.recordRunOutcome(runError ? "failure" : "success", stats2.costByTier);
+        } catch {
+        }
+      }
       try {
         const stats2 = this.router.getStats();
         const durationMs2 = Date.now() - startMs;
@@ -6449,7 +7486,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 && fs11.existsSync(this.storePath)) {
+      if (password && fs15.existsSync(this.storePath)) {
         try {
           const fileEntries = this.decryptFile(password);
           for (const [k, v] of Object.entries(fileEntries)) {
@@ -6468,7 +7505,7 @@ var Keystore = class {
         "Keystore unlock requires a password because the OS keychain (keytar) is not available on this system."
       );
     }
-    if (!fs11.existsSync(this.storePath)) {
+    if (!fs15.existsSync(this.storePath)) {
       const salt = crypto.randomBytes(SALT_LEN);
       this.masterKey = this.deriveKey(password, salt);
       this.writeWithSalt({}, salt);
@@ -6482,7 +7519,7 @@ var Keystore = class {
   }
   /** Synchronous legacy unlock kept for AES-only environments. */
   unlockSync(password) {
-    if (!fs11.existsSync(this.storePath)) {
+    if (!fs15.existsSync(this.storePath)) {
       const salt = crypto.randomBytes(SALT_LEN);
       this.masterKey = this.deriveKey(password, salt);
       this.writeWithSalt({}, salt);
@@ -6540,7 +7577,7 @@ var Keystore = class {
     }
   }
   decryptFile(password, knownSalt) {
-    if (!fs11.existsSync(this.storePath)) return {};
+    if (!fs15.existsSync(this.storePath)) return {};
     try {
       const { salt, ciphertext, iv, tag } = this.readRaw();
       const useSalt = knownSalt ?? salt;
@@ -6562,8 +7599,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]);
-    fs11.mkdirSync(path13.dirname(this.storePath), { recursive: true });
-    fs11.writeFileSync(this.storePath, out, { mode: 384 });
+    fs15.mkdirSync(path16.dirname(this.storePath), { recursive: true });
+    fs15.writeFileSync(this.storePath, out, { mode: 384 });
   }
   writeWithSalt(data, salt) {
     if (!this.masterKey) throw new Error("writeWithSalt called before masterKey was set");
@@ -6573,11 +7610,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]);
-    fs11.mkdirSync(path13.dirname(this.storePath), { recursive: true });
-    fs11.writeFileSync(this.storePath, out, { mode: 384 });
+    fs15.mkdirSync(path16.dirname(this.storePath), { recursive: true });
+    fs15.writeFileSync(this.storePath, out, { mode: 384 });
   }
   readRaw() {
-    const buf = fs11.readFileSync(this.storePath);
+    const buf = fs15.readFileSync(this.storePath);
     let offset = 0;
     const salt = buf.subarray(offset, offset + SALT_LEN);
     offset += SALT_LEN;
@@ -6610,9 +7647,9 @@ var CascadeIgnore = class {
     ]);
   }
   async load(workspacePath) {
-    const filePath = path13.join(workspacePath, ".cascadeignore");
+    const filePath = path16.join(workspacePath, ".cascadeignore");
     try {
-      const content = await fs2.readFile(filePath, "utf-8");
+      const content = await fs3.readFile(filePath, "utf-8");
       const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
       this.ig.add(lines);
       this.loaded = true;
@@ -6621,7 +7658,7 @@ var CascadeIgnore = class {
   }
   isIgnored(filePath, workspacePath) {
     try {
-      const relative = workspacePath ? path13.relative(workspacePath, filePath) : filePath;
+      const relative = workspacePath ? path16.relative(workspacePath, filePath) : filePath;
       return this.ig.ignores(relative);
     } catch {
       return false;
@@ -6632,9 +7669,9 @@ var CascadeIgnore = class {
   }
 };
 async function loadCascadeMd(workspacePath) {
-  const filePath = path13.join(workspacePath, "CASCADE.md");
+  const filePath = path16.join(workspacePath, "CASCADE.md");
   try {
-    const raw = await fs2.readFile(filePath, "utf-8");
+    const raw = await fs3.readFile(filePath, "utf-8");
     return parseCascadeMd(raw);
   } catch {
     return null;
@@ -6663,7 +7700,7 @@ ${raw.trim()}`;
 var MemoryStore = class _MemoryStore {
   db;
   constructor(dbPath) {
-    fs11.mkdirSync(path13.dirname(dbPath), { recursive: true });
+    fs15.mkdirSync(path16.dirname(dbPath), { recursive: true });
     try {
       this.db = new Database(dbPath, { timeout: 5e3 });
       this.db.pragma("journal_mode = WAL");
@@ -7146,6 +8183,27 @@ Original error: ${err.message}`
     if (!row.oldest) return Infinity;
     return Date.now() - new Date(row.oldest).getTime();
   }
+  saveModelProfile(modelId, provider, specializations) {
+    const cacheKey = `${provider}:${modelId}`;
+    const existing = this.db.prepare("SELECT metadata FROM model_cache WHERE id = ?").get(cacheKey);
+    const meta = existing ? JSON.parse(existing.metadata) : { id: modelId, provider, name: modelId, contextWindow: 0, isVisionCapable: false, inputCostPer1kTokens: 0, outputCostPer1kTokens: 0, maxOutputTokens: 0, supportsStreaming: false, isLocal: false };
+    meta.specializations = specializations;
+    this.db.prepare(`
+      INSERT INTO model_cache (id, provider, model_id, name, metadata, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET metadata = excluded.metadata, updated_at = excluded.updated_at
+    `).run(cacheKey, provider, modelId, meta.name ?? modelId, JSON.stringify(meta), (/* @__PURE__ */ new Date()).toISOString());
+  }
+  getModelProfile(modelId, provider) {
+    const row = this.db.prepare("SELECT metadata FROM model_cache WHERE id = ?").get(`${provider}:${modelId}`);
+    return row ? JSON.parse(row.metadata) : void 0;
+  }
+  getProfiledModelIds() {
+    const rows = this.db.prepare(
+      "SELECT model_id FROM model_cache WHERE json_extract(metadata, '$.specializations') IS NOT NULL"
+    ).all();
+    return rows.map((r) => r.model_id);
+  }
   // ── Tool Result Cache (in-memory, TTL-based) ──────────────────────────
   // Avoids redundant calls for read-only tools within a short window.
   // Not persisted to DB — cleared on process restart.
@@ -7400,15 +8458,15 @@ var ConfigManager = class {
   globalDir;
   constructor(workspacePath = process.cwd()) {
     this.workspacePath = workspacePath;
-    this.globalDir = path13.join(os2.homedir(), GLOBAL_CONFIG_DIR);
+    this.globalDir = path16.join(os3.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(path13.join(this.globalDir, GLOBAL_KEYSTORE_FILE));
-    this.store = new MemoryStore(path13.join(this.workspacePath, CASCADE_DB_FILE));
+    this.keystore = new Keystore(path16.join(this.globalDir, GLOBAL_KEYSTORE_FILE));
+    this.store = new MemoryStore(path16.join(this.workspacePath, CASCADE_DB_FILE));
     await this.injectEnvKeys();
     await this.ensureDefaultIdentity();
   }
@@ -7431,9 +8489,9 @@ var ConfigManager = class {
     return this.workspacePath;
   }
   async save() {
-    const configPath = path13.join(this.workspacePath, CASCADE_CONFIG_FILE);
-    await fs2.mkdir(path13.dirname(configPath), { recursive: true });
-    await fs2.writeFile(configPath, JSON.stringify(this.config, null, 2), "utf-8");
+    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");
   }
   async updateConfig(updates) {
     this.config = validateConfig({ ...this.config, ...updates });
@@ -7456,9 +8514,9 @@ var ConfigManager = class {
     return configProvider?.apiKey;
   }
   async loadConfig() {
-    const configPath = path13.join(this.workspacePath, CASCADE_CONFIG_FILE);
+    const configPath = path16.join(this.workspacePath, CASCADE_CONFIG_FILE);
     try {
-      const raw = await fs2.readFile(configPath, "utf-8");
+      const raw = await fs3.readFile(configPath, "utf-8");
       return validateConfig(JSON.parse(raw));
     } catch (err) {
       if (err.code === "ENOENT") {
@@ -7622,6 +8680,9 @@ var DashboardSocket = class {
   emitStreamToken(tierId, text, sessionId) {
     this.io.to(`session:${sessionId}`).emit("stream:token", { tierId, text, sessionId });
   }
+  emitPeerMessage(event) {
+    this.io.to(`session:${event.sessionId}`).emit("peer:message", event);
+  }
   emitApprovalRequest(request) {
     this.io.emit("permission:user-required", request);
   }
@@ -7664,16 +8725,13 @@ var DashboardSocket = class {
         const { sessionId } = normalizeSessionSubscriptionPayload(payload);
         socket.leave(`session:${sessionId}`);
       });
-      socket.on("join:tenant", (tenantId) => {
-        socket.join(`tenant:${tenantId}`);
-      });
     });
   }
   close() {
     this.io.close();
   }
 };
-var __dirname$1 = path13.dirname(fileURLToPath(import.meta.url));
+var __dirname$1 = path16.dirname(fileURLToPath(import.meta.url));
 var DashboardServer = class {
   app;
   httpServer;
@@ -7739,15 +8797,15 @@ var DashboardServer = class {
   resolveDashboardSecret() {
     const fromConfig = this.config.dashboard.secret ?? process.env["CASCADE_DASHBOARD_SECRET"];
     if (fromConfig) return fromConfig;
-    const secretPath = path13.join(this.workspacePath, CASCADE_DASHBOARD_SECRET_FILE);
+    const secretPath = path16.join(this.workspacePath, CASCADE_DASHBOARD_SECRET_FILE);
     try {
-      if (fs11.existsSync(secretPath)) {
-        const existing = fs11.readFileSync(secretPath, "utf-8").trim();
+      if (fs15.existsSync(secretPath)) {
+        const existing = fs15.readFileSync(secretPath, "utf-8").trim();
         if (existing.length >= 16) return existing;
       }
       const generated = randomUUID();
-      fs11.mkdirSync(path13.dirname(secretPath), { recursive: true });
-      fs11.writeFileSync(secretPath, generated, { encoding: "utf-8", mode: 384 });
+      fs15.mkdirSync(path16.dirname(secretPath), { recursive: true });
+      fs15.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.`
@@ -7774,7 +8832,7 @@ var DashboardServer = class {
   // ── Setup ─────────────────────────────────────
   getGlobalStore() {
     if (!this.globalStore) {
-      const globalDbPath = path13.join(os2.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path16.join(os3.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       this.globalStore = new MemoryStore(globalDbPath);
     }
     return this.globalStore;
@@ -7835,12 +8893,12 @@ var DashboardServer = class {
     }
   }
   watchRuntimeChanges() {
-    const workspaceDbPath = path13.join(this.workspacePath, CASCADE_DB_FILE);
-    const globalDbPath = path13.join(os2.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+    const workspaceDbPath = path16.join(this.workspacePath, CASCADE_DB_FILE);
+    const globalDbPath = path16.join(os3.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 (!fs11.existsSync(watchPath)) continue;
-      fs11.watchFile(watchPath, { interval: 3e3 }, () => {
+      if (!fs15.existsSync(watchPath)) continue;
+      fs15.watchFile(watchPath, { interval: 3e3 }, () => {
         this.throttledBroadcast(watchPath === globalDbPath ? "global" : "workspace");
       });
     }
@@ -7871,6 +8929,21 @@ var DashboardServer = class {
       legacyHeaders: false,
       message: { error: "Too many login attempts. Try again in 15 minutes." }
     });
+    const apiLimiter = rateLimit({
+      windowMs: 60 * 1e3,
+      limit: 60,
+      standardHeaders: "draft-7",
+      legacyHeaders: false,
+      message: { error: "Too many requests. Slow down." }
+    });
+    this.app.use("/api", apiLimiter);
+    const mutationLimiter = rateLimit({
+      windowMs: 60 * 1e3,
+      limit: 10,
+      standardHeaders: "draft-7",
+      legacyHeaders: false,
+      message: { error: "Too many requests on this endpoint." }
+    });
     this.app.post("/api/auth/login", loginLimiter, (req, res) => {
       const { username, password } = req.body ?? {};
       if (!authRequired) {
@@ -7906,22 +8979,33 @@ var DashboardServer = class {
         res.status(401).json({ error: "Invalid credentials" });
       }
     });
-    this.app.post("/api/force-halt", auth, (req, res) => {
-      const { sessionId, nodeId } = req.body;
+    this.app.post("/api/force-halt", auth, mutationLimiter, (req, res) => {
+      const body = req.body;
+      const sessionId = typeof body["sessionId"] === "string" ? body["sessionId"] : void 0;
+      const nodeId = typeof body["nodeId"] === "string" ? body["nodeId"] : void 0;
       const payload = { sessionId, nodeId, requestedAt: (/* @__PURE__ */ new Date()).toISOString() };
       this.socket.broadcast("session:halt", payload);
       if (sessionId) this.socket.broadcastToRoom(`session:${sessionId}`, "session:halt", payload);
       res.json({ success: true, ...payload });
     });
-    this.app.post("/api/approve", auth, (req, res) => {
-      const { nodeId, sessionId } = req.body;
+    this.app.post("/api/approve", auth, mutationLimiter, (req, res) => {
+      const body = req.body;
+      const sessionId = typeof body["sessionId"] === "string" ? body["sessionId"] : void 0;
+      const nodeId = typeof body["nodeId"] === "string" ? body["nodeId"] : void 0;
       const payload = { sessionId, nodeId, requestedAt: (/* @__PURE__ */ new Date()).toISOString() };
       this.socket.broadcast("session:approve", payload);
       if (sessionId) this.socket.broadcastToRoom(`session:${sessionId}`, "session:approve", payload);
       res.json({ success: true, ...payload });
     });
-    this.app.post("/api/inject", auth, (req, res) => {
-      const { message, sessionId, nodeId } = req.body;
+    this.app.post("/api/inject", auth, mutationLimiter, (req, res) => {
+      const body = req.body;
+      const message = typeof body["message"] === "string" ? body["message"] : void 0;
+      const sessionId = typeof body["sessionId"] === "string" ? body["sessionId"] : void 0;
+      const nodeId = typeof body["nodeId"] === "string" ? body["nodeId"] : void 0;
+      if (!message) {
+        res.status(400).json({ error: "message is required and must be a string" });
+        return;
+      }
       const payload = { sessionId, nodeId, message, requestedAt: (/* @__PURE__ */ new Date()).toISOString() };
       this.socket.broadcast("session:message-injected", payload);
       if (sessionId) this.socket.broadcastToRoom(`session:${sessionId}`, "session:message-injected", payload);
@@ -7944,7 +9028,7 @@ var DashboardServer = class {
       const sessionId = req.params.id;
       this.store.deleteSession(sessionId);
       this.store.deleteRuntimeSession(sessionId);
-      const globalDbPath = path13.join(os2.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path16.join(os3.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteRuntimeSession(sessionId);
@@ -7958,7 +9042,7 @@ var DashboardServer = class {
     });
     this.app.delete("/api/sessions", auth, (req, res) => {
       const body = req.body;
-      const globalDbPath = path13.join(os2.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path16.join(os3.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 {
@@ -7981,7 +9065,7 @@ var DashboardServer = class {
     });
     this.app.delete("/api/runtime", auth, (_req, res) => {
       this.store.deleteAllRuntimeNodes();
-      const globalDbPath = path13.join(os2.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path16.join(os3.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteAllRuntimeNodes();
@@ -8043,16 +9127,26 @@ var DashboardServer = class {
     });
     this.app.put("/api/config", auth, async (req, res) => {
       const body = req.body;
-      if (body.tierLimits) this.config.tierLimits = { ...this.config.tierLimits, ...body.tierLimits };
-      if (body.budget) this.config.budget = { ...this.config.budget, ...body.budget };
+      if (body["tierLimits"] !== void 0 && (typeof body["tierLimits"] !== "object" || Array.isArray(body["tierLimits"]))) {
+        res.status(400).json({ error: "tierLimits must be an object" });
+        return;
+      }
+      if (body["budget"] !== void 0 && (typeof body["budget"] !== "object" || Array.isArray(body["budget"]))) {
+        res.status(400).json({ error: "budget must be an object" });
+        return;
+      }
+      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 = path13.join(this.workspacePath, CASCADE_CONFIG_FILE);
-        const existing = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf-8")) : {};
+        const configPath = path16.join(this.workspacePath, CASCADE_CONFIG_FILE);
+        const existing = fs15.existsSync(configPath) ? JSON.parse(fs15.readFileSync(configPath, "utf-8")) : {};
         const updated = { ...existing, tierLimits: this.config.tierLimits, budget: this.config.budget };
-        fs11.writeFileSync(configPath, JSON.stringify(updated, null, 2), "utf-8");
+        const tmp = configPath + ".tmp";
+        fs15.writeFileSync(tmp, JSON.stringify(updated, null, 2), "utf-8");
+        fs15.renameSync(tmp, configPath);
         res.json({ ok: true });
       } catch (err) {
-        res.status(500).json({ error: `Failed to save config: ${String(err)}` });
+        res.status(500).json({ error: `Failed to save config: ${err instanceof Error ? err.message : String(err)}` });
       }
     });
     this.app.get("/api/runtime/logs/:sessionId", auth, (req, res) => {
@@ -8077,7 +9171,7 @@ var DashboardServer = class {
     this.app.get("/api/runtime", auth, (req, res) => {
       const scope = req.query["scope"] ?? "workspace";
       if (scope === "global") {
-        const globalDbPath = path13.join(os2.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+        const globalDbPath = path16.join(os3.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
         const globalStore = new MemoryStore(globalDbPath);
         try {
           res.json({
@@ -8098,7 +9192,7 @@ var DashboardServer = class {
         logs: this.store.listRuntimeNodeLogs(void 0, void 0, 500)
       });
     });
-    this.app.post("/api/run", auth, (req, res) => {
+    this.app.post("/api/run", auth, mutationLimiter, (req, res) => {
       const body = req.body;
       if (!body.prompt || typeof body.prompt !== "string") {
         res.status(400).json({ error: "prompt is required" });
@@ -8119,12 +9213,15 @@ var DashboardServer = class {
         cascade.on("permission:user-required", (e) => {
           this.socket.broadcastToRoom(`session:${sessionId}`, "permission:user-required", { sessionId, ...e });
         });
+        cascade.on("peer:message", (e) => {
+          this.socket.emitPeerMessage(e);
+        });
         try {
           const result = await cascade.run({ prompt: body.prompt, identityId: body.identityId });
           this.socket.broadcast("cost:update", {
             sessionId,
-            tokens: result.usage.totalTokens,
-            costUsd: result.usage.estimatedCostUsd
+            totalTokens: result.usage.totalTokens,
+            totalCostUsd: result.usage.estimatedCostUsd
           });
           this.socket.broadcastToRoom(`session:${sessionId}`, "session:complete", { sessionId, result });
           this.throttledBroadcast("workspace");
@@ -8147,13 +9244,13 @@ var DashboardServer = class {
         }))
       });
     });
-    const prodPath = path13.resolve(__dirname$1, "../web/dist");
-    const devPath = path13.resolve(__dirname$1, "../../web/dist");
-    const webDistPath = fs11.existsSync(prodPath) ? prodPath : devPath;
-    if (fs11.existsSync(webDistPath)) {
+    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)) {
       this.app.use(express.static(webDistPath));
       this.app.get("*", (_req, res) => {
-        res.sendFile(path13.join(webDistPath, "index.html"));
+        res.sendFile(path16.join(webDistPath, "index.html"));
       });
     } else {
       this.app.get("/", (_req, res) => {
@@ -8230,7 +9327,7 @@ var TaskScheduler = class {
     return cron.validate(expression);
   }
 };
-var execFileAsync = promisify(execFile);
+var execFileAsync2 = promisify(execFile);
 var SAFE_ENV_NAME = /^[A-Z][A-Z0-9_]*$/;
 function sanitizeEnvValue(v) {
   const raw = typeof v === "string" ? v : JSON.stringify(v);
@@ -8269,7 +9366,7 @@ var HooksRunner = class {
         const isWin = process.platform === "win32";
         const shell = isWin ? "cmd.exe" : "/bin/sh";
         const shellArgs = isWin ? ["/d", "/s", "/c", hook.command] : ["-c", hook.command];
-        const { stdout } = await execFileAsync(shell, shellArgs, {
+        const { stdout } = await execFileAsync2(shell, shellArgs, {
           timeout: hook.timeout ?? 1e4,
           env: { ...process.env, ...envVars },
           windowsHide: true