cascade-ai 0.2.2 → 0.2.12

package/dist/cli.cjs

@@ -11,7 +11,7 @@ var chalk8 = require('chalk');
 var dotenv = require('dotenv');
 var fs7 = require('fs/promises');
 var path17 = require('path');
-var os = require('os');
+var os3 = require('os');
 var crypto = require('crypto');
 var fs14 = require('fs');
 var _ignoreModule = require('ignore');
@@ -20,6 +20,7 @@ var zod = require('zod');
 var child_process = require('child_process');
 var jsxRuntime = require('react/jsx-runtime');
 var EventEmitter = require('events');
+var glob = require('glob');
 var util = require('util');
 var simpleGit = require('simple-git');
 var PDFDocument = require('pdfkit');
@@ -68,7 +69,7 @@ var chalk8__default = /*#__PURE__*/_interopDefault(chalk8);
 var dotenv__default = /*#__PURE__*/_interopDefault(dotenv);
 var fs7__default = /*#__PURE__*/_interopDefault(fs7);
 var path17__default = /*#__PURE__*/_interopDefault(path17);
-var os__default = /*#__PURE__*/_interopDefault(os);
+var os3__default = /*#__PURE__*/_interopDefault(os3);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var fs14__default = /*#__PURE__*/_interopDefault(fs14);
 var _ignoreModule__namespace = /*#__PURE__*/_interopNamespace(_ignoreModule);
@@ -129,7 +130,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var CASCADE_VERSION, CASCADE_CONFIG_FILE, CASCADE_DB_FILE, CASCADE_DASHBOARD_SECRET_FILE, GLOBAL_CONFIG_DIR, GLOBAL_DB_FILE, GLOBAL_KEYSTORE_FILE, GLOBAL_RUNTIME_DB_FILE, DEFAULT_DASHBOARD_PORT, DEFAULT_CONTEXT_LIMIT, DEFAULT_AUTO_SUMMARIZE_AT, MODELS, T1_MODEL_PRIORITY, T2_MODEL_PRIORITY, T3_MODEL_PRIORITY, VISION_MODEL_PRIORITY, COMPLEXITY_T2_COUNT, THEME_NAMES, DEFAULT_THEME, OLLAMA_BASE_URL, LM_STUDIO_BASE_URL, AZURE_BASE_URL_TEMPLATE, TOOL_NAMES, DEFAULT_APPROVAL_REQUIRED;
 var init_constants = __esm({
   "src/constants.ts"() {
-    CASCADE_VERSION = "0.2.2";
+    CASCADE_VERSION = "0.2.12";
     CASCADE_CONFIG_FILE = ".cascade/config.json";
     CASCADE_DB_FILE = ".cascade/memory.db";
     CASCADE_DASHBOARD_SECRET_FILE = ".cascade/dashboard-secret";
@@ -424,7 +425,8 @@ var init_constants = __esm({
       IMAGE_ANALYZE: "image_analyze",
       PDF_CREATE: "pdf_create",
       RUN_CODE: "run_code",
-      PEER_MESSAGE: "peer_message"
+      PEER_MESSAGE: "peer_message",
+      WEB_SEARCH: "web_search"
     };
     DEFAULT_APPROVAL_REQUIRED = [
       TOOL_NAMES.SHELL,
@@ -567,17 +569,38 @@ var init_anthropic = __esm({
           messages,
           tools: tools?.length ? tools : void 0
         });
+        let isThinking = false;
         for await (const event of stream) {
-          if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
-            const text = event.delta.text;
-            fullContent += text;
-            onChunk({ text, finishReason: null });
+          if (event.type === "content_block_delta") {
+            if (event.delta.type === "thinking_delta") {
+              if (!isThinking) {
+                isThinking = true;
+                fullContent += "<think>\n";
+                onChunk({ text: "<think>\n", finishReason: null });
+              }
+              const text = event.delta.thinking;
+              fullContent += text;
+              onChunk({ text, finishReason: null });
+            } else if (event.delta.type === "text_delta") {
+              if (isThinking) {
+                isThinking = false;
+                fullContent += "\n</think>\n\n";
+                onChunk({ text: "\n</think>\n\n", finishReason: null });
+              }
+              const text = event.delta.text;
+              fullContent += text;
+              onChunk({ text, finishReason: null });
+            }
           } else if (event.type === "message_delta" && event.usage) {
             outputTokens = event.usage.output_tokens;
           } else if (event.type === "message_start" && event.message.usage) {
             inputTokens = event.message.usage.input_tokens;
           }
         }
+        if (isThinking) {
+          fullContent += "\n</think>\n\n";
+          onChunk({ text: "\n</think>\n\n", finishReason: null });
+        }
         const finalMessage = await stream.finalMessage();
         const toolCalls = finalMessage.content.filter((b) => b.type === "tool_use").map((b) => ({
           id: b.id,
@@ -638,33 +661,61 @@ var init_anthropic = __esm({
         }
       }
       convertMessages(messages) {
-        return messages.filter((m) => m.role !== "system").map((m) => {
-          if (typeof m.content === "string") {
-            return { role: m.role, content: m.content };
+        const result = [];
+        for (const m of messages) {
+          if (m.role === "system") continue;
+          if (m.role === "tool") {
+            const toolContent = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+            result.push({
+              role: "user",
+              content: [{
+                type: "tool_result",
+                tool_use_id: m.toolCallId ?? "",
+                content: toolContent
+              }]
+            });
+            continue;
           }
-          const content = m.content.map((block) => {
-            if (block.type === "text") return { type: "text", text: block.text };
-            if (block.type === "image") {
-              const img = block.image;
-              if (img.type === "base64") {
-                return {
-                  type: "image",
-                  source: {
-                    type: "base64",
-                    media_type: img.mimeType,
-                    data: img.data
+          if (m.role === "assistant") {
+            const content = [];
+            const text = typeof m.content === "string" ? m.content : "";
+            if (text) content.push({ type: "text", text });
+            for (const tc of m.toolCalls ?? []) {
+              content.push({
+                type: "tool_use",
+                id: tc.id,
+                name: tc.name,
+                input: tc.input
+              });
+            }
+            if (content.length > 0) {
+              result.push({ role: "assistant", content });
+            }
+            continue;
+          }
+          if (m.role === "user") {
+            if (typeof m.content === "string") {
+              result.push({ role: "user", content: m.content });
+            } else {
+              const content = m.content.map((block) => {
+                if (block.type === "text") return { type: "text", text: block.text };
+                if (block.type === "image") {
+                  const img = block.image;
+                  if (img.type === "base64") {
+                    return {
+                      type: "image",
+                      source: { type: "base64", media_type: img.mimeType, data: img.data }
+                    };
                   }
-                };
-              }
-              return {
-                type: "image",
-                source: { type: "url", url: img.data }
-              };
+                  return { type: "image", source: { type: "url", url: img.data } };
+                }
+                return { type: "text", text: "" };
+              });
+              result.push({ role: "user", content });
             }
-            return { type: "text", text: "" };
-          });
-          return { role: m.role, content };
-        });
+          }
+        }
+        return result;
       }
     };
   }
@@ -733,9 +784,25 @@ var init_openai = __esm({
           }
         }
         const toolCallsMap = {};
+        let isThinking = false;
         for await (const chunk of stream) {
           const delta = chunk.choices[0]?.delta;
+          const reasoningContent = delta?.reasoning_content;
+          if (reasoningContent) {
+            if (!isThinking) {
+              isThinking = true;
+              fullContent += "<think>\n";
+              onChunk({ text: "<think>\n", finishReason: null });
+            }
+            fullContent += reasoningContent;
+            onChunk({ text: reasoningContent, finishReason: null });
+          }
           if (delta?.content) {
+            if (isThinking) {
+              isThinking = false;
+              fullContent += "\n</think>\n\n";
+              onChunk({ text: "\n</think>\n\n", finishReason: null });
+            }
             fullContent += delta.content;
             onChunk({ text: delta.content, finishReason: null });
           }
@@ -758,6 +825,10 @@ var init_openai = __esm({
             outputTokens = chunk.usage.completion_tokens;
           }
         }
+        if (isThinking) {
+          fullContent += "\n</think>\n\n";
+          onChunk({ text: "\n</think>\n\n", finishReason: null });
+        }
         const toolCalls = Object.values(toolCallsMap).map((tc) => {
           let input = {};
           try {
@@ -962,7 +1033,7 @@ var init_gemini = __esm({
             for (const part of candidate?.content?.parts ?? []) {
               if (part.functionCall) {
                 toolCalls.push({
-                  id: `gemini-tool-${Date.now()}-${toolCalls.length}`,
+                  id: part.functionCall.name,
                   name: part.functionCall.name,
                   input: part.functionCall.args ?? {}
                 });
@@ -1050,10 +1121,70 @@ var init_gemini = __esm({
       }
       // ── Private ──────────────────────────────────
       buildContents(messages, extraImages) {
-        return messages.filter((m) => m.role === "user" || m.role === "assistant").map((m) => ({
-          role: m.role === "assistant" ? "model" : "user",
-          parts: typeof m.content === "string" ? [{ text: m.content }] : this.convertMessageContent(m, extraImages)
-        }));
+        const contents = [];
+        for (const m of messages) {
+          if (m.role === "system") {
+            const text = typeof m.content === "string" ? m.content : "";
+            if (!text.trim()) continue;
+            const prev = contents[contents.length - 1];
+            if (prev?.role === "user") {
+              prev.parts.unshift({ text: `[System context]: ${text}
+
+` });
+            } else {
+              contents.push({ role: "user", parts: [{ text: `[System context]: ${text}` }] });
+            }
+            continue;
+          }
+          if (m.role === "tool") {
+            const toolContent = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+            const functionName = m.toolCallId ?? "unknown_function";
+            contents.push({
+              role: "user",
+              parts: [{
+                functionResponse: {
+                  name: functionName,
+                  response: { output: toolContent }
+                }
+              }]
+            });
+            continue;
+          }
+          if (m.role === "assistant") {
+            const parts = [];
+            const textContent = typeof m.content === "string" ? m.content : "";
+            if (textContent) parts.push({ text: textContent });
+            for (const tc of m.toolCalls ?? []) {
+              parts.push({
+                functionCall: {
+                  name: tc.name,
+                  args: tc.input
+                }
+              });
+            }
+            if (parts.length > 0) {
+              contents.push({ role: "model", parts });
+            }
+            continue;
+          }
+          if (m.role === "user") {
+            const parts = this.convertMessageContent(m, contents.length === 0 ? extraImages : void 0);
+            if (extraImages?.length && contents.length > 0) {
+              const isLastUser = !messages.slice(messages.indexOf(m) + 1).some((x) => x.role === "user");
+              if (isLastUser) {
+                for (const img of extraImages) {
+                  if (img.type === "base64") {
+                    parts.push({ inlineData: { mimeType: img.mimeType, data: img.data } });
+                  }
+                }
+              }
+            }
+            if (parts.length > 0) {
+              contents.push({ role: "user", parts });
+            }
+          }
+        }
+        return contents;
       }
       convertMessageContent(msg, extraImages) {
         const parts = [];
@@ -1615,9 +1746,10 @@ var MemoryStore = class _MemoryStore {
   constructor(dbPath) {
     fs14__default.default.mkdirSync(path17__default.default.dirname(dbPath), { recursive: true });
     try {
-      this.db = new Database__default.default(dbPath);
+      this.db = new Database__default.default(dbPath, { timeout: 5e3 });
       this.db.pragma("journal_mode = WAL");
       this.db.pragma("foreign_keys = ON");
+      this.db.pragma("synchronous = NORMAL");
       this.migrate();
     } catch (err) {
       if (err instanceof Error && err.message.includes("Could not locate the bindings file")) {
@@ -1631,6 +1763,38 @@ Original error: ${err.message}`
       throw err;
     }
   }
+  // ── Async Write Queue ─────────────────────────
+  writeQueue = [];
+  isProcessingQueue = false;
+  async processQueue() {
+    if (this.isProcessingQueue) return;
+    this.isProcessingQueue = true;
+    while (this.writeQueue.length > 0) {
+      const op = this.writeQueue.shift();
+      if (op) {
+        let attempts = 0;
+        while (attempts < 5) {
+          try {
+            op();
+            break;
+          } catch (err) {
+            if (err instanceof Error && err.code === "SQLITE_BUSY") {
+              attempts++;
+              await new Promise((r) => setTimeout(r, 100 * Math.pow(2, attempts)));
+            } else {
+              console.error("Cascade AI: DB Write Error:", err);
+              break;
+            }
+          }
+        }
+      }
+    }
+    this.isProcessingQueue = false;
+  }
+  enqueueWrite(op) {
+    this.writeQueue.push(op);
+    this.processQueue().catch(console.error);
+  }
   // ── Sessions ──────────────────────────────────
   createSession(session) {
     this.db.prepare(`
@@ -1717,26 +1881,28 @@ Original error: ${err.message}`
   }
   // ── Runtime Sessions / Nodes ─────────────────
   upsertRuntimeSession(session) {
-    this.db.prepare(`
-      INSERT INTO runtime_sessions (session_id, title, workspace_path, status, started_at, updated_at, latest_prompt, is_global)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(session_id) DO UPDATE SET
-        title = excluded.title,
-        workspace_path = excluded.workspace_path,
-        status = excluded.status,
-        updated_at = excluded.updated_at,
-        latest_prompt = excluded.latest_prompt,
-        is_global = excluded.is_global
-    `).run(
-      session.sessionId,
-      session.title,
-      session.workspacePath,
-      session.status,
-      session.startedAt,
-      session.updatedAt,
-      session.latestPrompt ?? null,
-      session.isGlobal ? 1 : 0
-    );
+    this.enqueueWrite(() => {
+      this.db.prepare(`
+        INSERT INTO runtime_sessions (session_id, title, workspace_path, status, started_at, updated_at, latest_prompt, is_global)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(session_id) DO UPDATE SET
+          title = excluded.title,
+          workspace_path = excluded.workspace_path,
+          status = excluded.status,
+          updated_at = excluded.updated_at,
+          latest_prompt = excluded.latest_prompt,
+          is_global = excluded.is_global
+      `).run(
+        session.sessionId,
+        session.title,
+        session.workspacePath,
+        session.status,
+        session.startedAt,
+        session.updatedAt,
+        session.latestPrompt ?? null,
+        session.isGlobal ? 1 : 0
+      );
+    });
   }
   listRuntimeSessions(limit = 100) {
     const rows = this.db.prepare(`
@@ -1754,33 +1920,35 @@ Original error: ${err.message}`
     }));
   }
   upsertRuntimeNode(node) {
-    this.db.prepare(`
-      INSERT INTO runtime_nodes (tier_id, session_id, parent_id, role, label, status, current_action, progress_pct, updated_at, workspace_path, is_global)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(tier_id) DO UPDATE SET
-        session_id = excluded.session_id,
-        parent_id = excluded.parent_id,
-        role = excluded.role,
-        label = excluded.label,
-        status = excluded.status,
-        current_action = excluded.current_action,
-        progress_pct = excluded.progress_pct,
-        updated_at = excluded.updated_at,
-        workspace_path = excluded.workspace_path,
-        is_global = excluded.is_global
-    `).run(
-      node.tierId,
-      node.sessionId,
-      node.parentId ?? null,
-      node.role,
-      node.label,
-      node.status,
-      node.currentAction ?? null,
-      node.progressPct ?? null,
-      node.updatedAt,
-      node.workspacePath ?? null,
-      node.isGlobal ? 1 : 0
-    );
+    this.enqueueWrite(() => {
+      this.db.prepare(`
+        INSERT INTO runtime_nodes (tier_id, session_id, parent_id, role, label, status, current_action, progress_pct, updated_at, workspace_path, is_global)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(tier_id) DO UPDATE SET
+          session_id = excluded.session_id,
+          parent_id = excluded.parent_id,
+          role = excluded.role,
+          label = excluded.label,
+          status = excluded.status,
+          current_action = excluded.current_action,
+          progress_pct = excluded.progress_pct,
+          updated_at = excluded.updated_at,
+          workspace_path = excluded.workspace_path,
+          is_global = excluded.is_global
+      `).run(
+        node.tierId,
+        node.sessionId,
+        node.parentId ?? null,
+        node.role,
+        node.label,
+        node.status,
+        node.currentAction ?? null,
+        node.progressPct ?? null,
+        node.updatedAt,
+        node.workspacePath ?? null,
+        node.isGlobal ? 1 : 0
+      );
+    });
   }
   listRuntimeNodes(sessionId, limit = 500) {
     const rows = sessionId ? this.db.prepare(`
@@ -1803,30 +1971,32 @@ Original error: ${err.message}`
     }));
   }
   addRuntimeNodeLog(log) {
-    this.db.prepare(`
-      INSERT INTO runtime_node_logs (id, session_id, tier_id, role, label, status, current_action, progress_pct, timestamp, workspace_path, is_global)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      log.id,
-      log.sessionId,
-      log.tierId,
-      log.role,
-      log.label,
-      log.status,
-      log.currentAction ?? null,
-      log.progressPct ?? null,
-      log.timestamp,
-      log.workspacePath ?? null,
-      log.isGlobal ? 1 : 0
-    );
-    this.db.prepare(`
-      DELETE FROM runtime_node_logs
-      WHERE id NOT IN (
-        SELECT id FROM runtime_node_logs
-        ORDER BY timestamp DESC
-        LIMIT 2000
-      )
-    `).run();
+    this.enqueueWrite(() => {
+      this.db.prepare(`
+        INSERT INTO runtime_node_logs (id, session_id, tier_id, role, label, status, current_action, progress_pct, timestamp, workspace_path, is_global)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        log.id,
+        log.sessionId,
+        log.tierId,
+        log.role,
+        log.label,
+        log.status,
+        log.currentAction ?? null,
+        log.progressPct ?? null,
+        log.timestamp,
+        log.workspacePath ?? null,
+        log.isGlobal ? 1 : 0
+      );
+      this.db.prepare(`
+        DELETE FROM runtime_node_logs
+        WHERE id NOT IN (
+          SELECT id FROM runtime_node_logs
+          ORDER BY timestamp DESC
+          LIMIT 2000
+        )
+      `).run();
+    });
   }
   listRuntimeNodeLogs(sessionId, tierId, limit = 200) {
     let rows;
@@ -1864,19 +2034,21 @@ Original error: ${err.message}`
   }
   // ── Messages ──────────────────────────────────
   addMessage(message) {
-    this.db.prepare(`
-      INSERT INTO messages (id, session_id, role, content, timestamp, tokens, agent_messages)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      message.id,
-      message.sessionId,
-      message.role,
-      typeof message.content === "string" ? message.content : JSON.stringify(message.content),
-      message.timestamp,
-      message.tokens ? JSON.stringify(message.tokens) : null,
-      message.agentMessages ? JSON.stringify(message.agentMessages) : null
-    );
-    this.db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(message.timestamp, message.sessionId);
+    this.enqueueWrite(() => {
+      this.db.prepare(`
+        INSERT INTO messages (id, session_id, role, content, timestamp, tokens, agent_messages)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        message.id,
+        message.sessionId,
+        message.role,
+        typeof message.content === "string" ? message.content : JSON.stringify(message.content),
+        message.timestamp,
+        message.tokens ? JSON.stringify(message.tokens) : null,
+        message.agentMessages ? JSON.stringify(message.agentMessages) : null
+      );
+      this.db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(message.timestamp, message.sessionId);
+    });
   }
   getSessionMessages(sessionId) {
     const rows = this.db.prepare("SELECT * FROM messages WHERE session_id = ? ORDER BY timestamp ASC").all(sessionId);
@@ -1973,10 +2145,12 @@ Original error: ${err.message}`
   }
   // ── Audit Log ─────────────────────────────────
   addAuditEntry(entry) {
-    this.db.prepare(`
-      INSERT INTO audit_log (id, session_id, timestamp, tier_id, action, details)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `).run(entry.id, entry.sessionId, entry.timestamp, entry.tierId, entry.action, JSON.stringify(entry.details));
+    this.enqueueWrite(() => {
+      this.db.prepare(`
+        INSERT INTO audit_log (id, session_id, timestamp, tier_id, action, details)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(entry.id, entry.sessionId, entry.timestamp, entry.tierId, entry.action, JSON.stringify(entry.details));
+    });
   }
   getAuditLog(sessionId, limit = 100) {
     const rows = this.db.prepare("SELECT * FROM audit_log WHERE session_id = ? ORDER BY timestamp DESC LIMIT ?").all(sessionId, limit);
@@ -1991,10 +2165,12 @@ Original error: ${err.message}`
   }
   // ── File Snapshots ────────────────────────────
   addFileSnapshot(sessionId, filePath, content) {
-    this.db.prepare(`
-      INSERT INTO file_snapshots (id, session_id, file_path, content, timestamp)
-      VALUES (?, ?, ?, ?, ?)
-    `).run(crypto.randomUUID(), sessionId, filePath, content, (/* @__PURE__ */ new Date()).toISOString());
+    this.enqueueWrite(() => {
+      this.db.prepare(`
+        INSERT INTO file_snapshots (id, session_id, file_path, content, timestamp)
+        VALUES (?, ?, ?, ?, ?)
+      `).run(crypto.randomUUID(), sessionId, filePath, content, (/* @__PURE__ */ new Date()).toISOString());
+    });
   }
   getLatestFileSnapshots(sessionId) {
     const rows = this.db.prepare(`
@@ -2298,12 +2474,24 @@ var McpServerConfigSchema = zod.z.object({
   args: zod.z.array(zod.z.string()).optional(),
   env: zod.z.record(zod.z.string()).optional()
 });
+var WebSearchConfigSchema = zod.z.object({
+  /** Base URL of your SearXNG instance (e.g. http://localhost:8080) */
+  searxngUrl: zod.z.string().optional(),
+  /** Brave Search API key — get one at https://api.search.brave.com */
+  braveApiKey: zod.z.string().optional(),
+  /** Tavily API key — get one at https://tavily.com */
+  tavilyApiKey: zod.z.string().optional(),
+  /** Max results per search (default 5) */
+  maxResults: zod.z.number().default(5)
+});
 var ToolsConfigSchema = zod.z.object({
   shellAllowlist: zod.z.array(zod.z.string()).default([]),
   shellBlocklist: zod.z.array(zod.z.string()).default(["rm -rf", "sudo rm", "format", "mkfs"]),
   requireApprovalFor: zod.z.array(zod.z.string()).default([]),
   browserEnabled: zod.z.boolean().default(false),
-  mcpServers: zod.z.array(McpServerConfigSchema).optional()
+  mcpServers: zod.z.array(McpServerConfigSchema).optional(),
+  /** Web search backends — at least one should be configured for best results */
+  webSearch: WebSearchConfigSchema.optional()
 });
 var HookDefinitionSchema = zod.z.object({
   command: zod.z.string(),
@@ -2408,7 +2596,7 @@ var ConfigManager = class {
   globalDir;
   constructor(workspacePath = process.cwd()) {
     this.workspacePath = workspacePath;
-    this.globalDir = path17__default.default.join(os__default.default.homedir(), GLOBAL_CONFIG_DIR);
+    this.globalDir = path17__default.default.join(os3__default.default.homedir(), GLOBAL_CONFIG_DIR);
   }
   async load() {
     this.config = await this.loadConfig();
@@ -2476,6 +2664,7 @@ var ConfigManager = class {
     }
   }
   async injectEnvKeys() {
+    const isFirstRun = this.config.providers.length === 0;
     const envProviders = [
       { env: "ANTHROPIC_API_KEY", type: "anthropic" },
       { env: "OPENAI_API_KEY", type: "openai" },
@@ -2486,10 +2675,13 @@ var ConfigManager = class {
       const key = process.env[env];
       if (!key) continue;
       const existing = this.config.providers.find((p) => p.type === type);
-      if (!existing) this.config.providers.push({ type, apiKey: key });
-      else if (!existing.apiKey) existing.apiKey = key;
+      if (!existing && isFirstRun) {
+        this.config.providers.push({ type, apiKey: key });
+      } else if (existing && !existing.apiKey) {
+        existing.apiKey = key;
+      }
     }
-    if (!this.config.providers.find((p) => p.type === "ollama")) {
+    if (isFirstRun && !this.config.providers.find((p) => p.type === "ollama")) {
       this.config.providers.push({ type: "ollama" });
     }
   }
@@ -3407,6 +3599,16 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
     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";
+  }
+};
+
+// src/core/tiers/base.ts
 var BaseTier = class extends EventEmitter__default.default {
   id;
   role;
@@ -3416,6 +3618,8 @@ var BaseTier = class extends EventEmitter__default.default {
   label;
   systemPromptOverride = "";
   hierarchyContext = "";
+  /** Propagated AbortSignal — set by the tier's `execute()` before work begins. */
+  signal;
   constructor(role, id, parentId) {
     super();
     this.role = role;
@@ -3478,6 +3682,18 @@ var BaseTier = class extends EventEmitter__default.default {
   log(message, data) {
     this.emit("log", { tierId: this.id, role: this.role, message, data, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   }
+  /**
+   * Throws `CascadeCancelledError` if the run's `AbortSignal` has fired.
+   * Call this at safe checkpoints (before LLM calls, between T3 dispatches)
+   * to provide a fast, clean cancellation path.
+   */
+  throwIfCancelled() {
+    if (this.signal?.aborted) {
+      throw new CascadeCancelledError(
+        typeof this.signal.reason === "string" ? this.signal.reason : "Run cancelled by caller"
+      );
+    }
+  }
 };
 
 // src/core/context/manager.ts
@@ -3679,6 +3895,7 @@ Rules:
 - Execute the subtask completely \u2014 do not stop partway through.
 - Use tools when needed. Ask for approval only when the tool registry requires it.
 - If the task asks for a file or artifact, you must actually create it in the workspace, verify that it exists, and inspect it before claiming success.
+- Use the "web_search" tool to find current information, documentation, news, or general web data.
 - Use the "pdf_create" tool for PDF requests.
 - Use the "run_code" tool for any file types (Excel, Zip, csv, etc.) or complex processing not covered by other tools. Always cleanup after code execution.
 - If you are not making meaningful progress, stop and escalate rather than looping or padding the response.
@@ -3722,7 +3939,8 @@ var T3Worker = class extends BaseTier {
     this.store = store;
     this.audit = new AuditLogger(store, sessionId);
   }
-  async execute(assignment, taskId) {
+  async execute(assignment, taskId, signal) {
+    this.signal = signal;
     this.assignment = assignment;
     this.taskId = taskId;
     this.setLabel(assignment.subtaskTitle);
@@ -3872,6 +4090,7 @@ Now execute your subtask using this context where relevant.`
     tools = [...tools];
     while (iterations < MAX_ITERATIONS) {
       iterations++;
+      this.throwIfCancelled();
       const options = {
         messages: this.context.getMessages(),
         systemPrompt: this.systemPromptOverride + systemPrompt + (this.hierarchyContext ? `
@@ -3892,21 +4111,8 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
         if (requiresArtifact) {
           stalledArtifactIterations += 1;
           if (stalledArtifactIterations >= 2) {
-            if (this.toolCreator && stalledArtifactIterations === 2) {
-              const toolName = await this.toolCreator.createTool(
-                `Help complete: ${this.assignment?.subtaskTitle ?? "unknown task"}`,
-                this.assignment?.description ?? ""
-              );
-              if (toolName) {
-                tools = this.toolRegistry.getToolDefinitions();
-                this.sendStatusUpdate({
-                  progressPct: 50,
-                  currentAction: `Dynamic tool created: ${toolName}`,
-                  status: "IN_PROGRESS"
-                });
-                this.emit("tool:created", { tierId: this.id, toolName });
-                continue;
-              }
+            if (stalledArtifactIterations === 2) {
+              throw new Error(`Worker stalled waiting for artifact creation. Requesting dynamic tool generation from T2 Manager for: ${this.assignment?.subtaskTitle ?? "unknown task"}`);
             }
             throw new Error("Artifact-producing task stalled without creating or verifying the required files");
           }
@@ -4066,6 +4272,9 @@ ${assignment.expectedOutput}`;
     const artifactPaths = this.extractArtifactPaths(assignment);
     if (!artifactPaths.length) return { ok: true, issues: [] };
     const issues = [];
+    const { exec: exec4 } = await import('child_process');
+    const { promisify: promisify3 } = await import('util');
+    const execAsync3 = promisify3(exec4);
     for (const artifactPath of artifactPaths) {
       const absolutePath = path17__default.default.resolve(process.cwd(), artifactPath);
       try {
@@ -4082,9 +4291,27 @@ ${assignment.expectedOutput}`;
           const content = await fs7__default.default.readFile(absolutePath, "utf-8");
           if (!content.trim()) {
             issues.push(`Artifact content is empty: ${artifactPath}`);
+            continue;
           }
         } else if (stat.size < 100) {
           issues.push(`PDF artifact looks too small to be valid: ${artifactPath}`);
+          continue;
+        }
+        const ext = path17__default.default.extname(absolutePath).toLowerCase();
+        try {
+          if (ext === ".ts" || ext === ".tsx") {
+            await execAsync3(`npx tsc --noEmit ${absolutePath}`, { timeout: 1e4 });
+          } else if (ext === ".js" || ext === ".jsx") {
+            await execAsync3(`node --check ${absolutePath}`, { timeout: 1e4 });
+          } else if (ext === ".py") {
+            await execAsync3(`python -m py_compile ${absolutePath}`, { timeout: 1e4 });
+          }
+        } catch (err) {
+          const stderr = err?.stderr || String(err);
+          const stdout = err?.stdout || "";
+          issues.push(`Semantic error in ${artifactPath}:
+${stderr}
+${stdout}`);
         }
       } catch {
         issues.push(`Required artifact was not created: ${artifactPath}`);
@@ -4481,7 +4708,8 @@ var T2Manager = class extends BaseTier {
     });
     this.emit("peer-sync-received", { fromId, content });
   }
-  async execute(assignment, taskId) {
+  async execute(assignment, taskId, signal) {
+    this.signal = signal;
     this.assignment = assignment;
     this.taskId = taskId;
     this.setLabel(assignment.sectionTitle);
@@ -4493,12 +4721,14 @@ var T2Manager = class extends BaseTier {
     });
     this.log(`T2 managing section: ${assignment.sectionTitle}`);
     try {
+      this.throwIfCancelled();
       const subtasks = assignment.t3Subtasks.length > 0 ? assignment.t3Subtasks : await this.decomposeSection(assignment);
       this.sendStatusUpdate({
         progressPct: 20,
         currentAction: `Dispatching ${subtasks.length} T3 workers`,
         status: "IN_PROGRESS"
       });
+      this.throwIfCancelled();
       const t3Results = await this.executeSubtasks(subtasks, taskId);
       this.sendStatusUpdate({
         progressPct: 90,
@@ -4665,11 +4895,12 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
         ).join(", ")}`,
         status: "IN_PROGRESS"
       });
+      this.throwIfCancelled();
       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);
+          const result = await worker.execute(assignment, taskId, this.signal);
           resultMap.set(id, result);
           return result;
         })
@@ -4683,6 +4914,60 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
           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"
+            });
+            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) ?? []) {
           inDegree.set(dependent, Math.max(0, (inDegree.get(dependent) ?? 0) - 1));
@@ -4746,7 +5031,8 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
     }));
     return worker.execute(
       { ...assignment, description: `[RETRY] ${assignment.description}` },
-      taskId
+      taskId,
+      this.signal
     );
   }
   publishSectionOutput(result) {
@@ -4760,29 +5046,51 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
   async aggregateResults(assignment, results) {
     const completed = results.filter((r) => r.status === "COMPLETED");
     if (!completed.length) return `Section ${assignment.sectionTitle} failed \u2014 no T3 workers completed.`;
-    const outputs = completed.map((r, i) => `[T3-${i + 1}]: ${r.output}`).join("\n\n");
     const peerOutputs = this.peerSyncBuffer.filter((p) => p.content?.type === "T2_SECTION_OUTPUT").map((p) => `[Peer ${p.fromId} Output]: ${p.content.output}`).join("\n\n");
-    const prompt = `Summarize these T3 worker outputs for section "${assignment.sectionTitle}" in 2-3 sentences:
-
-${outputs}
-${peerOutputs ? `
+    const peerContext = peerOutputs ? `
 
 Context from sibling T2 completed sections (use this to ensure your summary aligns with the overall state):
-${peerOutputs}` : ""}`;
-    const messages = [{ role: "user", content: prompt }];
-    try {
-      const result = await this.router.generate("T2", {
-        messages,
-        systemPrompt: this.systemPromptOverride + "You are a T2 Manager. Summarize the work of your T3 workers succinctly." + (this.hierarchyContext ? `
+${peerOutputs}` : "";
+    const MAX_CHUNK_LENGTH = 15e3;
+    let currentSummary = "";
+    let i = 0;
+    while (i < completed.length) {
+      let chunkText = "";
+      let chunkEnd = i;
+      while (chunkEnd < completed.length) {
+        const nextOutput = `[T3-${chunkEnd + 1}]: ${completed[chunkEnd].output}
+
+`;
+        if (chunkText.length + nextOutput.length > MAX_CHUNK_LENGTH && chunkEnd > i) {
+          break;
+        }
+        chunkText += nextOutput;
+        chunkEnd++;
+      }
+      i = chunkEnd;
+      const prompt = `Summarize these T3 worker outputs for section "${assignment.sectionTitle}" in 2-3 sentences.
+  ${currentSummary ? `
+PREVIOUS SUMMARY SO FAR:
+${currentSummary}
+
+NEW OUTPUTS TO INTEGRATE:
+` : "\nOUTPUTS:\n"}${chunkText}${peerContext}`;
+      const messages = [{ role: "user", content: prompt }];
+      try {
+        const result = await this.router.generate("T2", {
+          messages,
+          systemPrompt: this.systemPromptOverride + "You are a T2 Manager. Summarize the work of your T3 workers succinctly." + (this.hierarchyContext ? `
 
 HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
-        maxTokens: 300
-      });
-      return result.content;
-    } catch (err) {
-      this.log(`aggregateResults: LLM summarization failed \u2014 returning raw T3 outputs. Error: ${err instanceof Error ? err.message : String(err)}`);
-      return outputs;
+          maxTokens: 500
+        });
+        currentSummary = result.content;
+      } catch (err) {
+        this.log(`aggregateResults: LLM summarization failed at chunk \u2014 returning raw T3 outputs. Error: ${err instanceof Error ? err.message : String(err)}`);
+        return currentSummary + "\n\n" + chunkText;
+      }
     }
+    return currentSummary;
   }
   determineStatus(results) {
     if (results.every((r) => r.status === "COMPLETED")) return "COMPLETED";
@@ -4910,10 +5218,10 @@ Rules:
 - If the user asks for Excel/Zip/complex processing, use "run_code" with Python or Node.js
 - Ensure every plan includes explicit creation and verification steps for requested artifacts
 
-EXECUTION MODE GUIDANCE:
-- Use "parallel" for sections that are independent (e.g. writing different files, researching different topics).
-- Use "sequential" ONLY when a later section strictly depends on the output of an earlier one (e.g. write code \u2192 then test it).
-- Prefer parallel execution: it is significantly faster and reduces total wall-clock time.
+DEPENDENCY GUIDANCE:
+- Leave "dependsOn" empty [] for sections that are independent (e.g. writing different files, researching different topics).
+- Populate "dependsOn" with section IDs ONLY when a later section strictly depends on the output of an earlier one (e.g. write code \u2192 then test it).
+- Prefer empty dependencies (parallel execution): it is significantly faster and reduces total wall-clock time.
 - Within a sequential section, mark T3 subtasks with "dependsOn" only when they truly block each other.
 
 QUALITY RULES:
@@ -4952,7 +5260,8 @@ var T1Administrator = class extends BaseTier {
   setToolCreator(creator) {
     this.toolCreator = creator;
   }
-  async execute(userPrompt, images, systemContext) {
+  async execute(userPrompt, images, systemContext, signal) {
+    this.signal = signal;
     this.taskId = crypto.randomUUID();
     this.setLabel("Administrator");
     this.setStatus("ACTIVE");
@@ -4963,10 +5272,12 @@ var T1Administrator = class extends BaseTier {
       status: "IN_PROGRESS"
     });
     this.log(`T1 received task: ${userPrompt.slice(0, 100)}...`);
+    this.throwIfCancelled();
     let enrichedPrompt = userPrompt;
     if (images?.length) {
       enrichedPrompt = await this.analyzeImages(userPrompt, images);
     }
+    this.throwIfCancelled();
     const plan = await this.decomposeTask(enrichedPrompt, systemContext);
     this.sendStatusUpdate({
       progressPct: 10,
@@ -4974,21 +5285,83 @@ var T1Administrator = class extends BaseTier {
       status: "IN_PROGRESS"
     });
     this.emit("plan", { taskId: this.taskId, plan });
-    const t2Results = await this.dispatchT2Managers(plan.sections);
+    this.throwIfCancelled();
+    let allT2Results = await this.dispatchT2Managers(plan.sections);
+    let pass = 1;
+    const MAX_REPLAN_PASSES = 2;
+    while (pass <= MAX_REPLAN_PASSES) {
+      const reviewResult = await this.reviewT2Outputs(enrichedPrompt, plan, allT2Results);
+      if (reviewResult.approved) {
+        this.log("T1 Review passed.");
+        break;
+      }
+      this.log(`T1 Review rejected outputs. Replanning (Pass ${pass}). Reason: ${reviewResult.reason}`);
+      this.sendStatusUpdate({
+        progressPct: 80 + pass * 5,
+        currentAction: `Review failed: ${reviewResult.reason}. Replanning...`,
+        status: "IN_PROGRESS"
+      });
+      const correctionPlan = await this.decomposeTask(`The previous execution plan failed to fully satisfy the original goal or encountered errors.
+Review reason: ${reviewResult.reason}
+
+Original goal: ${enrichedPrompt}
+
+Create a CORRECTION PLAN that contains only the new sections needed to fix the issues. Do not repeat successful sections.`);
+      const correctionResults = await this.dispatchT2Managers(correctionPlan.sections);
+      allT2Results = [...allT2Results, ...correctionResults];
+      pass++;
+    }
     this.sendStatusUpdate({
       progressPct: 95,
       currentAction: "Compiling final output",
       status: "IN_PROGRESS"
     });
-    const output = await this.compileFinalOutput(userPrompt, plan, t2Results);
+    const output = await this.compileFinalOutput(userPrompt, plan, allT2Results);
     this.setStatus("COMPLETED");
     this.sendStatusUpdate({ progressPct: 100, currentAction: "Task complete", status: "IN_PROGRESS" });
-    return { output, t2Results, taskId: this.taskId, complexity: plan.complexity };
+    return { output, t2Results: allT2Results, taskId: this.taskId, complexity: plan.complexity };
   }
   getEscalations() {
     return [...this.escalations];
   }
   // ── Private ──────────────────────────────────
+  async reviewT2Outputs(originalPrompt, plan, t2Results) {
+    const failedSections = t2Results.filter((r) => r.status === "FAILED");
+    if (failedSections.length > 0) {
+      return {
+        approved: false,
+        reason: `Some T2 managers failed entirely: ${failedSections.map((s) => s.sectionTitle).join(", ")}. Errors: ${failedSections.flatMap((s) => s.issues).join("; ")}`
+      };
+    }
+    const sectionsText = t2Results.map((r) => `**${r.sectionTitle}**
+${r.sectionSummary}`).join("\n\n");
+    const prompt = `You are a strict QA Reviewer for the Cascade AI system.
+Review the following execution outputs against the original user prompt.
+
+Original Request: ${originalPrompt}
+
+T2 Manager Summaries:
+${sectionsText}
+
+Does the current state of the workspace and the outputs fully satisfy the user's request?
+If yes, reply with exactly: "APPROVED".
+If no, reply with "REJECTED: [Detailed reason explaining exactly what is missing or incorrect]".`;
+    try {
+      const result = await this.router.generate("T1", {
+        messages: [{ role: "user", content: prompt }],
+        systemPrompt: this.systemPromptOverride + "You are a QA Reviewer.",
+        maxTokens: 500,
+        temperature: 0
+      });
+      const response = result.content.trim();
+      if (response.toUpperCase().startsWith("APPROVED")) {
+        return { approved: true };
+      }
+      return { approved: false, reason: response.replace(/^REJECTED:\s*/i, "") };
+    } catch {
+      return { approved: true };
+    }
+  }
   async analyzeImages(prompt, images) {
     const visionModel = this.router.getModelForTier("T1");
     if (!visionModel?.isVisionCapable) return prompt;
@@ -5017,29 +5390,35 @@ ${systemContext}` : "";
     Example: if asked to create files "inside python_exclusive", every subtask that 
     creates a file must use "python_exclusive/filename.ext" as the path.
 
-Return JSON where subtasks can declare dependencies:
+Return JSON where SECTIONS can declare dependencies on other SECTIONS:
 {
   "sections": [{
+    "sectionId": "s1",
+    "sectionTitle": "Setup Project",
+    "description": "Initialize the project",
+    "expectedOutput": "Basic structure created",
+    "constraints": [],
+    "dependsOn": [],           // \u2190 empty = runs immediately
     "t3Subtasks": [{
       "subtaskId": "t1",
-      "subtaskTitle": "Generate Source Code",
-      "dependsOn": [],           // \u2190 empty = runs immediately
-      "executionMode": "parallel"
-    }, {
-      "subtaskId": "t2", 
-      "subtaskTitle": "Save Code to File",
-      "dependsOn": ["t1"],       // \u2190 waits for t1 to complete first
-      "executionMode": "parallel"
-    }, {
-      "subtaskId": "t3",
-      "subtaskTitle": "Execute and Verify",
-      "dependsOn": ["t2"],       // \u2190 waits for t2
-      "executionMode": "parallel"
+      "subtaskTitle": "Init NPM",
+      "description": "Run npm init",
+      "expectedOutput": "package.json created",
+      "constraints": [],
+      "dependsOn": []
     }]
+  }, {
+    "sectionId": "s2", 
+    "sectionTitle": "Write Tests",
+    "description": "Write tests for the project",
+    "expectedOutput": "Tests passing",
+    "constraints": [],
+    "dependsOn": ["s1"],       // \u2190 waits for section s1 to complete first
+    "t3Subtasks": [...]
   }]
 }
-Use dependsOn when a subtask needs the output of a previous one.
-Leave dependsOn empty for subtasks that can run immediately in parallel.`;
+Use dependsOn at the SECTION level when a whole T2 Manager needs the output of a previous T2 Manager.
+Leave dependsOn empty for sections that can run immediately in parallel.`;
     const messages = [{ role: "user", content: decompositionPrompt }];
     const result = await this.router.generate("T1", {
       messages,
@@ -5167,92 +5546,127 @@ Leave dependsOn empty for subtasks that can run immediately in parallel.`;
       ].filter(Boolean).join(" ");
       m.setHierarchyContext(context);
     });
-    if (overlapSections.size > 0 && !sections.some((s) => s.executionMode === "sequential")) {
-      this.log("Overlap detected \u2014 switching to sequential execution for conflicting sections");
-      for (const section of sections) {
-        if (overlapSections.has(section.sectionId)) {
-          section.executionMode = "sequential";
+    if (overlapSections.size > 0) {
+      this.log("Overlap detected \u2014 adding sequential dependencies for conflicting sections to prevent race conditions");
+      const overlapArray = Array.from(overlapSections);
+      for (let i = 1; i < overlapArray.length; i++) {
+        const section = sections.find((s) => s.sectionId === overlapArray[i]);
+        if (section) {
+          section.dependsOn = [...section.dependsOn || [], overlapArray[i - 1]];
         }
       }
     }
-    const pct = (i) => 10 + Math.floor(i / sections.length * 85);
-    const isSequential = sections.some((s) => s.executionMode === "sequential");
     const t2Results = [];
     try {
-      if (isSequential) {
-        this.log("Dispatching T2 managers sequentially");
-        for (let i = 0; i < managers.length; i++) {
-          const m = managers[i];
-          this.sendStatusUpdate({
-            progressPct: pct(i),
-            currentAction: `T2 working on: ${sections[i].sectionTitle} (Sequential)`,
-            status: "IN_PROGRESS"
-          });
-          try {
-            const result = await m.execute(sections[i], this.taskId);
-            t2Results.push(result);
-            m.shareCompletedOutput(sections[i].sectionId, result.sectionSummary);
-            if (result.status === "ESCALATED") {
-              this.escalations.push({
-                raisedBy: `T2_${sections[i].sectionId}`,
-                sectionId: sections[i].sectionId,
-                attempted: result.issues,
-                blocker: result.issues.join("; "),
-                needs: "Human review required"
-              });
-            }
-          } catch (err) {
-            t2Results.push({
-              sectionId: sections[i].sectionId,
-              sectionTitle: sections[i].sectionTitle,
-              status: "FAILED",
-              t3Results: [],
-              sectionSummary: "",
-              issues: [err instanceof Error ? err.message : String(err)]
-            });
+      t2Results.push(...await this.runT2sWithDependencies(sections, managers, this.taskId));
+    } finally {
+      cleanup();
+    }
+    return t2Results;
+  }
+  /**
+   * Runs T2 managers respecting dependsOn declarations using Kahn's algorithm.
+   */
+  async runT2sWithDependencies(sections, managers, taskId) {
+    const adj = /* @__PURE__ */ new Map();
+    const inDegree = /* @__PURE__ */ new Map();
+    const resultMap = /* @__PURE__ */ new Map();
+    const allKeys = new Set(sections.map((s) => s.sectionId));
+    for (const s of sections) {
+      if (!adj.has(s.sectionId)) adj.set(s.sectionId, /* @__PURE__ */ new Set());
+      inDegree.set(s.sectionId, 0);
+      s.dependsOn = (s.dependsOn ?? []).filter((d) => allKeys.has(d));
+    }
+    for (const s of sections) {
+      for (const dep of s.dependsOn ?? []) {
+        adj.get(dep).add(s.sectionId);
+        inDegree.set(s.sectionId, (inDegree.get(s.sectionId) ?? 0) + 1);
+      }
+    }
+    const queue = [];
+    const degree = new Map(inDegree);
+    for (const [id, deg] of degree.entries()) if (deg === 0) queue.push(id);
+    const visited = /* @__PURE__ */ new Set();
+    while (queue.length > 0) {
+      const u = queue.shift();
+      visited.add(u);
+      for (const v of adj.get(u) ?? /* @__PURE__ */ new Set()) {
+        const newDeg = (degree.get(v) ?? 1) - 1;
+        degree.set(v, newDeg);
+        if (newDeg === 0) queue.push(v);
+      }
+    }
+    const cycleNodes = [...inDegree.keys()].filter((id) => !visited.has(id));
+    if (cycleNodes.length > 0) {
+      this.log(`\u26A0 Circular dependency detected among sections: [${cycleNodes.join(", ")}]. Breaking cycles.`);
+      for (const s of sections) {
+        if (cycleNodes.includes(s.sectionId)) {
+          const safeDeps = (s.dependsOn ?? []).filter((d) => !cycleNodes.includes(d));
+          for (const removed of (s.dependsOn ?? []).filter((d) => cycleNodes.includes(d))) {
+            inDegree.set(s.sectionId, Math.max(0, (inDegree.get(s.sectionId) ?? 1) - 1));
+            adj.get(removed)?.delete(s.sectionId);
           }
+          s.dependsOn = safeDeps;
         }
-      } else {
-        const results = await Promise.allSettled(
-          managers.map((m, i) => {
-            this.sendStatusUpdate({
-              progressPct: pct(i),
-              currentAction: `T2 working on: ${sections[i].sectionTitle}`,
-              status: "IN_PROGRESS"
-            });
-            return m.execute(sections[i], this.taskId);
-          })
-        );
-        for (let i = 0; i < results.length; i++) {
-          const r = results[i];
-          if (r.status === "fulfilled") {
-            t2Results.push(r.value);
-            managers[i].shareCompletedOutput(sections[i].sectionId, r.value.sectionSummary);
-            if (r.value.status === "ESCALATED") {
-              this.escalations.push({
-                raisedBy: `T2_${sections[i].sectionId}`,
-                sectionId: sections[i].sectionId,
-                attempted: r.value.issues,
-                blocker: r.value.issues.join("; "),
-                needs: "Human review required"
-              });
-            }
-          } else {
-            t2Results.push({
-              sectionId: sections[i].sectionId,
-              sectionTitle: sections[i].sectionTitle,
-              status: "FAILED",
-              t3Results: [],
-              sectionSummary: "",
-              issues: [r.reason instanceof Error ? r.reason.message : String(r.reason)]
+      }
+    }
+    const totalSections = sections.length;
+    let completedSections = 0;
+    const executeWave = async () => {
+      const readyIds = [];
+      for (const [id, deg] of inDegree.entries()) {
+        if (deg === 0 && !resultMap.has(id)) {
+          readyIds.push(id);
+        }
+      }
+      if (readyIds.length === 0) return;
+      await Promise.all(readyIds.map(async (id) => {
+        resultMap.set(id, null);
+        const index = sections.findIndex((s) => s.sectionId === id);
+        const section = sections[index];
+        const manager = managers[index];
+        const progressPct = 10 + Math.floor(completedSections / totalSections * 85);
+        this.sendStatusUpdate({
+          progressPct,
+          currentAction: `T2 working on: ${section.sectionTitle}`,
+          status: "IN_PROGRESS"
+        });
+        this.throwIfCancelled();
+        let result;
+        try {
+          result = await manager.execute(section, taskId, this.signal);
+          manager.shareCompletedOutput(section.sectionId, result.sectionSummary);
+          if (result.status === "ESCALATED") {
+            this.escalations.push({
+              raisedBy: `T2_${section.sectionId}`,
+              sectionId: section.sectionId,
+              attempted: result.issues,
+              blocker: result.issues.join("; "),
+              needs: "Human review required"
             });
           }
+        } catch (err) {
+          result = {
+            sectionId: section.sectionId,
+            sectionTitle: section.sectionTitle,
+            status: "FAILED",
+            t3Results: [],
+            sectionSummary: "",
+            issues: [err instanceof Error ? err.message : String(err)]
+          };
+        }
+        resultMap.set(id, result);
+        completedSections++;
+        for (const dependentId of adj.get(id) ?? /* @__PURE__ */ new Set()) {
+          inDegree.set(dependentId, Math.max(0, (inDegree.get(dependentId) ?? 1) - 1));
         }
+      }));
+      if (Array.from(inDegree.values()).some((deg) => deg === 0) && resultMap.size < totalSections) {
+        await executeWave();
       }
-    } finally {
-      cleanup();
-    }
-    return t2Results;
+    };
+    await executeWave();
+    return sections.map((s) => resultMap.get(s.sectionId)).filter(Boolean);
   }
   async compileFinalOutput(originalPrompt, plan, t2Results) {
     const completedSections = t2Results.filter((r) => r.status !== "FAILED");
@@ -5702,13 +6116,47 @@ var GitHubTool = class extends BaseTool {
   }
   async execute(input, _options) {
     const platform = input["platform"] ?? "github";
-    const token = input["token"] ?? process.env["GITHUB_TOKEN"] ?? process.env["GITLAB_TOKEN"] ?? "";
     const operation = input["operation"];
     const repo = input["repo"];
-    if (platform === "github") {
-      return this.executeGitHub(operation, repo, token, input);
+    let token = input["token"];
+    if (!token) {
+      if (platform === "github") {
+        token = process.env["GITHUB_TOKEN"];
+      } else {
+        token = process.env["GITLAB_TOKEN"];
+      }
+    }
+    if (!token) {
+      const envName = platform === "github" ? "GITHUB_TOKEN" : "GITLAB_TOKEN";
+      return `Error: No ${platform} token provided. Set the ${envName} environment variable or pass a "token" field in the input.`;
+    }
+    try {
+      if (platform === "github") {
+        return await this.executeGitHub(operation, repo, token, input);
+      }
+      return await this.executeGitLab(operation, repo, token, input);
+    } catch (err) {
+      const axiosErr = err;
+      if (axiosErr?.response?.status) {
+        const status = axiosErr.response.status;
+        const msg = axiosErr.response.data?.message ?? "";
+        switch (status) {
+          case 401:
+            return `Authentication failed: Your ${platform} token is invalid or expired. Check your token and try again.`;
+          case 403:
+            return `Permission denied: Your ${platform} token lacks the required scopes for this operation. Needed: repo or workflow.`;
+          case 404:
+            return `Not found: Repository "${repo}" does not exist, or your token cannot access it.`;
+          case 422:
+            return `Validation error from ${platform}: ${msg || "Check your input parameters (branch names, base/head refs, etc.)."}`;
+          case 429:
+            return `Rate limited by ${platform}. Please wait a moment before trying again.`;
+          default:
+            return `${platform} API error (${status}): ${msg || (axiosErr.message ?? "Unknown error")}`;
+        }
+      }
+      return `${platform} request failed: ${axiosErr.message ?? String(err)}`;
     }
-    return this.executeGitLab(operation, repo, token, input);
   }
   async executeGitHub(operation, repo, token, input) {
     const headers = {
@@ -5795,6 +6243,7 @@ ${response.data.description}`;
 };
 
 // src/tools/browser.ts
+var BROWSER_LAUNCH_TIMEOUT_MS = 15e3;
 var BrowserTool = class extends BaseTool {
   name = "browser";
   description = "Control a browser: navigate to URLs, click elements, fill forms, take screenshots. Only available with multimodal models.";
@@ -5803,7 +6252,7 @@ var BrowserTool = class extends BaseTool {
     properties: {
       action: {
         type: "string",
-        enum: ["navigate", "click", "fill", "screenshot", "evaluate", "extract_text", "wait"]
+        enum: ["navigate", "click", "fill", "screenshot", "evaluate", "extract_text", "wait", "close"]
       },
       url: { type: "string", description: "URL to navigate to" },
       selector: { type: "string", description: "CSS selector for click/fill" },
@@ -5823,53 +6272,86 @@ var BrowserTool = class extends BaseTool {
     try {
       playwright = await import('playwright');
     } catch {
-      throw new Error("Playwright is not installed. Run: npm install playwright && npx playwright install chromium");
+      return "Error: Playwright is not installed. Run: npm install playwright && npx playwright install chromium";
     }
-    if (!this.browser) {
-      const pw = playwright;
-      this.browser = await pw.chromium.launch({ headless: true });
-      const b = this.browser;
-      this.page = await b.newPage();
-    }
-    const page = this.page;
     const action = input["action"];
     const timeout = input["timeout"] ?? 1e4;
-    switch (action) {
-      case "navigate": {
-        await page.goto(input["url"], { timeout });
-        return `Navigated to ${input["url"]}`;
-      }
-      case "click": {
-        await page.click(input["selector"], { timeout });
-        return `Clicked ${input["selector"]}`;
-      }
-      case "fill": {
-        await page.fill(input["selector"], input["value"]);
-        return `Filled ${input["selector"]} with value`;
-      }
-      case "screenshot": {
-        const buf = await page.screenshot({ type: "png" });
-        return `data:image/png;base64,${buf.toString("base64")}`;
-      }
-      case "evaluate": {
-        const result = await page.evaluate(input["script"]);
-        return JSON.stringify(result);
+    if (action === "close") {
+      await this.close();
+      return "Browser closed.";
+    }
+    if (!this.browser || !this.page) {
+      await this.close();
+      const launchPromise = playwright.chromium.launch({ headless: true });
+      const timeoutPromise = new Promise(
+        (_, reject) => setTimeout(() => reject(new Error(`Browser launch timed out after ${BROWSER_LAUNCH_TIMEOUT_MS}ms. Is Chromium installed? Run: npx playwright install chromium`)), BROWSER_LAUNCH_TIMEOUT_MS)
+      );
+      try {
+        this.browser = await Promise.race([launchPromise, timeoutPromise]);
+        this.page = await this.browser.newPage();
+      } catch (err) {
+        this.browser = null;
+        this.page = null;
+        return `Browser launch failed: ${err instanceof Error ? err.message : String(err)}`;
       }
-      case "extract_text": {
-        const text = await page.locator("body").innerText();
-        return text.slice(0, 1e4);
+    }
+    const page = this.page;
+    try {
+      switch (action) {
+        case "navigate": {
+          await page.goto(input["url"], { timeout });
+          const title = await page.title();
+          return `Navigated to ${input["url"]} (title: "${title}")`;
+        }
+        case "click": {
+          await page.click(input["selector"], { timeout });
+          return `Clicked ${input["selector"]}`;
+        }
+        case "fill": {
+          await page.fill(input["selector"], input["value"]);
+          return `Filled ${input["selector"]} with value`;
+        }
+        case "screenshot": {
+          const buf = await page.screenshot({ type: "png" });
+          return `data:image/png;base64,${buf.toString("base64")}`;
+        }
+        case "evaluate": {
+          const result = await page.evaluate(input["script"]);
+          return JSON.stringify(result);
+        }
+        case "extract_text": {
+          const text = await page.locator("body").innerText();
+          return text.slice(0, 1e4);
+        }
+        case "wait": {
+          await page.waitForTimeout(timeout);
+          return `Waited ${timeout}ms`;
+        }
+        default:
+          return `Unknown browser action: ${action}. Supported: navigate, click, fill, screenshot, evaluate, extract_text, wait, close`;
       }
-      case "wait": {
-        await page.waitForTimeout(timeout);
-        return `Waited ${timeout}ms`;
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      if (/Target closed|Page crashed|Navigation failed/i.test(errMsg)) {
+        await this.close();
+        return `Browser error (page reset): ${errMsg}`;
       }
-      default:
-        throw new Error(`Unknown browser action: ${action}`);
+      return `Browser action "${action}" failed: ${errMsg}`;
     }
   }
   async close() {
-    if (this.browser) {
-      await this.browser.close();
+    try {
+      if (this.page) {
+        await this.page.close().catch(() => {
+        });
+        this.page = null;
+      }
+      if (this.browser) {
+        await this.browser.close().catch(() => {
+        });
+        this.browser = null;
+      }
+    } catch {
       this.browser = null;
       this.page = null;
     }
@@ -5966,6 +6448,19 @@ var PDFCreateTool = class extends BaseTool {
     });
   }
 };
+function detectCommand(candidates2) {
+  for (const cmd of candidates2) {
+    try {
+      const which = process.platform === "win32" ? "where" : "which";
+      child_process.execSync(`${which} ${cmd}`, { stdio: "ignore" });
+      return cmd;
+    } catch {
+    }
+  }
+  return null;
+}
+var PYTHON_CMD = detectCommand(["python3", "python"]);
+var NODE_CMD = detectCommand(["node"]);
 var CodeInterpreterTool = class extends BaseTool {
   name = "run_code";
   description = "Execute a Python or Node.js script to perform complex tasks (data processing, file conversion, etc.). The script is automatically cleaned up after execution.";
@@ -5981,10 +6476,30 @@ var CodeInterpreterTool = class extends BaseTool {
   isDangerous() {
     return true;
   }
-  async execute(input, options) {
+  async execute(input, _options) {
     const language = input["language"];
     const code = input["code"];
     const args = input["args"] ?? [];
+    let cmdPrefix;
+    if (language === "python") {
+      if (!PYTHON_CMD) {
+        return [
+          "Error: Python interpreter not found.",
+          "Please install Python and ensure it is in your PATH.",
+          "Tried: python3, python"
+        ].join("\n");
+      }
+      cmdPrefix = PYTHON_CMD;
+    } else {
+      if (!NODE_CMD) {
+        return [
+          "Error: Node.js interpreter not found.",
+          "Please install Node.js and ensure it is in your PATH.",
+          "Tried: node"
+        ].join("\n");
+      }
+      cmdPrefix = NODE_CMD;
+    }
     const tmpDir = path17__default.default.join(process.cwd(), ".cascade", "tmp");
     if (!fs14__default.default.existsSync(tmpDir)) {
       fs14__default.default.mkdirSync(tmpDir, { recursive: true });
@@ -5993,8 +6508,9 @@ var CodeInterpreterTool = class extends BaseTool {
     const fileName = `intp_${crypto.randomUUID().slice(0, 8)}.${extension}`;
     const filePath = path17__default.default.join(tmpDir, fileName);
     fs14__default.default.writeFileSync(filePath, code, "utf-8");
-    const cmdPrefix = language === "python" ? "python3" : "node";
-    const fullCmd = `${cmdPrefix} "${filePath}" ${args.map((a) => `"${a}"`).join(" ")}`;
+    const quotedPath = `"${filePath}"`;
+    const quotedArgs = args.map((a) => `"${a}"`).join(" ");
+    const fullCmd = `${cmdPrefix} ${quotedPath}${quotedArgs ? " " + quotedArgs : ""}`;
     return new Promise((resolve) => {
       const startMs = Date.now();
       child_process.exec(fullCmd, { cwd: process.cwd(), timeout: 3e4 }, (error, stdout, stderr) => {
@@ -6007,10 +6523,17 @@ var CodeInterpreterTool = class extends BaseTool {
           console.error(`Failed to cleanup interpreter script ${filePath}:`, cleanupErr);
         }
         if (error) {
-          resolve(`Execution failed (${duration}ms):
+          const timedOut = error.killed && duration >= 3e4;
+          if (timedOut) {
+            resolve(`Execution timed out after 30s. Consider breaking the task into smaller pieces.
+Partial stdout: ${stdout}
+Stderr: ${stderr}`);
+          } else {
+            resolve(`Execution failed (${duration}ms):
 Error: ${error.message}
 Stderr: ${stderr}
 Stdout: ${stdout}`);
+          }
         } else {
           resolve(`Execution successful (${duration}ms):
 Stdout: ${stdout}
@@ -6075,6 +6598,186 @@ ${formatted}`;
   }
 };
 
+// src/tools/web-search.ts
+async function searchSearXNG(query, baseUrl, maxResults) {
+  const url = new URL("/search", baseUrl);
+  url.searchParams.set("q", query);
+  url.searchParams.set("format", "json");
+  url.searchParams.set("categories", "general");
+  url.searchParams.set("engines", "google,bing,duckduckgo");
+  const resp = await fetch(url.toString(), {
+    headers: { "User-Agent": "Cascade-AI/1.0 WebSearchTool" },
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!resp.ok) {
+    throw new Error(`SearXNG returned HTTP ${resp.status}`);
+  }
+  const data = await resp.json();
+  return (data.results ?? []).filter((r) => r.url && r.title).slice(0, maxResults).map((r) => ({
+    title: r.title ?? "",
+    url: r.url ?? "",
+    snippet: r.content ?? "",
+    engine: `searxng(${r.engine ?? "unknown"})`
+  }));
+}
+async function searchBrave(query, apiKey, maxResults) {
+  const url = `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${maxResults}&safesearch=off`;
+  const resp = await fetch(url, {
+    headers: {
+      "Accept": "application/json",
+      "Accept-Encoding": "gzip",
+      "X-Subscription-Token": apiKey
+    },
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!resp.ok) {
+    throw new Error(`Brave Search returned HTTP ${resp.status}`);
+  }
+  const data = await resp.json();
+  return (data.web?.results ?? []).filter((r) => r.url && r.title).slice(0, maxResults).map((r) => ({
+    title: r.title ?? "",
+    url: r.url ?? "",
+    snippet: r.description ?? "",
+    engine: "brave"
+  }));
+}
+async function searchTavily(query, apiKey, maxResults) {
+  const resp = await fetch("https://api.tavily.com/search", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      query,
+      max_results: maxResults,
+      search_depth: "basic",
+      include_answer: false,
+      include_raw_content: false
+    }),
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!resp.ok) {
+    throw new Error(`Tavily returned HTTP ${resp.status}`);
+  }
+  const data = await resp.json();
+  return (data.results ?? []).filter((r) => r.url && r.title).slice(0, maxResults).map((r) => ({
+    title: r.title ?? "",
+    url: r.url ?? "",
+    snippet: r.content ?? "",
+    engine: "tavily"
+  }));
+}
+async function searchDuckDuckGoLite(query, maxResults) {
+  const resp = await fetch(`https://lite.duckduckgo.com/lite/?q=${encodeURIComponent(query)}`, {
+    headers: { "User-Agent": "Mozilla/5.0 (compatible; Cascade-AI/1.0)" },
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!resp.ok) throw new Error(`DuckDuckGo Lite returned HTTP ${resp.status}`);
+  const html = await resp.text();
+  const linkPattern = /<a[^>]+class="result-link"[^>]+href="([^"]+)"[^>]*>([^<]+)<\/a>/g;
+  const snippetPattern = /<td[^>]+class="result-snippet"[^>]*>([\s\S]*?)<\/td>/g;
+  const links = [];
+  const snippets = [];
+  let m;
+  while ((m = linkPattern.exec(html)) !== null) {
+    links.push({ url: m[1], title: m[2].trim() });
+  }
+  while ((m = snippetPattern.exec(html)) !== null) {
+    snippets.push(m[1].replace(/<[^>]+>/g, "").trim());
+  }
+  return links.slice(0, maxResults).map((link, i) => ({
+    title: link.title,
+    url: link.url,
+    snippet: snippets[i] ?? "",
+    engine: "duckduckgo-lite"
+  }));
+}
+var WebSearchTool = class extends BaseTool {
+  name = "web_search";
+  description = "Search the web for current information, news, documentation, or any topic. Returns a list of relevant results with titles, URLs, and snippets.";
+  inputSchema = {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "The search query" },
+      maxResults: { type: "number", description: "Number of results to return (default: 5, max: 10)" }
+    },
+    required: ["query"]
+  };
+  config;
+  constructor(config = {}) {
+    super();
+    this.config = {
+      searxngUrl: config.searxngUrl ?? process.env["SEARXNG_URL"],
+      braveApiKey: config.braveApiKey ?? process.env["BRAVE_SEARCH_API_KEY"],
+      tavilyApiKey: config.tavilyApiKey ?? process.env["TAVILY_API_KEY"],
+      maxResults: config.maxResults ?? 5
+    };
+  }
+  async execute(input, _options) {
+    const query = input["query"];
+    if (!query?.trim()) return "Error: query is required and must be non-empty.";
+    const maxResults = Math.min(
+      input["maxResults"] ?? this.config.maxResults ?? 5,
+      10
+    );
+    const errors = [];
+    let results = [];
+    if (this.config.searxngUrl) {
+      try {
+        results = await searchSearXNG(query, this.config.searxngUrl, maxResults);
+        if (results.length > 0) return this.formatResults(query, results);
+        errors.push("SearXNG: returned 0 results");
+      } catch (err) {
+        errors.push(`SearXNG: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    if (this.config.braveApiKey) {
+      try {
+        results = await searchBrave(query, this.config.braveApiKey, maxResults);
+        if (results.length > 0) return this.formatResults(query, results);
+        errors.push("Brave: returned 0 results");
+      } catch (err) {
+        errors.push(`Brave: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    if (this.config.tavilyApiKey) {
+      try {
+        results = await searchTavily(query, this.config.tavilyApiKey, maxResults);
+        if (results.length > 0) return this.formatResults(query, results);
+        errors.push("Tavily: returned 0 results");
+      } catch (err) {
+        errors.push(`Tavily: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    try {
+      results = await searchDuckDuckGoLite(query, maxResults);
+      if (results.length > 0) return this.formatResults(query, results);
+      errors.push("DuckDuckGo Lite: returned 0 results");
+    } catch (err) {
+      errors.push(`DuckDuckGo Lite: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const configHint = !this.config.searxngUrl && !this.config.braveApiKey && !this.config.tavilyApiKey ? "\nTip: Configure a search backend for better results:\n  \u2022 Self-hosted: set SEARXNG_URL in your environment\n  \u2022 Brave Search API: set BRAVE_SEARCH_API_KEY\n  \u2022 Tavily API: set TAVILY_API_KEY" : "";
+    return [
+      `Web search for "${query}" failed across all backends:`,
+      ...errors.map((e) => `  \u2022 ${e}`),
+      configHint
+    ].join("\n");
+  }
+  formatResults(query, results) {
+    const lines = [`Web search results for: "${query}"`, ""];
+    for (let i = 0; i < results.length; i++) {
+      const r = results[i];
+      lines.push(`[${i + 1}] ${r.title}`);
+      lines.push(`    URL: ${r.url}`);
+      if (r.snippet) lines.push(`    ${r.snippet.slice(0, 300)}`);
+      if (r.engine) lines.push(`    Source: ${r.engine}`);
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+};
+
 // src/tools/mcp.ts
 var McpToolWrapper = class extends BaseTool {
   name;
@@ -6196,7 +6899,8 @@ var ToolRegistry = class {
       new ImageAnalyzeTool(),
       new PDFCreateTool(),
       new CodeInterpreterTool(),
-      new PeerCommunicationTool()
+      new PeerCommunicationTool(),
+      new WebSearchTool(this.config.webSearch)
     ];
     for (const tool of tools) {
       tool.setWorkspaceRoot(this.workspaceRoot);
@@ -6220,8 +6924,23 @@ var ToolRegistry = class {
     return this.ignoreMatcher.ignores(posixRel);
   }
 };
-var McpClient = class {
+var McpClient = class _McpClient {
+  static activeProcessPids = /* @__PURE__ */ new Set();
+  /** 
+   * Forcefully kills all known MCP child processes. 
+   * Call this from global process exit handlers to prevent zombie processes.
+   */
+  static killAllProcesses() {
+    for (const pid of _McpClient.activeProcessPids) {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+    _McpClient.activeProcessPids.clear();
+  }
   clients = /* @__PURE__ */ new Map();
+  transports = /* @__PURE__ */ new Map();
   tools = /* @__PURE__ */ new Map();
   trustedServers;
   approvalCallback;
@@ -6250,6 +6969,8 @@ var McpClient = class {
     );
     await client.connect(transport);
     this.clients.set(server.name, client);
+    this.transports.set(server.name, transport);
+    if (transport.pid) _McpClient.activeProcessPids.add(transport.pid);
     const toolsResult = await client.listTools();
     for (const tool of toolsResult.tools) {
       for (const existing of this.tools.values()) {
@@ -6271,8 +6992,11 @@ var McpClient = class {
   async disconnect(serverName) {
     const client = this.clients.get(serverName);
     if (client) {
+      const transport = this.transports.get(serverName);
+      if (transport?.pid) _McpClient.activeProcessPids.delete(transport.pid);
       await client.close();
       this.clients.delete(serverName);
+      this.transports.delete(serverName);
       for (const key of this.tools.keys()) {
         if (key.startsWith(`${serverName}::`)) this.tools.delete(key);
       }
@@ -6300,6 +7024,13 @@ var McpClient = class {
   getConnectedServers() {
     return Array.from(this.clients.keys());
   }
+  getActivePids() {
+    const pids = [];
+    for (const transport of this.transports.values()) {
+      if (transport.pid) pids.push(transport.pid);
+    }
+    return pids;
+  }
   isConnected(serverName) {
     return this.clients.has(serverName);
   }
@@ -6868,12 +7599,25 @@ var Cascade = class extends EventEmitter__default.default {
   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, conversationHistory = []) {
+  async determineComplexity(prompt, workspacePath, conversationHistory = []) {
     if (this.looksLikeSimpleArtifactTask(prompt)) {
       return "Simple";
     }
+    let workspaceContext = "";
+    try {
+      const files = await glob.glob("**/*.*", {
+        cwd: workspacePath,
+        ignore: ["node_modules/**", ".git/**", "dist/**", "build/**"],
+        nodir: true
+      });
+      workspaceContext = `Workspace Scout: Found ~${files.length} source files in the project.`;
+    } catch {
+      workspaceContext = "Workspace Scout: Could not scan workspace.";
+    }
     const sysPrompt = `You are a routing classifier for a hierarchical AI system. Determine task complexity using BOTH the latest user message and the recent conversation context.
 
+${workspaceContext}
+
 Classification:
 - "Simple": basic conversation, direct single-step work, or small troubleshooting
 - "Moderate": requires a few steps, some tool use, or a manager coordinating workers
@@ -6948,7 +7692,7 @@ ${prompt}` : prompt;
       }
       escalator.resolveUserDecision(req.id, approved, always);
     });
-    const complexity = await this.determineComplexity(options.prompt, options.conversationHistory);
+    const complexity = await this.determineComplexity(options.prompt, options.workspacePath || process.cwd(), options.conversationHistory);
     this.telemetry.capture("cascade:session_start", {
       complexity,
       providerCount: this.config.providers.length,
@@ -7028,7 +7772,7 @@ ${prompt}` : prompt;
           peerT3Ids: [],
           parentT2: "root"
         };
-        const t3Result = await t3.execute(assignment, taskId);
+        const t3Result = await t3.execute(assignment, taskId, options.signal);
         finalOutput = typeof t3Result.output === "string" ? t3Result.output : JSON.stringify(t3Result.output);
         this.emit("tier:status", { tierId: "t3-root", status: "COMPLETED", role: "T3" });
       } else if (complexity === "Moderate") {
@@ -7051,7 +7795,7 @@ ${prompt}` : prompt;
           constraints: [],
           t3Subtasks: []
         };
-        const t2Result = await t2.execute(assignment, taskId);
+        const t2Result = await t2.execute(assignment, taskId, options.signal);
         this.emit("tier:status", { tierId: "t2-root", status: "COMPLETED", role: "T2" });
         t2Results = [t2Result];
         const completed = t2Result.t3Results.filter((r) => r.status === "COMPLETED");
@@ -7073,13 +7817,22 @@ ${prompt}` : prompt;
         if (toolCreator) t1.setToolCreator(toolCreator);
         bindTierEvents(t1);
         t1.on("plan", (e) => this.emit("plan", e));
-        const result = await t1.execute(options.prompt, options.images);
+        const result = await t1.execute(options.prompt, options.images, void 0, options.signal);
         finalOutput = result.output;
         t2Results = result.t2Results;
       }
     } catch (err) {
-      runError = err;
-      throw err;
+      if (err instanceof CascadeCancelledError) {
+        this.emit("run:cancelled", {
+          taskId,
+          reason: err.message,
+          partialOutput: finalOutput || ""
+        });
+        runError = null;
+      } else {
+        runError = err;
+        throw err;
+      }
     } finally {
       try {
         escalator.cancelAllPending();
@@ -7394,11 +8147,6 @@ var SlashCommandRegistry = class {
       description: "Show active models per tier",
       handler: (_args, ctx) => ({ output: ctx.onModelInfo(), handled: true })
     });
-    this.register({
-      command: "/models",
-      description: "Browse available models by provider",
-      handler: (_args, ctx) => ({ output: ctx.onModelsInfo(), handled: true })
-    });
     this.register({
       command: "/providers",
       description: "Show configured providers",
@@ -7814,6 +8562,9 @@ var ModelsDisplay = ({
   });
   const title = step === "PROVIDER" ? "\u25C8 SELECT PROVIDER" : step === "TIER" ? `\u25C8 APPLY ${picked.provider === "auto" ? "AUTO" : String(picked.provider).toUpperCase()} TO WHICH TIER?` : `\u25C8 ${String(picked.provider).toUpperCase()} \u2192 SELECT MODEL FOR ${picked.tier}`;
   const breadcrumb = step === "PROVIDER" ? "Step 1 / 3" : step === "TIER" ? `Step 2 / 3  \xB7  provider: ${picked.provider}` : `Step 3 / 3  \xB7  ${picked.provider} \u2192 ${picked.tier}`;
+  const PAGE_SIZE = 8;
+  const viewStart = Math.max(0, Math.min(cursor - Math.floor(PAGE_SIZE / 2), currentItems.length - PAGE_SIZE));
+  const visibleItems = currentItems.slice(viewStart, viewStart + PAGE_SIZE);
   return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
     /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { justifyContent: "space-between", children: [
       /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, color: "cyan", children: title }),
@@ -7823,16 +8574,29 @@ var ModelsDisplay = ({
       breadcrumb,
       "  \xB7  \u2191/\u2193 navigate  \xB7  1\u20139 jump"
     ] }) }),
-    currentItems.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { italic: true, color: "yellow", children: "No items to show." }) : /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { flexDirection: "column", children: currentItems.map((item, i) => {
-      const focused = i === cursor;
-      return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "row", children: [
-        /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: focused ? "green" : "gray", children: focused ? "\u276F " : "  " }),
-        /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
-          /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: focused ? "white" : "gray", bold: focused, children: item.label }),
-          item.sublabel && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "gray", dimColor: true, children: `    ${item.sublabel}` })
-        ] })
-      ] }, `${step}-${item.value}-${i}`);
-    }) })
+    currentItems.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { italic: true, color: "yellow", children: "No items to show." }) : /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
+      viewStart > 0 && /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "gray", dimColor: true, children: [
+        "  \u2191 ",
+        viewStart,
+        " more above"
+      ] }),
+      visibleItems.map((item, i) => {
+        const globalIdx = viewStart + i;
+        const focused = globalIdx === cursor;
+        return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "row", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: focused ? "green" : "gray", children: focused ? "\u276F " : "  " }),
+          /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: focused ? "white" : "gray", bold: focused, children: item.label }),
+            item.sublabel && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "gray", dimColor: true, children: `    ${item.sublabel}` })
+          ] })
+        ] }, `${step}-${item.value}-${globalIdx}`);
+      }),
+      viewStart + PAGE_SIZE < currentItems.length && /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "gray", dimColor: true, children: [
+        "  \u2193 ",
+        currentItems.length - viewStart - PAGE_SIZE,
+        " more below"
+      ] })
+    ] })
   ] });
 };
 function CostTracker({
@@ -8026,13 +8790,18 @@ function replReducer(state, action) {
 async function refreshModelCache(store, providers) {
   for (const provider of providers) {
     try {
-      const dummyModel = { id: "dummy", name: "dummy", provider: provider.type, contextWindow: 0, isVisionCapable: false, inputCostPer1kTokens: 0, outputCostPer1kTokens: 0, maxOutputTokens: 0, supportsStreaming: false, isLocal: false };
+      const dummyId = provider.type === "azure" ? provider.deploymentName || "azure-model" : "dummy";
+      const dummyModel = { id: dummyId, name: dummyId, provider: provider.type, contextWindow: 0, isVisionCapable: false, inputCostPer1kTokens: 0, outputCostPer1kTokens: 0, maxOutputTokens: 0, supportsStreaming: false, isLocal: false };
       let instance;
       if (provider.type === "openai") instance = new OpenAIProvider(provider, dummyModel);
       else if (provider.type === "gemini") instance = new GeminiProvider(provider, dummyModel);
       else if (provider.type === "anthropic") instance = new AnthropicProvider(provider, dummyModel);
       else if (provider.type === "ollama") instance = new OllamaProvider(provider, dummyModel);
       else if (provider.type === "openai-compatible") instance = new OpenAICompatibleProvider(provider, dummyModel);
+      else if (provider.type === "azure") {
+        const { AzureOpenAIProvider: AzureOpenAIProvider2 } = await Promise.resolve().then(() => (init_azure(), azure_exports));
+        instance = new AzureOpenAIProvider2(provider, dummyModel);
+      }
       if (instance) {
         const fetched = await instance.listModels();
         for (const m of fetched) store.upsertCachedModel(m);
@@ -8170,7 +8939,7 @@ function Repl({ config, workspacePath, themeName, initialPrompt, identityName })
     };
     const store = new MemoryStore(path17__default.default.join(workspacePath, CASCADE_DB_FILE));
     storeRef.current = store;
-    globalStoreRef.current = new MemoryStore(path17__default.default.join(process.env["HOME"] ?? process.cwd(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE));
+    globalStoreRef.current = new MemoryStore(path17__default.default.join(os3__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE));
     const identityRows = store.listIdentities().map((i) => ({ id: i.id, name: i.name, isDefault: i.isDefault }));
     setIdentities(identityRows);
     let initialIdentityId = config.defaultIdentityId ?? identityRows.find((i) => i.isDefault)?.id ?? identityRows[0]?.id;
@@ -8655,14 +9424,29 @@ Use /identity <name|id> to switch.`;
   const isAutoScrollingRef = React5.useRef(true);
   const width = stdout?.columns ?? 100;
   const height = stdout?.rows ?? 24;
-  const statusHeight = state.showDetails ? state.agentTree ? 10 : 4 : 3;
+  const hasActiveOrFailed2 = (node) => {
+    if (node.status === "ACTIVE" || node.status === "FAILED") return true;
+    return node.children?.some(hasActiveOrFailed2) ?? false;
+  };
+  let agentTreeHeight = 0;
+  if (state.agentTree && hasActiveOrFailed2(state.agentTree)) {
+    agentTreeHeight = 1;
+    const childrenCount = state.agentTree.children?.length ?? 0;
+    agentTreeHeight += Math.min(childrenCount, 6);
+    if (childrenCount > 6) agentTreeHeight += 1;
+  }
+  let timelineHeight = 0;
+  if (state.showDetails && treeNodesRef.current.size > 0) {
+    timelineHeight = 1;
+    timelineHeight += Math.min(3, treeNodesRef.current.size);
+  }
+  const statusHeight = agentTreeHeight + timelineHeight;
   const costHeight = state.showCost ? 6 : 0;
   const approvalHeight = state.approvalRequest ? 12 : 0;
-  const slashVisibleCount = Math.min(SLASH_PAGE_SIZE, slashEntries.length);
-  const slashHeight = slashVisibleCount > 0 ? slashVisibleCount + 2 : 0;
+  Math.min(SLASH_PAGE_SIZE, slashEntries.length);
+  const slashHeight = isTypingCommand ? SLASH_PAGE_SIZE + 2 : 0;
   const chromeHeight = statusHeight + costHeight + approvalHeight + slashHeight + 7;
-  const totalCap = Math.floor(height * 0.7);
-  const availableHeight = Math.max(4, totalCap - chromeHeight);
+  const availableHeight = Math.max(4, height - chromeHeight);
   const allLines = formatToLines(
     state.isStreaming ? [...state.messages, { id: "stream", role: "assistant", content: state.streamBuffer, timestamp: (/* @__PURE__ */ new Date()).toISOString() }] : state.messages,
     width - 4,
@@ -9043,10 +9827,14 @@ function wizardReducer(state, action) {
       return { ...state, currentEntryIdx: next };
     }
     case "ADD_AZURE": {
+      const prevAzure = state.entries.find((e) => e.type === "azure");
       const newEntry = {
         id: crypto.randomUUID(),
         type: "azure",
-        label: `Azure deployment ${state.entries.filter((e) => e.type === "azure").length + 1}`
+        label: `Azure deployment ${state.entries.filter((e) => e.type === "azure").length + 1}`,
+        baseUrl: prevAzure?.baseUrl,
+        apiKey: prevAzure?.apiKey,
+        apiVersion: prevAzure?.apiVersion
       };
       return {
         ...state,
@@ -9068,8 +9856,21 @@ function wizardReducer(state, action) {
         addingAnotherCompat: false
       };
     }
+    case "ADD_OLLAMA": {
+      const newEntry = {
+        id: crypto.randomUUID(),
+        type: "ollama",
+        label: `Ollama endpoint ${state.entries.filter((e) => e.type === "ollama").length + 1}`
+      };
+      return {
+        ...state,
+        entries: [...state.entries, newEntry],
+        currentEntryIdx: state.entries.length,
+        addingAnotherOllama: false
+      };
+    }
     case "SKIP_MORE":
-      return { ...state, addingAnotherAzure: false, addingAnotherCompat: false, step: "FETCH_MODELS", currentEntryIdx: 0 };
+      return { ...state, addingAnotherAzure: false, addingAnotherCompat: false, addingAnotherOllama: false, step: "FETCH_MODELS", currentEntryIdx: 0 };
     case "GO_FETCH":
       return { ...state, step: "FETCH_MODELS", fetchLog: [], fetchedModels: [] };
     case "SET_FETCH_LOG":
@@ -9102,6 +9903,7 @@ function SetupWizard({ workspacePath, onComplete }) {
     currentEntryIdx: 0,
     addingAnotherAzure: false,
     addingAnotherCompat: false,
+    addingAnotherOllama: false,
     fetchedModels: [],
     fetchLog: [],
     tierT1: "auto",
@@ -9155,8 +9957,9 @@ function SetupWizard({ workspacePath, onComplete }) {
             dispatchRef.current({ type: "SET_FETCH_LOG", line: `  \u2714 ${entry.label} \u2014 ${fetched.length} models` });
           } else if (type === "azure") {
             const { AzureOpenAIProvider: AzureOpenAIProvider2 } = await Promise.resolve().then(() => (init_azure(), azure_exports));
-            const dummyModel = { id: "dummy", name: "dummy", provider: type, contextWindow: 0, isVisionCapable: false, inputCostPer1kTokens: 0, outputCostPer1kTokens: 0, maxOutputTokens: 0, supportsStreaming: false, isLocal: false };
-            const p = new AzureOpenAIProvider2({ type, apiKey, baseUrl, deploymentName }, dummyModel);
+            const actualModelId = deploymentName || `azure-${entry.id}`;
+            const dummyModel = { id: actualModelId, name: actualModelId, provider: type, contextWindow: 0, isVisionCapable: false, inputCostPer1kTokens: 0, outputCostPer1kTokens: 0, maxOutputTokens: 0, supportsStreaming: false, isLocal: false };
+            const p = new AzureOpenAIProvider2({ type, apiKey, baseUrl, deploymentName, apiVersion: entry.apiVersion }, dummyModel);
             const fetched = await p.listModels();
             fetched.forEach((m) => models.push({ id: m.id, name: m.name, providerLabel: entry.label }));
             dispatchRef.current({ type: "SET_FETCH_LOG", line: `  \u2714 ${entry.label} \u2014 ${fetched.length} models` });
@@ -9177,7 +9980,8 @@ function SetupWizard({ workspacePath, onComplete }) {
           type: e.type,
           ...e.apiKey ? { apiKey: e.apiKey } : {},
           ...e.baseUrl ? { baseUrl: e.baseUrl } : {},
-          ...e.deploymentName ? { deploymentName: e.deploymentName } : {}
+          ...e.deploymentName ? { deploymentName: e.deploymentName } : {},
+          ...e.apiVersion ? { apiVersion: e.apiVersion } : {}
         }));
         const models = {};
         if (state.tierT1 !== "auto") models["t1"] = state.tierT1;
@@ -9199,25 +10003,28 @@ function SetupWizard({ workspacePath, onComplete }) {
   }, [state.step, state.entries, state.tierT1, state.tierT2, state.tierT3, workspacePath, onComplete, exit]);
   ink.useInput((_input, key) => {
     if (state.step === "PROVIDER_SELECT") {
-      if (key.upArrow) setProviderCursor((p) => Math.max(0, p - 1));
-      if (key.downArrow) setProviderCursor((p) => Math.min(providerOrder.length - 1, p + 1));
+      if (key.upArrow) setProviderCursor((p) => p <= 0 ? providerOrder.length - 1 : p - 1);
+      if (key.downArrow) setProviderCursor((p) => p >= providerOrder.length - 1 ? 0 : p + 1);
       if (_input === " ") dispatch({ type: "TOGGLE_PROVIDER", provider: providerOrder[providerCursor] });
       if (_input === "a") dispatch({ type: "TOGGLE_ALL" });
       if (_input === "i") dispatch({ type: "INVERT_SELECTION" });
       if (key.return) {
-        if (state.selectedTypes.size === 0) return;
+        if (state.selectedTypes.size === 0) {
+          dispatch({ type: "SET_ERROR", error: "Please select at least one provider using <space> before pressing <enter>." });
+          return;
+        }
         dispatch({ type: "CONFIRM_PROVIDERS" });
-        setFieldStage("apiKey");
+        const firstType = [...state.selectedTypes][0];
+        setFieldStage(firstType === "azure" ? "deploymentName" : firstType === "openai-compatible" ? "label" : firstType === "ollama" ? "baseUrl" : "apiKey");
         setFieldBuffer("");
       }
     }
     if (state.step === "TIER_ASSIGN") {
-      if (key.tab || key.downArrow) {
+      if (key.tab || key.rightArrow) {
         const order = ["T1", "T2", "T3"];
         const idx = order.indexOf(state.tierSelectFocus);
         dispatch({ type: "SET_TIER_FOCUS", tier: order[(idx + 1) % 3] });
       }
-      if (key.return) dispatch({ type: "GO_SAVE" });
     }
   });
   const currentEntry = state.entries[state.currentEntryIdx];
@@ -9227,7 +10034,11 @@ function SetupWizard({ workspacePath, onComplete }) {
       if (fieldStage === "deploymentName") {
         dispatch({ type: "SET_ENTRY_FIELD", field: "deploymentName", value: val });
         setFieldBuffer("");
-        setFieldStage("baseUrl");
+        if (currentEntry.baseUrl && currentEntry.apiKey && currentEntry.apiVersion) {
+          setFieldStage("askMore");
+        } else {
+          setFieldStage("baseUrl");
+        }
       } else if (fieldStage === "baseUrl") {
         dispatch({ type: "SET_ENTRY_FIELD", field: "baseUrl", value: val });
         setFieldBuffer("");
@@ -9235,6 +10046,10 @@ function SetupWizard({ workspacePath, onComplete }) {
       } else if (fieldStage === "apiKey") {
         dispatch({ type: "SET_ENTRY_FIELD", field: "apiKey", value: val });
         setFieldBuffer("");
+        setFieldStage("apiVersion");
+      } else if (fieldStage === "apiVersion") {
+        dispatch({ type: "SET_ENTRY_FIELD", field: "apiVersion", value: val || "2024-08-01-preview" });
+        setFieldBuffer("");
         setFieldStage("askMore");
       }
     } else if (currentEntry.type === "openai-compatible") {
@@ -9254,13 +10069,15 @@ function SetupWizard({ workspacePath, onComplete }) {
     } else if (currentEntry.type === "ollama") {
       dispatch({ type: "SET_ENTRY_FIELD", field: "baseUrl", value: val || "http://localhost:11434" });
       setFieldBuffer("");
-      dispatch({ type: "NEXT_ENTRY" });
-      setFieldStage("apiKey");
+      setFieldStage("askMore");
     } else {
       dispatch({ type: "SET_ENTRY_FIELD", field: "apiKey", value: val });
       setFieldBuffer("");
+      const nextEntry = state.entries[state.currentEntryIdx + 1];
+      if (nextEntry) {
+        setFieldStage(nextEntry.type === "azure" ? "deploymentName" : nextEntry.type === "openai-compatible" ? "label" : nextEntry.type === "ollama" ? "baseUrl" : "apiKey");
+      }
       dispatch({ type: "NEXT_ENTRY" });
-      setFieldStage("apiKey");
     }
   }, [currentEntry, fieldStage]);
   if (state.step === "PROVIDER_SELECT") {
@@ -9293,7 +10110,7 @@ function SetupWizard({ workspacePath, onComplete }) {
       return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
         /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { marginBottom: 1, children: [
           /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "magenta", bold: true, children: "? " }),
-          /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, children: isAzure ? "Add another Azure deployment? (y/n)" : "Add another custom endpoint? (y/n)" })
+          /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, children: isAzure ? "Add another Azure deployment? (y/n)" : isOllama ? "Add another Ollama endpoint? (y/n)" : "Add another custom endpoint? (y/n)" })
         ] }),
         /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { children: /* @__PURE__ */ jsxRuntime.jsx(
           SelectInput__default.default,
@@ -9307,12 +10124,16 @@ function SetupWizard({ workspacePath, onComplete }) {
             onSelect: (item) => {
               if (item.value === "yes") {
                 if (isAzure) dispatch({ type: "ADD_AZURE" });
+                else if (isOllama) dispatch({ type: "ADD_OLLAMA" });
                 else dispatch({ type: "ADD_COMPAT" });
-                setFieldStage(isAzure ? "deploymentName" : "label");
+                setFieldStage(isAzure ? "deploymentName" : isOllama ? "baseUrl" : "label");
                 setFieldBuffer("");
               } else {
+                const nextEntry = state.entries[state.currentEntryIdx + 1];
+                if (nextEntry) {
+                  setFieldStage(nextEntry.type === "azure" ? "deploymentName" : nextEntry.type === "openai-compatible" ? "label" : nextEntry.type === "ollama" ? "baseUrl" : "apiKey");
+                }
                 dispatch({ type: "NEXT_ENTRY" });
-                setFieldStage("apiKey");
                 setFieldBuffer("");
               }
             }
@@ -9321,7 +10142,7 @@ function SetupWizard({ workspacePath, onComplete }) {
       ] });
     }
     const prompt = isAzure && fieldStage === "deploymentName" ? `Azure deployment name (${currentEntry.label})` : isAzure && fieldStage === "baseUrl" ? `Azure endpoint URL` : isCompat && fieldStage === "label" ? `Name for this endpoint (e.g. Groq)` : isCompat && fieldStage === "baseUrl" ? `Base URL (e.g. https://api.groq.com/openai/v1)` : isOllama ? `Ollama URL (Enter for http://localhost:11434)` : `${currentEntry.label} API Key`;
-    const isMasked = fieldStage === "apiKey";
+    const isMasked = fieldStage === "apiKey" && !isOllama;
     return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
       /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { marginBottom: 1, children: [
         /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "magenta", bold: true, children: "? " }),
@@ -9393,7 +10214,16 @@ function SetupWizard({ workspacePath, onComplete }) {
           SelectInput__default.default,
           {
             items: modelOptions,
-            onSelect: (item) => dispatch({ type: "SET_TIER", tier, value: item.value }),
+            onSelect: (item) => {
+              dispatch({ type: "SET_TIER", tier, value: item.value });
+              const order = ["T1", "T2", "T3"];
+              const idx = order.indexOf(tier);
+              if (idx < 2) {
+                dispatch({ type: "SET_TIER_FOCUS", tier: order[idx + 1] });
+              } else {
+                dispatch({ type: "GO_SAVE" });
+              }
+            },
             indicatorComponent: ({ isSelected }) => /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "magenta", children: isSelected ? "\u276F " : "  " }),
             itemComponent: ({ isSelected, label }) => /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: isSelected ? "magenta" : "white", children: label })
           }
@@ -9871,7 +10701,7 @@ var DashboardServer = class {
   // ── Setup ─────────────────────────────────────
   getGlobalStore() {
     if (!this.globalStore) {
-      const globalDbPath = path17__default.default.join(process.env["HOME"] ?? process.cwd(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path17__default.default.join(os3__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       this.globalStore = new MemoryStore(globalDbPath);
     }
     return this.globalStore;
@@ -9933,7 +10763,7 @@ var DashboardServer = class {
   }
   watchRuntimeChanges() {
     const workspaceDbPath = path17__default.default.join(this.workspacePath, CASCADE_DB_FILE);
-    const globalDbPath = path17__default.default.join(process.env["HOME"] ?? process.cwd(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+    const globalDbPath = path17__default.default.join(os3__default.default.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 (!fs14__default.default.existsSync(watchPath)) continue;
@@ -10041,7 +10871,7 @@ var DashboardServer = class {
       const sessionId = req.params.id;
       this.store.deleteSession(sessionId);
       this.store.deleteRuntimeSession(sessionId);
-      const globalDbPath = path17__default.default.join(process.env["HOME"] ?? process.cwd(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path17__default.default.join(os3__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteRuntimeSession(sessionId);
@@ -10055,7 +10885,7 @@ var DashboardServer = class {
     });
     this.app.delete("/api/sessions", auth, (req, res) => {
       const body = req.body;
-      const globalDbPath = path17__default.default.join(process.env["HOME"] ?? process.cwd(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path17__default.default.join(os3__default.default.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 {
@@ -10078,7 +10908,7 @@ var DashboardServer = class {
     });
     this.app.delete("/api/runtime", auth, (_req, res) => {
       this.store.deleteAllRuntimeNodes();
-      const globalDbPath = path17__default.default.join(process.env["HOME"] ?? process.cwd(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path17__default.default.join(os3__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteAllRuntimeNodes();
@@ -10174,7 +11004,7 @@ var DashboardServer = class {
     this.app.get("/api/runtime", auth, (req, res) => {
       const scope = req.query["scope"] ?? "workspace";
       if (scope === "global") {
-        const globalDbPath = path17__default.default.join(process.env["HOME"] ?? process.cwd(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+        const globalDbPath = path17__default.default.join(os3__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
         const globalStore = new MemoryStore(globalDbPath);
         try {
           res.json({
@@ -10424,7 +11254,15 @@ async function exportCommand(options = {}) {
   const spin = ora__default.default({ text: "Loading sessions\u2026", color: "magenta" }).start();
   let store;
   try {
-    const dbPath = path17__default.default.join(process.env["HOME"] ?? "~", GLOBAL_CONFIG_DIR, GLOBAL_DB_FILE);
+    const workspacePath = options.workspacePath ?? process.cwd();
+    const workspaceDbPath = path17__default.default.join(workspacePath, CASCADE_DB_FILE);
+    const globalDbPath = path17__default.default.join(os3__default.default.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_DB_FILE);
+    let dbPath = globalDbPath;
+    try {
+      await fs7__default.default.access(workspaceDbPath);
+      dbPath = workspaceDbPath;
+    } catch {
+    }
     store = new MemoryStore(dbPath);
   } catch (err) {
     spin.fail(chalk8__default.default.red(`Cannot open memory store: ${err instanceof Error ? err.message : String(err)}`));
@@ -10563,6 +11401,15 @@ async function telemetryCommand(action) {
 
 // src/cli/index.ts
 dotenv__default.default.config();
+process.on("exit", () => McpClient.killAllProcesses());
+process.on("SIGINT", () => {
+  McpClient.killAllProcesses();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  McpClient.killAllProcesses();
+  process.exit(0);
+});
 var program = new commander.Command();
 program.name("cascade").description("Multi-tier AI orchestration CLI").version(CASCADE_VERSION, "-v, --version").option("-p, --prompt <text>", "Run a single prompt non-interactively").option("-t, --theme <name>", "Color theme", DEFAULT_THEME).option("-w, --workspace <path>", "Workspace path", process.cwd()).option("-i, --identity <name>", "Identity name or ID").option("--no-color", "Disable colors").action(async (options) => {
   await startRepl(options);