@probelabs/probe 0.6.0-rc154 → 0.6.0-rc161

package/build/agent/index.js

@@ -1893,6 +1893,28 @@ import { exec as execCallback } from "child_process";
 import tar from "tar";
 import os2 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
+function sanitizeError(err) {
+  try {
+    const status = err?.response?.status;
+    const statusText = err?.response?.statusText;
+    const url = err?.config?.url || err?.response?.config?.url;
+    const code = err?.code;
+    const serverMsg = typeof err?.response?.data === "string" ? err.response.data.slice(0, 500) : typeof err?.response?.data?.message === "string" ? err.response.data.message : void 0;
+    const base = err?.message || String(err);
+    const parts = [base];
+    if (status || statusText) parts.push(`[${status ?? ""} ${statusText ?? ""}]`.trim());
+    if (code) parts.push(`code=${code}`);
+    if (url) parts.push(`url=${url}`);
+    if (serverMsg) parts.push(`server="${String(serverMsg).replace(/\s+/g, " ").trim()}"`);
+    const e = new Error(parts.filter(Boolean).join(" "));
+    if (status) e.status = status;
+    if (code) e.code = code;
+    if (url) e.url = url;
+    return e;
+  } catch (_) {
+    return new Error(err?.message || String(err));
+  }
+}
 async function acquireFileLock(lockPath, version) {
   const lockData = {
     version,
@@ -1985,7 +2007,7 @@ async function waitForFileLock(lockPath, binaryPath) {
       }
     } catch {
     }
-    await new Promise((resolve5) => setTimeout(resolve5, LOCK_POLL_INTERVAL_MS));
+    await new Promise((resolve6) => setTimeout(resolve6, LOCK_POLL_INTERVAL_MS));
   }
   if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
     console.log(`Timeout waiting for file lock`);
@@ -2041,7 +2063,7 @@ function detectOsArch() {
     case "linux":
       osInfo = {
         type: "linux",
-        keywords: ["linux", "Linux", "gnu"]
+        keywords: ["linux", "Linux", "musl", "gnu"]
       };
       break;
     case "darwin":
@@ -2085,7 +2107,7 @@ function constructAssetInfo(version, osInfo, archInfo) {
   let extension;
   switch (osInfo.type) {
     case "linux":
-      platform = `${archInfo.type}-unknown-linux-gnu`;
+      platform = `${archInfo.type}-unknown-linux-musl`;
       extension = "tar.gz";
       break;
     case "darwin":
@@ -2202,7 +2224,7 @@ async function getLatestRelease(version) {
       }
       return { tag, assets };
     }
-    throw error;
+    throw sanitizeError(error);
   }
 }
 function findBestAsset(assets, osInfo, archInfo) {
@@ -2416,7 +2438,7 @@ async function extractBinary(assetPath, outputDir) {
     return binaryPath;
   } catch (error) {
     console.error(`Error extracting binary: ${error instanceof Error ? error.message : String(error)}`);
-    throw error;
+    throw sanitizeError(error);
   }
 }
 async function getVersionInfo(binDir) {
@@ -2581,8 +2603,8 @@ async function downloadProbeBinary(version) {
     }
     return await withDownloadLock(version, () => doDownload(version));
   } catch (error) {
-    console.error("Error downloading probe binary:", error);
-    throw error;
+    console.error("Error downloading probe binary:", error?.message || String(error));
+    throw sanitizeError(error);
   }
 }
 var exec, REPO_OWNER, REPO_NAME, BINARY_NAME, __filename2, __dirname2, downloadLocks, LOCK_TIMEOUT_MS, LOCK_POLL_INTERVAL_MS, MAX_LOCK_WAIT_MS;
@@ -2619,9 +2641,15 @@ async function getBinaryPath(options = {}) {
     probeBinaryPath = await downloadProbeBinary(version);
     return probeBinaryPath;
   }
-  const binDir = await getPackageBinDir();
   const isWindows = process.platform === "win32";
   const binaryName = isWindows ? "probe.exe" : "probe-binary";
+  const localPackageBin = path3.resolve(__dirname3, "..", "bin");
+  const localBinaryPath = path3.join(localPackageBin, binaryName);
+  if (fs3.existsSync(localBinaryPath) && !forceDownload) {
+    probeBinaryPath = localBinaryPath;
+    return probeBinaryPath;
+  }
+  const binDir = await getPackageBinDir();
   const binaryPath = path3.join(binDir, binaryName);
   if (fs3.existsSync(binaryPath) && !forceDownload) {
     probeBinaryPath = binaryPath;
@@ -2950,7 +2978,7 @@ Command: ${command}`;
   }
 }
 function extractWithStdin(binaryPath, cliArgs, content, options) {
-  return new Promise((resolve5, reject2) => {
+  return new Promise((resolve6, reject2) => {
     const childProcess = spawn(binaryPath, ["extract", ...cliArgs], {
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -2972,7 +3000,7 @@ function extractWithStdin(binaryPath, cliArgs, content, options) {
       }
       try {
         const result = processExtractOutput(stdout, options);
-        resolve5(result);
+        resolve6(result);
       } catch (error) {
         reject2(error);
       }
@@ -3063,6 +3091,262 @@ var init_grep = __esm({
   }
 });
 
+// src/delegate.js
+import { randomUUID } from "crypto";
+async function delegate({
+  task,
+  timeout = 300,
+  debug = false,
+  currentIteration = 0,
+  maxIterations = 30,
+  tracer = null,
+  parentSessionId = null,
+  path: path7 = null,
+  provider = null,
+  model = null
+}) {
+  if (!task || typeof task !== "string") {
+    throw new Error("Task parameter is required and must be a string");
+  }
+  const sessionId = randomUUID();
+  const startTime = Date.now();
+  const remainingIterations = Math.max(1, maxIterations - currentIteration);
+  const delegationSpan = tracer ? tracer.createDelegationSpan(sessionId, task) : null;
+  let timeoutId = null;
+  let acquired = false;
+  try {
+    delegationManager.tryAcquire(parentSessionId);
+    acquired = true;
+    if (debug) {
+      const stats = delegationManager.getStats();
+      console.error(`[DELEGATE] Starting delegation session ${sessionId}`);
+      console.error(`[DELEGATE] Parent session: ${parentSessionId || "none"}`);
+      console.error(`[DELEGATE] Task: ${task}`);
+      console.error(`[DELEGATE] Current iteration: ${currentIteration}/${maxIterations}`);
+      console.error(`[DELEGATE] Remaining iterations for subagent: ${remainingIterations}`);
+      console.error(`[DELEGATE] Timeout configured: ${timeout} seconds`);
+      console.error(`[DELEGATE] Global active delegations: ${stats.globalActive}/${stats.maxConcurrent}`);
+      console.error(`[DELEGATE] Using ProbeAgent SDK with code-researcher prompt`);
+    }
+    const subagent = new ProbeAgent({
+      sessionId,
+      promptType: "code-researcher",
+      // Clean prompt, not inherited from parent
+      enableDelegate: false,
+      // Explicitly disable delegation to prevent recursion
+      disableMermaidValidation: true,
+      // Faster processing
+      disableJsonValidation: true,
+      // Simpler responses
+      maxIterations: remainingIterations,
+      debug,
+      tracer,
+      path: path7,
+      // Inherit from parent
+      provider,
+      // Inherit from parent
+      model
+      // Inherit from parent
+    });
+    if (debug) {
+      console.error(`[DELEGATE] Created subagent with session ${sessionId}`);
+      console.error(`[DELEGATE] Subagent config: promptType=code-researcher, enableDelegate=false, maxIterations=${remainingIterations}`);
+    }
+    const timeoutPromise = new Promise((_, reject2) => {
+      timeoutId = setTimeout(() => {
+        reject2(new Error(`Delegation timed out after ${timeout} seconds`));
+      }, timeout * 1e3);
+    });
+    const answerPromise = subagent.answer(task);
+    const response = await Promise.race([answerPromise, timeoutPromise]);
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    const duration = Date.now() - startTime;
+    if (typeof response !== "string") {
+      throw new Error("Delegate agent returned invalid response (not a string)");
+    }
+    const trimmedResponse = response.trim();
+    if (trimmedResponse.length === 0) {
+      throw new Error("Delegate agent returned empty or whitespace-only response");
+    }
+    if (trimmedResponse.includes("\0")) {
+      throw new Error("Delegate agent returned response containing null bytes");
+    }
+    if (debug) {
+      console.error(`[DELEGATE] Task completed successfully for session ${sessionId}`);
+      console.error(`[DELEGATE] Duration: ${(duration / 1e3).toFixed(2)}s`);
+      console.error(`[DELEGATE] Response length: ${response.length} chars`);
+    }
+    if (tracer) {
+      tracer.recordDelegationEvent("completed", {
+        "delegation.session_id": sessionId,
+        "delegation.parent_session_id": parentSessionId,
+        "delegation.duration_ms": duration,
+        "delegation.response_length": response.length,
+        "delegation.success": true
+      });
+      if (delegationSpan) {
+        delegationSpan.setAttributes({
+          "delegation.result.success": true,
+          "delegation.result.response_length": response.length,
+          "delegation.result.duration_ms": duration
+        });
+        delegationSpan.setStatus({ code: 1 });
+        delegationSpan.end();
+      }
+    }
+    if (acquired) {
+      delegationManager.release(parentSessionId, debug);
+    }
+    return response;
+  } catch (error) {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    const duration = Date.now() - startTime;
+    if (acquired) {
+      delegationManager.release(parentSessionId, debug);
+    }
+    if (debug) {
+      console.error(`[DELEGATE] Task failed for session ${sessionId} after ${duration}ms`);
+      console.error(`[DELEGATE] Error: ${error.message}`);
+      console.error(`[DELEGATE] Stack: ${error.stack}`);
+    }
+    if (tracer) {
+      tracer.recordDelegationEvent("failed", {
+        "delegation.session_id": sessionId,
+        "delegation.parent_session_id": parentSessionId,
+        "delegation.duration_ms": duration,
+        "delegation.error_message": error.message,
+        "delegation.success": false
+      });
+      if (delegationSpan) {
+        delegationSpan.setAttributes({
+          "delegation.result.success": false,
+          "delegation.result.error": error.message,
+          "delegation.result.duration_ms": duration
+        });
+        delegationSpan.setStatus({ code: 2, message: error.message });
+        delegationSpan.end();
+      }
+    }
+    throw new Error(`Delegation failed: ${error.message}`);
+  }
+}
+var DelegationManager, delegationManager;
+var init_delegate = __esm({
+  "src/delegate.js"() {
+    "use strict";
+    init_ProbeAgent();
+    DelegationManager = class {
+      constructor() {
+        this.maxConcurrent = parseInt(process.env.MAX_CONCURRENT_DELEGATIONS || "3", 10);
+        this.maxPerSession = parseInt(process.env.MAX_DELEGATIONS_PER_SESSION || "10", 10);
+        this.sessionDelegations = /* @__PURE__ */ new Map();
+        this.globalActive = 0;
+        this.cleanupInterval = setInterval(() => {
+          try {
+            this.cleanupStaleSessions();
+          } catch (error) {
+            console.error("[DelegationManager] Error during cleanup:", error);
+          }
+        }, 5 * 60 * 1e3);
+        if (this.cleanupInterval.unref) {
+          this.cleanupInterval.unref();
+        }
+      }
+      /**
+       * Check limits and increment counters (synchronous, atomic in Node.js event loop)
+       * @param {string|null|undefined} parentSessionId - Parent session ID for tracking
+       */
+      tryAcquire(parentSessionId) {
+        if (parentSessionId !== null && parentSessionId !== void 0 && typeof parentSessionId !== "string") {
+          throw new TypeError("parentSessionId must be a string, null, or undefined");
+        }
+        if (this.globalActive >= this.maxConcurrent) {
+          throw new Error(`Maximum concurrent delegations (${this.maxConcurrent}) reached. Please wait for some delegations to complete.`);
+        }
+        if (parentSessionId) {
+          const sessionData = this.sessionDelegations.get(parentSessionId);
+          const sessionCount = sessionData?.count || 0;
+          if (sessionCount >= this.maxPerSession) {
+            throw new Error(`Maximum delegations per session (${this.maxPerSession}) reached for session ${parentSessionId}`);
+          }
+        }
+        this.globalActive++;
+        if (parentSessionId) {
+          const sessionData = this.sessionDelegations.get(parentSessionId);
+          if (sessionData) {
+            sessionData.count++;
+            sessionData.lastUpdated = Date.now();
+          } else {
+            this.sessionDelegations.set(parentSessionId, {
+              count: 1,
+              lastUpdated: Date.now()
+            });
+          }
+        }
+        return true;
+      }
+      /**
+       * Decrement counters (synchronous, atomic in Node.js event loop)
+       */
+      release(parentSessionId, debug = false) {
+        this.globalActive = Math.max(0, this.globalActive - 1);
+        if (parentSessionId) {
+          const sessionData = this.sessionDelegations.get(parentSessionId);
+          if (sessionData) {
+            sessionData.count = Math.max(0, sessionData.count - 1);
+            if (sessionData.count === 0) {
+              this.sessionDelegations.delete(parentSessionId);
+            }
+          }
+        }
+        if (debug) {
+          console.error(`[DELEGATE] Released. Global active: ${this.globalActive}`);
+        }
+      }
+      /**
+       * Get current stats for monitoring
+       */
+      getStats() {
+        return {
+          globalActive: this.globalActive,
+          maxConcurrent: this.maxConcurrent,
+          maxPerSession: this.maxPerSession,
+          sessionCount: this.sessionDelegations.size
+        };
+      }
+      /**
+       * Clean up stale sessions (sessions with count=0 that haven't been updated in 1 hour)
+       */
+      cleanupStaleSessions() {
+        const oneHourAgo = Date.now() - 60 * 60 * 1e3;
+        for (const [sessionId, data] of this.sessionDelegations.entries()) {
+          if (data.count === 0 && data.lastUpdated < oneHourAgo) {
+            this.sessionDelegations.delete(sessionId);
+          }
+        }
+      }
+      /**
+       * Cleanup all resources (for testing or shutdown)
+       */
+      cleanup() {
+        if (this.cleanupInterval) {
+          clearInterval(this.cleanupInterval);
+          this.cleanupInterval = null;
+        }
+        this.sessionDelegations.clear();
+        this.globalActive = 0;
+      }
+    };
+    delegationManager = new DelegationManager();
+  }
+});
+
 // node_modules/zod/v3/helpers/util.js
 var util, objectUtil, ZodParsedType, getParsedType;
 var init_util2 = __esm({
@@ -7276,7 +7560,7 @@ function parseTargets(targets) {
   }
   return targets.split(/\s+/).filter((f) => f.length > 0);
 }
-var searchSchema, querySchema, extractSchema, delegateSchema, bashSchema, attemptCompletionSchema, searchToolDefinition, queryToolDefinition, extractToolDefinition, attemptCompletionToolDefinition, searchDescription, queryDescription, extractDescription, delegateDescription, DEFAULT_VALID_TOOLS;
+var searchSchema, querySchema, extractSchema, delegateSchema, bashSchema, attemptCompletionSchema, searchToolDefinition, queryToolDefinition, extractToolDefinition, delegateToolDefinition, attemptCompletionToolDefinition, bashToolDefinition, searchDescription, queryDescription, extractDescription, delegateDescription, DEFAULT_VALID_TOOLS;
 var init_common = __esm({
   "src/tools/common.js"() {
     "use strict";
@@ -7289,11 +7573,12 @@ var init_common = __esm({
       pattern: external_exports.string().describe("AST pattern to search for. Use $NAME for variable names, $$$PARAMS for parameter lists, etc."),
       path: external_exports.string().optional().default(".").describe("Path to search in"),
       language: external_exports.string().optional().default("rust").describe("Programming language to use for parsing"),
-      allow_tests: external_exports.boolean().optional().default(false).describe("Allow test files in search results")
+      allow_tests: external_exports.boolean().optional().default(true).describe("Allow test files in search results")
     });
     extractSchema = external_exports.object({
       targets: external_exports.string().optional().describe('File paths or symbols to extract from. Formats: "file.js" (whole file), "file.js:42" (line 42), "file.js:10-20" (lines 10-20), "file.js#funcName" (symbol). Multiple targets separated by spaces.'),
-      input_content: external_exports.string().optional().describe("Text content to extract file paths from (alternative to targets)")
+      input_content: external_exports.string().optional().describe("Text content to extract file paths from (alternative to targets)"),
+      allow_tests: external_exports.boolean().optional().default(true).describe("Include test files in extraction results")
     });
     delegateSchema = external_exports.object({
       task: external_exports.string().describe("The task to delegate to a subagent. Be specific about what needs to be accomplished.")
@@ -7420,7 +7705,7 @@ Parameters:
 - pattern: (required) AST pattern to search for. Use $NAME for variable names, $$$PARAMS for parameter lists, etc.
 - path: (optional, default: '.') Path to search in.
 - language: (optional, default: 'rust') Programming language to use for parsing.
-- allow_tests: (optional, default: false) Allow test files in search results (true/false).
+- allow_tests: (optional, default: true) Allow test files in search results (true/false).
 Usage Example:
 
 <examples>
@@ -7445,6 +7730,7 @@ Full file extraction should be the LAST RESORT! Always prefer search.
 Parameters:
 - targets: (required) File paths or symbols to extract from. Formats: "file.js" (whole file), "file.js:42" (code block at line 42), "file.js:10-20" (lines 10-20), "file.js#funcName" (specific symbol). Multiple targets separated by spaces.
 - input_content: (optional) Text content to extract file paths from (alternative to targets for processing diffs/logs).
+- allow_tests: (optional, default: true) Include test files in extraction results.
 
 Usage Example:
 
@@ -7481,6 +7767,26 @@ User: Read file inside the dependency
 </extract>
 
 </examples>
+`;
+    delegateToolDefinition = `
+## delegate
+Description: Automatically delegate big distinct tasks to specialized probe subagents within the agentic loop. Use this when you recognize that a user's request involves multiple large, distinct components that would benefit from parallel processing or specialized focus. The AI agent should automatically identify opportunities for task separation and use delegation without explicit user instruction.
+
+Parameters:
+- task: (required) A complete, self-contained task that can be executed independently by a subagent. Should be specific and focused on one area of expertise.
+
+Usage Pattern:
+When the AI agent encounters complex multi-part requests, it should automatically break them down and delegate:
+
+<delegate>
+<task>Analyze all authentication and authorization code in the codebase for security vulnerabilities and provide specific remediation recommendations</task>
+</delegate>
+
+<delegate>
+<task>Review database queries and API endpoints for performance bottlenecks and suggest optimization strategies</task>
+</delegate>
+
+The agent uses this tool automatically when it identifies that work can be separated into distinct, parallel tasks for more efficient processing.
 `;
     attemptCompletionToolDefinition = `
 ## attempt_completion
@@ -7491,6 +7797,61 @@ Usage Example:
 <attempt_completion>
 I have refactored the search module according to the requirements and verified the tests pass. The module now uses the new BM25 ranking algorithm and has improved error handling.
 </attempt_completion>
+`;
+    bashToolDefinition = `
+## bash
+Description: Execute bash commands for system exploration and development tasks. This tool has built-in security with allow/deny lists. By default, only safe read-only commands are allowed for code exploration.
+
+Parameters:
+- command: (required) The bash command to execute
+- workingDirectory: (optional) Directory to execute the command in
+- timeout: (optional) Command timeout in milliseconds
+- env: (optional) Additional environment variables as an object
+
+Security: Commands are filtered through allow/deny lists for safety:
+- Allowed by default: ls, cat, git status, npm list, find, grep, etc.
+- Denied by default: rm -rf, sudo, npm install, dangerous system commands
+
+Usage Examples:
+
+<examples>
+
+User: What files are in the src directory?
+<bash>
+<command>ls -la src/</command>
+</bash>
+
+User: Show me the git status
+<bash>
+<command>git status</command>
+</bash>
+
+User: Find all TypeScript files
+<bash>
+<command>find . -name "*.ts" -type f</command>
+</bash>
+
+User: Check installed npm packages
+<bash>
+<command>npm list --depth=0</command>
+</bash>
+
+User: Search for TODO comments in code
+<bash>
+<command>grep -r "TODO" src/</command>
+</bash>
+
+User: Show recent git commits
+<bash>
+<command>git log --oneline -10</command>
+</bash>
+
+User: Check system info
+<bash>
+<command>uname -a</command>
+</bash>
+
+</examples>
 `;
     searchDescription = "Search code in the repository using Elasticsearch-like query syntax. Use this tool first for any code-related questions.";
     queryDescription = "Search code using ast-grep structural pattern matching. Use this tool to find specific code structures like functions, classes, or methods.";
@@ -7509,193 +7870,6 @@ I have refactored the search module according to the requirements and verified t
   }
 });
 
-// src/delegate.js
-import { spawn as spawn2 } from "child_process";
-import { randomUUID } from "crypto";
-async function delegate({ task, timeout = 300, debug = false, currentIteration = 0, maxIterations = 30, tracer = null }) {
-  if (!task || typeof task !== "string") {
-    throw new Error("Task parameter is required and must be a string");
-  }
-  const sessionId = randomUUID();
-  const startTime = Date.now();
-  const remainingIterations = Math.max(1, maxIterations - currentIteration);
-  if (debug) {
-    console.error(`[DELEGATE] Starting delegation session ${sessionId}`);
-    console.error(`[DELEGATE] Task: ${task}`);
-    console.error(`[DELEGATE] Current iteration: ${currentIteration}/${maxIterations}`);
-    console.error(`[DELEGATE] Remaining iterations for subagent: ${remainingIterations}`);
-    console.error(`[DELEGATE] Timeout configured: ${timeout} seconds`);
-    console.error(`[DELEGATE] Using clean agent environment with code-researcher prompt`);
-  }
-  try {
-    const binaryPath = await getBinaryPath();
-    const args = [
-      "agent",
-      "--task",
-      task,
-      "--session-id",
-      sessionId,
-      "--prompt-type",
-      "code-researcher",
-      // Automatically use default code researcher prompt
-      "--no-schema-validation",
-      // Automatically disable schema validation
-      "--no-mermaid-validation",
-      // Automatically disable mermaid validation
-      "--max-iterations",
-      remainingIterations.toString()
-      // Automatically limit to remaining iterations
-    ];
-    if (debug) {
-      args.push("--debug");
-      console.error(`[DELEGATE] Using binary at: ${binaryPath}`);
-      console.error(`[DELEGATE] Command args: ${args.join(" ")}`);
-    }
-    return new Promise((resolve5, reject2) => {
-      const delegationSpan = tracer ? tracer.createDelegationSpan(sessionId, task) : null;
-      const process2 = spawn2(binaryPath, args, {
-        stdio: ["pipe", "pipe", "pipe"],
-        timeout: timeout * 1e3
-      });
-      let stdout = "";
-      let stderr = "";
-      let isResolved = false;
-      process2.stdout.on("data", (data) => {
-        const chunk = data.toString();
-        stdout += chunk;
-        if (debug) {
-          const preview = createMessagePreview(chunk);
-          console.error(`[DELEGATE] stdout chunk received (${chunk.length} chars): ${preview}`);
-        }
-      });
-      process2.stderr.on("data", (data) => {
-        const chunk = data.toString();
-        stderr += chunk;
-        if (debug) {
-          const preview = createMessagePreview(chunk);
-          console.error(`[DELEGATE] stderr chunk received (${chunk.length} chars): ${preview}`);
-        }
-      });
-      process2.on("close", (code) => {
-        if (isResolved) return;
-        isResolved = true;
-        const duration = Date.now() - startTime;
-        if (debug) {
-          console.error(`[DELEGATE] Process completed with code ${code} in ${duration}ms`);
-          console.error(`[DELEGATE] Duration: ${(duration / 1e3).toFixed(2)}s`);
-          console.error(`[DELEGATE] Total stdout: ${stdout.length} chars`);
-          console.error(`[DELEGATE] Total stderr: ${stderr.length} chars`);
-        }
-        if (code === 0) {
-          const response = stdout.trim();
-          if (!response) {
-            if (debug) {
-              console.error(`[DELEGATE] Task completed but returned empty response for session ${sessionId}`);
-            }
-            reject2(new Error("Delegate agent returned empty response"));
-            return;
-          }
-          if (debug) {
-            console.error(`[DELEGATE] Task completed successfully for session ${sessionId}`);
-            console.error(`[DELEGATE] Response length: ${response.length} chars`);
-          }
-          if (tracer) {
-            tracer.recordDelegationEvent("completed", {
-              "delegation.session_id": sessionId,
-              "delegation.duration_ms": duration,
-              "delegation.response_length": response.length,
-              "delegation.success": true
-            });
-            if (delegationSpan) {
-              delegationSpan.setAttributes({
-                "delegation.result.success": true,
-                "delegation.result.response_length": response.length,
-                "delegation.result.duration_ms": duration
-              });
-              delegationSpan.setStatus({ code: 1 });
-              delegationSpan.end();
-            }
-          }
-          resolve5(response);
-        } else {
-          const errorMessage = stderr.trim() || `Delegate process failed with exit code ${code}`;
-          if (debug) {
-            console.error(`[DELEGATE] Task failed for session ${sessionId} with code ${code}`);
-            console.error(`[DELEGATE] Error message: ${errorMessage}`);
-          }
-          if (tracer) {
-            tracer.recordDelegationEvent("failed", {
-              "delegation.session_id": sessionId,
-              "delegation.duration_ms": duration,
-              "delegation.exit_code": code,
-              "delegation.error_message": errorMessage,
-              "delegation.success": false
-            });
-            if (delegationSpan) {
-              delegationSpan.setAttributes({
-                "delegation.result.success": false,
-                "delegation.result.exit_code": code,
-                "delegation.result.error": errorMessage,
-                "delegation.result.duration_ms": duration
-              });
-              delegationSpan.setStatus({ code: 2, message: errorMessage });
-              delegationSpan.end();
-            }
-          }
-          reject2(new Error(`Delegation failed: ${errorMessage}`));
-        }
-      });
-      process2.on("error", (error) => {
-        if (isResolved) return;
-        isResolved = true;
-        const duration = Date.now() - startTime;
-        if (debug) {
-          console.error(`[DELEGATE] Process spawn error after ${duration}ms:`, error);
-          console.error(`[DELEGATE] Session ${sessionId} failed during process creation`);
-          console.error(`[DELEGATE] Error type: ${error.code || "unknown"}`);
-        }
-        reject2(new Error(`Failed to start delegate process: ${error.message}`));
-      });
-      setTimeout(() => {
-        if (isResolved) return;
-        isResolved = true;
-        const duration = Date.now() - startTime;
-        if (debug) {
-          console.error(`[DELEGATE] Process timeout after ${(duration / 1e3).toFixed(2)}s (limit: ${timeout}s)`);
-          console.error(`[DELEGATE] Terminating session ${sessionId} due to timeout`);
-          console.error(`[DELEGATE] Partial stdout: ${stdout.substring(0, 500)}${stdout.length > 500 ? "..." : ""}`);
-          console.error(`[DELEGATE] Partial stderr: ${stderr.substring(0, 500)}${stderr.length > 500 ? "..." : ""}`);
-        }
-        process2.kill("SIGTERM");
-        setTimeout(() => {
-          if (!process2.killed) {
-            if (debug) {
-              console.error(`[DELEGATE] Force killing process ${sessionId} after graceful timeout`);
-            }
-            process2.kill("SIGKILL");
-          }
-        }, 5e3);
-        reject2(new Error(`Delegation timed out after ${timeout} seconds`));
-      }, timeout * 1e3);
-    });
-  } catch (error) {
-    const duration = Date.now() - startTime;
-    if (debug) {
-      console.error(`[DELEGATE] Error in delegate function after ${duration}ms:`, error);
-      console.error(`[DELEGATE] Session ${sessionId} failed during setup`);
-      console.error(`[DELEGATE] Error stack: ${error.stack}`);
-    }
-    throw new Error(`Delegation setup failed: ${error.message}`);
-  }
-}
-var init_delegate = __esm({
-  "src/delegate.js"() {
-    "use strict";
-    init_utils();
-    init_common();
-  }
-});
-
 // src/tools/vercel.js
 import { tool } from "ai";
 var searchTool, queryTool, extractTool, delegateTool;
@@ -7868,21 +8042,50 @@ var init_vercel = __esm({
         name: "delegate",
         description: delegateDescription,
         inputSchema: delegateSchema,
-        execute: async ({ task }) => {
-          try {
-            if (debug) {
-              console.error(`Executing delegate with task: "${task}"`);
-            }
-            const result = await delegate({
-              task,
-              timeout,
-              debug
-            });
-            return result;
-          } catch (error) {
-            console.error("Error executing delegate command:", error);
-            return `Error executing delegate command: ${error.message}`;
+        execute: async ({ task, currentIteration, maxIterations, parentSessionId, path: path7, provider, model, tracer }) => {
+          if (!task || typeof task !== "string") {
+            throw new Error("Task parameter is required and must be a non-empty string");
+          }
+          if (task.trim().length === 0) {
+            throw new Error("Task parameter cannot be empty or whitespace only");
+          }
+          if (currentIteration !== void 0 && (typeof currentIteration !== "number" || currentIteration < 0)) {
+            throw new Error("currentIteration must be a non-negative number");
+          }
+          if (maxIterations !== void 0 && (typeof maxIterations !== "number" || maxIterations < 1)) {
+            throw new Error("maxIterations must be a positive number");
+          }
+          if (parentSessionId !== void 0 && parentSessionId !== null && typeof parentSessionId !== "string") {
+            throw new TypeError("parentSessionId must be a string, null, or undefined");
           }
+          if (path7 !== void 0 && path7 !== null && typeof path7 !== "string") {
+            throw new TypeError("path must be a string, null, or undefined");
+          }
+          if (provider !== void 0 && provider !== null && typeof provider !== "string") {
+            throw new TypeError("provider must be a string, null, or undefined");
+          }
+          if (model !== void 0 && model !== null && typeof model !== "string") {
+            throw new TypeError("model must be a string, null, or undefined");
+          }
+          if (debug) {
+            console.error(`Executing delegate with task: "${task.substring(0, 100)}${task.length > 100 ? "..." : ""}"`);
+            if (parentSessionId) {
+              console.error(`Parent session: ${parentSessionId}`);
+            }
+          }
+          const result = await delegate({
+            task,
+            timeout,
+            debug,
+            currentIteration: currentIteration || 0,
+            maxIterations: maxIterations || 30,
+            parentSessionId,
+            path: path7,
+            provider,
+            model,
+            tracer
+          });
+          return result;
         }
       });
     };
@@ -8711,7 +8914,7 @@ var init_bashPermissions = __esm({
 });
 
 // src/agent/bashExecutor.js
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { resolve, join } from "path";
 import { existsSync } from "fs";
 async function executeBashCommand(command, options = {}) {
@@ -8748,14 +8951,14 @@ async function executeBashCommand(command, options = {}) {
     console.log(`[BashExecutor] Working directory: "${cwd}"`);
     console.log(`[BashExecutor] Timeout: ${timeout}ms`);
   }
-  return new Promise((resolve5, reject2) => {
+  return new Promise((resolve6, reject2) => {
     const processEnv = {
       ...process.env,
       ...env
     };
     const args = parseCommandForExecution(command);
     if (!args || args.length === 0) {
-      resolve5({
+      resolve6({
         success: false,
         error: "Failed to parse command",
         stdout: "",
@@ -8768,7 +8971,7 @@ async function executeBashCommand(command, options = {}) {
       return;
     }
     const [cmd, ...cmdArgs] = args;
-    const child = spawn3(cmd, cmdArgs, {
+    const child = spawn2(cmd, cmdArgs, {
       cwd,
       env: processEnv,
       stdio: ["ignore", "pipe", "pipe"],
@@ -8838,7 +9041,7 @@ async function executeBashCommand(command, options = {}) {
         success = false;
         error = `Command exited with code ${code}`;
       }
-      resolve5({
+      resolve6({
         success,
         error,
         stdout: stdout.trim(),
@@ -8858,7 +9061,7 @@ async function executeBashCommand(command, options = {}) {
       if (debug) {
         console.log(`[BashExecutor] Spawn error:`, error);
       }
-      resolve5({
+      resolve6({
         success: false,
         error: `Failed to execute command: ${error.message}`,
         stdout: "",
@@ -9130,6 +9333,283 @@ Command failed with exit code ${result.exitCode}`;
   }
 });
 
+// src/tools/edit.js
+import { tool as tool3 } from "ai";
+import { promises as fs4 } from "fs";
+import { dirname, resolve as resolve3, isAbsolute, sep } from "path";
+import { existsSync as existsSync2 } from "fs";
+function isPathAllowed(filePath, allowedFolders) {
+  if (!allowedFolders || allowedFolders.length === 0) {
+    const resolvedPath2 = resolve3(filePath);
+    const cwd = resolve3(process.cwd());
+    return resolvedPath2 === cwd || resolvedPath2.startsWith(cwd + sep);
+  }
+  const resolvedPath = resolve3(filePath);
+  return allowedFolders.some((folder) => {
+    const allowedPath = resolve3(folder);
+    return resolvedPath === allowedPath || resolvedPath.startsWith(allowedPath + sep);
+  });
+}
+function parseFileToolOptions(options = {}) {
+  return {
+    debug: options.debug || false,
+    allowedFolders: options.allowedFolders || [],
+    defaultPath: options.defaultPath
+  };
+}
+var editTool, createTool, editDescription, createDescription, editToolDefinition, createToolDefinition;
+var init_edit = __esm({
+  "src/tools/edit.js"() {
+    "use strict";
+    editTool = (options = {}) => {
+      const { debug, allowedFolders, defaultPath } = parseFileToolOptions(options);
+      return tool3({
+        name: "edit",
+        description: `Edit files using exact string replacement (Claude Code style).
+
+This tool performs exact string replacements in files. It requires the old_string to match exactly what's in the file, including all whitespace and indentation.
+
+Parameters:
+- file_path: Path to the file to edit (absolute or relative)
+- old_string: Exact text to find and replace (must be unique in the file unless replace_all is true)
+- new_string: Text to replace with
+- replace_all: (optional) Replace all occurrences instead of requiring uniqueness
+
+Important:
+- The old_string must match EXACTLY including whitespace
+- If old_string appears multiple times and replace_all is false, the edit will fail
+- Use larger context around the string to ensure uniqueness when needed`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            file_path: {
+              type: "string",
+              description: "Path to the file to edit"
+            },
+            old_string: {
+              type: "string",
+              description: "Exact text to find and replace"
+            },
+            new_string: {
+              type: "string",
+              description: "Text to replace with"
+            },
+            replace_all: {
+              type: "boolean",
+              description: "Replace all occurrences (default: false)",
+              default: false
+            }
+          },
+          required: ["file_path", "old_string", "new_string"]
+        },
+        execute: async ({ file_path, old_string, new_string, replace_all = false }) => {
+          try {
+            if (!file_path || typeof file_path !== "string" || file_path.trim() === "") {
+              return `Error editing file: Invalid file_path - must be a non-empty string`;
+            }
+            if (old_string === void 0 || old_string === null || typeof old_string !== "string") {
+              return `Error editing file: Invalid old_string - must be a string`;
+            }
+            if (new_string === void 0 || new_string === null || typeof new_string !== "string") {
+              return `Error editing file: Invalid new_string - must be a string`;
+            }
+            const resolvedPath = isAbsolute(file_path) ? file_path : resolve3(defaultPath || process.cwd(), file_path);
+            if (debug) {
+              console.error(`[Edit] Attempting to edit file: ${resolvedPath}`);
+            }
+            if (!isPathAllowed(resolvedPath, allowedFolders)) {
+              return `Error editing file: Permission denied - ${file_path} is outside allowed directories`;
+            }
+            if (!existsSync2(resolvedPath)) {
+              return `Error editing file: File not found - ${file_path}`;
+            }
+            const content = await fs4.readFile(resolvedPath, "utf-8");
+            if (!content.includes(old_string)) {
+              return `Error editing file: String not found - the specified old_string was not found in ${file_path}`;
+            }
+            const occurrences = content.split(old_string).length - 1;
+            if (!replace_all && occurrences > 1) {
+              return `Error editing file: Multiple occurrences found - the old_string appears ${occurrences} times. Use replace_all: true to replace all occurrences, or provide more context to make the string unique.`;
+            }
+            let newContent;
+            if (replace_all) {
+              newContent = content.replaceAll(old_string, new_string);
+            } else {
+              newContent = content.replace(old_string, new_string);
+            }
+            if (newContent === content) {
+              return `Error editing file: No changes made - old_string and new_string might be the same`;
+            }
+            await fs4.writeFile(resolvedPath, newContent, "utf-8");
+            const replacedCount = replace_all ? occurrences : 1;
+            if (debug) {
+              console.error(`[Edit] Successfully edited ${resolvedPath}, replaced ${replacedCount} occurrence(s)`);
+            }
+            return `Successfully edited ${file_path} (${replacedCount} replacement${replacedCount !== 1 ? "s" : ""})`;
+          } catch (error) {
+            console.error("[Edit] Error:", error);
+            return `Error editing file: ${error.message}`;
+          }
+        }
+      });
+    };
+    createTool = (options = {}) => {
+      const { debug, allowedFolders, defaultPath } = parseFileToolOptions(options);
+      return tool3({
+        name: "create",
+        description: `Create new files with specified content.
+
+This tool creates new files in the filesystem. It will create parent directories if they don't exist.
+
+Parameters:
+- file_path: Path where the file should be created (absolute or relative)
+- content: Content to write to the file
+- overwrite: (optional) Whether to overwrite if file exists (default: false)
+
+Important:
+- By default, will fail if the file already exists
+- Set overwrite: true to replace existing files
+- Parent directories will be created automatically if needed`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            file_path: {
+              type: "string",
+              description: "Path where the file should be created"
+            },
+            content: {
+              type: "string",
+              description: "Content to write to the file"
+            },
+            overwrite: {
+              type: "boolean",
+              description: "Overwrite if file exists (default: false)",
+              default: false
+            }
+          },
+          required: ["file_path", "content"]
+        },
+        execute: async ({ file_path, content, overwrite = false }) => {
+          try {
+            if (!file_path || typeof file_path !== "string" || file_path.trim() === "") {
+              return `Error creating file: Invalid file_path - must be a non-empty string`;
+            }
+            if (content === void 0 || content === null || typeof content !== "string") {
+              return `Error creating file: Invalid content - must be a string`;
+            }
+            const resolvedPath = isAbsolute(file_path) ? file_path : resolve3(defaultPath || process.cwd(), file_path);
+            if (debug) {
+              console.error(`[Create] Attempting to create file: ${resolvedPath}`);
+            }
+            if (!isPathAllowed(resolvedPath, allowedFolders)) {
+              return `Error creating file: Permission denied - ${file_path} is outside allowed directories`;
+            }
+            if (existsSync2(resolvedPath) && !overwrite) {
+              return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
+            }
+            const dir = dirname(resolvedPath);
+            await fs4.mkdir(dir, { recursive: true });
+            await fs4.writeFile(resolvedPath, content, "utf-8");
+            const action = existsSync2(resolvedPath) && overwrite ? "overwrote" : "created";
+            const bytes = Buffer.byteLength(content, "utf-8");
+            if (debug) {
+              console.error(`[Create] Successfully ${action} ${resolvedPath}`);
+            }
+            return `Successfully ${action} ${file_path} (${bytes} bytes)`;
+          } catch (error) {
+            console.error("[Create] Error:", error);
+            return `Error creating file: ${error.message}`;
+          }
+        }
+      });
+    };
+    editDescription = "Edit files using exact string replacement. Requires exact match including whitespace.";
+    createDescription = "Create new files with specified content. Will create parent directories if needed.";
+    editToolDefinition = `
+## edit
+Description: ${editDescription}
+
+When to use:
+- For precise, surgical edits to existing files
+- When you need to change specific lines or blocks of code
+- For renaming functions, variables, or updating configuration values
+- When the exact text to replace is known and unique (or use replace_all for multiple occurrences)
+
+When NOT to use:
+- For creating new files (use 'create' tool instead)
+- When you cannot determine the exact text to replace
+- When changes span multiple locations that would be better handled together
+
+Parameters:
+- file_path: (required) Path to the file to edit
+- old_string: (required) Exact text to find and replace (must match including whitespace, newlines, and indentation)
+- new_string: (required) Text to replace with
+- replace_all: (optional, default: false) Replace all occurrences if the string appears multiple times
+
+Important notes:
+- The old_string MUST match EXACTLY, including all whitespace, indentation, and line breaks
+- If old_string appears multiple times and replace_all is false, the tool will fail
+- Always verify the exact formatting of the text you want to replace
+
+Examples:
+<edit>
+<file_path>src/main.js</file_path>
+<old_string>function oldName() {
+  return 42;
+}</old_string>
+<new_string>function newName() {
+  return 42;
+}</new_string>
+</edit>
+
+<edit>
+<file_path>config.json</file_path>
+<old_string>"debug": false</old_string>
+<new_string>"debug": true</new_string>
+<replace_all>true</replace_all>
+</edit>`;
+    createToolDefinition = `
+## create
+Description: ${createDescription}
+
+When to use:
+- For creating brand new files from scratch
+- When you need to add configuration files, documentation, or new modules
+- For generating boilerplate code or templates
+- When you have the complete content ready to write
+
+When NOT to use:
+- For editing existing files (use 'edit' tool instead)
+- When a file already exists unless you explicitly want to overwrite it
+
+Parameters:
+- file_path: (required) Path where the file should be created
+- content: (required) Complete content to write to the file
+- overwrite: (optional, default: false) Whether to overwrite if file already exists
+
+Important notes:
+- Parent directories will be created automatically if they don't exist
+- The tool will fail if the file already exists and overwrite is false
+- Be careful with the overwrite option as it completely replaces existing files
+
+Examples:
+<create>
+<file_path>src/newFile.js</file_path>
+<content>export function hello() {
+  return "Hello, world!";
+}</content>
+</create>
+
+<create>
+<file_path>README.md</file_path>
+<content># My Project
+
+This is a new project.</content>
+<overwrite>true</overwrite>
+</create>`;
+  }
+});
+
 // src/tools/langchain.js
 var init_langchain = __esm({
   "src/tools/langchain.js"() {
@@ -9279,8 +9759,10 @@ var init_tools = __esm({
     "use strict";
     init_vercel();
     init_bash();
+    init_edit();
     init_langchain();
     init_common();
+    init_edit();
     init_system_message();
     init_vercel();
     init_bash();
@@ -9297,7 +9779,7 @@ var init_tools = __esm({
 });
 
 // src/utils/file-lister.js
-import fs4 from "fs";
+import fs5 from "fs";
 import path4 from "path";
 import { promisify as promisify6 } from "util";
 import { exec as exec4 } from "child_process";
@@ -9307,10 +9789,10 @@ async function listFilesByLevel(options) {
     maxFiles = 100,
     respectGitignore = true
   } = options;
-  if (!fs4.existsSync(directory)) {
+  if (!fs5.existsSync(directory)) {
     throw new Error(`Directory does not exist: ${directory}`);
   }
-  const gitDirExists = fs4.existsSync(path4.join(directory, ".git"));
+  const gitDirExists = fs5.existsSync(path4.join(directory, ".git"));
   if (gitDirExists && respectGitignore) {
     try {
       return await listFilesUsingGit(directory, maxFiles);
@@ -9341,7 +9823,7 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   while (queue.length > 0 && result.length < maxFiles) {
     const { dir, level } = queue.shift();
     try {
-      const entries = fs4.readdirSync(dir, { withFileTypes: true });
+      const entries = fs5.readdirSync(dir, { withFileTypes: true });
       const files = entries.filter((entry) => entry.isFile());
       for (const file of files) {
         if (result.length >= maxFiles) break;
@@ -9366,11 +9848,11 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
 }
 function loadGitignorePatterns(directory) {
   const gitignorePath = path4.join(directory, ".gitignore");
-  if (!fs4.existsSync(gitignorePath)) {
+  if (!fs5.existsSync(gitignorePath)) {
     return [];
   }
   try {
-    const content = fs4.readFileSync(gitignorePath, "utf8");
+    const content = fs5.readFileSync(gitignorePath, "utf8");
     return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   } catch (error) {
     console.error(`Warning: Could not read .gitignore: ${error.message}`);
@@ -9397,8 +9879,8 @@ var init_file_lister = __esm({
 });
 
 // src/agent/simpleTelemetry.js
-import { existsSync as existsSync2, mkdirSync, createWriteStream } from "fs";
-import { dirname } from "path";
+import { existsSync as existsSync3, mkdirSync, createWriteStream } from "fs";
+import { dirname as dirname2 } from "path";
 function initializeSimpleTelemetryFromOptions(options) {
   const telemetry = new SimpleTelemetry({
     serviceName: "probe-agent",
@@ -9425,8 +9907,8 @@ var init_simpleTelemetry = __esm({
       }
       initializeFileExporter() {
         try {
-          const dir = dirname(this.filePath);
-          if (!existsSync2(dir)) {
+          const dir = dirname2(this.filePath);
+          if (!existsSync3(dir)) {
             mkdirSync(dir, { recursive: true });
           }
           this.stream = createWriteStream(this.filePath, { flags: "a" });
@@ -9490,20 +9972,20 @@ var init_simpleTelemetry = __esm({
       }
       async flush() {
         if (this.stream) {
-          return new Promise((resolve5) => {
-            this.stream.once("drain", resolve5);
+          return new Promise((resolve6) => {
+            this.stream.once("drain", resolve6);
             if (!this.stream.writableNeedDrain) {
-              resolve5();
+              resolve6();
             }
           });
         }
       }
       async shutdown() {
         if (this.stream) {
-          return new Promise((resolve5) => {
+          return new Promise((resolve6) => {
             this.stream.end(() => {
               console.log(`[SimpleTelemetry] File stream closed: ${this.filePath}`);
-              resolve5();
+              resolve6();
             });
           });
         }
@@ -10466,7 +10948,7 @@ var init_escape = __esm({
 });
 
 // node_modules/minimatch/dist/esm/index.js
-var import_brace_expansion, minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path5, sep, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
+var import_brace_expansion, minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path5, sep2, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
 var init_esm = __esm({
   "node_modules/minimatch/dist/esm/index.js"() {
     import_brace_expansion = __toESM(require_brace_expansion(), 1);
@@ -10539,8 +11021,8 @@ var init_esm = __esm({
       win32: { sep: "\\" },
       posix: { sep: "/" }
     };
-    sep = defaultPlatform === "win32" ? path5.win32.sep : path5.posix.sep;
-    minimatch.sep = sep;
+    sep2 = defaultPlatform === "win32" ? path5.win32.sep : path5.posix.sep;
+    minimatch.sep = sep2;
     GLOBSTAR = Symbol("globstar **");
     minimatch.GLOBSTAR = GLOBSTAR;
     qmark2 = "[^/]";
@@ -13302,10 +13784,10 @@ var init_esm3 = __esm({
        * Return a void Promise that resolves once the stream ends.
        */
       async promise() {
-        return new Promise((resolve5, reject2) => {
+        return new Promise((resolve6, reject2) => {
           this.on(DESTROYED, () => reject2(new Error("stream destroyed")));
           this.on("error", (er) => reject2(er));
-          this.on("end", () => resolve5());
+          this.on("end", () => resolve6());
         });
       }
       /**
@@ -13329,7 +13811,7 @@ var init_esm3 = __esm({
             return Promise.resolve({ done: false, value: res });
           if (this[EOF])
             return stop();
-          let resolve5;
+          let resolve6;
           let reject2;
           const onerr = (er) => {
             this.off("data", ondata);
@@ -13343,19 +13825,19 @@ var init_esm3 = __esm({
             this.off("end", onend);
             this.off(DESTROYED, ondestroy);
             this.pause();
-            resolve5({ value, done: !!this[EOF] });
+            resolve6({ value, done: !!this[EOF] });
           };
           const onend = () => {
             this.off("error", onerr);
             this.off("data", ondata);
             this.off(DESTROYED, ondestroy);
             stop();
-            resolve5({ done: true, value: void 0 });
+            resolve6({ done: true, value: void 0 });
           };
           const ondestroy = () => onerr(new Error("stream destroyed"));
           return new Promise((res2, rej) => {
             reject2 = rej;
-            resolve5 = res2;
+            resolve6 = res2;
             this.once(DESTROYED, ondestroy);
             this.once("error", onerr);
             this.once("end", onend);
@@ -14335,9 +14817,9 @@ var init_esm4 = __esm({
         if (this.#asyncReaddirInFlight) {
           await this.#asyncReaddirInFlight;
         } else {
-          let resolve5 = () => {
+          let resolve6 = () => {
           };
-          this.#asyncReaddirInFlight = new Promise((res) => resolve5 = res);
+          this.#asyncReaddirInFlight = new Promise((res) => resolve6 = res);
           try {
             for (const e of await this.#fs.promises.readdir(fullpath, {
               withFileTypes: true
@@ -14350,7 +14832,7 @@ var init_esm4 = __esm({
             children.provisional = 0;
           }
           this.#asyncReaddirInFlight = void 0;
-          resolve5();
+          resolve6();
         }
         return children.slice(0, children.provisional);
       }
@@ -14580,8 +15062,8 @@ var init_esm4 = __esm({
        *
        * @internal
        */
-      constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs6 = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs6);
+      constructor(cwd = process.cwd(), pathImpl, sep3, { nocase, childrenCacheSize = 16 * 1024, fs: fs7 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs7);
         if (cwd instanceof URL || cwd.startsWith("file://")) {
           cwd = fileURLToPath4(cwd);
         }
@@ -14591,7 +15073,7 @@ var init_esm4 = __esm({
         this.#resolveCache = new ResolveCache();
         this.#resolvePosixCache = new ResolveCache();
         this.#children = new ChildrenCache(childrenCacheSize);
-        const split = cwdPath.substring(this.rootPath.length).split(sep2);
+        const split = cwdPath.substring(this.rootPath.length).split(sep3);
         if (split.length === 1 && !split[0]) {
           split.pop();
         }
@@ -15139,8 +15621,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs6) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+      newRoot(fs7) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -15168,8 +15650,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs6) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+      newRoot(fs7) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -16309,7 +16791,7 @@ import { exec as exec5 } from "child_process";
 import { promisify as promisify7 } from "util";
 import { randomUUID as randomUUID2 } from "crypto";
 import { EventEmitter as EventEmitter2 } from "events";
-import fs5 from "fs";
+import fs6 from "fs";
 import { promises as fsPromises } from "fs";
 import path6 from "path";
 function isSessionCancelled(sessionId) {
@@ -16369,6 +16851,20 @@ function createWrappedTools(baseTools) {
       baseTools.bashTool.execute
     );
   }
+  if (baseTools.editTool) {
+    wrappedTools.editToolInstance = wrapToolWithEmitter(
+      baseTools.editTool,
+      "edit",
+      baseTools.editTool.execute
+    );
+  }
+  if (baseTools.createTool) {
+    wrappedTools.createToolInstance = wrapToolWithEmitter(
+      baseTools.createTool,
+      "create",
+      baseTools.createTool.execute
+    );
+  }
   return wrappedTools;
 }
 var toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
@@ -16379,9 +16875,9 @@ var init_probeTool = __esm({
     init_esm5();
     toolCallEmitter = new EventEmitter2();
     activeToolExecutions = /* @__PURE__ */ new Map();
-    wrapToolWithEmitter = (tool3, toolName, baseExecute) => {
+    wrapToolWithEmitter = (tool4, toolName, baseExecute) => {
       return {
-        ...tool3,
+        ...tool4,
         // Spread schema, description etc.
         execute: async (params) => {
           const debug = process.env.DEBUG === "1";
@@ -16616,8 +17112,10 @@ var init_index = __esm({
     init_file_lister();
     init_system_message();
     init_common();
+    init_edit();
     init_vercel();
     init_bash();
+    init_edit();
     init_ProbeAgent();
     init_simpleTelemetry();
     init_probeTool();
@@ -16699,8 +17197,8 @@ function checkAttemptCompleteRecovery(cleanedXmlString, validTools = []) {
 function hasOtherToolTags(xmlString, validTools = []) {
   const defaultTools = ["search", "query", "extract", "listFiles", "searchFiles", "implement", "attempt_completion"];
   const toolsToCheck = validTools.length > 0 ? validTools : defaultTools;
-  for (const tool3 of toolsToCheck) {
-    if (tool3 !== "attempt_completion" && xmlString.includes(`<${tool3}`)) {
+  for (const tool4 of toolsToCheck) {
+    if (tool4 !== "attempt_completion" && xmlString.includes(`<${tool4}`)) {
       return true;
     }
   }
@@ -16738,6 +17236,10 @@ function createTools(configOptions) {
   if (configOptions.enableBash) {
     tools2.bashTool = bashTool(configOptions);
   }
+  if (configOptions.allowEdit) {
+    tools2.editTool = editTool(configOptions);
+    tools2.createTool = createTool(configOptions);
+  }
   return tools2;
 }
 function parseXmlToolCallWithThinking(xmlString, validTools) {
@@ -16838,7 +17340,7 @@ function createMockProvider() {
       provider: "mock",
       // Mock the doGenerate method used by Vercel AI SDK
       doGenerate: async ({ messages, tools: tools2 }) => {
-        await new Promise((resolve5) => setTimeout(resolve5, 10));
+        await new Promise((resolve6) => setTimeout(resolve6, 10));
         return {
           text: "This is a mock response for testing",
           toolCalls: [],
@@ -28825,16 +29327,6 @@ var init_parser2 = __esm({
         this.subgraph = this.RULE("subgraph", () => {
           this.CONSUME(SubgraphKeyword);
           this.OR([
-            {
-              ALT: () => {
-                this.CONSUME(Identifier, { LABEL: "subgraphId" });
-                this.OPTION(() => {
-                  this.CONSUME1(SquareOpen);
-                  this.SUBRULE(this.nodeContent);
-                  this.CONSUME1(SquareClose);
-                });
-              }
-            },
             {
               ALT: () => {
                 this.CONSUME(QuotedString, { LABEL: "subgraphTitleQ" });
@@ -28846,6 +29338,33 @@ var init_parser2 = __esm({
                 this.SUBRULE2(this.nodeContent);
                 this.CONSUME2(SquareClose);
               }
+            },
+            {
+              ALT: () => {
+                this.CONSUME1(Identifier, { LABEL: "subgraphIdOrFirstWord" });
+                this.OPTION(() => {
+                  this.OR1([
+                    {
+                      ALT: () => {
+                        this.CONSUME1(SquareOpen);
+                        this.SUBRULE(this.nodeContent);
+                        this.CONSUME1(SquareClose);
+                      }
+                    },
+                    {
+                      ALT: () => {
+                        this.AT_LEAST_ONE(() => {
+                          this.OR2([
+                            { ALT: () => this.CONSUME2(Identifier) },
+                            { ALT: () => this.CONSUME(Text) },
+                            { ALT: () => this.CONSUME(NumberLiteral) }
+                          ]);
+                        });
+                      }
+                    }
+                  ]);
+                });
+              }
             }
           ]);
           this.CONSUME(Newline);
@@ -29449,7 +29968,6 @@ var init_semantics = __esm({
             const last2 = allChildren[allChildren.length - 1];
             const isSlash = (t) => t.image === "/" || t.image === "\\";
             if (isSlash(first2) && isSlash(last2)) {
-              continue;
             }
           }
           const opens = ch.RoundOpen || [];
@@ -29929,13 +30447,24 @@ function mapFlowchartParserError(err, text) {
       length: len
     };
   }
-  if (tokType === "QuotedString") {
+  if (tokType === "QuotedString" || tokType === "SquareOpen" || tokType === "SquareClose") {
     const context = err?.context;
     const inLinkRule = context?.ruleStack?.includes("linkTextInline") || context?.ruleStack?.includes("link") || false;
     const lineContent = allLines[Math.max(0, line - 1)] || "";
     const beforeQuote = lineContent.slice(0, Math.max(0, column - 1));
     const hasLinkBefore = beforeQuote.match(/--\s*$|==\s*$|-\.\s*$|-\.-\s*$|\[\s*$/);
     if (inLinkRule || hasLinkBefore) {
+      if (tokType === "SquareOpen" || tokType === "SquareClose") {
+        return {
+          line,
+          column,
+          severity: "error",
+          code: "FL-EDGE-LABEL-BRACKET",
+          message: "Square brackets [ ] are not supported inside inline edge labels.",
+          hint: "Use HTML entities &#91; and &#93; inside |...|, e.g., --|run: &#91;aggregate&#93;|-->",
+          length: len
+        };
+      }
       const quotedText = found.startsWith('"') ? found.slice(1, -1) : found;
       return {
         line,
@@ -30029,7 +30558,7 @@ function mapFlowchartParserError(err, text) {
           }
         }
       }
-      if (tokType === "QuotedString") {
+      if (tokType === "QuotedString" || tokType === "SquareOpen" || tokType === "SquareClose") {
         return {
           line,
           column,
@@ -30050,7 +30579,7 @@ function mapFlowchartParserError(err, text) {
       return { line, column, severity: "error", code: "FL-NODE-UNCLOSED-BRACKET", message: "Unclosed '['. Add a matching ']' before the arrow or newline.", hint: "Example: A[Label] --> B", length: 1 };
     }
     if (expecting(err, "RoundClose")) {
-      if (tokType === "QuotedString") {
+      if (tokType === "QuotedString" || tokType === "SquareOpen" || tokType === "SquareClose") {
         return {
           line,
           column,
@@ -30089,7 +30618,7 @@ function mapFlowchartParserError(err, text) {
       return { line, column, severity: "error", code: "FL-NODE-UNCLOSED-BRACKET", message: "Unclosed '('. Add a matching ')'.", hint: "Example: B(Label)", length: 1 };
     }
     if (expecting(err, "DiamondClose")) {
-      if (tokType === "QuotedString") {
+      if (tokType === "QuotedString" || tokType === "SquareOpen" || tokType === "SquareClose") {
         return {
           line,
           column,
@@ -30232,16 +30761,19 @@ function mapFlowchartParserError(err, text) {
     const subgraphIdx = lineStr.indexOf("subgraph");
     if (subgraphIdx !== -1) {
       const afterSubgraph = lineStr.slice(subgraphIdx + 8).trim();
-      if (afterSubgraph && !afterSubgraph.startsWith('"') && !afterSubgraph.startsWith("'") && afterSubgraph.includes(" ")) {
-        return {
-          line,
-          column,
-          severity: "error",
-          code: "FL-SUBGRAPH-UNQUOTED-TITLE",
-          message: "Subgraph titles with spaces must be quoted.",
-          hint: 'Example: subgraph "Existing Logic Path" or use underscores: subgraph Existing_Logic_Path',
-          length: afterSubgraph.length
-        };
+      if (afterSubgraph && !afterSubgraph.startsWith('"') && !afterSubgraph.startsWith("'")) {
+        const hasHazard = /[\[\](){}/:|"'\\]/.test(afterSubgraph);
+        if (hasHazard) {
+          return {
+            line,
+            column,
+            severity: "error",
+            code: "FL-SUBGRAPH-UNQUOTED-TITLE",
+            message: "Subgraph title contains special characters; wrap it in quotes.",
+            hint: 'Example: subgraph "Streams (inside Gateway)"',
+            length: afterSubgraph.length
+          };
+        }
       }
     }
   }
@@ -30935,6 +31467,111 @@ function validateFlowchart(text, options = {}) {
           }
         }
       }
+      {
+        const byLine = /* @__PURE__ */ new Map();
+        const collect = (arr) => {
+          for (const e of arr || []) {
+            if (e && (e.code === "FL-LABEL-PARENS-UNQUOTED" || e.code === "FL-LABEL-AT-IN-UNQUOTED")) {
+              const ln = e.line ?? 0;
+              const col = e.column ?? 1;
+              const list = byLine.get(ln) || [];
+              list.push({ start: col, end: col });
+              byLine.set(ln, list);
+            }
+          }
+        };
+        collect(prevErrors);
+        collect(errs);
+        const lines2 = text2.split(/\r?\n/);
+        for (let ii = 0; ii < lines2.length; ii++) {
+          const raw = lines2[ii] || "";
+          if (!raw.includes("[") || !raw.includes("]"))
+            continue;
+          let i = 0;
+          const n = raw.length;
+          let inQuote = false;
+          let esc = false;
+          while (i < n) {
+            const ch = raw[i];
+            if (inQuote) {
+              if (esc) {
+                esc = false;
+              } else if (ch === "\\") {
+                esc = true;
+              } else if (ch === '"') {
+                inQuote = false;
+              }
+              i++;
+              continue;
+            }
+            if (ch === '"') {
+              inQuote = true;
+              i++;
+              continue;
+            }
+            if (ch === "[") {
+              let j = i + 1;
+              let inQ = false;
+              let esc2 = false;
+              let depth = 1;
+              while (j < n && depth > 0) {
+                const cj = raw[j];
+                if (inQ) {
+                  if (esc2) {
+                    esc2 = false;
+                  } else if (cj === "\\") {
+                    esc2 = true;
+                  } else if (cj === '"') {
+                    inQ = false;
+                  }
+                  j++;
+                  continue;
+                }
+                if (cj === '"') {
+                  inQ = true;
+                  j++;
+                  continue;
+                }
+                if (cj === "[")
+                  depth++;
+                else if (cj === "]")
+                  depth--;
+                j++;
+              }
+              if (depth === 0) {
+                const startCol = i + 2;
+                const endCol = j;
+                const seg = raw.slice(i + 1, j - 1);
+                const trimmed = seg.trim();
+                const ln = ii + 1;
+                const lsp = trimmed.slice(0, 1), rsp = trimmed.slice(-1);
+                const isSlashPair = (lsp === "/" || lsp === "\\") && (rsp === "/" || rsp === "\\");
+                const isParenWrapped = lsp === "(" && rsp === ")";
+                const isQuoted = /^"[\s\S]*"$/.test(trimmed);
+                const existing = byLine.get(ln) || [];
+                const covered = existing.some((r) => !(endCol < r.start || startCol > r.end));
+                const hasParens = seg.includes("(") || seg.includes(")");
+                const hasAt = seg.includes("@");
+                if (!covered && !isQuoted && !isParenWrapped && hasParens) {
+                  errs.push({ line: ln, column: startCol, severity: "error", code: "FL-LABEL-PARENS-UNQUOTED", message: "Parentheses inside an unquoted label are not supported by Mermaid.", hint: 'Wrap the label in quotes, e.g., A["Mark (X)"] \u2014 or replace ( and ) with HTML entities: &#40; and &#41;.' });
+                  existing.push({ start: startCol, end: endCol });
+                  byLine.set(ln, existing);
+                }
+                if (!covered && !isQuoted && !isSlashPair && hasAt) {
+                  errs.push({ line: ln, column: startCol, severity: "error", code: "FL-LABEL-AT-IN-UNQUOTED", message: "'@' inside an unquoted label can be misparsed by Mermaid.", hint: 'Wrap the label in quotes, e.g., B["@probelabs/probe v0.6.0-rc149"]' });
+                  existing.push({ start: startCol, end: endCol });
+                  byLine.set(ln, existing);
+                }
+                i = j;
+                continue;
+              } else {
+                break;
+              }
+            }
+            i++;
+          }
+        }
+      }
       const dblEsc = (text2.match(/\\\"/g) || []).length;
       const dq = (text2.match(/\"/g) || []).length - dblEsc;
       const sq = (text2.match(/'/g) || []).length;
@@ -33279,6 +33916,21 @@ function computeFixes(text, errors, level = "safe") {
       }
       continue;
     }
+    if (is("FL-EDGE-LABEL-BRACKET", e)) {
+      const lineText = lineTextAt(text, e.line);
+      const firstBar = lineText.indexOf("|");
+      const secondBar = firstBar >= 0 ? lineText.indexOf("|", firstBar + 1) : -1;
+      if (firstBar >= 0 && secondBar > firstBar) {
+        const before = lineText.slice(0, firstBar + 1);
+        const label = lineText.slice(firstBar + 1, secondBar);
+        const after = lineText.slice(secondBar);
+        const fixedLabel = label.replace(/\[/g, "&#91;").replace(/\]/g, "&#93;");
+        const fixedLine = before + fixedLabel + after;
+        const finalLine = fixedLine.replace(/\[([^\]]*)\]/g, (m, seg) => "[" + String(seg).replace(/`/g, "") + "]");
+        edits.push({ start: { line: e.line, column: 1 }, end: { line: e.line, column: lineText.length + 1 }, newText: finalLine });
+      }
+      continue;
+    }
     if (is("FL-EDGE-LABEL-BACKTICK", e)) {
       const lineText = lineTextAt(text, e.line);
       const re = /^(.*?--)\s*([^|>]+?)\s*(-->|==>|\.->|->)(.*)$/;
@@ -42402,7 +43054,7 @@ var require_bk = __commonJS({
       return xs;
     }
     function buildBlockGraph(g, layering, root2, reverseSep) {
-      var blockGraph = new Graph(), graphLabel = g.graph(), sepFn = sep2(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
+      var blockGraph = new Graph(), graphLabel = g.graph(), sepFn = sep3(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
       _.forEach(layering, function(layer) {
         var u;
         _.forEach(layer, function(v) {
@@ -42492,7 +43144,7 @@ var require_bk = __commonJS({
       alignCoordinates(xss, smallestWidth);
       return balance(xss, g.graph().align);
     }
-    function sep2(nodeSep, edgeSep, reverseSep) {
+    function sep3(nodeSep, edgeSep, reverseSep) {
       return function(g, v, w) {
         var vLabel = g.node(v);
         var wLabel = g.node(w);
@@ -49786,7 +50438,7 @@ var require_compile = __commonJS({
       const schOrFunc = root2.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve5.call(this, root2, ref);
+      let _sch = resolve6.call(this, root2, ref);
       if (_sch === void 0) {
         const schema = (_a = root2.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -49813,7 +50465,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve5(root2, ref) {
+    function resolve6(root2, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -50388,7 +51040,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve5(baseURI, relativeURI, options) {
+    function resolve6(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse6(baseURI, schemelessOptions), parse6(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -50615,7 +51267,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize: normalize2,
-      resolve: resolve5,
+      resolve: resolve6,
       resolveComponent,
       equal,
       serialize,
@@ -54633,15 +55285,15 @@ Provide only the corrected Mermaid diagram within a mermaid code block. Do not a
 });
 
 // src/agent/mcp/config.js
-import { readFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync } from "fs";
-import { join as join2, dirname as dirname2 } from "path";
+import { readFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { join as join2, dirname as dirname3 } from "path";
 import { homedir } from "os";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function loadMCPConfigurationFromPath(configPath) {
   if (!configPath) {
     throw new Error("Config path is required");
   }
-  if (!existsSync3(configPath)) {
+  if (!existsSync4(configPath)) {
     throw new Error(`MCP configuration file not found: ${configPath}`);
   }
   try {
@@ -54670,7 +55322,7 @@ function loadMCPConfiguration() {
   ].filter(Boolean);
   let config = null;
   for (const configPath of configPaths) {
-    if (existsSync3(configPath)) {
+    if (existsSync4(configPath)) {
       try {
         const content = readFileSync(configPath, "utf8");
         config = JSON.parse(content);
@@ -54773,7 +55425,7 @@ var init_config = __esm({
   "src/agent/mcp/config.js"() {
     "use strict";
     __filename4 = fileURLToPath6(import.meta.url);
-    __dirname4 = dirname2(__filename4);
+    __dirname4 = dirname3(__filename4);
     DEFAULT_CONFIG = {
       mcpServers: {
         // Example probe server configuration
@@ -54962,12 +55614,12 @@ var init_client = __esm({
           const toolsResponse = await client.listTools();
           const toolCount = toolsResponse?.tools?.length || 0;
           if (toolsResponse && toolsResponse.tools) {
-            for (const tool3 of toolsResponse.tools) {
-              const qualifiedName = `${name}_${tool3.name}`;
+            for (const tool4 of toolsResponse.tools) {
+              const qualifiedName = `${name}_${tool4.name}`;
               this.tools.set(qualifiedName, {
-                ...tool3,
+                ...tool4,
                 serverName: name,
-                originalName: tool3.name
+                originalName: tool4.name
               });
               if (this.debug) {
                 console.error(`[MCP DEBUG]     Registered tool: ${qualifiedName}`);
@@ -54990,13 +55642,13 @@ var init_client = __esm({
        * @param {Object} args - Tool arguments
        */
       async callTool(toolName, args) {
-        const tool3 = this.tools.get(toolName);
-        if (!tool3) {
+        const tool4 = this.tools.get(toolName);
+        if (!tool4) {
           throw new Error(`Unknown tool: ${toolName}`);
         }
-        const clientInfo = this.clients.get(tool3.serverName);
+        const clientInfo = this.clients.get(tool4.serverName);
         if (!clientInfo) {
-          throw new Error(`Server ${tool3.serverName} not connected`);
+          throw new Error(`Server ${tool4.serverName} not connected`);
         }
         try {
           if (this.debug) {
@@ -55010,7 +55662,7 @@ var init_client = __esm({
           });
           const result = await Promise.race([
             clientInfo.client.callTool({
-              name: tool3.originalName,
+              name: tool4.originalName,
               arguments: args
             }),
             timeoutPromise
@@ -55033,11 +55685,11 @@ var init_client = __esm({
        */
       getTools() {
         const tools2 = {};
-        for (const [name, tool3] of this.tools.entries()) {
+        for (const [name, tool4] of this.tools.entries()) {
           tools2[name] = {
-            description: tool3.description,
-            inputSchema: tool3.inputSchema,
-            serverName: tool3.serverName
+            description: tool4.description,
+            inputSchema: tool4.inputSchema,
+            serverName: tool4.serverName
           };
         }
         return tools2;
@@ -55048,10 +55700,10 @@ var init_client = __esm({
        */
       getVercelTools() {
         const tools2 = {};
-        for (const [name, tool3] of this.tools.entries()) {
+        for (const [name, tool4] of this.tools.entries()) {
           tools2[name] = {
-            description: tool3.description,
-            inputSchema: tool3.inputSchema,
+            description: tool4.description,
+            inputSchema: tool4.inputSchema,
             execute: async (args) => {
               const result = await this.callTool(name, args);
               if (result.content && result.content[0]) {
@@ -55100,9 +55752,9 @@ var init_client = __esm({
 });
 
 // src/agent/mcp/xmlBridge.js
-function mcpToolToXmlDefinition(name, tool3) {
-  const description = tool3.description || "MCP tool";
-  const inputSchema = tool3.inputSchema || tool3.parameters || {};
+function mcpToolToXmlDefinition(name, tool4) {
+  const description = tool4.description || "MCP tool";
+  const inputSchema = tool4.inputSchema || tool4.parameters || {};
   let paramDocs = "";
   if (inputSchema.properties) {
     paramDocs = "\n\nParameters (provide as JSON object):";
@@ -55281,8 +55933,8 @@ var init_xmlBridge = __esm({
           const vercelTools = this.mcpManager.getVercelTools();
           this.mcpTools = vercelTools;
           const toolCount = Object.keys(vercelTools).length;
-          for (const [name, tool3] of Object.entries(vercelTools)) {
-            this.xmlDefinitions[name] = mcpToolToXmlDefinition(name, tool3);
+          for (const [name, tool4] of Object.entries(vercelTools)) {
+            this.xmlDefinitions[name] = mcpToolToXmlDefinition(name, tool4);
           }
           if (toolCount === 0) {
             console.error("[MCP INFO] MCP initialization complete: 0 tools loaded");
@@ -55329,14 +55981,14 @@ var init_xmlBridge = __esm({
           console.error(`[MCP DEBUG] Executing MCP tool: ${toolName}`);
           console.error(`[MCP DEBUG] Parameters:`, JSON.stringify(params, null, 2));
         }
-        const tool3 = this.mcpTools[toolName];
-        if (!tool3) {
+        const tool4 = this.mcpTools[toolName];
+        if (!tool4) {
           console.error(`[MCP ERROR] Unknown MCP tool: ${toolName}`);
           console.error(`[MCP ERROR] Available tools: ${this.getToolNames().join(", ")}`);
           throw new Error(`Unknown MCP tool: ${toolName}`);
         }
         try {
-          const result = await tool3.execute(params);
+          const result = await tool4.execute(params);
           if (this.debug) {
             console.error(`[MCP DEBUG] Tool ${toolName} executed successfully`);
           }
@@ -55390,22 +56042,636 @@ var init_mcp = __esm({
   }
 });
 
+// src/agent/RetryManager.js
+function isRetryableError(error, retryableErrors = DEFAULT_RETRYABLE_ERRORS) {
+  if (!error) return false;
+  const errorString = error.toString().toLowerCase();
+  const errorMessage = (error.message || "").toLowerCase();
+  const errorCode = (error.code || "").toLowerCase();
+  const errorType = (error.type || "").toLowerCase();
+  const statusCode = error.statusCode || error.status;
+  for (const pattern of retryableErrors) {
+    const lowerPattern = pattern.toLowerCase();
+    if (errorString.includes(lowerPattern) || errorMessage.includes(lowerPattern) || errorCode.includes(lowerPattern) || errorType.includes(lowerPattern) || statusCode?.toString() === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractErrorInfo(error) {
+  return {
+    message: error.message || error.toString(),
+    type: error.type || error.constructor.name,
+    code: error.code,
+    statusCode: error.statusCode || error.status,
+    provider: error.provider,
+    isRetryable: isRetryableError(error)
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
+}
+var DEFAULT_RETRYABLE_ERRORS, RetryManager;
+var init_RetryManager = __esm({
+  "src/agent/RetryManager.js"() {
+    "use strict";
+    DEFAULT_RETRYABLE_ERRORS = [
+      "Overloaded",
+      "overloaded",
+      "rate_limit",
+      "rate limit",
+      "429",
+      "500",
+      "502",
+      "503",
+      "504",
+      "timeout",
+      "ECONNRESET",
+      "ETIMEDOUT",
+      "ENOTFOUND",
+      "api_error"
+    ];
+    RetryManager = class {
+      /**
+       * Create a new RetryManager
+       * @param {Object} options - Configuration options
+       * @param {number} [options.maxRetries=3] - Maximum retry attempts
+       * @param {number} [options.initialDelay=1000] - Initial delay in ms (1 second)
+       * @param {number} [options.maxDelay=30000] - Maximum delay in ms (30 seconds)
+       * @param {number} [options.backoffFactor=2] - Exponential backoff multiplier
+       * @param {Array<string>} [options.retryableErrors] - List of retryable error patterns
+       * @param {boolean} [options.debug=false] - Enable debug logging
+       */
+      constructor(options = {}) {
+        this.maxRetries = this._validateNumber(options.maxRetries, 3, "maxRetries", 0, 100);
+        this.initialDelay = this._validateNumber(options.initialDelay, 1e3, "initialDelay", 0, 6e4);
+        this.maxDelay = this._validateNumber(options.maxDelay, 3e4, "maxDelay", 0, 3e5);
+        this.backoffFactor = this._validateNumber(options.backoffFactor, 2, "backoffFactor", 1, 10);
+        this.retryableErrors = options.retryableErrors || DEFAULT_RETRYABLE_ERRORS;
+        this.debug = options.debug ?? false;
+        this.jitter = options.jitter ?? true;
+        if (this.maxDelay < this.initialDelay) {
+          throw new Error("maxDelay must be greater than or equal to initialDelay");
+        }
+        this.stats = {
+          totalAttempts: 0,
+          totalRetries: 0,
+          successfulRetries: 0,
+          failedRetries: 0
+        };
+      }
+      /**
+       * Validate a numeric parameter
+       * @param {*} value - Value to validate
+       * @param {number} defaultValue - Default if undefined
+       * @param {string} name - Parameter name for error messages
+       * @param {number} min - Minimum allowed value
+       * @param {number} max - Maximum allowed value
+       * @returns {number} - Validated number
+       * @private
+       */
+      _validateNumber(value, defaultValue, name, min, max) {
+        if (value === void 0 || value === null) {
+          return defaultValue;
+        }
+        const num = Number(value);
+        if (isNaN(num)) {
+          throw new Error(`${name} must be a number, got: ${value}`);
+        }
+        if (num < min || num > max) {
+          throw new Error(`${name} must be between ${min} and ${max}, got: ${num}`);
+        }
+        return num;
+      }
+      /**
+       * Execute a function with retry logic
+       * @param {Function} fn - Async function to execute
+       * @param {Object} [context={}] - Context information for logging
+       * @param {AbortSignal} [context.signal] - Optional abort signal for cancellation
+       * @returns {Promise<*>} - Result from the function
+       * @throws {Error} - If all retries are exhausted or operation is aborted
+       */
+      async executeWithRetry(fn, context = {}) {
+        let lastError = null;
+        let currentDelay = this.initialDelay;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+          if (context.signal?.aborted) {
+            const abortError = new Error("Operation aborted");
+            abortError.name = "AbortError";
+            throw abortError;
+          }
+          this.stats.totalAttempts++;
+          try {
+            if (this.debug && attempt > 0) {
+              console.log(`[RetryManager] Retry attempt ${attempt}/${this.maxRetries}`, context);
+            }
+            const result = await fn();
+            if (attempt > 0) {
+              this.stats.successfulRetries++;
+              if (this.debug) {
+                console.log(`[RetryManager] \u2705 Retry successful on attempt ${attempt + 1}`, context);
+              }
+            }
+            return result;
+          } catch (error) {
+            lastError = error;
+            const errorInfo = extractErrorInfo(error);
+            const shouldRetry = isRetryableError(error, this.retryableErrors);
+            const hasRetriesLeft = attempt < this.maxRetries;
+            if (this.debug) {
+              console.log(`[RetryManager] \u274C Attempt ${attempt + 1}/${this.maxRetries + 1} failed:`, {
+                ...context,
+                error: errorInfo,
+                shouldRetry,
+                hasRetriesLeft
+              });
+            }
+            if (!shouldRetry) {
+              if (this.debug) {
+                console.log(`[RetryManager] Error is not retryable, failing immediately`, errorInfo);
+              }
+              throw error;
+            }
+            if (!hasRetriesLeft) {
+              this.stats.failedRetries++;
+              if (this.debug) {
+                console.log(`[RetryManager] Max retries (${this.maxRetries}) exhausted`, context);
+              }
+              throw error;
+            }
+            this.stats.totalRetries++;
+            let delayWithJitter = currentDelay;
+            if (this.jitter) {
+              const jitterAmount = currentDelay * 0.25;
+              delayWithJitter = currentDelay + (Math.random() * jitterAmount * 2 - jitterAmount);
+            }
+            if (this.debug) {
+              console.log(`[RetryManager] Waiting ${Math.round(delayWithJitter)}ms before retry...`);
+            }
+            await sleep(delayWithJitter);
+            currentDelay = Math.min(currentDelay * this.backoffFactor, this.maxDelay);
+          }
+        }
+        throw lastError;
+      }
+      /**
+       * Check if an error is retryable
+       * @param {Error} error - The error to check
+       * @returns {boolean} - True if error should be retried
+       */
+      isRetryable(error) {
+        return isRetryableError(error, this.retryableErrors);
+      }
+      /**
+       * Get retry statistics
+       * @returns {Object} - Statistics object
+       */
+      getStats() {
+        return { ...this.stats };
+      }
+      /**
+       * Reset statistics
+       */
+      resetStats() {
+        this.stats = {
+          totalAttempts: 0,
+          totalRetries: 0,
+          successfulRetries: 0,
+          failedRetries: 0
+        };
+      }
+    };
+  }
+});
+
+// src/agent/FallbackManager.js
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
+function createFallbackManagerFromEnv(debug = false) {
+  const fallbackProvidersEnv = process.env.FALLBACK_PROVIDERS;
+  const fallbackModelsEnv = process.env.FALLBACK_MODELS;
+  if (!fallbackProvidersEnv && !fallbackModelsEnv) {
+    return null;
+  }
+  let providers = [];
+  let models = [];
+  let strategy = FALLBACK_STRATEGIES.ANY;
+  if (fallbackProvidersEnv) {
+    try {
+      if (typeof fallbackProvidersEnv !== "string" || fallbackProvidersEnv.length > 1e4) {
+        console.error("[FallbackManager] FALLBACK_PROVIDERS must be a valid JSON string under 10KB");
+        return null;
+      }
+      const parsed = JSON.parse(fallbackProvidersEnv);
+      if (!Array.isArray(parsed)) {
+        console.error("[FallbackManager] FALLBACK_PROVIDERS must be a JSON array");
+        return null;
+      }
+      providers = parsed;
+      strategy = FALLBACK_STRATEGIES.CUSTOM;
+    } catch (error) {
+      console.error("[FallbackManager] Failed to parse FALLBACK_PROVIDERS:", error.message);
+      return null;
+    }
+  }
+  if (fallbackModelsEnv) {
+    try {
+      if (typeof fallbackModelsEnv !== "string" || fallbackModelsEnv.length > 1e4) {
+        console.error("[FallbackManager] FALLBACK_MODELS must be a valid JSON string under 10KB");
+        return null;
+      }
+      const parsed = JSON.parse(fallbackModelsEnv);
+      if (!Array.isArray(parsed)) {
+        console.error("[FallbackManager] FALLBACK_MODELS must be a JSON array");
+        return null;
+      }
+      models = parsed;
+      strategy = FALLBACK_STRATEGIES.SAME_PROVIDER;
+    } catch (error) {
+      console.error("[FallbackManager] Failed to parse FALLBACK_MODELS:", error.message);
+      return null;
+    }
+  }
+  const maxTotalAttempts = process.env.FALLBACK_MAX_TOTAL_ATTEMPTS ? (() => {
+    const val = parseInt(process.env.FALLBACK_MAX_TOTAL_ATTEMPTS, 10);
+    if (isNaN(val) || val < 1 || val > 100) {
+      console.warn("[FallbackManager] FALLBACK_MAX_TOTAL_ATTEMPTS must be between 1 and 100, using default: 10");
+      return 10;
+    }
+    return val;
+  })() : 10;
+  return new FallbackManager({
+    strategy,
+    providers,
+    models,
+    maxTotalAttempts,
+    debug
+  });
+}
+function buildFallbackProvidersFromEnv(options = {}) {
+  const providers = [];
+  const anthropicApiKey = process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN;
+  const openaiApiKey = process.env.OPENAI_API_KEY;
+  const googleApiKey = process.env.GOOGLE_GENERATIVE_AI_API_KEY || process.env.GOOGLE_API_KEY;
+  const awsAccessKeyId = process.env.AWS_ACCESS_KEY_ID;
+  const awsSecretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
+  const awsRegion = process.env.AWS_REGION;
+  const awsApiKey = process.env.AWS_BEDROCK_API_KEY;
+  const llmBaseUrl = process.env.LLM_BASE_URL;
+  const anthropicApiUrl = process.env.ANTHROPIC_API_URL || process.env.ANTHROPIC_BASE_URL || llmBaseUrl;
+  const openaiApiUrl = process.env.OPENAI_API_URL || llmBaseUrl;
+  const googleApiUrl = process.env.GOOGLE_API_URL || llmBaseUrl;
+  const awsBedrockBaseUrl = process.env.AWS_BEDROCK_BASE_URL || llmBaseUrl;
+  const primaryProvider = options.primaryProvider?.toLowerCase();
+  const primaryModel = options.primaryModel;
+  if (primaryProvider === "anthropic" && anthropicApiKey) {
+    providers.push({
+      provider: "anthropic",
+      apiKey: anthropicApiKey,
+      ...anthropicApiUrl && { baseURL: anthropicApiUrl },
+      ...primaryModel && { model: primaryModel }
+    });
+  } else if (primaryProvider === "openai" && openaiApiKey) {
+    providers.push({
+      provider: "openai",
+      apiKey: openaiApiKey,
+      ...openaiApiUrl && { baseURL: openaiApiUrl },
+      ...primaryModel && { model: primaryModel }
+    });
+  } else if (primaryProvider === "google" && googleApiKey) {
+    providers.push({
+      provider: "google",
+      apiKey: googleApiKey,
+      ...googleApiUrl && { baseURL: googleApiUrl },
+      ...primaryModel && { model: primaryModel }
+    });
+  } else if (primaryProvider === "bedrock" && (awsAccessKeyId && awsSecretAccessKey && awsRegion || awsApiKey)) {
+    const config = { provider: "bedrock" };
+    if (awsApiKey) {
+      config.apiKey = awsApiKey;
+    } else {
+      config.accessKeyId = awsAccessKeyId;
+      config.secretAccessKey = awsSecretAccessKey;
+      config.region = awsRegion;
+      if (process.env.AWS_SESSION_TOKEN) {
+        config.sessionToken = process.env.AWS_SESSION_TOKEN;
+      }
+    }
+    if (awsBedrockBaseUrl) config.baseURL = awsBedrockBaseUrl;
+    if (primaryModel) config.model = primaryModel;
+    providers.push(config);
+  }
+  if (anthropicApiKey && primaryProvider !== "anthropic") {
+    providers.push({
+      provider: "anthropic",
+      apiKey: anthropicApiKey,
+      ...anthropicApiUrl && { baseURL: anthropicApiUrl }
+    });
+  }
+  if (openaiApiKey && primaryProvider !== "openai") {
+    providers.push({
+      provider: "openai",
+      apiKey: openaiApiKey,
+      ...openaiApiUrl && { baseURL: openaiApiUrl }
+    });
+  }
+  if (googleApiKey && primaryProvider !== "google") {
+    providers.push({
+      provider: "google",
+      apiKey: googleApiKey,
+      ...googleApiUrl && { baseURL: googleApiUrl }
+    });
+  }
+  if ((awsAccessKeyId && awsSecretAccessKey && awsRegion || awsApiKey) && primaryProvider !== "bedrock") {
+    const config = { provider: "bedrock" };
+    if (awsApiKey) {
+      config.apiKey = awsApiKey;
+    } else {
+      config.accessKeyId = awsAccessKeyId;
+      config.secretAccessKey = awsSecretAccessKey;
+      config.region = awsRegion;
+      if (process.env.AWS_SESSION_TOKEN) {
+        config.sessionToken = process.env.AWS_SESSION_TOKEN;
+      }
+    }
+    if (awsBedrockBaseUrl) config.baseURL = awsBedrockBaseUrl;
+    providers.push(config);
+  }
+  return providers;
+}
+var FALLBACK_STRATEGIES, DEFAULT_MODELS, FallbackManager;
+var init_FallbackManager = __esm({
+  "src/agent/FallbackManager.js"() {
+    "use strict";
+    FALLBACK_STRATEGIES = {
+      SAME_MODEL: "same-model",
+      // Try same model on different providers
+      SAME_PROVIDER: "same-provider",
+      // Try different models on same provider
+      ANY: "any",
+      // Try any available provider/model
+      CUSTOM: "custom"
+      // Use custom provider list
+    };
+    DEFAULT_MODELS = {
+      anthropic: "claude-sonnet-4-5-20250929",
+      openai: "gpt-4o",
+      google: "gemini-2.0-flash-exp",
+      bedrock: "anthropic.claude-sonnet-4-20250514-v1:0"
+    };
+    FallbackManager = class {
+      /**
+       * Create a new FallbackManager
+       * @param {Object} options - Configuration options
+       * @param {string} [options.strategy='any'] - Fallback strategy
+       * @param {Array<string>} [options.models] - List of models for same-provider fallback
+       * @param {Array<ProviderConfig>} [options.providers] - List of provider configurations
+       * @param {boolean} [options.stopOnSuccess=true] - Stop on first success
+       * @param {boolean} [options.continueOnNonRetryableError=false] - Continue to fallback on non-retryable errors
+       * @param {number} [options.maxTotalAttempts=10] - Maximum total attempts across all providers
+       * @param {boolean} [options.debug=false] - Enable debug logging
+       */
+      constructor(options = {}) {
+        this.strategy = options.strategy || FALLBACK_STRATEGIES.ANY;
+        this.models = Array.isArray(options.models) ? options.models : [];
+        this.providers = Array.isArray(options.providers) ? options.providers : [];
+        this.stopOnSuccess = options.stopOnSuccess ?? true;
+        this.continueOnNonRetryableError = options.continueOnNonRetryableError ?? false;
+        this.debug = options.debug ?? false;
+        const maxAttempts = options.maxTotalAttempts ?? 10;
+        if (typeof maxAttempts !== "number" || isNaN(maxAttempts) || maxAttempts < 1 || maxAttempts > 100) {
+          throw new Error(`FallbackManager: maxTotalAttempts must be a number between 1 and 100, got: ${maxAttempts}`);
+        }
+        this.maxTotalAttempts = maxAttempts;
+        this.stats = {
+          totalAttempts: 0,
+          providerAttempts: {},
+          successfulProvider: null,
+          failedProviders: []
+        };
+        this._validateConfiguration();
+      }
+      /**
+       * Validate the fallback configuration
+       * @private
+       */
+      _validateConfiguration() {
+        if (this.strategy === FALLBACK_STRATEGIES.SAME_PROVIDER && this.models.length === 0) {
+          throw new Error('FallbackManager: strategy "same-provider" requires models list');
+        }
+        if (this.strategy === FALLBACK_STRATEGIES.CUSTOM && this.providers.length === 0) {
+          throw new Error('FallbackManager: strategy "custom" requires providers list');
+        }
+        for (const config of this.providers) {
+          if (!config.provider) {
+            throw new Error('FallbackManager: Each provider config must have a "provider" field');
+          }
+          if (!["anthropic", "openai", "google", "bedrock"].includes(config.provider)) {
+            throw new Error(`FallbackManager: Invalid provider "${config.provider}". Must be: anthropic, openai, google, or bedrock`);
+          }
+          if (config.provider === "bedrock") {
+            const hasCredentials = config.accessKeyId && config.secretAccessKey && config.region;
+            const hasApiKey = config.apiKey;
+            if (!hasCredentials && !hasApiKey) {
+              throw new Error("FallbackManager: Bedrock provider requires either (accessKeyId, secretAccessKey, region) or apiKey");
+            }
+          } else {
+            if (!config.apiKey) {
+              throw new Error(`FallbackManager: Provider "${config.provider}" requires apiKey`);
+            }
+          }
+        }
+      }
+      /**
+       * Create a provider instance from configuration
+       * @param {ProviderConfig} config - Provider configuration
+       * @returns {Object} - Provider instance
+       * @throws {Error} - If provider creation fails
+       * @private
+       */
+      _createProviderInstance(config) {
+        try {
+          switch (config.provider) {
+            case "anthropic":
+              return createAnthropic({
+                apiKey: config.apiKey,
+                ...config.baseURL && { baseURL: config.baseURL }
+              });
+            case "openai":
+              return createOpenAI({
+                compatibility: "strict",
+                apiKey: config.apiKey,
+                ...config.baseURL && { baseURL: config.baseURL }
+              });
+            case "google":
+              return createGoogleGenerativeAI({
+                apiKey: config.apiKey,
+                ...config.baseURL && { baseURL: config.baseURL }
+              });
+            case "bedrock": {
+              const bedrockConfig = {};
+              if (config.apiKey) {
+                bedrockConfig.apiKey = config.apiKey;
+              } else if (config.accessKeyId && config.secretAccessKey) {
+                bedrockConfig.accessKeyId = config.accessKeyId;
+                bedrockConfig.secretAccessKey = config.secretAccessKey;
+                if (config.sessionToken) {
+                  bedrockConfig.sessionToken = config.sessionToken;
+                }
+              }
+              if (config.region) {
+                bedrockConfig.region = config.region;
+              }
+              if (config.baseURL) {
+                bedrockConfig.baseURL = config.baseURL;
+              }
+              return createAmazonBedrock(bedrockConfig);
+            }
+            default:
+              throw new Error(`FallbackManager: Unknown provider "${config.provider}"`);
+          }
+        } catch (error) {
+          const providerName = this._getProviderDisplayName(config);
+          throw new Error(`Failed to create provider instance for ${providerName}: ${error.message}`);
+        }
+      }
+      /**
+       * Get the model name for a provider configuration
+       * @param {ProviderConfig} config - Provider configuration
+       * @returns {string} - Model name
+       * @private
+       */
+      _getModelName(config) {
+        return config.model || DEFAULT_MODELS[config.provider];
+      }
+      /**
+       * Get provider display name for logging
+       * @param {ProviderConfig} config - Provider configuration
+       * @returns {string} - Display name
+       * @private
+       */
+      _getProviderDisplayName(config) {
+        const model = this._getModelName(config);
+        const provider = config.provider;
+        const url = config.baseURL ? ` (${config.baseURL})` : "";
+        return `${provider}/${model}${url}`;
+      }
+      /**
+       * Execute a function with fallback support
+       * @param {Function} fn - Function that takes (provider, model, config) and returns a Promise
+       * @returns {Promise<*>} - Result from the function
+       * @throws {Error} - If all fallbacks are exhausted
+       */
+      async executeWithFallback(fn) {
+        if (this.providers.length === 0) {
+          throw new Error("FallbackManager: No providers configured for fallback");
+        }
+        let lastError = null;
+        let totalAttempts = 0;
+        for (const config of this.providers) {
+          if (totalAttempts >= this.maxTotalAttempts) {
+            if (this.debug) {
+              console.log(`[FallbackManager] \u26A0\uFE0F  Max total attempts (${this.maxTotalAttempts}) reached`);
+            }
+            break;
+          }
+          totalAttempts++;
+          this.stats.totalAttempts++;
+          const providerName = this._getProviderDisplayName(config);
+          this.stats.providerAttempts[providerName] = (this.stats.providerAttempts[providerName] || 0) + 1;
+          try {
+            if (this.debug) {
+              console.log(`[FallbackManager] Attempting provider: ${providerName} (attempt ${totalAttempts}/${this.maxTotalAttempts})`);
+            }
+            const provider = this._createProviderInstance(config);
+            const model = this._getModelName(config);
+            const result = await fn(provider, model, config);
+            this.stats.successfulProvider = providerName;
+            if (this.debug) {
+              console.log(`[FallbackManager] \u2705 Success with provider: ${providerName}`);
+            }
+            return result;
+          } catch (error) {
+            lastError = error;
+            const errorInfo = {
+              message: error.message || error.toString(),
+              type: error.type || error.constructor.name,
+              statusCode: error.statusCode || error.status
+            };
+            this.stats.failedProviders.push({
+              provider: providerName,
+              error: errorInfo
+            });
+            if (this.debug) {
+              console.log(`[FallbackManager] \u274C Failed with provider: ${providerName}`, errorInfo);
+            }
+            if (!this.continueOnNonRetryableError && error.nonRetryable) {
+              if (this.debug) {
+                console.log(`[FallbackManager] Non-retryable error, stopping fallback chain`);
+              }
+              throw error;
+            }
+            if (this.debug) {
+              const remaining = this.providers.length - (this.providers.indexOf(config) + 1);
+              console.log(`[FallbackManager] Trying next provider (${remaining} remaining)...`);
+            }
+          }
+        }
+        if (this.debug) {
+          console.log(`[FallbackManager] \u274C All providers exhausted. Total attempts: ${totalAttempts}`);
+        }
+        const fallbackError = new Error(
+          `All provider fallbacks exhausted after ${totalAttempts} attempts. Last error: ${lastError?.message || "Unknown error"}`
+        );
+        fallbackError.cause = lastError;
+        fallbackError.stats = this.getStats();
+        fallbackError.allProvidersFailed = true;
+        throw fallbackError;
+      }
+      /**
+       * Get fallback statistics
+       * @returns {Object} - Statistics object
+       */
+      getStats() {
+        return {
+          ...this.stats,
+          providerAttempts: { ...this.stats.providerAttempts },
+          failedProviders: [...this.stats.failedProviders]
+        };
+      }
+      /**
+       * Reset statistics
+       */
+      resetStats() {
+        this.stats = {
+          totalAttempts: 0,
+          providerAttempts: {},
+          successfulProvider: null,
+          failedProviders: []
+        };
+      }
+    };
+  }
+});
+
 // src/agent/ProbeAgent.js
 var ProbeAgent_exports = {};
 __export(ProbeAgent_exports, {
   ProbeAgent: () => ProbeAgent
 });
 import dotenv2 from "dotenv";
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createOpenAI } from "@ai-sdk/openai";
-import { createGoogleGenerativeAI } from "@ai-sdk/google";
-import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
+import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
+import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI as createGoogleGenerativeAI2 } from "@ai-sdk/google";
+import { createAmazonBedrock as createAmazonBedrock2 } from "@ai-sdk/amazon-bedrock";
 import { streamText } from "ai";
 import { randomUUID as randomUUID4 } from "crypto";
 import { EventEmitter as EventEmitter3 } from "events";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { readFile, stat } from "fs/promises";
-import { resolve as resolve3, isAbsolute, dirname as dirname3 } from "path";
+import { resolve as resolve4, isAbsolute as isAbsolute2, dirname as dirname4 } from "path";
 var MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
@@ -55422,8 +56688,17 @@ var init_ProbeAgent = __esm({
     init_schemaUtils();
     init_xmlParsingUtils();
     init_mcp();
+    init_RetryManager();
+    init_FallbackManager();
     dotenv2.config();
-    MAX_TOOL_ITERATIONS = parseInt(process.env.MAX_TOOL_ITERATIONS || "30", 10);
+    MAX_TOOL_ITERATIONS = (() => {
+      const val = parseInt(process.env.MAX_TOOL_ITERATIONS || "30", 10);
+      if (isNaN(val) || val < 1 || val > 200) {
+        console.warn("[ProbeAgent] MAX_TOOL_ITERATIONS must be between 1 and 200, using default: 30");
+        return 30;
+      }
+      return val;
+    })();
     MAX_HISTORY_MESSAGES = 100;
     MAX_IMAGE_FILE_SIZE = 20 * 1024 * 1024;
     ProbeAgent = class _ProbeAgent {
@@ -55434,6 +56709,7 @@ var init_ProbeAgent = __esm({
        * @param {string} [options.customPrompt] - Custom prompt to replace the default system message
        * @param {string} [options.promptType] - Predefined prompt type (architect, code-review, support)
        * @param {boolean} [options.allowEdit=false] - Allow the use of the 'implement' tool
+       * @param {boolean} [options.enableDelegate=false] - Enable the delegate tool for task distribution to subagents
        * @param {string} [options.path] - Search directory path
        * @param {string} [options.provider] - Force specific AI provider
        * @param {string} [options.model] - Override model name
@@ -55449,17 +56725,36 @@ var init_ProbeAgent = __esm({
        * @param {Array} [options.mcpServers] - Deprecated, use mcpConfig instead
        * @param {Object} [options.storageAdapter] - Custom storage adapter for history management
        * @param {Object} [options.hooks] - Hook callbacks for events (e.g., {'tool:start': callback})
+       * @param {Object} [options.retry] - Retry configuration
+       * @param {number} [options.retry.maxRetries=3] - Maximum retry attempts per provider
+       * @param {number} [options.retry.initialDelay=1000] - Initial delay in ms
+       * @param {number} [options.retry.maxDelay=30000] - Maximum delay in ms
+       * @param {number} [options.retry.backoffFactor=2] - Exponential backoff multiplier
+       * @param {Array<string>} [options.retry.retryableErrors] - List of retryable error patterns
+       * @param {Object} [options.fallback] - Fallback configuration
+       * @param {string} [options.fallback.strategy] - Fallback strategy: 'same-model', 'same-provider', 'any', 'custom'
+       * @param {Array<string>} [options.fallback.models] - List of models for same-provider fallback
+       * @param {Array<Object>} [options.fallback.providers] - List of provider configurations for custom fallback
+       * @param {boolean} [options.fallback.stopOnSuccess=true] - Stop on first success
+       * @param {number} [options.fallback.maxTotalAttempts=10] - Maximum total attempts across all providers
        */
       constructor(options = {}) {
         this.sessionId = options.sessionId || randomUUID4();
         this.customPrompt = options.customPrompt || null;
         this.promptType = options.promptType || "code-explorer";
         this.allowEdit = !!options.allowEdit;
+        this.enableDelegate = !!options.enableDelegate;
         this.debug = options.debug || process.env.DEBUG === "1";
         this.cancelled = false;
         this.tracer = options.tracer || null;
         this.outline = !!options.outline;
-        this.maxResponseTokens = options.maxResponseTokens || parseInt(process.env.MAX_RESPONSE_TOKENS || "0", 10) || null;
+        this.maxResponseTokens = options.maxResponseTokens || (() => {
+          const val = parseInt(process.env.MAX_RESPONSE_TOKENS || "0", 10);
+          if (isNaN(val) || val < 0 || val > 2e5) {
+            return null;
+          }
+          return val || null;
+        })();
         this.maxIterations = options.maxIterations || null;
         this.disableMermaidValidation = !!options.disableMermaidValidation;
         this.disableJsonValidation = !!options.disableJsonValidation;
@@ -55500,6 +56795,10 @@ var init_ProbeAgent = __esm({
         this.mcpServers = options.mcpServers || null;
         this.mcpBridge = null;
         this._mcpInitialized = false;
+        this.retryConfig = options.retry || {};
+        this.retryManager = null;
+        this.fallbackConfig = options.fallback || null;
+        this.fallbackManager = null;
         this.initializeModel();
       }
       /**
@@ -55584,6 +56883,14 @@ var init_ProbeAgent = __esm({
         if (this.enableBash && wrappedTools.bashToolInstance) {
           this.toolImplementations.bash = wrappedTools.bashToolInstance;
         }
+        if (this.allowEdit) {
+          if (wrappedTools.editToolInstance) {
+            this.toolImplementations.edit = wrappedTools.editToolInstance;
+          }
+          if (wrappedTools.createToolInstance) {
+            this.toolImplementations.create = wrappedTools.createToolInstance;
+          }
+        }
         this.wrappedTools = wrappedTools;
         if (this.debug) {
           console.error("\n[DEBUG] ========================================");
@@ -55634,36 +56941,147 @@ var init_ProbeAgent = __esm({
         if (forceProvider) {
           if (forceProvider === "anthropic" && anthropicApiKey) {
             this.initializeAnthropicModel(anthropicApiKey, anthropicApiUrl, modelName);
+            this.initializeFallbackManager(forceProvider, modelName);
             return;
           } else if (forceProvider === "openai" && openaiApiKey) {
             this.initializeOpenAIModel(openaiApiKey, openaiApiUrl, modelName);
+            this.initializeFallbackManager(forceProvider, modelName);
             return;
           } else if (forceProvider === "google" && googleApiKey) {
             this.initializeGoogleModel(googleApiKey, googleApiUrl, modelName);
+            this.initializeFallbackManager(forceProvider, modelName);
             return;
           } else if (forceProvider === "bedrock" && (awsAccessKeyId && awsSecretAccessKey && awsRegion || awsApiKey)) {
             this.initializeBedrockModel(awsAccessKeyId, awsSecretAccessKey, awsRegion, awsSessionToken, awsApiKey, awsBedrockBaseUrl, modelName);
+            this.initializeFallbackManager(forceProvider, modelName);
             return;
           }
           console.warn(`WARNING: Forced provider "${forceProvider}" selected but required API key is missing or invalid! Falling back to auto-detection.`);
         }
         if (anthropicApiKey) {
           this.initializeAnthropicModel(anthropicApiKey, anthropicApiUrl, modelName);
+          this.initializeFallbackManager("anthropic", modelName);
         } else if (openaiApiKey) {
           this.initializeOpenAIModel(openaiApiKey, openaiApiUrl, modelName);
+          this.initializeFallbackManager("openai", modelName);
         } else if (googleApiKey) {
           this.initializeGoogleModel(googleApiKey, googleApiUrl, modelName);
+          this.initializeFallbackManager("google", modelName);
         } else if (awsAccessKeyId && awsSecretAccessKey && awsRegion || awsApiKey) {
           this.initializeBedrockModel(awsAccessKeyId, awsSecretAccessKey, awsRegion, awsSessionToken, awsApiKey, awsBedrockBaseUrl, modelName);
+          this.initializeFallbackManager("bedrock", modelName);
         } else {
           throw new Error("No API key provided. Please set ANTHROPIC_API_KEY (or ANTHROPIC_AUTH_TOKEN), OPENAI_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY (or GOOGLE_API_KEY), AWS credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION), or AWS_BEDROCK_API_KEY environment variables.");
         }
       }
+      /**
+       * Initialize fallback manager based on configuration
+       * @param {string} primaryProvider - The primary provider being used
+       * @param {string} primaryModel - The primary model being used
+       * @private
+       */
+      initializeFallbackManager(primaryProvider, primaryModel) {
+        if (this.fallbackConfig === false || process.env.DISABLE_FALLBACK === "1") {
+          return;
+        }
+        if (this.fallbackConfig && this.fallbackConfig.providers) {
+          try {
+            this.fallbackManager = new FallbackManager({
+              ...this.fallbackConfig,
+              debug: this.debug
+            });
+            if (this.debug) {
+              console.log(`[DEBUG] Fallback manager initialized with ${this.fallbackManager.providers.length} providers`);
+            }
+          } catch (error) {
+            console.error("[WARNING] Failed to initialize fallback manager:", error.message);
+          }
+          return;
+        }
+        const envFallbackManager = createFallbackManagerFromEnv(this.debug);
+        if (envFallbackManager) {
+          this.fallbackManager = envFallbackManager;
+          if (this.debug) {
+            console.log(`[DEBUG] Fallback manager initialized from environment variables`);
+          }
+          return;
+        }
+        if (process.env.AUTO_FALLBACK === "1" || this.fallbackConfig?.auto) {
+          const providers = buildFallbackProvidersFromEnv({
+            primaryProvider,
+            primaryModel
+          });
+          if (providers.length > 1) {
+            try {
+              this.fallbackManager = new FallbackManager({
+                strategy: "custom",
+                providers,
+                debug: this.debug
+              });
+              if (this.debug) {
+                console.log(`[DEBUG] Auto-fallback enabled with ${providers.length} providers`);
+              }
+            } catch (error) {
+              console.error("[WARNING] Failed to initialize auto-fallback:", error.message);
+            }
+          }
+        }
+      }
+      /**
+       * Execute streamText with retry and fallback support
+       * @param {Object} options - streamText options
+       * @returns {Promise<Object>} - streamText result
+       * @private
+       */
+      async streamTextWithRetryAndFallback(options) {
+        if (!this.retryManager) {
+          this.retryManager = new RetryManager({
+            maxRetries: this.retryConfig.maxRetries ?? 3,
+            initialDelay: this.retryConfig.initialDelay ?? 1e3,
+            maxDelay: this.retryConfig.maxDelay ?? 3e4,
+            backoffFactor: this.retryConfig.backoffFactor ?? 2,
+            retryableErrors: this.retryConfig.retryableErrors,
+            debug: this.debug
+          });
+        }
+        if (!this.fallbackManager) {
+          return await this.retryManager.executeWithRetry(
+            () => streamText(options),
+            {
+              provider: this.apiType,
+              model: this.model
+            }
+          );
+        }
+        return await this.fallbackManager.executeWithFallback(
+          async (provider, model, config) => {
+            const fallbackOptions = {
+              ...options,
+              model: provider(model)
+            };
+            const providerRetryManager = new RetryManager({
+              maxRetries: config.maxRetries ?? this.retryConfig.maxRetries ?? 3,
+              initialDelay: this.retryConfig.initialDelay ?? 1e3,
+              maxDelay: this.retryConfig.maxDelay ?? 3e4,
+              backoffFactor: this.retryConfig.backoffFactor ?? 2,
+              retryableErrors: this.retryConfig.retryableErrors,
+              debug: this.debug
+            });
+            return await providerRetryManager.executeWithRetry(
+              () => streamText(fallbackOptions),
+              {
+                provider: config.provider,
+                model
+              }
+            );
+          }
+        );
+      }
       /**
        * Initialize Anthropic model
        */
       initializeAnthropicModel(apiKey, apiUrl, modelName) {
-        this.provider = createAnthropic({
+        this.provider = createAnthropic2({
           apiKey,
           ...apiUrl && { baseURL: apiUrl }
         });
@@ -55677,7 +57095,7 @@ var init_ProbeAgent = __esm({
        * Initialize OpenAI model
        */
       initializeOpenAIModel(apiKey, apiUrl, modelName) {
-        this.provider = createOpenAI({
+        this.provider = createOpenAI2({
           compatibility: "strict",
           apiKey,
           ...apiUrl && { baseURL: apiUrl }
@@ -55692,7 +57110,7 @@ var init_ProbeAgent = __esm({
        * Initialize Google model
        */
       initializeGoogleModel(apiKey, apiUrl, modelName) {
-        this.provider = createGoogleGenerativeAI({
+        this.provider = createGoogleGenerativeAI2({
           apiKey,
           ...apiUrl && { baseURL: apiUrl }
         });
@@ -55722,7 +57140,7 @@ var init_ProbeAgent = __esm({
         if (baseURL) {
           config.baseURL = baseURL;
         }
-        this.provider = createAmazonBedrock(config);
+        this.provider = createAmazonBedrock2(config);
         this.model = modelName || "anthropic.claude-sonnet-4-20250514-v1:0";
         this.apiType = "bedrock";
         if (this.debug) {
@@ -55767,7 +57185,7 @@ var init_ProbeAgent = __esm({
           let resolvedPath = imagePath;
           if (!imagePath.includes("/") && !imagePath.includes("\\")) {
             for (const dir of listFilesDirectories) {
-              const potentialPath = resolve3(dir, imagePath);
+              const potentialPath = resolve4(dir, imagePath);
               const loaded = await this.loadImageIfValid(potentialPath);
               if (loaded) {
                 if (this.debug) {
@@ -55792,7 +57210,7 @@ var init_ProbeAgent = __esm({
         let match2;
         while ((match2 = fileHeaderPattern.exec(content)) !== null) {
           const filePath = match2[1].trim();
-          const dir = dirname3(filePath);
+          const dir = dirname4(filePath);
           if (dir && dir !== ".") {
             directories.push(dir);
             if (this.debug) {
@@ -55836,21 +57254,21 @@ var init_ProbeAgent = __esm({
           }
           const allowedDirs = this.allowedFolders && this.allowedFolders.length > 0 ? this.allowedFolders : [process.cwd()];
           let absolutePath;
-          let isPathAllowed = false;
-          if (isAbsolute(imagePath)) {
+          let isPathAllowed2 = false;
+          if (isAbsolute2(imagePath)) {
             absolutePath = imagePath;
-            isPathAllowed = allowedDirs.some((dir) => absolutePath.startsWith(resolve3(dir)));
+            isPathAllowed2 = allowedDirs.some((dir) => absolutePath.startsWith(resolve4(dir)));
           } else {
             for (const dir of allowedDirs) {
-              const resolvedPath = resolve3(dir, imagePath);
-              if (resolvedPath.startsWith(resolve3(dir))) {
+              const resolvedPath = resolve4(dir, imagePath);
+              if (resolvedPath.startsWith(resolve4(dir))) {
                 absolutePath = resolvedPath;
-                isPathAllowed = true;
+                isPathAllowed2 = true;
                 break;
               }
             }
           }
-          if (!isPathAllowed) {
+          if (!isPathAllowed2) {
             if (this.debug) {
               console.log(`[DEBUG] Image path outside allowed directories: ${imagePath}`);
             }
@@ -56049,6 +57467,18 @@ ${attemptCompletionToolDefinition}
 `;
         if (this.allowEdit) {
           toolDefinitions += `${implementToolDefinition}
+`;
+          toolDefinitions += `${editToolDefinition}
+`;
+          toolDefinitions += `${createToolDefinition}
+`;
+        }
+        if (this.enableBash) {
+          toolDefinitions += `${bashToolDefinition}
+`;
+        }
+        if (this.enableDelegate) {
+          toolDefinitions += `${delegateToolDefinition}
 `;
         }
         let xmlToolGuidelines = `
@@ -56112,7 +57542,7 @@ Available Tools:
 - extract: Extract specific code blocks or lines from files.
 - listFiles: List files and directories in a specified location.
 - searchFiles: Find files matching a glob pattern with recursive search capability.
-${this.allowEdit ? "- implement: Implement a feature or fix a bug using aider.\n" : ""}
+${this.allowEdit ? "- implement: Implement a feature or fix a bug using aider.\n- edit: Edit files using exact string replacement.\n- create: Create new files with specified content.\n" : ""}${this.enableDelegate ? "- delegate: Delegate big distinct tasks to specialized probe subagents.\n" : ""}${this.enableBash ? "- bash: Execute bash commands for system operations.\n" : ""}
 - attempt_completion: Finalize the task and provide the result to the user.
 - attempt_complete: Quick completion using previous response (shorthand).
 `;
@@ -56126,7 +57556,10 @@ Follow these instructions carefully:
 6. You MUST respond with exactly ONE tool call per message, using the specified XML format, until the task is complete.
 7. Wait for the tool execution result (provided in the next user message in a <tool_result> block) before proceeding to the next step.
 8. Once the task is fully completed, use the '<attempt_completion>' tool to provide the final result. This is the ONLY way to signal completion.
-9. Prefer concise and focused search queries. Use specific keywords and phrases to narrow down results.
+9. Prefer concise and focused search queries. Use specific keywords and phrases to narrow down results.${this.allowEdit ? `
+10. When modifying files, choose the appropriate tool:
+    - Use 'edit' for precise changes to existing files (requires exact string match)
+    - Use 'create' for new files or complete file rewrites` : ""}
 </instructions>
 `;
         const predefinedPrompts = {
@@ -56378,7 +57811,7 @@ You are working with a repository located at: ${searchDirectory}
             try {
               const executeAIRequest = async () => {
                 const messagesForAI = this.prepareMessagesWithImages(currentMessages);
-                const result = await streamText({
+                const result = await this.streamTextWithRetryAndFallback({
                   model: this.provider(this.model),
                   messages: messagesForAI,
                   maxTokens: maxResponseTokens,
@@ -56430,7 +57863,13 @@ You are working with a repository located at: ${searchDirectory}
               "attempt_completion"
             ];
             if (this.allowEdit) {
-              validTools.push("implement");
+              validTools.push("implement", "edit", "create");
+            }
+            if (this.enableBash) {
+              validTools.push("bash");
+            }
+            if (this.enableDelegate) {
+              validTools.push("delegate");
             }
             const nativeTools = validTools;
             const parsedTool = this.mcpBridge ? parseHybridXmlToolCall(assistantResponseContent, nativeTools, this.mcpBridge) : parseXmlToolCallWithThinking(assistantResponseContent, validTools);
@@ -56545,11 +57984,21 @@ ${toolResultContent}
                           ...toolParams,
                           currentIteration,
                           maxIterations,
+                          parentSessionId: this.sessionId,
+                          // Pass parent session ID for tracking
+                          path: this.searchPath,
+                          // Inherit search path
+                          provider: this.provider,
+                          // Inherit AI provider
+                          model: this.model,
+                          // Inherit model
                           debug: this.debug,
                           tracer: this.tracer
                         };
                         if (this.debug) {
                           console.log(`[DEBUG] Executing delegate tool at iteration ${currentIteration}/${maxIterations}`);
+                          console.log(`[DEBUG] Parent session: ${this.sessionId}`);
+                          console.log(`[DEBUG] Inherited config: path=${this.searchPath}, provider=${this.provider}, model=${this.model}`);
                           console.log(`[DEBUG] Delegate task: ${toolParams.task?.substring(0, 100)}...`);
                         }
                         if (this.tracer) {
@@ -57140,6 +58589,7 @@ Convert your previous response content into actual JSON data that follows this s
           customPrompt: this.customPrompt,
           promptType: this.promptType,
           allowEdit: this.allowEdit,
+          enableDelegate: this.enableDelegate,
           path: this.allowedFolders[0],
           // Use first allowed folder as primary path
           allowedFolders: [...this.allowedFolders],
@@ -57330,8 +58780,8 @@ import {
   ListToolsRequestSchema,
   McpError
 } from "@modelcontextprotocol/sdk/types.js";
-import { readFileSync as readFileSync2, existsSync as existsSync5 } from "fs";
-import { resolve as resolve4 } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync6 } from "fs";
+import { resolve as resolve5 } from "path";
 
 // src/agent/acp/server.js
 import { randomUUID as randomUUID5 } from "crypto";
@@ -57590,8 +59040,8 @@ var ACPConnection = class extends EventEmitter4 {
     if (params !== null) {
       message.params = params;
     }
-    return new Promise((resolve5, reject2) => {
-      this.pendingRequests.set(id, { resolve: resolve5, reject: reject2 });
+    return new Promise((resolve6, reject2) => {
+      this.pendingRequests.set(id, { resolve: resolve6, reject: reject2 });
       this.sendMessage(message);
       setTimeout(() => {
         if (this.pendingRequests.has(id)) {
@@ -57896,6 +59346,7 @@ var ACPServer = class {
       provider: this.options.provider,
       model: this.options.model,
       allowEdit: this.options.allowEdit,
+      enableDelegate: this.options.enableDelegate,
       debug: this.options.debug,
       enableMcp: this.options.enableMcp,
       mcpConfig: this.options.mcpConfig,
@@ -58004,8 +59455,8 @@ dotenv3.config();
 function readInputContent(input) {
   if (!input) return null;
   try {
-    const resolvedPath = resolve4(input);
-    if (existsSync5(resolvedPath)) {
+    const resolvedPath = resolve5(input);
+    if (existsSync6(resolvedPath)) {
       return readFileSync2(resolvedPath, "utf-8").trim();
     }
   } catch (error) {
@@ -58013,7 +59464,7 @@ function readInputContent(input) {
   return input;
 }
 function readFromStdin() {
-  return new Promise((resolve5, reject2) => {
+  return new Promise((resolve6, reject2) => {
     let data = "";
     let hasReceivedData = false;
     let dataChunks = [];
@@ -58038,7 +59489,7 @@ function readFromStdin() {
       if (!trimmed && dataChunks.length === 0) {
         reject2(new Error("No input received from stdin"));
       } else {
-        resolve5(trimmed);
+        resolve6(trimmed);
       }
     });
     process.stdin.on("error", (error) => {
@@ -58070,6 +59521,7 @@ function parseArgs() {
     provider: null,
     model: null,
     allowEdit: false,
+    enableDelegate: false,
     verbose: false,
     help: false,
     maxIterations: null,
@@ -58104,6 +59556,10 @@ function parseArgs() {
       config.verbose = true;
     } else if (arg === "--allow-edit") {
       config.allowEdit = true;
+    } else if (arg === "--enable-delegate") {
+      config.enableDelegate = true;
+    } else if (arg === "--no-delegate") {
+      config.enableDelegate = false;
     } else if (arg === "--path" && i + 1 < args.length) {
       config.path = args[++i];
     } else if (arg === "--allowed-folders" && i + 1 < args.length) {
@@ -58175,6 +59631,7 @@ Options:
   --provider <name>                Force AI provider: anthropic, openai, google
   --model <name>                   Override model name
   --allow-edit                     Enable code modification capabilities
+  --enable-delegate                Enable delegate tool for task distribution to subagents
   --verbose                        Enable verbose output
   --outline                        Use outline-xml format for code search results
   --mcp                           Run as MCP server
@@ -58455,6 +59912,7 @@ async function main() {
       model: config.model,
       path: config.path,
       allowEdit: config.allowEdit,
+      enableDelegate: config.enableDelegate,
       debug: config.verbose
     });
     await server.start();
@@ -58557,7 +60015,7 @@ async function main() {
         bashConfig.timeout = timeout;
       }
       if (config.bashWorkingDir) {
-        if (!existsSync5(config.bashWorkingDir)) {
+        if (!existsSync6(config.bashWorkingDir)) {
           console.error(`Error: Bash working directory does not exist: ${config.bashWorkingDir}`);
           process.exit(1);
         }
@@ -58573,6 +60031,7 @@ async function main() {
       promptType: config.prompt,
       customPrompt: systemPrompt,
       allowEdit: config.allowEdit,
+      enableDelegate: config.enableDelegate,
       debug: config.verbose,
       tracer: appTracer,
       outline: config.outline,