@probelabs/probe 0.6.0-rc173 → 0.6.0-rc175

package/build/agent/index.js

@@ -2210,9 +2210,50 @@ var init_directory_resolver = __esm({
   }
 });
 
+// src/utils/symlink-utils.js
+import fs2 from "fs";
+import { promises as fsPromises } from "fs";
+async function getEntryType(entry, fullPath) {
+  try {
+    const stats = await fsPromises.stat(fullPath);
+    return {
+      isFile: stats.isFile(),
+      isDirectory: stats.isDirectory(),
+      size: stats.size
+    };
+  } catch {
+    return {
+      isFile: entry.isFile(),
+      isDirectory: entry.isDirectory(),
+      size: 0
+    };
+  }
+}
+function getEntryTypeSync(entry, fullPath) {
+  try {
+    const stats = fs2.statSync(fullPath);
+    return {
+      isFile: stats.isFile(),
+      isDirectory: stats.isDirectory(),
+      size: stats.size
+    };
+  } catch {
+    return {
+      isFile: entry.isFile(),
+      isDirectory: entry.isDirectory(),
+      size: 0
+    };
+  }
+}
+var init_symlink_utils = __esm({
+  "src/utils/symlink-utils.js"() {
+    "use strict";
+  }
+});
+
 // src/downloader.js
 import axios from "axios";
-import fs2 from "fs-extra";
+import fs3 from "fs-extra";
 import path2 from "path";
 import { createHash } from "crypto";
 import { promisify } from "util";
@@ -2249,7 +2290,7 @@ async function acquireFileLock(lockPath, version) {
     timestamp: Date.now()
   };
   try {
-    await fs2.writeFile(lockPath, JSON.stringify(lockData), { flag: "wx" });
+    await fs3.writeFile(lockPath, JSON.stringify(lockData), { flag: "wx" });
     if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
       console.log(`Acquired file lock: ${lockPath}`);
     }
@@ -2257,13 +2298,13 @@ async function acquireFileLock(lockPath, version) {
   } catch (error) {
     if (error.code === "EEXIST") {
       try {
-        const existingLock = JSON.parse(await fs2.readFile(lockPath, "utf-8"));
+        const existingLock = JSON.parse(await fs3.readFile(lockPath, "utf-8"));
         const lockAge = Date.now() - existingLock.timestamp;
         if (lockAge > LOCK_TIMEOUT_MS) {
           if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
             console.log(`Removing stale lock file (age: ${Math.round(lockAge / 1e3)}s, pid: ${existingLock.pid})`);
           }
-          await fs2.remove(lockPath);
+          await fs3.remove(lockPath);
           return false;
         }
         if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
@@ -2275,7 +2316,7 @@ async function acquireFileLock(lockPath, version) {
           console.log(`Lock file corrupted, removing: ${readError.message}`);
         }
         try {
-          await fs2.remove(lockPath);
+          await fs3.remove(lockPath);
         } catch {
         }
         return false;
@@ -2297,7 +2338,7 @@ async function acquireFileLock(lockPath, version) {
 }
 async function releaseFileLock(lockPath) {
   try {
-    await fs2.remove(lockPath);
+    await fs3.remove(lockPath);
     if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
       console.log(`Released file lock: ${lockPath}`);
     }
@@ -2310,13 +2351,13 @@ async function releaseFileLock(lockPath) {
 async function waitForFileLock(lockPath, binaryPath) {
   const startTime = Date.now();
   while (Date.now() - startTime < MAX_LOCK_WAIT_MS) {
-    if (await fs2.pathExists(binaryPath)) {
+    if (await fs3.pathExists(binaryPath)) {
       if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
         console.log(`Binary now available at ${binaryPath}, download completed by another process`);
       }
       return true;
     }
-    const lockExists = await fs2.pathExists(lockPath);
+    const lockExists = await fs3.pathExists(lockPath);
     if (!lockExists) {
       if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
         console.log(`Lock file removed but binary not found - download may have failed`);
@@ -2324,7 +2365,7 @@ async function waitForFileLock(lockPath, binaryPath) {
       return false;
     }
     try {
-      const lockData = JSON.parse(await fs2.readFile(lockPath, "utf-8"));
+      const lockData = JSON.parse(await fs3.readFile(lockPath, "utf-8"));
       const lockAge = Date.now() - lockData.timestamp;
       if (lockAge > LOCK_TIMEOUT_MS) {
         if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
@@ -2642,13 +2683,13 @@ function findBestAsset(assets, osInfo, archInfo) {
   return bestAsset;
 }
 async function downloadAsset(asset, outputDir) {
-  await fs2.ensureDir(outputDir);
+  await fs3.ensureDir(outputDir);
   const assetPath = path2.join(outputDir, asset.name);
   if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
     console.log(`Downloading ${asset.name}...`);
   }
   const assetResponse = await axios.get(asset.url, { responseType: "arraybuffer" });
-  await fs2.writeFile(assetPath, Buffer.from(assetResponse.data));
+  await fs3.writeFile(assetPath, Buffer.from(assetResponse.data));
   const checksumUrl = asset.checksumUrl || `${asset.url}.sha256`;
   const checksumFileName = asset.checksumName || `${asset.name}.sha256`;
   let checksumPath = null;
@@ -2658,7 +2699,7 @@ async function downloadAsset(asset, outputDir) {
     }
     const checksumResponse = await axios.get(checksumUrl);
     checksumPath = path2.join(outputDir, checksumFileName);
-    await fs2.writeFile(checksumPath, checksumResponse.data);
+    await fs3.writeFile(checksumPath, checksumResponse.data);
   } catch (error) {
     if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
       console.log("No checksum file found, skipping verification");
@@ -2673,9 +2714,9 @@ async function verifyChecksum(assetPath, checksumPath) {
   if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
     console.log(`Verifying checksum...`);
   }
-  const checksumContent = await fs2.readFile(checksumPath, "utf-8");
+  const checksumContent = await fs3.readFile(checksumPath, "utf-8");
   const expectedChecksum = checksumContent.trim().split(" ")[0];
-  const fileBuffer = await fs2.readFile(assetPath);
+  const fileBuffer = await fs3.readFile(assetPath);
   const actualChecksum = createHash("sha256").update(fileBuffer).digest("hex");
   if (expectedChecksum !== actualChecksum) {
     console.error(`Checksum verification failed!`);
@@ -2698,7 +2739,7 @@ async function extractBinary(assetPath, outputDir) {
   const binaryPath = path2.join(outputDir, binaryName);
   try {
     const extractDir = path2.join(outputDir, "temp_extract");
-    await fs2.ensureDir(extractDir);
+    await fs3.ensureDir(extractDir);
     if (assetName.endsWith(".tar.gz") || assetName.endsWith(".tgz")) {
       if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
         console.log(`Extracting tar.gz to ${extractDir}...`);
@@ -2716,11 +2757,11 @@ async function extractBinary(assetPath, outputDir) {
       if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
         console.log(`Copying binary directly to ${binaryPath}`);
       }
-      await fs2.copyFile(assetPath, binaryPath);
+      await fs3.copyFile(assetPath, binaryPath);
       if (!isWindows) {
-        await fs2.chmod(binaryPath, 493);
+        await fs3.chmod(binaryPath, 493);
       }
-      await fs2.remove(extractDir);
+      await fs3.remove(extractDir);
       if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
         console.log(`Binary installed to ${binaryPath}`);
       }
@@ -2730,13 +2771,14 @@ async function extractBinary(assetPath, outputDir) {
       console.log(`Searching for binary in extracted files...`);
     }
     const findBinary = async (dir) => {
-      const entries = await fs2.readdir(dir, { withFileTypes: true });
+      const entries = await fs3.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path2.join(dir, entry.name);
-        if (entry.isDirectory()) {
+        const entryType = await getEntryType(entry, fullPath);
+        if (entryType.isDirectory) {
           const result = await findBinary(fullPath);
           if (result) return result;
-        } else if (entry.isFile()) {
+        } else if (entryType.isFile) {
           if (entry.name === binaryName || entry.name === BINARY_NAME || isWindows && entry.name.endsWith(".exe")) {
             return fullPath;
           }
@@ -2746,7 +2788,7 @@ async function extractBinary(assetPath, outputDir) {
     };
     const binaryFilePath = await findBinary(extractDir);
     if (!binaryFilePath) {
-      const allFiles = await fs2.readdir(extractDir, { recursive: true });
+      const allFiles = await fs3.readdir(extractDir, { recursive: true });
       console.error(`Binary not found in extracted files. Found: ${allFiles.join(", ")}`);
       throw new Error(`Binary not found in the archive.`);
     }
@@ -2754,11 +2796,11 @@ async function extractBinary(assetPath, outputDir) {
       console.log(`Found binary at ${binaryFilePath}`);
       console.log(`Copying binary to ${binaryPath}`);
     }
-    await fs2.copyFile(binaryFilePath, binaryPath);
+    await fs3.copyFile(binaryFilePath, binaryPath);
     if (!isWindows) {
-      await fs2.chmod(binaryPath, 493);
+      await fs3.chmod(binaryPath, 493);
     }
-    await fs2.remove(extractDir);
+    await fs3.remove(extractDir);
     if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
       console.log(`Binary successfully installed to ${binaryPath}`);
     }
@@ -2771,8 +2813,8 @@ async function extractBinary(assetPath, outputDir) {
 async function getVersionInfo(binDir) {
   try {
     const versionInfoPath = path2.join(binDir, "version-info.json");
-    if (await fs2.pathExists(versionInfoPath)) {
-      const content = await fs2.readFile(versionInfoPath, "utf-8");
+    if (await fs3.pathExists(versionInfoPath)) {
+      const content = await fs3.readFile(versionInfoPath, "utf-8");
       return JSON.parse(content);
     }
     return null;
@@ -2787,7 +2829,7 @@ async function saveVersionInfo(version, binDir) {
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
   };
   const versionInfoPath = path2.join(binDir, "version-info.json");
-  await fs2.writeFile(versionInfoPath, JSON.stringify(versionInfo, null, 2));
+  await fs3.writeFile(versionInfoPath, JSON.stringify(versionInfo, null, 2));
   if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
     console.log(`Version info saved: ${version} at ${versionInfoPath}`);
   }
@@ -2802,11 +2844,11 @@ async function getPackageVersion() {
     ];
     for (const packageJsonPath of possiblePaths) {
       try {
-        if (fs2.existsSync(packageJsonPath)) {
+        if (fs3.existsSync(packageJsonPath)) {
           if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
             console.log(`Found package.json at: ${packageJsonPath}`);
           }
-          const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
+          const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
           if (packageJson.version) {
             if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
               console.log(`Using version from package.json: ${packageJson.version}`);
@@ -2862,9 +2904,9 @@ async function doDownload(version) {
   const extractedBinaryPath = await extractBinary(assetPath, localDir);
   await saveVersionInfo(tagVersion, localDir);
   try {
-    await fs2.remove(assetPath);
+    await fs3.remove(assetPath);
     if (checksumPath) {
-      await fs2.remove(checksumPath);
+      await fs3.remove(checksumPath);
     }
   } catch (err) {
     if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
@@ -2885,7 +2927,7 @@ async function downloadProbeBinary(version) {
     const isWindows = os2.platform() === "win32";
     const binaryName = isWindows ? `${BINARY_NAME}.exe` : `${BINARY_NAME}-binary`;
     const binaryPath = path2.join(localDir, binaryName);
-    if (await fs2.pathExists(binaryPath)) {
+    if (await fs3.pathExists(binaryPath)) {
       const versionInfo = await getVersionInfo(localDir);
       if (versionInfo && versionInfo.version === version) {
         if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
@@ -2940,6 +2982,7 @@ var init_downloader = __esm({
     "use strict";
     init_utils();
     init_directory_resolver();
+    init_symlink_utils();
     exec = promisify(execCallback);
     REPO_OWNER = "probelabs";
     REPO_NAME = "probe";
@@ -2955,11 +2998,11 @@ var init_downloader = __esm({
 
 // src/utils.js
 import path3 from "path";
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 import { fileURLToPath as fileURLToPath3 } from "url";
 async function getBinaryPath(options = {}) {
   const { forceDownload = false, version } = options;
-  if (process.env.PROBE_PATH && fs3.existsSync(process.env.PROBE_PATH) && !forceDownload) {
+  if (process.env.PROBE_PATH && fs4.existsSync(process.env.PROBE_PATH) && !forceDownload) {
     probeBinaryPath = process.env.PROBE_PATH;
     return probeBinaryPath;
   }
@@ -2972,13 +3015,13 @@ async function getBinaryPath(options = {}) {
   const binaryName = isWindows ? "probe.exe" : "probe-binary";
   const localPackageBin = path3.resolve(__dirname3, "..", "bin");
   const localBinaryPath = path3.join(localPackageBin, binaryName);
-  if (fs3.existsSync(localBinaryPath) && !forceDownload) {
+  if (fs4.existsSync(localBinaryPath) && !forceDownload) {
     probeBinaryPath = localBinaryPath;
     return probeBinaryPath;
   }
   const binDir = await getPackageBinDir();
   const binaryPath = path3.join(binDir, binaryName);
-  if (fs3.existsSync(binaryPath) && !forceDownload) {
+  if (fs4.existsSync(binaryPath) && !forceDownload) {
     probeBinaryPath = binaryPath;
     return probeBinaryPath;
   }
@@ -3025,6 +3068,31 @@ var init_utils = __esm({
   }
 });
 
+// src/utils/path-validation.js
+import path4 from "path";
+import { promises as fs5 } from "fs";
+async function validateCwdPath(inputPath, defaultPath = process.cwd()) {
+  const targetPath = inputPath || defaultPath;
+  const normalizedPath = path4.normalize(path4.resolve(targetPath));
+  try {
+    const stats = await fs5.stat(normalizedPath);
+    if (!stats.isDirectory()) {
+      throw new Error(`Path is not a directory: ${normalizedPath}`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Path does not exist: ${normalizedPath}`);
+    }
+    throw error;
+  }
+  return normalizedPath;
+}
+var init_path_validation = __esm({
+  "src/utils/path-validation.js"() {
+    "use strict";
+  }
+});
+
 // src/search.js
 import { execFile } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -3066,9 +3134,11 @@ async function search(options) {
     options.session = process.env.PROBE_SESSION_ID;
   }
   const queries = Array.isArray(options.query) ? options.query : [options.query];
+  const cwd = await validateCwdPath(options.cwd);
   if (process.env.DEBUG === "1") {
     let logMessage = `
 Search: query="${queries[0]}" path="${options.path}"`;
+    if (options.cwd) logMessage += ` cwd="${options.cwd}"`;
     if (options.maxResults) logMessage += ` maxResults=${options.maxResults}`;
     logMessage += ` maxTokens=${options.maxTokens}`;
     logMessage += ` timeout=${options.timeout}`;
@@ -3088,6 +3158,7 @@ Search: query="${queries[0]}" path="${options.path}"`;
   }
   try {
     const { stdout, stderr } = await execFileAsync(binaryPath, args, {
+      cwd,
       timeout: options.timeout * 1e3,
       // Convert seconds to milliseconds
       maxBuffer: 50 * 1024 * 1024
@@ -3141,13 +3212,15 @@ Search results: ${resultCount} matches, ${tokenCount} tokens`;
     if (error.code === "ETIMEDOUT" || error.killed) {
       const timeoutMessage = `Search operation timed out after ${options.timeout} seconds.
 Binary: ${binaryPath}
-Args: ${args.join(" ")}`;
+Args: ${args.join(" ")}
+Cwd: ${cwd}`;
       console.error(timeoutMessage);
       throw new Error(timeoutMessage);
     }
     const errorMessage = `Error executing search command: ${error.message}
 Binary: ${binaryPath}
-Args: ${args.join(" ")}`;
+Args: ${args.join(" ")}
+Cwd: ${cwd}`;
     throw new Error(errorMessage);
   }
 }
@@ -3156,6 +3229,7 @@ var init_search = __esm({
   "src/search.js"() {
     "use strict";
     init_utils();
+    init_path_validation();
     execFileAsync = promisify2(execFile);
     SEARCH_FLAG_MAP = {
       filesOnly: "--files-only",
@@ -3195,8 +3269,10 @@ async function query(options) {
     cliArgs.push("--format", "json");
   }
   cliArgs.push(escapeString(options.pattern), escapeString(options.path));
+  const cwd = await validateCwdPath(options.cwd);
   if (process.env.DEBUG === "1") {
     let logMessage = `Query: pattern="${options.pattern}" path="${options.path}"`;
+    if (options.cwd) logMessage += ` cwd="${options.cwd}"`;
     if (options.language) logMessage += ` language=${options.language}`;
     if (options.maxResults) logMessage += ` maxResults=${options.maxResults}`;
     if (options.allowTests) logMessage += " allowTests=true";
@@ -3204,7 +3280,7 @@ async function query(options) {
   }
   const command = `${binaryPath} query ${cliArgs.join(" ")}`;
   try {
-    const { stdout, stderr } = await execAsync(command);
+    const { stdout, stderr } = await execAsync(command, { cwd });
     if (stderr) {
       console.error(`stderr: ${stderr}`);
     }
@@ -3229,7 +3305,8 @@ async function query(options) {
     return stdout;
   } catch (error) {
     const errorMessage = `Error executing query command: ${error.message}
-Command: ${command}`;
+Command: ${command}
+Cwd: ${cwd}`;
     throw new Error(errorMessage);
   }
 }
@@ -3238,6 +3315,7 @@ var init_query = __esm({
   "src/query.js"() {
     "use strict";
     init_utils();
+    init_path_validation();
     execAsync = promisify3(exec2);
     QUERY_FLAG_MAP = {
       language: "--language",
@@ -3274,6 +3352,7 @@ async function extract(options) {
       cliArgs.push(escapeString(file));
     }
   }
+  const cwd = await validateCwdPath(options.cwd);
   if (process.env.DEBUG === "1") {
     let logMessage = `
 Extract:`;
@@ -3282,6 +3361,7 @@ Extract:`;
     }
     if (options.inputFile) logMessage += ` inputFile="${options.inputFile}"`;
     if (options.content) logMessage += ` content=(${typeof options.content === "string" ? options.content.length : options.content.byteLength} bytes)`;
+    if (options.cwd) logMessage += ` cwd="${cwd}"`;
     if (options.allowTests) logMessage += " allowTests=true";
     if (options.contextLines) logMessage += ` contextLines=${options.contextLines}`;
     if (options.format) logMessage += ` format=${options.format}`;
@@ -3289,25 +3369,27 @@ Extract:`;
     console.error(logMessage);
   }
   if (hasContent) {
-    return extractWithStdin(binaryPath, cliArgs, options.content, options);
+    return extractWithStdin(binaryPath, cliArgs, options.content, options, cwd);
   }
   const command = `${binaryPath} extract ${cliArgs.join(" ")}`;
   try {
-    const { stdout, stderr } = await execAsync2(command);
+    const { stdout, stderr } = await execAsync2(command, { cwd });
     if (stderr) {
       console.error(`stderr: ${stderr}`);
     }
     return processExtractOutput(stdout, options);
   } catch (error) {
     const errorMessage = `Error executing extract command: ${error.message}
-Command: ${command}`;
+Command: ${command}
+Cwd: ${cwd}`;
     throw new Error(errorMessage);
   }
 }
-function extractWithStdin(binaryPath, cliArgs, content, options) {
+function extractWithStdin(binaryPath, cliArgs, content, options, cwd) {
   return new Promise((resolve6, reject2) => {
     const childProcess = spawn(binaryPath, ["extract", ...cliArgs], {
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd
     });
     let stdout = "";
     let stderr = "";
@@ -3396,6 +3478,7 @@ var init_extract = __esm({
   "src/extract.js"() {
     "use strict";
     init_utils();
+    init_path_validation();
     execAsync2 = promisify4(exec3);
     EXTRACT_FLAG_MAP = {
       allowTests: "--allow-tests",
@@ -3428,7 +3511,7 @@ async function delegate({
   maxIterations = 30,
   tracer = null,
   parentSessionId = null,
-  path: path8 = null,
+  path: path9 = null,
   provider = null,
   model = null
 }) {
@@ -3468,7 +3551,7 @@ async function delegate({
       maxIterations: remainingIterations,
       debug,
       tracer,
-      path: path8,
+      path: path9,
       // Inherit from parent
       provider,
       // Inherit from parent
@@ -4086,8 +4169,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path8, errorMaps, issueData } = params;
-      const fullPath = [...path8, ...issueData.path || []];
+      const { data, path: path9, errorMaps, issueData } = params;
+      const fullPath = [...path9, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -4395,11 +4478,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util2();
     ParseInputLazyPath = class {
-      constructor(parent, value, path8, key) {
+      constructor(parent, value, path9, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path8;
+        this._path = path9;
         this._key = key;
       }
       get path() {
@@ -8222,15 +8305,15 @@ var init_vercel = __esm({
         name: "search",
         description: searchDescription,
         inputSchema: searchSchema,
-        execute: async ({ query: searchQuery, path: path8, allow_tests, exact, maxTokens: paramMaxTokens, language }) => {
+        execute: async ({ query: searchQuery, path: path9, allow_tests, exact, maxTokens: paramMaxTokens, language }) => {
           try {
             const effectiveMaxTokens = paramMaxTokens || maxTokens;
-            let searchPath = path8 || options.defaultPath || ".";
-            if ((searchPath === "." || searchPath === "./") && options.defaultPath) {
+            let searchPath = path9 || options.cwd || ".";
+            if ((searchPath === "." || searchPath === "./") && options.cwd) {
               if (debug) {
-                console.error(`Using default path "${options.defaultPath}" instead of "${searchPath}"`);
+                console.error(`Using cwd "${options.cwd}" instead of "${searchPath}"`);
               }
-              searchPath = options.defaultPath;
+              searchPath = options.cwd;
             }
             if (debug) {
               console.error(`Executing search with query: "${searchQuery}", path: "${searchPath}", exact: ${exact ? "true" : "false"}, language: ${language || "all"}, session: ${sessionId || "none"}`);
@@ -8238,6 +8321,8 @@ var init_vercel = __esm({
             const searchOptions = {
               query: searchQuery,
               path: searchPath,
+              cwd: options.cwd,
+              // Working directory for resolving relative paths
               allowTests: allow_tests,
               exact,
               json: false,
@@ -8265,14 +8350,14 @@ var init_vercel = __esm({
         name: "query",
         description: queryDescription,
         inputSchema: querySchema,
-        execute: async ({ pattern, path: path8, language, allow_tests }) => {
+        execute: async ({ pattern, path: path9, language, allow_tests }) => {
           try {
-            let queryPath = path8 || options.defaultPath || ".";
-            if ((queryPath === "." || queryPath === "./") && options.defaultPath) {
+            let queryPath = path9 || options.cwd || ".";
+            if ((queryPath === "." || queryPath === "./") && options.cwd) {
               if (debug) {
-                console.error(`Using default path "${options.defaultPath}" instead of "${queryPath}"`);
+                console.error(`Using cwd "${options.cwd}" instead of "${queryPath}"`);
               }
-              queryPath = options.defaultPath;
+              queryPath = options.cwd;
             }
             if (debug) {
               console.error(`Executing query with pattern: "${pattern}", path: "${queryPath}", language: ${language || "auto"}`);
@@ -8280,6 +8365,8 @@ var init_vercel = __esm({
             const results = await query({
               pattern,
               path: queryPath,
+              cwd: options.cwd,
+              // Working directory for resolving relative paths
               language,
               allow_tests,
               json: false
@@ -8300,22 +8387,16 @@ var init_vercel = __esm({
         inputSchema: extractSchema,
         execute: async ({ targets, input_content, line, end_line, allow_tests, context_lines, format }) => {
           try {
-            let extractPath = options.defaultPath || ".";
-            if ((extractPath === "." || extractPath === "./") && options.defaultPath) {
-              if (debug) {
-                console.error(`Using default path "${options.defaultPath}" instead of "${extractPath}"`);
-              }
-              extractPath = options.defaultPath;
-            }
+            const effectiveCwd = options.cwd || ".";
             if (debug) {
               if (targets) {
-                console.error(`Executing extract with targets: "${targets}", path: "${extractPath}", context lines: ${context_lines || 10}`);
+                console.error(`Executing extract with targets: "${targets}", cwd: "${effectiveCwd}", context lines: ${context_lines || 10}`);
               } else if (input_content) {
-                console.error(`Executing extract with input content, path: "${extractPath}", context lines: ${context_lines || 10}`);
+                console.error(`Executing extract with input content, cwd: "${effectiveCwd}", context lines: ${context_lines || 10}`);
               }
             }
             let tempFilePath = null;
-            let extractOptions = { path: extractPath };
+            let extractOptions = { cwd: effectiveCwd };
             if (input_content) {
               const { writeFileSync: writeFileSync2, unlinkSync } = await import("fs");
               const { join: join3 } = await import("path");
@@ -8332,6 +8413,7 @@ var init_vercel = __esm({
               }
               extractOptions = {
                 inputFile: tempFilePath,
+                cwd: effectiveCwd,
                 allowTests: allow_tests,
                 contextLines: context_lines,
                 format: effectiveFormat
@@ -8344,6 +8426,7 @@ var init_vercel = __esm({
               }
               extractOptions = {
                 files,
+                cwd: effectiveCwd,
                 allowTests: allow_tests,
                 contextLines: context_lines,
                 format: effectiveFormat
@@ -8372,12 +8455,12 @@ var init_vercel = __esm({
       });
     };
     delegateTool = (options = {}) => {
-      const { debug = false, timeout = 300, defaultPath, allowedFolders } = options;
+      const { debug = false, timeout = 300, cwd, allowedFolders } = options;
       return tool({
         name: "delegate",
         description: delegateDescription,
         inputSchema: delegateSchema,
-        execute: async ({ task, currentIteration, maxIterations, parentSessionId, path: path8, provider, model, tracer }) => {
+        execute: async ({ task, currentIteration, maxIterations, parentSessionId, path: path9, provider, model, tracer }) => {
           if (!task || typeof task !== "string") {
             throw new Error("Task parameter is required and must be a non-empty string");
           }
@@ -8393,7 +8476,7 @@ var init_vercel = __esm({
           if (parentSessionId !== void 0 && parentSessionId !== null && typeof parentSessionId !== "string") {
             throw new TypeError("parentSessionId must be a string, null, or undefined");
           }
-          if (path8 !== void 0 && path8 !== null && typeof path8 !== "string") {
+          if (path9 !== void 0 && path9 !== null && typeof path9 !== "string") {
             throw new TypeError("path must be a string, null, or undefined");
           }
           if (provider !== void 0 && provider !== null && typeof provider !== "string") {
@@ -8402,13 +8485,13 @@ var init_vercel = __esm({
           if (model !== void 0 && model !== null && typeof model !== "string") {
             throw new TypeError("model must be a string, null, or undefined");
           }
-          const effectivePath = path8 || defaultPath || allowedFolders && allowedFolders[0];
+          const effectivePath = path9 || cwd || allowedFolders && allowedFolders[0];
           if (debug) {
             console.error(`Executing delegate with task: "${task.substring(0, 100)}${task.length > 100 ? "..." : ""}"`);
             if (parentSessionId) {
               console.error(`Parent session: ${parentSessionId}`);
             }
-            if (effectivePath && effectivePath !== path8) {
+            if (effectivePath && effectivePath !== path9) {
               console.error(`Using inherited path: ${effectivePath}`);
             }
           }
@@ -9514,7 +9597,7 @@ var init_bash = __esm({
       const {
         bashConfig = {},
         debug = false,
-        defaultPath,
+        cwd,
         allowedFolders = []
       } = options;
       const permissionChecker = new BashPermissionChecker({
@@ -9528,8 +9611,8 @@ var init_bash = __esm({
         if (bashConfig.workingDirectory) {
           return bashConfig.workingDirectory;
         }
-        if (defaultPath) {
-          return defaultPath;
+        if (cwd) {
+          return cwd;
         }
         if (allowedFolders && allowedFolders.length > 0) {
           return allowedFolders[0];
@@ -9674,7 +9757,7 @@ Command failed with exit code ${result.exitCode}`;
 
 // src/tools/edit.js
 import { tool as tool3 } from "ai";
-import { promises as fs4 } from "fs";
+import { promises as fs6 } from "fs";
 import { dirname, resolve as resolve3, isAbsolute, sep } from "path";
 import { existsSync as existsSync2 } from "fs";
 function isPathAllowed(filePath, allowedFolders) {
@@ -9693,7 +9776,7 @@ function parseFileToolOptions(options = {}) {
   return {
     debug: options.debug || false,
     allowedFolders: options.allowedFolders || [],
-    defaultPath: options.defaultPath
+    cwd: options.cwd
   };
 }
 var editTool, createTool, editDescription, createDescription, editToolDefinition, createToolDefinition;
@@ -9701,7 +9784,7 @@ var init_edit = __esm({
   "src/tools/edit.js"() {
     "use strict";
     editTool = (options = {}) => {
-      const { debug, allowedFolders, defaultPath } = parseFileToolOptions(options);
+      const { debug, allowedFolders, cwd } = parseFileToolOptions(options);
       return tool3({
         name: "edit",
         description: `Edit files using exact string replacement (Claude Code style).
@@ -9752,7 +9835,7 @@ Important:
             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);
+            const resolvedPath = isAbsolute(file_path) ? file_path : resolve3(cwd || process.cwd(), file_path);
             if (debug) {
               console.error(`[Edit] Attempting to edit file: ${resolvedPath}`);
             }
@@ -9762,7 +9845,7 @@ Important:
             if (!existsSync2(resolvedPath)) {
               return `Error editing file: File not found - ${file_path}`;
             }
-            const content = await fs4.readFile(resolvedPath, "utf-8");
+            const content = await fs6.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}`;
             }
@@ -9779,7 +9862,7 @@ Important:
             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");
+            await fs6.writeFile(resolvedPath, newContent, "utf-8");
             const replacedCount = replace_all ? occurrences : 1;
             if (debug) {
               console.error(`[Edit] Successfully edited ${resolvedPath}, replaced ${replacedCount} occurrence(s)`);
@@ -9793,7 +9876,7 @@ Important:
       });
     };
     createTool = (options = {}) => {
-      const { debug, allowedFolders, defaultPath } = parseFileToolOptions(options);
+      const { debug, allowedFolders, cwd } = parseFileToolOptions(options);
       return tool3({
         name: "create",
         description: `Create new files with specified content.
@@ -9836,7 +9919,7 @@ Important:
             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);
+            const resolvedPath = isAbsolute(file_path) ? file_path : resolve3(cwd || process.cwd(), file_path);
             if (debug) {
               console.error(`[Create] Attempting to create file: ${resolvedPath}`);
             }
@@ -9847,8 +9930,8 @@ Important:
               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");
+            await fs6.mkdir(dir, { recursive: true });
+            await fs6.writeFile(resolvedPath, content, "utf-8");
             const action = existsSync2(resolvedPath) && overwrite ? "overwrote" : "created";
             const bytes = Buffer.byteLength(content, "utf-8");
             if (debug) {
@@ -10118,8 +10201,8 @@ var init_tools = __esm({
 });
 
 // src/utils/file-lister.js
-import fs5 from "fs";
-import path4 from "path";
+import fs7 from "fs";
+import path5 from "path";
 import { promisify as promisify6 } from "util";
 import { exec as exec4 } from "child_process";
 async function listFilesByLevel(options) {
@@ -10128,10 +10211,10 @@ async function listFilesByLevel(options) {
     maxFiles = 100,
     respectGitignore = true
   } = options;
-  if (!fs5.existsSync(directory)) {
+  if (!fs7.existsSync(directory)) {
     throw new Error(`Directory does not exist: ${directory}`);
   }
-  const gitDirExists = fs5.existsSync(path4.join(directory, ".git"));
+  const gitDirExists = fs7.existsSync(path5.join(directory, ".git"));
   if (gitDirExists && respectGitignore) {
     try {
       return await listFilesUsingGit(directory, maxFiles);
@@ -10146,8 +10229,8 @@ async function listFilesUsingGit(directory, maxFiles) {
   const { stdout } = await execAsync3("git ls-files", { cwd: directory });
   const files = stdout.split("\n").filter(Boolean);
   const sortedFiles = files.sort((a, b) => {
-    const depthA = a.split(path4.sep).length;
-    const depthB = b.split(path4.sep).length;
+    const depthA = a.split(path5.sep).length;
+    const depthB = b.split(path5.sep).length;
     return depthA - depthB;
   });
   return sortedFiles.slice(0, maxFiles);
@@ -10162,19 +10245,25 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   while (queue.length > 0 && result.length < maxFiles) {
     const { dir, level } = queue.shift();
     try {
-      const entries = fs5.readdirSync(dir, { withFileTypes: true });
-      const files = entries.filter((entry) => entry.isFile());
+      const entries = fs7.readdirSync(dir, { withFileTypes: true });
+      const files = entries.filter((entry) => {
+        const fullPath = path5.join(dir, entry.name);
+        return getEntryTypeSync(entry, fullPath).isFile;
+      });
       for (const file of files) {
         if (result.length >= maxFiles) break;
-        const filePath = path4.join(dir, file.name);
-        const relativePath = path4.relative(directory, filePath);
+        const filePath = path5.join(dir, file.name);
+        const relativePath = path5.relative(directory, filePath);
         if (shouldIgnore(relativePath, ignorePatterns)) continue;
         result.push(relativePath);
       }
-      const dirs = entries.filter((entry) => entry.isDirectory());
+      const dirs = entries.filter((entry) => {
+        const fullPath = path5.join(dir, entry.name);
+        return getEntryTypeSync(entry, fullPath).isDirectory;
+      });
       for (const subdir of dirs) {
-        const subdirPath = path4.join(dir, subdir.name);
-        const relativeSubdirPath = path4.relative(directory, subdirPath);
+        const subdirPath = path5.join(dir, subdir.name);
+        const relativeSubdirPath = path5.relative(directory, subdirPath);
         if (shouldIgnore(relativeSubdirPath, ignorePatterns)) continue;
         if (subdir.name === "node_modules" || subdir.name === ".git") continue;
         queue.push({ dir: subdirPath, level: level + 1 });
@@ -10186,12 +10275,12 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   return result;
 }
 function loadGitignorePatterns(directory) {
-  const gitignorePath = path4.join(directory, ".gitignore");
-  if (!fs5.existsSync(gitignorePath)) {
+  const gitignorePath = path5.join(directory, ".gitignore");
+  if (!fs7.existsSync(gitignorePath)) {
     return [];
   }
   try {
-    const content = fs5.readFileSync(gitignorePath, "utf8");
+    const content = fs7.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}`);
@@ -10213,6 +10302,7 @@ var execAsync3;
 var init_file_lister = __esm({
   "src/utils/file-lister.js"() {
     "use strict";
+    init_symlink_utils();
     execAsync3 = promisify6(exec4);
   }
 });
@@ -11287,7 +11377,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, sep2, 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, path6, 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);
@@ -11356,11 +11446,11 @@ var init_esm = __esm({
       return (f) => f.length === len && f !== "." && f !== "..";
     };
     defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-    path5 = {
+    path6 = {
       win32: { sep: "\\" },
       posix: { sep: "/" }
     };
-    sep2 = defaultPlatform === "win32" ? path5.win32.sep : path5.posix.sep;
+    sep2 = defaultPlatform === "win32" ? path6.win32.sep : path6.posix.sep;
     minimatch.sep = sep2;
     GLOBSTAR = Symbol("globstar **");
     minimatch.GLOBSTAR = GLOBSTAR;
@@ -14547,12 +14637,12 @@ var init_esm4 = __esm({
       /**
        * Get the Path object referenced by the string path, resolved from this Path
        */
-      resolve(path8) {
-        if (!path8) {
+      resolve(path9) {
+        if (!path9) {
           return this;
         }
-        const rootPath = this.getRootString(path8);
-        const dir = path8.substring(rootPath.length);
+        const rootPath = this.getRootString(path9);
+        const dir = path9.substring(rootPath.length);
         const dirParts = dir.split(this.splitSep);
         const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
         return result;
@@ -15304,8 +15394,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      getRootString(path8) {
-        return win32.parse(path8).root;
+      getRootString(path9) {
+        return win32.parse(path9).root;
       }
       /**
        * @internal
@@ -15351,8 +15441,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      getRootString(path8) {
-        return path8.startsWith("/") ? "/" : "";
+      getRootString(path9) {
+        return path9.startsWith("/") ? "/" : "";
       }
       /**
        * @internal
@@ -15401,8 +15491,8 @@ var init_esm4 = __esm({
        *
        * @internal
        */
-      constructor(cwd = process.cwd(), pathImpl, sep4, { nocase, childrenCacheSize = 16 * 1024, fs: fs8 = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs8);
+      constructor(cwd = process.cwd(), pathImpl, sep4, { nocase, childrenCacheSize = 16 * 1024, fs: fs10 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs10);
         if (cwd instanceof URL || cwd.startsWith("file://")) {
           cwd = fileURLToPath4(cwd);
         }
@@ -15441,11 +15531,11 @@ var init_esm4 = __esm({
       /**
        * Get the depth of a provided path, string, or the cwd
        */
-      depth(path8 = this.cwd) {
-        if (typeof path8 === "string") {
-          path8 = this.cwd.resolve(path8);
+      depth(path9 = this.cwd) {
+        if (typeof path9 === "string") {
+          path9 = this.cwd.resolve(path9);
         }
-        return path8.depth();
+        return path9.depth();
       }
       /**
        * Return the cache of child entries.  Exposed so subclasses can create
@@ -15932,9 +16022,9 @@ var init_esm4 = __esm({
         process2();
         return results;
       }
-      chdir(path8 = this.cwd) {
+      chdir(path9 = this.cwd) {
         const oldCwd = this.cwd;
-        this.cwd = typeof path8 === "string" ? this.cwd.resolve(path8) : path8;
+        this.cwd = typeof path9 === "string" ? this.cwd.resolve(path9) : path9;
         this.cwd[setAsCwd](oldCwd);
       }
     };
@@ -15960,8 +16050,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs8) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs8 });
+      newRoot(fs10) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs10 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -15989,8 +16079,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs8) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs8 });
+      newRoot(fs10) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs10 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -16309,8 +16399,8 @@ var init_processor = __esm({
       }
       // match, absolute, ifdir
       entries() {
-        return [...this.store.entries()].map(([path8, n]) => [
-          path8,
+        return [...this.store.entries()].map(([path9, n]) => [
+          path9,
           !!(n & 2),
           !!(n & 1)
         ]);
@@ -16523,9 +16613,9 @@ var init_walker = __esm({
       signal;
       maxDepth;
       includeChildMatches;
-      constructor(patterns, path8, opts) {
+      constructor(patterns, path9, opts) {
         this.patterns = patterns;
-        this.path = path8;
+        this.path = path9;
         this.opts = opts;
         this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
         this.includeChildMatches = opts.includeChildMatches !== false;
@@ -16544,11 +16634,11 @@ var init_walker = __esm({
           });
         }
       }
-      #ignored(path8) {
-        return this.seen.has(path8) || !!this.#ignore?.ignored?.(path8);
+      #ignored(path9) {
+        return this.seen.has(path9) || !!this.#ignore?.ignored?.(path9);
       }
-      #childrenIgnored(path8) {
-        return !!this.#ignore?.childrenIgnored?.(path8);
+      #childrenIgnored(path9) {
+        return !!this.#ignore?.childrenIgnored?.(path9);
       }
       // backpressure mechanism
       pause() {
@@ -16763,8 +16853,8 @@ var init_walker = __esm({
     };
     GlobWalker = class extends GlobUtil {
       matches = /* @__PURE__ */ new Set();
-      constructor(patterns, path8, opts) {
-        super(patterns, path8, opts);
+      constructor(patterns, path9, opts) {
+        super(patterns, path9, opts);
       }
       matchEmit(e) {
         this.matches.add(e);
@@ -16801,8 +16891,8 @@ var init_walker = __esm({
     };
     GlobStream = class extends GlobUtil {
       results;
-      constructor(patterns, path8, opts) {
-        super(patterns, path8, opts);
+      constructor(patterns, path9, opts) {
+        super(patterns, path9, opts);
         this.results = new Minipass({
           signal: this.signal,
           objectMode: true
@@ -17130,9 +17220,9 @@ 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 fs6 from "fs";
-import { promises as fsPromises } from "fs";
-import path6 from "path";
+import fs8 from "fs";
+import { promises as fsPromises2 } from "fs";
+import path7 from "path";
 function isSessionCancelled(sessionId) {
   return activeToolExecutions.get(sessionId)?.cancelled || false;
 }
@@ -17212,6 +17302,7 @@ var init_probeTool = __esm({
     "use strict";
     init_index();
     init_esm5();
+    init_symlink_utils();
     toolCallEmitter = new EventEmitter2();
     activeToolExecutions = /* @__PURE__ */ new Map();
     wrapToolWithEmitter = (tool4, toolName, baseExecute) => {
@@ -17298,17 +17389,17 @@ var init_probeTool = __esm({
       execute: async (params) => {
         const { directory = ".", workingDirectory } = params;
         const baseCwd = workingDirectory || process.cwd();
-        const secureBaseDir = path6.resolve(baseCwd);
+        const secureBaseDir = path7.resolve(baseCwd);
         const isDependencyPath = directory.startsWith("/dep/") || directory.startsWith("go:") || directory.startsWith("js:") || directory.startsWith("rust:");
         let targetDir;
-        if (path6.isAbsolute(directory)) {
-          targetDir = path6.resolve(directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + path6.sep) && targetDir !== secureBaseDir) {
+        if (path7.isAbsolute(directory)) {
+          targetDir = path7.resolve(directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + path7.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Cannot access directory outside workspace: ${directory}`);
           }
         } else {
-          targetDir = path6.resolve(secureBaseDir, directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + path6.sep) && targetDir !== secureBaseDir) {
+          targetDir = path7.resolve(secureBaseDir, directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + path7.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Access denied: ${directory}`);
           }
         }
@@ -17317,7 +17408,7 @@ var init_probeTool = __esm({
           console.log(`[DEBUG] Listing files in directory: ${targetDir}`);
         }
         try {
-          const files = await fsPromises.readdir(targetDir, { withFileTypes: true });
+          const files = await fsPromises2.readdir(targetDir, { withFileTypes: true });
           const formatSize = (size) => {
             if (size < 1024) return `${size}B`;
             if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)}K`;
@@ -17325,21 +17416,12 @@ var init_probeTool = __esm({
             return `${(size / (1024 * 1024 * 1024)).toFixed(1)}G`;
           };
           const entries = await Promise.all(files.map(async (file) => {
-            const isDirectory = file.isDirectory();
-            const fullPath = path6.join(targetDir, file.name);
-            let size = 0;
-            try {
-              const stats = await fsPromises.stat(fullPath);
-              size = stats.size;
-            } catch (statError) {
-              if (debug) {
-                console.log(`[DEBUG] Could not stat file ${file.name}:`, statError.message);
-              }
-            }
+            const fullPath = path7.join(targetDir, file.name);
+            const entryType = await getEntryType(file, fullPath);
             return {
               name: file.name,
-              isDirectory,
-              size
+              isDirectory: entryType.isDirectory,
+              size: entryType.size
             };
           }));
           entries.sort((a, b) => {
@@ -17371,17 +17453,17 @@ var init_probeTool = __esm({
           throw new Error("Pattern is required for file search");
         }
         const baseCwd = workingDirectory || process.cwd();
-        const secureBaseDir = path6.resolve(baseCwd);
+        const secureBaseDir = path7.resolve(baseCwd);
         const isDependencyPath = directory.startsWith("/dep/") || directory.startsWith("go:") || directory.startsWith("js:") || directory.startsWith("rust:");
         let targetDir;
-        if (path6.isAbsolute(directory)) {
-          targetDir = path6.resolve(directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + path6.sep) && targetDir !== secureBaseDir) {
+        if (path7.isAbsolute(directory)) {
+          targetDir = path7.resolve(directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + path7.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Cannot access directory outside workspace: ${directory}`);
           }
         } else {
-          targetDir = path6.resolve(secureBaseDir, directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + path6.sep) && targetDir !== secureBaseDir) {
+          targetDir = path7.resolve(secureBaseDir, directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + path7.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Access denied: ${directory}`);
           }
         }
@@ -19508,11 +19590,11 @@ var init_toKey = __esm({
 });
 
 // node_modules/lodash-es/_baseGet.js
-function baseGet(object, path8) {
-  path8 = castPath_default(path8, object);
-  var index = 0, length = path8.length;
+function baseGet(object, path9) {
+  path9 = castPath_default(path9, object);
+  var index = 0, length = path9.length;
   while (object != null && index < length) {
-    object = object[toKey_default(path8[index++])];
+    object = object[toKey_default(path9[index++])];
   }
   return index && index == length ? object : void 0;
 }
@@ -19526,8 +19608,8 @@ var init_baseGet = __esm({
 });
 
 // node_modules/lodash-es/get.js
-function get(object, path8, defaultValue) {
-  var result = object == null ? void 0 : baseGet_default(object, path8);
+function get(object, path9, defaultValue) {
+  var result = object == null ? void 0 : baseGet_default(object, path9);
   return result === void 0 ? defaultValue : result;
 }
 var get_default;
@@ -20890,11 +20972,11 @@ var init_baseHasIn = __esm({
 });
 
 // node_modules/lodash-es/_hasPath.js
-function hasPath(object, path8, hasFunc) {
-  path8 = castPath_default(path8, object);
-  var index = -1, length = path8.length, result = false;
+function hasPath(object, path9, hasFunc) {
+  path9 = castPath_default(path9, object);
+  var index = -1, length = path9.length, result = false;
   while (++index < length) {
-    var key = toKey_default(path8[index]);
+    var key = toKey_default(path9[index]);
     if (!(result = object != null && hasFunc(object, key))) {
       break;
     }
@@ -20920,8 +21002,8 @@ var init_hasPath = __esm({
 });
 
 // node_modules/lodash-es/hasIn.js
-function hasIn(object, path8) {
-  return object != null && hasPath_default(object, path8, baseHasIn_default);
+function hasIn(object, path9) {
+  return object != null && hasPath_default(object, path9, baseHasIn_default);
 }
 var hasIn_default;
 var init_hasIn = __esm({
@@ -20933,13 +21015,13 @@ var init_hasIn = __esm({
 });
 
 // node_modules/lodash-es/_baseMatchesProperty.js
-function baseMatchesProperty(path8, srcValue) {
-  if (isKey_default(path8) && isStrictComparable_default(srcValue)) {
-    return matchesStrictComparable_default(toKey_default(path8), srcValue);
+function baseMatchesProperty(path9, srcValue) {
+  if (isKey_default(path9) && isStrictComparable_default(srcValue)) {
+    return matchesStrictComparable_default(toKey_default(path9), srcValue);
   }
   return function(object) {
-    var objValue = get_default(object, path8);
-    return objValue === void 0 && objValue === srcValue ? hasIn_default(object, path8) : baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG6 | COMPARE_UNORDERED_FLAG4);
+    var objValue = get_default(object, path9);
+    return objValue === void 0 && objValue === srcValue ? hasIn_default(object, path9) : baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG6 | COMPARE_UNORDERED_FLAG4);
   };
 }
 var COMPARE_PARTIAL_FLAG6, COMPARE_UNORDERED_FLAG4, baseMatchesProperty_default;
@@ -20972,9 +21054,9 @@ var init_baseProperty = __esm({
 });
 
 // node_modules/lodash-es/_basePropertyDeep.js
-function basePropertyDeep(path8) {
+function basePropertyDeep(path9) {
   return function(object) {
-    return baseGet_default(object, path8);
+    return baseGet_default(object, path9);
   };
 }
 var basePropertyDeep_default;
@@ -20986,8 +21068,8 @@ var init_basePropertyDeep = __esm({
 });
 
 // node_modules/lodash-es/property.js
-function property(path8) {
-  return isKey_default(path8) ? baseProperty_default(toKey_default(path8)) : basePropertyDeep_default(path8);
+function property(path9) {
+  return isKey_default(path9) ? baseProperty_default(toKey_default(path9)) : basePropertyDeep_default(path9);
 }
 var property_default;
 var init_property = __esm({
@@ -21606,8 +21688,8 @@ var init_baseHas = __esm({
 });
 
 // node_modules/lodash-es/has.js
-function has(object, path8) {
-  return object != null && hasPath_default(object, path8, baseHas_default);
+function has(object, path9) {
+  return object != null && hasPath_default(object, path9, baseHas_default);
 }
 var has_default;
 var init_has = __esm({
@@ -21813,14 +21895,14 @@ var init_negate = __esm({
 });
 
 // node_modules/lodash-es/_baseSet.js
-function baseSet(object, path8, value, customizer) {
+function baseSet(object, path9, value, customizer) {
   if (!isObject_default(object)) {
     return object;
   }
-  path8 = castPath_default(path8, object);
-  var index = -1, length = path8.length, lastIndex = length - 1, nested = object;
+  path9 = castPath_default(path9, object);
+  var index = -1, length = path9.length, lastIndex = length - 1, nested = object;
   while (nested != null && ++index < length) {
-    var key = toKey_default(path8[index]), newValue = value;
+    var key = toKey_default(path9[index]), newValue = value;
     if (key === "__proto__" || key === "constructor" || key === "prototype") {
       return object;
     }
@@ -21828,7 +21910,7 @@ function baseSet(object, path8, value, customizer) {
       var objValue = nested[key];
       newValue = customizer ? customizer(objValue, key, nested) : void 0;
       if (newValue === void 0) {
-        newValue = isObject_default(objValue) ? objValue : isIndex_default(path8[index + 1]) ? [] : {};
+        newValue = isObject_default(objValue) ? objValue : isIndex_default(path9[index + 1]) ? [] : {};
       }
     }
     assignValue_default(nested, key, newValue);
@@ -21852,9 +21934,9 @@ var init_baseSet = __esm({
 function basePickBy(object, paths, predicate) {
   var index = -1, length = paths.length, result = {};
   while (++index < length) {
-    var path8 = paths[index], value = baseGet_default(object, path8);
-    if (predicate(value, path8)) {
-      baseSet_default(result, castPath_default(path8, object), value);
+    var path9 = paths[index], value = baseGet_default(object, path9);
+    if (predicate(value, path9)) {
+      baseSet_default(result, castPath_default(path9, object), value);
     }
   }
   return result;
@@ -21878,8 +21960,8 @@ function pickBy(object, predicate) {
     return [prop];
   });
   predicate = baseIteratee_default(predicate);
-  return basePickBy_default(object, props, function(value, path8) {
-    return predicate(value, path8[0]);
+  return basePickBy_default(object, props, function(value, path9) {
+    return predicate(value, path9[0]);
   });
 }
 var pickBy_default;
@@ -24592,12 +24674,12 @@ function assignCategoriesMapProp(tokenTypes) {
     singleAssignCategoriesToksMap([], currTokType);
   });
 }
-function singleAssignCategoriesToksMap(path8, nextNode) {
-  forEach_default(path8, (pathNode) => {
+function singleAssignCategoriesToksMap(path9, nextNode) {
+  forEach_default(path9, (pathNode) => {
     nextNode.categoryMatchesMap[pathNode.tokenTypeIdx] = true;
   });
   forEach_default(nextNode.CATEGORIES, (nextCategory) => {
-    const newPath = path8.concat(nextNode);
+    const newPath = path9.concat(nextNode);
     if (!includes_default(newPath, nextCategory)) {
       singleAssignCategoriesToksMap(newPath, nextCategory);
     }
@@ -25767,10 +25849,10 @@ var init_interpreter = __esm({
     init_rest();
     init_api2();
     AbstractNextPossibleTokensWalker = class extends RestWalker {
-      constructor(topProd, path8) {
+      constructor(topProd, path9) {
         super();
         this.topProd = topProd;
-        this.path = path8;
+        this.path = path9;
         this.possibleTokTypes = [];
         this.nextProductionName = "";
         this.nextProductionOccurrence = 0;
@@ -25814,9 +25896,9 @@ var init_interpreter = __esm({
       }
     };
     NextAfterTokenWalker = class extends AbstractNextPossibleTokensWalker {
-      constructor(topProd, path8) {
-        super(topProd, path8);
-        this.path = path8;
+      constructor(topProd, path9) {
+        super(topProd, path9);
+        this.path = path9;
         this.nextTerminalName = "";
         this.nextTerminalOccurrence = 0;
         this.nextTerminalName = this.path.lastTok.name;
@@ -26057,10 +26139,10 @@ function initializeArrayOfArrays(size) {
   }
   return result;
 }
-function pathToHashKeys(path8) {
+function pathToHashKeys(path9) {
   let keys2 = [""];
-  for (let i = 0; i < path8.length; i++) {
-    const tokType = path8[i];
+  for (let i = 0; i < path9.length; i++) {
+    const tokType = path9[i];
     const longerKeys = [];
     for (let j = 0; j < keys2.length; j++) {
       const currShorterKey = keys2[j];
@@ -26363,7 +26445,7 @@ function validateRuleIsOverridden(ruleName, definedRulesNames, className) {
   }
   return errors;
 }
-function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path8 = []) {
+function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path9 = []) {
   const errors = [];
   const nextNonTerminals = getFirstNoneTerminal(currRule.definition);
   if (isEmpty_default(nextNonTerminals)) {
@@ -26375,15 +26457,15 @@ function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path8 = [])
       errors.push({
         message: errMsgProvider.buildLeftRecursionError({
           topLevelRule: topRule,
-          leftRecursionPath: path8
+          leftRecursionPath: path9
         }),
         type: ParserDefinitionErrorType.LEFT_RECURSION,
         ruleName
       });
     }
-    const validNextSteps = difference_default(nextNonTerminals, path8.concat([topRule]));
+    const validNextSteps = difference_default(nextNonTerminals, path9.concat([topRule]));
     const errorsFromNextSteps = flatMap_default(validNextSteps, (currRefRule) => {
-      const newPath = clone_default(path8);
+      const newPath = clone_default(path9);
       newPath.push(currRefRule);
       return validateNoLeftRecursion(topRule, currRefRule, errMsgProvider, newPath);
     });
@@ -31858,7 +31940,7 @@ 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")) {
+            if (e && (e.code === "FL-LABEL-PARENS-UNQUOTED" || e.code === "FL-LABEL-AT-IN-UNQUOTED" || e.code === "FL-LABEL-QUOTE-IN-UNQUOTED")) {
               const ln = e.line ?? 0;
               const col = e.column ?? 1;
               const list = byLine.get(ln) || [];
@@ -31939,6 +32021,8 @@ function validateFlowchart(text, options = {}) {
                 const covered = existing.some((r) => !(endCol < r.start || startCol > r.end));
                 const hasParens = seg.includes("(") || seg.includes(")");
                 const hasAt = seg.includes("@");
+                const hasQuote = seg.includes('"');
+                const isSingleQuoted = /^'[^]*'$/.test(trimmed);
                 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 });
@@ -31949,6 +32033,11 @@ function validateFlowchart(text, options = {}) {
                   existing.push({ start: startCol, end: endCol });
                   byLine.set(ln, existing);
                 }
+                if (!covered && !isQuoted && !isSlashPair && hasQuote && !isSingleQuoted) {
+                  errs.push({ line: ln, column: startCol, severity: "error", code: "FL-LABEL-QUOTE-IN-UNQUOTED", message: "Quotes are not allowed inside unquoted node labels. Use &quot; for quotes or wrap the entire label in quotes.", hint: 'Example: C["HTML Output: data-trigger-visibility=&quot;true&quot;"]' });
+                  existing.push({ start: startCol, end: endCol });
+                  byLine.set(ln, existing);
+                }
                 i = j;
                 continue;
               } else {
@@ -38980,11 +39069,11 @@ var require_baseGet = __commonJS({
   "node_modules/lodash/_baseGet.js"(exports2, module2) {
     var castPath2 = require_castPath();
     var toKey2 = require_toKey();
-    function baseGet2(object, path8) {
-      path8 = castPath2(path8, object);
-      var index = 0, length = path8.length;
+    function baseGet2(object, path9) {
+      path9 = castPath2(path9, object);
+      var index = 0, length = path9.length;
       while (object != null && index < length) {
-        object = object[toKey2(path8[index++])];
+        object = object[toKey2(path9[index++])];
       }
       return index && index == length ? object : void 0;
     }
@@ -38996,8 +39085,8 @@ var require_baseGet = __commonJS({
 var require_get = __commonJS({
   "node_modules/lodash/get.js"(exports2, module2) {
     var baseGet2 = require_baseGet();
-    function get2(object, path8, defaultValue) {
-      var result = object == null ? void 0 : baseGet2(object, path8);
+    function get2(object, path9, defaultValue) {
+      var result = object == null ? void 0 : baseGet2(object, path9);
       return result === void 0 ? defaultValue : result;
     }
     module2.exports = get2;
@@ -39023,11 +39112,11 @@ var require_hasPath = __commonJS({
     var isIndex2 = require_isIndex();
     var isLength2 = require_isLength();
     var toKey2 = require_toKey();
-    function hasPath2(object, path8, hasFunc) {
-      path8 = castPath2(path8, object);
-      var index = -1, length = path8.length, result = false;
+    function hasPath2(object, path9, hasFunc) {
+      path9 = castPath2(path9, object);
+      var index = -1, length = path9.length, result = false;
       while (++index < length) {
-        var key = toKey2(path8[index]);
+        var key = toKey2(path9[index]);
         if (!(result = object != null && hasFunc(object, key))) {
           break;
         }
@@ -39048,8 +39137,8 @@ var require_hasIn = __commonJS({
   "node_modules/lodash/hasIn.js"(exports2, module2) {
     var baseHasIn2 = require_baseHasIn();
     var hasPath2 = require_hasPath();
-    function hasIn2(object, path8) {
-      return object != null && hasPath2(object, path8, baseHasIn2);
+    function hasIn2(object, path9) {
+      return object != null && hasPath2(object, path9, baseHasIn2);
     }
     module2.exports = hasIn2;
   }
@@ -39067,13 +39156,13 @@ var require_baseMatchesProperty = __commonJS({
     var toKey2 = require_toKey();
     var COMPARE_PARTIAL_FLAG7 = 1;
     var COMPARE_UNORDERED_FLAG5 = 2;
-    function baseMatchesProperty2(path8, srcValue) {
-      if (isKey2(path8) && isStrictComparable2(srcValue)) {
-        return matchesStrictComparable2(toKey2(path8), srcValue);
+    function baseMatchesProperty2(path9, srcValue) {
+      if (isKey2(path9) && isStrictComparable2(srcValue)) {
+        return matchesStrictComparable2(toKey2(path9), srcValue);
       }
       return function(object) {
-        var objValue = get2(object, path8);
-        return objValue === void 0 && objValue === srcValue ? hasIn2(object, path8) : baseIsEqual2(srcValue, objValue, COMPARE_PARTIAL_FLAG7 | COMPARE_UNORDERED_FLAG5);
+        var objValue = get2(object, path9);
+        return objValue === void 0 && objValue === srcValue ? hasIn2(object, path9) : baseIsEqual2(srcValue, objValue, COMPARE_PARTIAL_FLAG7 | COMPARE_UNORDERED_FLAG5);
       };
     }
     module2.exports = baseMatchesProperty2;
@@ -39096,9 +39185,9 @@ var require_baseProperty = __commonJS({
 var require_basePropertyDeep = __commonJS({
   "node_modules/lodash/_basePropertyDeep.js"(exports2, module2) {
     var baseGet2 = require_baseGet();
-    function basePropertyDeep2(path8) {
+    function basePropertyDeep2(path9) {
       return function(object) {
-        return baseGet2(object, path8);
+        return baseGet2(object, path9);
       };
     }
     module2.exports = basePropertyDeep2;
@@ -39112,8 +39201,8 @@ var require_property = __commonJS({
     var basePropertyDeep2 = require_basePropertyDeep();
     var isKey2 = require_isKey();
     var toKey2 = require_toKey();
-    function property2(path8) {
-      return isKey2(path8) ? baseProperty2(toKey2(path8)) : basePropertyDeep2(path8);
+    function property2(path9) {
+      return isKey2(path9) ? baseProperty2(toKey2(path9)) : basePropertyDeep2(path9);
     }
     module2.exports = property2;
   }
@@ -39175,8 +39264,8 @@ var require_has = __commonJS({
   "node_modules/lodash/has.js"(exports2, module2) {
     var baseHas2 = require_baseHas();
     var hasPath2 = require_hasPath();
-    function has2(object, path8) {
-      return object != null && hasPath2(object, path8, baseHas2);
+    function has2(object, path9) {
+      return object != null && hasPath2(object, path9, baseHas2);
     }
     module2.exports = has2;
   }
@@ -41450,14 +41539,14 @@ var require_baseSet = __commonJS({
     var isIndex2 = require_isIndex();
     var isObject2 = require_isObject();
     var toKey2 = require_toKey();
-    function baseSet2(object, path8, value, customizer) {
+    function baseSet2(object, path9, value, customizer) {
       if (!isObject2(object)) {
         return object;
       }
-      path8 = castPath2(path8, object);
-      var index = -1, length = path8.length, lastIndex = length - 1, nested = object;
+      path9 = castPath2(path9, object);
+      var index = -1, length = path9.length, lastIndex = length - 1, nested = object;
       while (nested != null && ++index < length) {
-        var key = toKey2(path8[index]), newValue = value;
+        var key = toKey2(path9[index]), newValue = value;
         if (key === "__proto__" || key === "constructor" || key === "prototype") {
           return object;
         }
@@ -41465,7 +41554,7 @@ var require_baseSet = __commonJS({
           var objValue = nested[key];
           newValue = customizer ? customizer(objValue, key, nested) : void 0;
           if (newValue === void 0) {
-            newValue = isObject2(objValue) ? objValue : isIndex2(path8[index + 1]) ? [] : {};
+            newValue = isObject2(objValue) ? objValue : isIndex2(path9[index + 1]) ? [] : {};
           }
         }
         assignValue2(nested, key, newValue);
@@ -41486,9 +41575,9 @@ var require_basePickBy = __commonJS({
     function basePickBy2(object, paths, predicate) {
       var index = -1, length = paths.length, result = {};
       while (++index < length) {
-        var path8 = paths[index], value = baseGet2(object, path8);
-        if (predicate(value, path8)) {
-          baseSet2(result, castPath2(path8, object), value);
+        var path9 = paths[index], value = baseGet2(object, path9);
+        if (predicate(value, path9)) {
+          baseSet2(result, castPath2(path9, object), value);
         }
       }
       return result;
@@ -41503,8 +41592,8 @@ var require_basePick = __commonJS({
     var basePickBy2 = require_basePickBy();
     var hasIn2 = require_hasIn();
     function basePick(object, paths) {
-      return basePickBy2(object, paths, function(value, path8) {
-        return hasIn2(object, path8);
+      return basePickBy2(object, paths, function(value, path9) {
+        return hasIn2(object, path9);
       });
     }
     module2.exports = basePick;
@@ -42558,15 +42647,15 @@ var require_parent_dummy_chains = __commonJS({
         var node = g.node(v);
         var edgeObj = node.edgeObj;
         var pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
-        var path8 = pathData.path;
+        var path9 = pathData.path;
         var lca = pathData.lca;
         var pathIdx = 0;
-        var pathV = path8[pathIdx];
+        var pathV = path9[pathIdx];
         var ascending = true;
         while (v !== edgeObj.w) {
           node = g.node(v);
           if (ascending) {
-            while ((pathV = path8[pathIdx]) !== lca && g.node(pathV).maxRank < node.rank) {
+            while ((pathV = path9[pathIdx]) !== lca && g.node(pathV).maxRank < node.rank) {
               pathIdx++;
             }
             if (pathV === lca) {
@@ -42574,10 +42663,10 @@ var require_parent_dummy_chains = __commonJS({
             }
           }
           if (!ascending) {
-            while (pathIdx < path8.length - 1 && g.node(pathV = path8[pathIdx + 1]).minRank <= node.rank) {
+            while (pathIdx < path9.length - 1 && g.node(pathV = path9[pathIdx + 1]).minRank <= node.rank) {
               pathIdx++;
             }
-            pathV = path8[pathIdx];
+            pathV = path9[pathIdx];
           }
           g.setParent(v, pathV);
           v = g.successors(v)[0];
@@ -44750,8 +44839,8 @@ var init_svg_generator = __esm({
           elements.push(this.generateNodeWithPad(node, padX, padY));
         }
         for (const edge of layout.edges) {
-          const { path: path8, overlay } = this.generateEdge(edge, padX, padY, nodeMap);
-          elements.push(path8);
+          const { path: path9, overlay } = this.generateEdge(edge, padX, padY, nodeMap);
+          elements.push(path9);
           if (overlay)
             overlays.push(overlay);
         }
@@ -51067,8 +51156,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path8) {
-      let input = path8;
+    function removeDotSegments(path9) {
+      let input = path9;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -51267,8 +51356,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path8, query2] = wsComponent.resourceName.split("?");
-        wsComponent.path = path8 && path8 !== "/" ? path8 : void 0;
+        const [path9, query2] = wsComponent.resourceName.split("?");
+        wsComponent.path = path9 && path9 !== "/" ? path9 : void 0;
         wsComponent.query = query2;
         wsComponent.resourceName = void 0;
       }
@@ -54611,7 +54700,7 @@ function validateJsonResponse(response, options = {}) {
       }
       if (!valid) {
         const formattedErrors = validate2.errors.map((err) => {
-          const path8 = err.instancePath ? err.instancePath.substring(1).replace(/\//g, ".") : "<root>";
+          const path9 = err.instancePath ? err.instancePath.substring(1).replace(/\//g, ".") : "<root>";
           let message = "";
           let suggestion = "";
           if (err.keyword === "additionalProperties") {
@@ -54649,7 +54738,7 @@ function validateJsonResponse(response, options = {}) {
             message = err.message;
             suggestion = "";
           }
-          const location = path8 ? `at '${path8}'` : "at root";
+          const location = path9 ? `at '${path9}'` : "at root";
           return suggestion ? `${location}: ${message} \u2192 ${suggestion}` : `${location}: ${message}`;
         });
         const errorSummary = formattedErrors.join("\n  ");
@@ -54972,7 +55061,7 @@ function extractMermaidFromJson(response) {
   }
   const diagrams = [];
   const jsonPaths = [];
-  function searchObject(obj, path8 = []) {
+  function searchObject(obj, path9 = []) {
     if (typeof obj === "string") {
       const mermaidPattern = /```mermaid([^\n`]*?)(?:\n|\\n)([\s\S]*?)```/gi;
       let match2;
@@ -54986,14 +55075,14 @@ function extractMermaidFromJson(response) {
           endIndex: match2.index + match2[0].length,
           attributes,
           isInJson: true,
-          jsonPath: path8.join(".")
+          jsonPath: path9.join(".")
         });
-        jsonPaths.push(path8.join("."));
+        jsonPaths.push(path9.join("."));
       }
     } else if (Array.isArray(obj)) {
-      obj.forEach((item, index) => searchObject(item, [...path8, `[${index}]`]));
+      obj.forEach((item, index) => searchObject(item, [...path9, `[${index}]`]));
     } else if (obj && typeof obj === "object") {
-      Object.entries(obj).forEach(([key, value]) => searchObject(value, [...path8, key]));
+      Object.entries(obj).forEach(([key, value]) => searchObject(value, [...path9, key]));
     }
   }
   searchObject(parsedJson);
@@ -55250,7 +55339,7 @@ async function tryMaidAutoFix(diagramContent, options = {}) {
   }
 }
 async function validateAndFixMermaidResponse(response, options = {}) {
-  const { schema, debug, path: path8, provider, model, tracer } = options;
+  const { schema, debug, path: path9, provider, model, tracer } = options;
   const startTime = Date.now();
   if (debug) {
     console.log(`[DEBUG] Mermaid validation: Starting maid-based validation for response (${response.length} chars)`);
@@ -55407,7 +55496,7 @@ ${maidResult.fixed}
     }
     const aiFixingStart = Date.now();
     const mermaidFixer = new MermaidFixingAgent({
-      path: path8,
+      path: path9,
       provider,
       model,
       debug,
@@ -55649,8 +55738,8 @@ Schema Validation Errors:
 ${validationResult.errorSummary}`;
         } else if (validationResult.schemaErrors && validationResult.schemaErrors.length > 0) {
           const errors = validationResult.schemaErrors.map((err) => {
-            const path8 = err.instancePath || "(root)";
-            return `  ${path8}: ${err.message}`;
+            const path9 = err.instancePath || "(root)";
+            return `  ${path9}: ${err.message}`;
           }).join("\n");
           schemaErrorDetails = `
 
@@ -58258,8 +58347,8 @@ __export(enhanced_claude_code_exports, {
 });
 import { spawn as spawn3 } from "child_process";
 import { randomBytes } from "crypto";
-import fs7 from "fs/promises";
-import path7 from "path";
+import fs9 from "fs/promises";
+import path8 from "path";
 import os3 from "os";
 import { EventEmitter as EventEmitter4 } from "events";
 async function createEnhancedClaudeCLIEngine(options = {}) {
@@ -58282,12 +58371,12 @@ async function createEnhancedClaudeCLIEngine(options = {}) {
       console.log("[DEBUG] Built-in MCP server started");
       console.log("[DEBUG] MCP URL:", `http://${host}:${port}/mcp`);
     }
-    mcpConfigPath = path7.join(os3.tmpdir(), `probe-mcp-${session.id}.json`);
+    mcpConfigPath = path8.join(os3.tmpdir(), `probe-mcp-${session.id}.json`);
     const mcpConfig = {
       mcpServers: {
         probe: {
           command: "node",
-          args: [path7.join(process.cwd(), "mcp-probe-server.js")],
+          args: [path8.join(process.cwd(), "mcp-probe-server.js")],
           env: {
             PROBE_WORKSPACE: process.cwd(),
             DEBUG: debug ? "true" : "false"
@@ -58295,7 +58384,7 @@ async function createEnhancedClaudeCLIEngine(options = {}) {
         }
       }
     };
-    await fs7.writeFile(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+    await fs9.writeFile(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
   }
   if (debug) {
     console.log("[DEBUG] Enhanced Claude Code Engine");
@@ -58489,7 +58578,7 @@ ${opts.schema}`;
           }
         }
         if (mcpConfigPath) {
-          await fs7.unlink(mcpConfigPath).catch(() => {
+          await fs9.unlink(mcpConfigPath).catch(() => {
           });
           if (debug) {
             console.log("[DEBUG] MCP config file removed");
@@ -59064,6 +59153,7 @@ var init_ProbeAgent = __esm({
        * @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.cwd] - Working directory for resolving relative paths (independent of allowedFolders)
        * @param {string} [options.provider] - Force specific AI provider
        * @param {string} [options.model] - Override model name
        * @param {boolean} [options.debug] - Enable debug mode
@@ -59092,6 +59182,7 @@ var init_ProbeAgent = __esm({
        * @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
+       * @param {string} [options.completionPrompt] - Custom prompt to run after attempt_completion for validation/review (runs before mermaid/JSON validation)
        */
       constructor(options = {}) {
         this.sessionId = options.sessionId || randomUUID5();
@@ -59113,6 +59204,7 @@ var init_ProbeAgent = __esm({
         this.maxIterations = options.maxIterations || null;
         this.disableMermaidValidation = !!options.disableMermaidValidation;
         this.disableJsonValidation = !!options.disableJsonValidation;
+        this.completionPrompt = options.completionPrompt || null;
         const effectiveAllowedTools = options.disableTools ? [] : options.allowedTools;
         this.allowedTools = this._parseAllowedTools(effectiveAllowedTools);
         this.storageAdapter = options.storageAdapter || new InMemoryStorageAdapter();
@@ -59131,6 +59223,7 @@ var init_ProbeAgent = __esm({
         } else {
           this.allowedFolders = [process.cwd()];
         }
+        this.cwd = options.cwd || null;
         this.clientApiProvider = options.provider || null;
         this.clientApiModel = options.model || null;
         this.clientApiKey = null;
@@ -59309,7 +59402,8 @@ var init_ProbeAgent = __esm({
         const configOptions = {
           sessionId: this.sessionId,
           debug: this.debug,
-          defaultPath: this.allowedFolders.length > 0 ? this.allowedFolders[0] : process.cwd(),
+          // Use explicit cwd if set, otherwise fall back to first allowed folder
+          cwd: this.cwd || (this.allowedFolders.length > 0 ? this.allowedFolders[0] : process.cwd()),
           allowedFolders: this.allowedFolders,
           outline: this.outline,
           allowEdit: this.allowEdit,
@@ -61160,6 +61254,46 @@ IMPORTANT: When using <attempt_complete>, this must be the ONLY content in your
           } catch (error) {
             console.error(`[ERROR] Failed to save messages to storage:`, error);
           }
+          if (completionAttempted && this.completionPrompt && !options._completionPromptProcessed) {
+            if (this.debug) {
+              console.log("[DEBUG] Running completion prompt for post-completion validation/review...");
+            }
+            try {
+              if (this.tracer) {
+                this.tracer.recordEvent("completion_prompt.started", {
+                  "completion_prompt.original_result_length": finalResult?.length || 0
+                });
+              }
+              const completionPromptMessage = `${this.completionPrompt}
+
+Here is the result to review:
+<result>
+${finalResult}
+</result>
+
+After reviewing, provide your final answer using attempt_completion.`;
+              const completionResult = await this.answer(completionPromptMessage, [], {
+                ...options,
+                _completionPromptProcessed: true
+              });
+              finalResult = completionResult;
+              if (this.debug) {
+                console.log(`[DEBUG] Completion prompt finished. New result length: ${finalResult?.length || 0}`);
+              }
+              if (this.tracer) {
+                this.tracer.recordEvent("completion_prompt.completed", {
+                  "completion_prompt.final_result_length": finalResult?.length || 0
+                });
+              }
+            } catch (error) {
+              console.error("[ERROR] Completion prompt failed:", error);
+              if (this.tracer) {
+                this.tracer.recordEvent("completion_prompt.error", {
+                  "completion_prompt.error": error.message
+                });
+              }
+            }
+          }
           const reachedMaxIterations = currentIteration >= maxIterations && !completionAttempted;
           if (options.schema && !options._schemaFormatted && !completionAttempted && !reachedMaxIterations) {
             if (this.debug) {
@@ -61626,6 +61760,8 @@ Convert your previous response content into actual JSON data that follows this s
           path: this.allowedFolders[0],
           // Use first allowed folder as primary path
           allowedFolders: [...this.allowedFolders],
+          cwd: this.cwd,
+          // Preserve explicit working directory
           provider: this.clientApiProvider,
           model: this.clientApiModel,
           debug: this.debug,
@@ -61634,6 +61770,7 @@ Convert your previous response content into actual JSON data that follows this s
           maxIterations: this.maxIterations,
           disableMermaidValidation: this.disableMermaidValidation,
           disableJsonValidation: this.disableJsonValidation,
+          completionPrompt: this.completionPrompt,
           allowedTools: allowedToolsArray,
           enableMcp: !!this.mcpBridge,
           mcpConfig: this.mcpConfig,