cascade-ai 0.2.2 → 0.2.12

package/dist/index.js

@@ -1,5 +1,6 @@
 import EventEmitter from 'events';
 import crypto, { randomUUID, timingSafeEqual } from 'crypto';
+import { glob } from 'glob';
 import Anthropic from '@anthropic-ai/sdk';
 import OpenAI from 'openai';
 import { GoogleGenAI, HarmBlockThreshold, HarmCategory } from '@google/genai';
@@ -8,7 +9,7 @@ import fs2 from 'fs/promises';
 import path13 from 'path';
 import * as ignoreFactory from 'ignore';
 import ignoreFactory__default from 'ignore';
-import { exec, execFile } from 'child_process';
+import { exec, execFile, execSync } from 'child_process';
 import { promisify } from 'util';
 import { simpleGit } from 'simple-git';
 import fs11 from 'fs';
@@ -17,7 +18,7 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { z } from 'zod';
 import { createContext, runInContext } from 'vm';
-import os from 'os';
+import os2 from 'os';
 import Database from 'better-sqlite3';
 import { createServer } from 'http';
 import { fileURLToPath } from 'url';
@@ -123,7 +124,7 @@ var require_keytar2 = __commonJS({
 });
 
 // src/constants.ts
-var CASCADE_VERSION = "0.2.2";
+var CASCADE_VERSION = "0.2.12";
 var CASCADE_CONFIG_DIR = ".cascade";
 var CASCADE_MD_FILE = "CASCADE.md";
 var CASCADE_IGNORE_FILE = ".cascadeignore";
@@ -426,7 +427,8 @@ var TOOL_NAMES = {
   IMAGE_ANALYZE: "image_analyze",
   PDF_CREATE: "pdf_create",
   RUN_CODE: "run_code",
-  PEER_MESSAGE: "peer_message"
+  PEER_MESSAGE: "peer_message",
+  WEB_SEARCH: "web_search"
 };
 var DEFAULT_APPROVAL_REQUIRED = [
   TOOL_NAMES.SHELL,
@@ -504,17 +506,38 @@ var AnthropicProvider = class extends BaseProvider {
       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,
@@ -575,33 +598,61 @@ var AnthropicProvider = class extends BaseProvider {
     }
   }
   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;
   }
 };
 var OpenAIProvider = class extends BaseProvider {
@@ -657,9 +708,25 @@ var OpenAIProvider = class extends BaseProvider {
       }
     }
     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 });
       }
@@ -682,6 +749,10 @@ var OpenAIProvider = class extends BaseProvider {
         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 {
@@ -862,7 +933,7 @@ var GeminiProvider = class extends BaseProvider {
         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 ?? {}
             });
@@ -950,10 +1021,70 @@ var GeminiProvider = class extends BaseProvider {
   }
   // ── 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 = [];
@@ -1820,6 +1951,29 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
     return /rate.?limit|429|too.?many.?requests|quota/i.test(msg);
   }
 };
+
+// src/utils/retry.ts
+var CascadeCancelledError = class extends Error {
+  constructor(reason) {
+    super(reason ?? "Run was cancelled via AbortSignal");
+    this.name = "CascadeCancelledError";
+  }
+};
+var CascadeToolError = class extends Error {
+  /** A friendly message to show the user / T3 */
+  userMessage;
+  /** Whether this error class is retryable by default */
+  retryable;
+  constructor(userMessage, cause, retryable = false) {
+    const causeMsg = cause instanceof Error ? cause.message : String(cause);
+    super(`${userMessage}: ${causeMsg}`);
+    this.name = "CascadeToolError";
+    this.userMessage = userMessage;
+    this.retryable = retryable;
+  }
+};
+
+// src/core/tiers/base.ts
 var BaseTier = class extends EventEmitter {
   id;
   role;
@@ -1829,6 +1983,8 @@ var BaseTier = class extends EventEmitter {
   label;
   systemPromptOverride = "";
   hierarchyContext = "";
+  /** Propagated AbortSignal — set by the tier's `execute()` before work begins. */
+  signal;
   constructor(role, id, parentId) {
     super();
     this.role = role;
@@ -1891,6 +2047,18 @@ var BaseTier = class extends EventEmitter {
   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
@@ -2091,6 +2259,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.
@@ -2134,7 +2303,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);
@@ -2284,6 +2454,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 ? `
@@ -2304,21 +2475,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");
           }
@@ -2478,6 +2636,9 @@ ${assignment.expectedOutput}`;
     const artifactPaths = this.extractArtifactPaths(assignment);
     if (!artifactPaths.length) return { ok: true, issues: [] };
     const issues = [];
+    const { exec: exec3 } = await import('child_process');
+    const { promisify: promisify3 } = await import('util');
+    const execAsync2 = promisify3(exec3);
     for (const artifactPath of artifactPaths) {
       const absolutePath = path13.resolve(process.cwd(), artifactPath);
       try {
@@ -2494,9 +2655,27 @@ ${assignment.expectedOutput}`;
           const content = await fs2.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 = path13.extname(absolutePath).toLowerCase();
+        try {
+          if (ext === ".ts" || ext === ".tsx") {
+            await execAsync2(`npx tsc --noEmit ${absolutePath}`, { timeout: 1e4 });
+          } else if (ext === ".js" || ext === ".jsx") {
+            await execAsync2(`node --check ${absolutePath}`, { timeout: 1e4 });
+          } else if (ext === ".py") {
+            await execAsync2(`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}`);
@@ -2893,7 +3072,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);
@@ -2905,12 +3085,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,
@@ -3077,11 +3259,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;
         })
@@ -3095,6 +3278,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));
@@ -3158,7 +3395,8 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
     }));
     return worker.execute(
       { ...assignment, description: `[RETRY] ${assignment.description}` },
-      taskId
+      taskId,
+      this.signal
     );
   }
   publishSectionOutput(result) {
@@ -3172,29 +3410,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";
@@ -3319,10 +3579,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:
@@ -3361,7 +3621,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 = randomUUID();
     this.setLabel("Administrator");
     this.setStatus("ACTIVE");
@@ -3372,10 +3633,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,
@@ -3383,21 +3646,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;
@@ -3426,29 +3751,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,
@@ -3576,92 +3907,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");
@@ -4108,13 +4474,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 = {
@@ -4201,6 +4601,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.";
@@ -4209,7 +4610,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" },
@@ -4229,53 +4630,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");
-    }
-    if (!this.browser) {
-      const pw = playwright;
-      this.browser = await pw.chromium.launch({ headless: true });
-      const b = this.browser;
-      this.page = await b.newPage();
+      return "Error: Playwright is not installed. Run: npm install playwright && npx playwright install chromium";
     }
-    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;
     }
@@ -4372,6 +4806,19 @@ var PDFCreateTool = class extends BaseTool {
     });
   }
 };
+function detectCommand(candidates) {
+  for (const cmd of candidates) {
+    try {
+      const which = process.platform === "win32" ? "where" : "which";
+      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.";
@@ -4387,10 +4834,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 = path13.join(process.cwd(), ".cascade", "tmp");
     if (!fs11.existsSync(tmpDir)) {
       fs11.mkdirSync(tmpDir, { recursive: true });
@@ -4399,8 +4866,9 @@ var CodeInterpreterTool = class extends BaseTool {
     const fileName = `intp_${randomUUID().slice(0, 8)}.${extension}`;
     const filePath = path13.join(tmpDir, fileName);
     fs11.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();
       exec(fullCmd, { cwd: process.cwd(), timeout: 3e4 }, (error, stdout, stderr) => {
@@ -4413,10 +4881,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}
@@ -4481,6 +4956,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;
@@ -4602,7 +5257,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);
@@ -4626,8 +5282,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;
@@ -4656,6 +5327,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()) {
@@ -4677,8 +5350,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);
       }
@@ -4706,6 +5382,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);
   }
@@ -4844,12 +5527,24 @@ var McpServerConfigSchema = z.object({
   args: z.array(z.string()).optional(),
   env: z.record(z.string()).optional()
 });
+var WebSearchConfigSchema = z.object({
+  /** Base URL of your SearXNG instance (e.g. http://localhost:8080) */
+  searxngUrl: z.string().optional(),
+  /** Brave Search API key — get one at https://api.search.brave.com */
+  braveApiKey: z.string().optional(),
+  /** Tavily API key — get one at https://tavily.com */
+  tavilyApiKey: z.string().optional(),
+  /** Max results per search (default 5) */
+  maxResults: z.number().default(5)
+});
 var ToolsConfigSchema = z.object({
   shellAllowlist: z.array(z.string()).default([]),
   shellBlocklist: z.array(z.string()).default(["rm -rf", "sudo rm", "format", "mkfs"]),
   requireApprovalFor: z.array(z.string()).default([]),
   browserEnabled: z.boolean().default(false),
-  mcpServers: z.array(McpServerConfigSchema).optional()
+  mcpServers: z.array(McpServerConfigSchema).optional(),
+  /** Web search backends — at least one should be configured for best results */
+  webSearch: WebSearchConfigSchema.optional()
 });
 var HookDefinitionSchema = z.object({
   command: z.string(),
@@ -5391,12 +6086,25 @@ var Cascade = class extends EventEmitter {
   looksLikeSimpleArtifactTask(prompt) {
     return /create .*\.(txt|md|json|csv)\b/i.test(prompt) && !/(research|compare|thorough|pdf|report|analy[sz]e|architecture|multi-agent)/i.test(prompt);
   }
-  async determineComplexity(prompt, conversationHistory = []) {
+  async determineComplexity(prompt, workspacePath, conversationHistory = []) {
     if (this.looksLikeSimpleArtifactTask(prompt)) {
       return "Simple";
     }
+    let workspaceContext = "";
+    try {
+      const files = await glob("**/*.*", {
+        cwd: workspacePath,
+        ignore: ["node_modules/**", ".git/**", "dist/**", "build/**"],
+        nodir: true
+      });
+      workspaceContext = `Workspace Scout: Found ~${files.length} source files in the project.`;
+    } 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
@@ -5471,7 +6179,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,
@@ -5551,7 +6259,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") {
@@ -5574,7 +6282,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");
@@ -5596,13 +6304,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();
@@ -5924,9 +6641,10 @@ var MemoryStore = class _MemoryStore {
   constructor(dbPath) {
     fs11.mkdirSync(path13.dirname(dbPath), { recursive: true });
     try {
-      this.db = new Database(dbPath);
+      this.db = new Database(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")) {
@@ -5940,6 +6658,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(`
@@ -6026,26 +6776,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(`
@@ -6063,33 +6815,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(`
@@ -6112,30 +6866,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;
@@ -6173,19 +6929,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);
@@ -6282,10 +7040,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);
@@ -6300,10 +7060,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(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(randomUUID(), sessionId, filePath, content, (/* @__PURE__ */ new Date()).toISOString());
+    });
   }
   getLatestFileSnapshots(sessionId) {
     const rows = this.db.prepare(`
@@ -6599,7 +7361,7 @@ var ConfigManager = class {
   globalDir;
   constructor(workspacePath = process.cwd()) {
     this.workspacePath = workspacePath;
-    this.globalDir = path13.join(os.homedir(), GLOBAL_CONFIG_DIR);
+    this.globalDir = path13.join(os2.homedir(), GLOBAL_CONFIG_DIR);
   }
   async load() {
     this.config = await this.loadConfig();
@@ -6667,6 +7429,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" },
@@ -6677,10 +7440,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" });
     }
   }
@@ -6969,7 +7735,7 @@ var DashboardServer = class {
   // ── Setup ─────────────────────────────────────
   getGlobalStore() {
     if (!this.globalStore) {
-      const globalDbPath = path13.join(process.env["HOME"] ?? process.cwd(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path13.join(os2.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       this.globalStore = new MemoryStore(globalDbPath);
     }
     return this.globalStore;
@@ -7031,7 +7797,7 @@ var DashboardServer = class {
   }
   watchRuntimeChanges() {
     const workspaceDbPath = path13.join(this.workspacePath, CASCADE_DB_FILE);
-    const globalDbPath = path13.join(process.env["HOME"] ?? process.cwd(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+    const globalDbPath = path13.join(os2.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
     const watchPaths = [workspaceDbPath, globalDbPath].filter((p, index, arr) => arr.indexOf(p) === index);
     for (const watchPath of watchPaths) {
       if (!fs11.existsSync(watchPath)) continue;
@@ -7139,7 +7905,7 @@ var DashboardServer = class {
       const sessionId = req.params.id;
       this.store.deleteSession(sessionId);
       this.store.deleteRuntimeSession(sessionId);
-      const globalDbPath = path13.join(process.env["HOME"] ?? process.cwd(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path13.join(os2.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteRuntimeSession(sessionId);
@@ -7153,7 +7919,7 @@ var DashboardServer = class {
     });
     this.app.delete("/api/sessions", auth, (req, res) => {
       const body = req.body;
-      const globalDbPath = path13.join(process.env["HOME"] ?? process.cwd(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path13.join(os2.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 {
@@ -7176,7 +7942,7 @@ var DashboardServer = class {
     });
     this.app.delete("/api/runtime", auth, (_req, res) => {
       this.store.deleteAllRuntimeNodes();
-      const globalDbPath = path13.join(process.env["HOME"] ?? process.cwd(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+      const globalDbPath = path13.join(os2.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
       const globalStore = new MemoryStore(globalDbPath);
       try {
         globalStore.deleteAllRuntimeNodes();
@@ -7272,7 +8038,7 @@ var DashboardServer = class {
     this.app.get("/api/runtime", auth, (req, res) => {
       const scope = req.query["scope"] ?? "workspace";
       if (scope === "global") {
-        const globalDbPath = path13.join(process.env["HOME"] ?? process.cwd(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
+        const globalDbPath = path13.join(os2.homedir(), GLOBAL_CONFIG_DIR, GLOBAL_RUNTIME_DB_FILE);
         const globalStore = new MemoryStore(globalDbPath);
         try {
           res.json({
@@ -7483,6 +8249,6 @@ var HooksRunner = class {
   }
 };
 
-export { AZURE_BASE_URL_TEMPLATE, AuditLogger, CASCADE_AUDIT_FILE, CASCADE_CONFIG_DIR, CASCADE_CONFIG_FILE, CASCADE_DASHBOARD_SECRET_FILE, CASCADE_DB_FILE, CASCADE_IGNORE_FILE, CASCADE_KEYSTORE_FILE, CASCADE_MD_FILE, CASCADE_VERSION, COMPLEXITY_T2_COUNT, Cascade, CascadeIgnore, CascadeRouter, ConfigManager, DEFAULT_API_PORT, DEFAULT_APPROVAL_REQUIRED, DEFAULT_AUTO_SUMMARIZE_AT, DEFAULT_CONTEXT_LIMIT, DEFAULT_DASHBOARD_PORT, DEFAULT_MAX_SESSION_MESSAGES, DEFAULT_RETENTION_DAYS, DEFAULT_THEME, DashboardServer, GLOBAL_CONFIG_DIR, GLOBAL_DB_FILE, GLOBAL_KEYSTORE_FILE, GLOBAL_RUNTIME_DB_FILE, HooksRunner, Keystore, LM_STUDIO_BASE_URL, MODELS, McpClient, MemoryStore, OLLAMA_BASE_URL, PROVIDER_DISPLAY_NAMES, T1Administrator, T1_MODEL_PRIORITY, T2Manager, T2_MODEL_PRIORITY, T3Worker, T3_MODEL_PRIORITY, THEME_NAMES, TOOL_NAMES, TaskScheduler, Telemetry, ToolRegistry, VISION_MODEL_PRIORITY, createCascade, runCascade, streamCascade };
+export { AZURE_BASE_URL_TEMPLATE, AuditLogger, CASCADE_AUDIT_FILE, CASCADE_CONFIG_DIR, CASCADE_CONFIG_FILE, CASCADE_DASHBOARD_SECRET_FILE, CASCADE_DB_FILE, CASCADE_IGNORE_FILE, CASCADE_KEYSTORE_FILE, CASCADE_MD_FILE, CASCADE_VERSION, COMPLEXITY_T2_COUNT, Cascade, CascadeCancelledError, CascadeIgnore, CascadeRouter, CascadeToolError, ConfigManager, DEFAULT_API_PORT, DEFAULT_APPROVAL_REQUIRED, DEFAULT_AUTO_SUMMARIZE_AT, DEFAULT_CONTEXT_LIMIT, DEFAULT_DASHBOARD_PORT, DEFAULT_MAX_SESSION_MESSAGES, DEFAULT_RETENTION_DAYS, DEFAULT_THEME, DashboardServer, GLOBAL_CONFIG_DIR, GLOBAL_DB_FILE, GLOBAL_KEYSTORE_FILE, GLOBAL_RUNTIME_DB_FILE, HooksRunner, Keystore, LM_STUDIO_BASE_URL, MODELS, McpClient, MemoryStore, OLLAMA_BASE_URL, PROVIDER_DISPLAY_NAMES, T1Administrator, T1_MODEL_PRIORITY, T2Manager, T2_MODEL_PRIORITY, T3Worker, T3_MODEL_PRIORITY, THEME_NAMES, TOOL_NAMES, TaskScheduler, Telemetry, ToolRegistry, VISION_MODEL_PRIORITY, createCascade, runCascade, streamCascade };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map