@probelabs/probe 0.6.0-rc154 → 0.6.0-rc159

package/cjs/agent/ProbeAgent.cjs

@@ -2440,7 +2440,7 @@ var require_dist_cjs15 = __commonJS({
     var MIN_WAIT_TIME = 6e3;
     async function writeRequestBody(httpRequest, request, maxContinueTimeoutMs = MIN_WAIT_TIME) {
       const headers = request.headers ?? {};
-      const expect = headers["Expect"] || headers["expect"];
+      const expect = headers.Expect || headers.expect;
       let timeoutId = -1;
       let sendBody = true;
       if (expect === "100-continue") {
@@ -2568,6 +2568,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
           this.config = await this.configProvider;
         }
         return new Promise((_resolve, _reject) => {
+          const config = this.config;
           let writeRequestBodyPromise = void 0;
           const timeouts = [];
           const resolve4 = async (arg) => {
@@ -2580,9 +2581,6 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             timeouts.forEach(timing.clearTimeout);
             _reject(arg);
           };
-          if (!this.config) {
-            throw new Error("Node HTTP request handler config is not resolved");
-          }
           if (abortSignal?.aborted) {
             const abortError = new Error("Request aborted");
             abortError.name = "AbortError";
@@ -2590,10 +2588,18 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             return;
           }
           const isSSL = request.protocol === "https:";
-          const agent = isSSL ? this.config.httpsAgent : this.config.httpAgent;
+          const headers = request.headers ?? {};
+          const expectContinue = (headers.Expect ?? headers.expect) === "100-continue";
+          let agent = isSSL ? config.httpsAgent : config.httpAgent;
+          if (expectContinue) {
+            agent = new (isSSL ? https.Agent : http.Agent)({
+              keepAlive: false,
+              maxSockets: Infinity
+            });
+          }
           timeouts.push(timing.setTimeout(() => {
-            this.socketWarningTimestamp = _NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp, this.config.logger);
-          }, this.config.socketAcquisitionWarningTimeout ?? (this.config.requestTimeout ?? 2e3) + (this.config.connectionTimeout ?? 1e3)));
+            this.socketWarningTimestamp = _NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp, config.logger);
+          }, config.socketAcquisitionWarningTimeout ?? (config.requestTimeout ?? 2e3) + (config.connectionTimeout ?? 1e3)));
           const queryString = querystringBuilder.buildQueryString(request.query || {});
           let auth = void 0;
           if (request.username != null || request.password != null) {
@@ -2655,10 +2661,10 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
               abortSignal.onabort = onAbort;
             }
           }
-          const effectiveRequestTimeout = requestTimeout ?? this.config.requestTimeout;
-          timeouts.push(setConnectionTimeout(req, reject2, this.config.connectionTimeout));
-          timeouts.push(setRequestTimeout(req, reject2, effectiveRequestTimeout, this.config.throwOnRequestTimeout, this.config.logger ?? console));
-          timeouts.push(setSocketTimeout(req, reject2, this.config.socketTimeout));
+          const effectiveRequestTimeout = requestTimeout ?? config.requestTimeout;
+          timeouts.push(setConnectionTimeout(req, reject2, config.connectionTimeout));
+          timeouts.push(setRequestTimeout(req, reject2, effectiveRequestTimeout, config.throwOnRequestTimeout, config.logger ?? console));
+          timeouts.push(setSocketTimeout(req, reject2, config.socketTimeout));
           const httpAgent = nodeHttpsOptions.agent;
           if (typeof httpAgent === "object" && "keepAlive" in httpAgent) {
             timeouts.push(setSocketKeepAlive(req, {
@@ -27643,6 +27649,28 @@ var init_directory_resolver = __esm({
 });
 
 // src/downloader.js
+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 e3 = new Error(parts.filter(Boolean).join(" "));
+    if (status) e3.status = status;
+    if (code) e3.code = code;
+    if (url) e3.url = url;
+    return e3;
+  } catch (_2) {
+    return new Error(err?.message || String(err));
+  }
+}
 async function acquireFileLock(lockPath, version) {
   const lockData = {
     version,
@@ -27791,7 +27819,7 @@ function detectOsArch() {
     case "linux":
       osInfo = {
         type: "linux",
-        keywords: ["linux", "Linux", "gnu"]
+        keywords: ["linux", "Linux", "musl", "gnu"]
       };
       break;
     case "darwin":
@@ -27835,7 +27863,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":
@@ -27952,7 +27980,7 @@ async function getLatestRelease(version) {
       }
       return { tag: tag2, assets };
     }
-    throw error2;
+    throw sanitizeError(error2);
   }
 }
 function findBestAsset(assets, osInfo, archInfo) {
@@ -28166,7 +28194,7 @@ async function extractBinary(assetPath, outputDir) {
     return binaryPath;
   } catch (error2) {
     console.error(`Error extracting binary: ${error2 instanceof Error ? error2.message : String(error2)}`);
-    throw error2;
+    throw sanitizeError(error2);
   }
 }
 async function getVersionInfo(binDir) {
@@ -28331,8 +28359,8 @@ async function downloadProbeBinary(version) {
     }
     return await withDownloadLock(version, () => doDownload(version));
   } catch (error2) {
-    console.error("Error downloading probe binary:", error2);
-    throw error2;
+    console.error("Error downloading probe binary:", error2?.message || String(error2));
+    throw sanitizeError(error2);
   }
 }
 var import_axios, import_fs_extra2, import_path2, import_crypto, import_util3, import_child_process, import_tar, import_os2, import_url2, exec, REPO_OWNER, REPO_NAME, BINARY_NAME, __filename2, __dirname2, downloadLocks, LOCK_TIMEOUT_MS, LOCK_POLL_INTERVAL_MS, MAX_LOCK_WAIT_MS;
@@ -28375,9 +28403,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 = import_path3.default.resolve(__dirname3, "..", "bin");
+  const localBinaryPath = import_path3.default.join(localPackageBin, binaryName);
+  if (import_fs_extra3.default.existsSync(localBinaryPath) && !forceDownload) {
+    probeBinaryPath = localBinaryPath;
+    return probeBinaryPath;
+  }
+  const binDir = await getPackageBinDir();
   const binaryPath = import_path3.default.join(binDir, binaryName);
   if (import_fs_extra3.default.existsSync(binaryPath) && !forceDownload) {
     probeBinaryPath = binaryPath;
@@ -28822,6 +28856,262 @@ var init_grep = __esm({
   }
 });
 
+// src/delegate.js
+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 = (0, import_crypto2.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((_2, 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 (error2) {
+    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: ${error2.message}`);
+      console.error(`[DELEGATE] Stack: ${error2.stack}`);
+    }
+    if (tracer) {
+      tracer.recordDelegationEvent("failed", {
+        "delegation.session_id": sessionId,
+        "delegation.parent_session_id": parentSessionId,
+        "delegation.duration_ms": duration,
+        "delegation.error_message": error2.message,
+        "delegation.success": false
+      });
+      if (delegationSpan) {
+        delegationSpan.setAttributes({
+          "delegation.result.success": false,
+          "delegation.result.error": error2.message,
+          "delegation.result.duration_ms": duration
+        });
+        delegationSpan.setStatus({ code: 2, message: error2.message });
+        delegationSpan.end();
+      }
+    }
+    throw new Error(`Delegation failed: ${error2.message}`);
+  }
+}
+var import_crypto2, DelegationManager, delegationManager;
+var init_delegate = __esm({
+  "src/delegate.js"() {
+    "use strict";
+    import_crypto2 = require("crypto");
+    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 (error2) {
+            console.error("[DelegationManager] Error during cleanup:", error2);
+          }
+        }, 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, data2] of this.sessionDelegations.entries()) {
+          if (data2.count === 0 && data2.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({
@@ -33035,7 +33325,7 @@ function parseTargets(targets) {
   }
   return targets.split(/\s+/).filter((f3) => f3.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, searchDescription, queryDescription, extractDescription, delegateDescription, DEFAULT_VALID_TOOLS;
 var init_common2 = __esm({
   "src/tools/common.js"() {
     "use strict";
@@ -33240,6 +33530,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
@@ -33268,194 +33578,6 @@ I have refactored the search module according to the requirements and verified t
   }
 });
 
-// src/delegate.js
-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 = (0, import_crypto2.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((resolve4, reject2) => {
-      const delegationSpan = tracer ? tracer.createDelegationSpan(sessionId, task) : null;
-      const process2 = (0, import_child_process6.spawn)(binaryPath, args, {
-        stdio: ["pipe", "pipe", "pipe"],
-        timeout: timeout * 1e3
-      });
-      let stdout = "";
-      let stderr = "";
-      let isResolved = false;
-      process2.stdout.on("data", (data2) => {
-        const chunk = data2.toString();
-        stdout += chunk;
-        if (debug) {
-          const preview = createMessagePreview(chunk);
-          console.error(`[DELEGATE] stdout chunk received (${chunk.length} chars): ${preview}`);
-        }
-      });
-      process2.stderr.on("data", (data2) => {
-        const chunk = data2.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();
-            }
-          }
-          resolve4(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", (error2) => {
-        if (isResolved) return;
-        isResolved = true;
-        const duration = Date.now() - startTime;
-        if (debug) {
-          console.error(`[DELEGATE] Process spawn error after ${duration}ms:`, error2);
-          console.error(`[DELEGATE] Session ${sessionId} failed during process creation`);
-          console.error(`[DELEGATE] Error type: ${error2.code || "unknown"}`);
-        }
-        reject2(new Error(`Failed to start delegate process: ${error2.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 (error2) {
-    const duration = Date.now() - startTime;
-    if (debug) {
-      console.error(`[DELEGATE] Error in delegate function after ${duration}ms:`, error2);
-      console.error(`[DELEGATE] Session ${sessionId} failed during setup`);
-      console.error(`[DELEGATE] Error stack: ${error2.stack}`);
-    }
-    throw new Error(`Delegation setup failed: ${error2.message}`);
-  }
-}
-var import_child_process6, import_crypto2;
-var init_delegate = __esm({
-  "src/delegate.js"() {
-    "use strict";
-    import_child_process6 = require("child_process");
-    import_crypto2 = require("crypto");
-    init_utils2();
-    init_common2();
-  }
-});
-
 // src/tools/vercel.js
 var import_ai, searchTool, queryTool, extractTool, delegateTool;
 var init_vercel = __esm({
@@ -33628,21 +33750,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 (error2) {
-            console.error("Error executing delegate command:", error2);
-            return `Error executing delegate command: ${error2.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;
         }
       });
     };
@@ -34525,7 +34676,7 @@ async function executeBashCommand(command, options = {}) {
       return;
     }
     const [cmd, ...cmdArgs] = args;
-    const child = (0, import_child_process7.spawn)(cmd, cmdArgs, {
+    const child = (0, import_child_process6.spawn)(cmd, cmdArgs, {
       cwd,
       env: processEnv,
       stdio: ["ignore", "pipe", "pipe"],
@@ -34709,11 +34860,11 @@ function validateExecutionOptions(options = {}) {
     warnings
   };
 }
-var import_child_process7, import_path4, import_fs;
+var import_child_process6, import_path4, import_fs;
 var init_bashExecutor = __esm({
   "src/agent/bashExecutor.js"() {
     "use strict";
-    import_child_process7 = require("child_process");
+    import_child_process6 = require("child_process");
     import_path4 = require("path");
     import_fs = require("fs");
     init_bashCommandUtils();
@@ -35145,15 +35296,15 @@ function shouldIgnore(filePath, ignorePatterns) {
   }
   return false;
 }
-var import_fs2, import_path6, import_util11, import_child_process8, execAsync3;
+var import_fs2, import_path6, import_util11, import_child_process7, execAsync3;
 var init_file_lister = __esm({
   "src/utils/file-lister.js"() {
     "use strict";
     import_fs2 = __toESM(require("fs"), 1);
     import_path6 = __toESM(require("path"), 1);
     import_util11 = require("util");
-    import_child_process8 = require("child_process");
-    execAsync3 = (0, import_util11.promisify)(import_child_process8.exec);
+    import_child_process7 = require("child_process");
+    execAsync3 = (0, import_util11.promisify)(import_child_process7.exec);
   }
 });
 
@@ -41910,12 +42061,12 @@ function createWrappedTools(baseTools) {
   }
   return wrappedTools;
 }
-var import_child_process9, import_util12, import_crypto3, import_events, import_fs5, import_fs6, import_path8, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
+var import_child_process8, import_util12, import_crypto3, import_events, import_fs5, import_fs6, import_path8, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
 var init_probeTool = __esm({
   "src/agent/probeTool.js"() {
     "use strict";
     init_index();
-    import_child_process9 = require("child_process");
+    import_child_process8 = require("child_process");
     import_util12 = require("util");
     import_crypto3 = require("crypto");
     import_events = require("events");
@@ -55476,13 +55627,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,
@@ -55576,7 +55738,7 @@ function mapFlowchartParserError(err, text) {
           }
         }
       }
-      if (tokType === "QuotedString") {
+      if (tokType === "QuotedString" || tokType === "SquareOpen" || tokType === "SquareClose") {
         return {
           line,
           column,
@@ -55597,7 +55759,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,
@@ -55636,7 +55798,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,
@@ -56482,6 +56644,53 @@ function validateFlowchart(text, options = {}) {
           }
         }
       }
+      {
+        const byLine = /* @__PURE__ */ new Map();
+        const collect = (arr) => {
+          for (const e3 of arr || []) {
+            if (e3 && e3.code === "FL-LABEL-PARENS-UNQUOTED") {
+              const ln = e3.line ?? 0;
+              const col = e3.column ?? 1;
+              const list2 = byLine.get(ln) || [];
+              list2.push(col);
+              byLine.set(ln, list2);
+            }
+          }
+        };
+        collect(prevErrors);
+        collect(errs);
+        const lines2 = text2.split(/\r?\n/);
+        for (let ii = 0; ii < lines2.length; ii++) {
+          const raw2 = lines2[ii] || "";
+          if (!raw2.includes("[") || !raw2.includes("]"))
+            continue;
+          let search2 = 0;
+          while (true) {
+            const open2 = raw2.indexOf("[", search2);
+            if (open2 === -1)
+              break;
+            const close2 = raw2.indexOf("]", open2 + 1);
+            if (close2 === -1)
+              break;
+            const seg2 = raw2.slice(open2 + 1, close2);
+            const trimmed2 = seg2.trim();
+            const ln2 = ii + 1;
+            const lsp = trimmed2.slice(0, 1);
+            const rsp = trimmed2.slice(-1);
+            const isSlashPair = (lsp === "/" || lsp === "\\") && (rsp === "/" || rsp === "\\");
+            const isParenWrapped = lsp === "(" && rsp === ")";
+            const segStartCol = open2 + 2;
+            const segEndCol = close2 + 1;
+            const existing = byLine.get(ln2) || [];
+            const covered = existing.some((c3) => c3 >= segStartCol && c3 <= segEndCol);
+            if (!covered && !/^".*"$/.test(trimmed2) && (seg2.includes("(") || seg2.includes(")")) && !isSlashPair && !isParenWrapped) {
+              errs.push({ line: ln2, column: segStartCol, 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;.' });
+              byLine.set(ln2, existing.concat([segStartCol]));
+            }
+            search2 = close2 + 1;
+          }
+        }
+      }
       const dblEsc = (text2.match(/\\\"/g) || []).length;
       const dq = (text2.match(/\"/g) || []).length - dblEsc;
       const sq = (text2.match(/'/g) || []).length;
@@ -58826,6 +59035,21 @@ function computeFixes(text, errors, level = "safe") {
       }
       continue;
     }
+    if (is("FL-EDGE-LABEL-BRACKET", e3)) {
+      const lineText = lineTextAt(text, e3.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, (m3, seg) => "[" + String(seg).replace(/`/g, "") + "]");
+        edits.push({ start: { line: e3.line, column: 1 }, end: { line: e3.line, column: lineText.length + 1 }, newText: finalLine });
+      }
+      continue;
+    }
     if (is("FL-EDGE-LABEL-BACKTICK", e3)) {
       const lineText = lineTextAt(text, e3.line);
       const re = /^(.*?--)\s*([^|>]+?)\s*(-->|==>|\.->|->)(.*)$/;
@@ -80981,6 +81205,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
@@ -81002,6 +81227,7 @@ var init_ProbeAgent = __esm({
         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;
@@ -81596,6 +81822,10 @@ ${attemptCompletionToolDefinition}
 `;
         if (this.allowEdit) {
           toolDefinitions += `${implementToolDefinition}
+`;
+        }
+        if (this.enableDelegate) {
+          toolDefinitions += `${delegateToolDefinition}
 `;
         }
         let xmlToolGuidelines = `
@@ -81659,7 +81889,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" : ""}${this.enableDelegate ? "- delegate: Delegate big distinct tasks to specialized probe subagents.\n" : ""}
 - attempt_completion: Finalize the task and provide the result to the user.
 - attempt_complete: Quick completion using previous response (shorthand).
 `;
@@ -81979,6 +82209,9 @@ You are working with a repository located at: ${searchDirectory}
             if (this.allowEdit) {
               validTools.push("implement");
             }
+            if (this.enableDelegate) {
+              validTools.push("delegate");
+            }
             const nativeTools = validTools;
             const parsedTool = this.mcpBridge ? parseHybridXmlToolCall(assistantResponseContent, nativeTools, this.mcpBridge) : parseXmlToolCallWithThinking(assistantResponseContent, validTools);
             if (parsedTool) {
@@ -82092,11 +82325,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) {
@@ -82687,6 +82930,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],