@probelabs/probe 0.6.0-rc154 → 0.6.0-rc159

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,
@@ -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;
@@ -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, searchDescription, queryDescription, extractDescription, delegateDescription, DEFAULT_VALID_TOOLS;
 var init_common = __esm({
   "src/tools/common.js"() {
     "use strict";
@@ -7481,6 +7765,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
@@ -7509,193 +7813,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 +7985,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 +8857,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 = {}) {
@@ -8768,7 +8914,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"],
@@ -29929,13 +30075,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 +30186,7 @@ function mapFlowchartParserError(err, text) {
           }
         }
       }
-      if (tokType === "QuotedString") {
+      if (tokType === "QuotedString" || tokType === "SquareOpen" || tokType === "SquareClose") {
         return {
           line,
           column,
@@ -30050,7 +30207,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 +30246,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,
@@ -30935,6 +31092,53 @@ 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") {
+              const ln = e.line ?? 0;
+              const col = e.column ?? 1;
+              const list = byLine.get(ln) || [];
+              list.push(col);
+              byLine.set(ln, list);
+            }
+          }
+        };
+        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((c) => c >= segStartCol && c <= 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;
@@ -33279,6 +33483,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*(-->|==>|\.->|->)(.*)$/;
@@ -55434,6 +55653,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
@@ -55455,6 +55675,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;
@@ -56049,6 +56270,10 @@ ${attemptCompletionToolDefinition}
 `;
         if (this.allowEdit) {
           toolDefinitions += `${implementToolDefinition}
+`;
+        }
+        if (this.enableDelegate) {
+          toolDefinitions += `${delegateToolDefinition}
 `;
         }
         let xmlToolGuidelines = `
@@ -56112,7 +56337,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).
 `;
@@ -56432,6 +56657,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) {
@@ -56545,11 +56773,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 +57378,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],
@@ -57896,6 +58135,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,
@@ -58070,6 +58310,7 @@ function parseArgs() {
     provider: null,
     model: null,
     allowEdit: false,
+    enableDelegate: false,
     verbose: false,
     help: false,
     maxIterations: null,
@@ -58104,6 +58345,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 +58420,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 +58701,7 @@ async function main() {
       model: config.model,
       path: config.path,
       allowEdit: config.allowEdit,
+      enableDelegate: config.enableDelegate,
       debug: config.verbose
     });
     await server.start();
@@ -58573,6 +58820,7 @@ async function main() {
       promptType: config.prompt,
       customPrompt: systemPrompt,
       allowEdit: config.allowEdit,
+      enableDelegate: config.enableDelegate,
       debug: config.verbose,
       tracer: appTracer,
       outline: config.outline,