@probelabs/probe 0.6.0-rc173 → 0.6.0-rc175

package/cjs/agent/ProbeAgent.cjs

@@ -104,8 +104,8 @@ var require_package = __commonJS({
 // node_modules/dotenv/lib/main.js
 var require_main = __commonJS({
   "node_modules/dotenv/lib/main.js"(exports2, module2) {
-    var fs8 = require("fs");
-    var path8 = require("path");
+    var fs10 = require("fs");
+    var path9 = require("path");
     var os4 = require("os");
     var crypto2 = require("crypto");
     var packageJson = require_package();
@@ -213,7 +213,7 @@ var require_main = __commonJS({
       if (options && options.path && options.path.length > 0) {
         if (Array.isArray(options.path)) {
           for (const filepath of options.path) {
-            if (fs8.existsSync(filepath)) {
+            if (fs10.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -221,15 +221,15 @@ var require_main = __commonJS({
           possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
         }
       } else {
-        possibleVaultPath = path8.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path9.resolve(process.cwd(), ".env.vault");
       }
-      if (fs8.existsSync(possibleVaultPath)) {
+      if (fs10.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path8.join(os4.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path9.join(os4.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = Boolean(options && options.debug);
@@ -246,7 +246,7 @@ var require_main = __commonJS({
       return { parsed };
     }
     function configDotenv(options) {
-      const dotenvPath = path8.resolve(process.cwd(), ".env");
+      const dotenvPath = path9.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       const debug = Boolean(options && options.debug);
       const quiet = options && "quiet" in options ? options.quiet : true;
@@ -270,13 +270,13 @@ var require_main = __commonJS({
       }
       let lastError;
       const parsedAll = {};
-      for (const path9 of optionPaths) {
+      for (const path10 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs8.readFileSync(path9, { encoding }));
+          const parsed = DotenvModule.parse(fs10.readFileSync(path10, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e4) {
           if (debug) {
-            _debug(`Failed to load ${path9} ${e4.message}`);
+            _debug(`Failed to load ${path10} ${e4.message}`);
           }
           lastError = e4;
         }
@@ -291,7 +291,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative = path8.relative(process.cwd(), filePath);
+            const relative = path9.relative(process.cwd(), filePath);
             shortPaths.push(relative);
           } catch (e4) {
             if (debug) {
@@ -1684,9 +1684,9 @@ var init_createPaginator = __esm({
       command = withCommand(command) ?? command;
       return await client.send(command, ...args);
     };
-    get = (fromObject, path8) => {
+    get = (fromObject, path9) => {
       let cursor2 = fromObject;
-      const pathComponents = path8.split(".");
+      const pathComponents = path9.split(".");
       for (const step of pathComponents) {
         if (!cursor2 || typeof cursor2 !== "object") {
           return void 0;
@@ -2649,12 +2649,12 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             const password = request.password ?? "";
             auth = `${username}:${password}`;
           }
-          let path8 = request.path;
+          let path9 = request.path;
           if (queryString) {
-            path8 += `?${queryString}`;
+            path9 += `?${queryString}`;
           }
           if (request.fragment) {
-            path8 += `#${request.fragment}`;
+            path9 += `#${request.fragment}`;
           }
           let hostname = request.hostname ?? "";
           if (hostname[0] === "[" && hostname.endsWith("]")) {
@@ -2666,7 +2666,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             headers: request.headers,
             host: hostname,
             method: request.method,
-            path: path8,
+            path: path9,
             port: request.port,
             agent,
             auth
@@ -2921,16 +2921,16 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             reject2(err);
           };
           const queryString = querystringBuilder.buildQueryString(query2 || {});
-          let path8 = request.path;
+          let path9 = request.path;
           if (queryString) {
-            path8 += `?${queryString}`;
+            path9 += `?${queryString}`;
           }
           if (request.fragment) {
-            path8 += `#${request.fragment}`;
+            path9 += `#${request.fragment}`;
           }
           const req = session.request({
             ...request.headers,
-            [http2.constants.HTTP2_HEADER_PATH]: path8,
+            [http2.constants.HTTP2_HEADER_PATH]: path9,
             [http2.constants.HTTP2_HEADER_METHOD]: method
           });
           session.ref();
@@ -3119,13 +3119,13 @@ var require_dist_cjs16 = __commonJS({
           abortError.name = "AbortError";
           return Promise.reject(abortError);
         }
-        let path8 = request.path;
+        let path9 = request.path;
         const queryString = querystringBuilder.buildQueryString(request.query || {});
         if (queryString) {
-          path8 += `?${queryString}`;
+          path9 += `?${queryString}`;
         }
         if (request.fragment) {
-          path8 += `#${request.fragment}`;
+          path9 += `#${request.fragment}`;
         }
         let auth = "";
         if (request.username != null || request.password != null) {
@@ -3134,7 +3134,7 @@ var require_dist_cjs16 = __commonJS({
           auth = `${username}:${password}@`;
         }
         const { port, method } = request;
-        const url = `${request.protocol}//${auth}${request.hostname}${port ? `:${port}` : ""}${path8}`;
+        const url = `${request.protocol}//${auth}${request.hostname}${port ? `:${port}` : ""}${path9}`;
         const body = method === "GET" || method === "HEAD" ? void 0 : request.body;
         const requestOptions = {
           body,
@@ -5196,13 +5196,13 @@ function __disposeResources(env) {
   }
   return next();
 }
-function __rewriteRelativeImportExtension(path8, preserveJsx) {
-  if (typeof path8 === "string" && /^\.\.?\//.test(path8)) {
-    return path8.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m4, tsx, d4, ext2, cm) {
+function __rewriteRelativeImportExtension(path9, preserveJsx) {
+  if (typeof path9 === "string" && /^\.\.?\//.test(path9)) {
+    return path9.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m4, tsx, d4, ext2, cm) {
       return tsx ? preserveJsx ? ".jsx" : ".js" : d4 && (!ext2 || !cm) ? m4 : d4 + ext2 + "." + cm.toLowerCase() + "js";
     });
   }
-  return path8;
+  return path9;
 }
 var extendStatics, __assign, __createBinding, __setModuleDefault, ownKeys, _SuppressedError, tslib_es6_default;
 var init_tslib_es6 = __esm({
@@ -6075,11 +6075,11 @@ var init_HttpBindingProtocol = __esm({
           const opTraits = translateTraits(operationSchema.traits);
           if (opTraits.http) {
             request.method = opTraits.http[0];
-            const [path8, search2] = opTraits.http[1].split("?");
+            const [path9, search2] = opTraits.http[1].split("?");
             if (request.path == "/") {
-              request.path = path8;
+              request.path = path9;
             } else {
-              request.path += path8;
+              request.path += path9;
             }
             const traitSearchParams = new URLSearchParams(search2 ?? "");
             Object.assign(query2, Object.fromEntries(traitSearchParams));
@@ -6457,8 +6457,8 @@ var init_requestBuilder = __esm({
         return this;
       }
       p(memberName, labelValueProvider, uriLabel, isGreedyLabel) {
-        this.resolvePathStack.push((path8) => {
-          this.path = resolvedPath(path8, this.input, memberName, labelValueProvider, uriLabel, isGreedyLabel);
+        this.resolvePathStack.push((path9) => {
+          this.path = resolvedPath(path9, this.input, memberName, labelValueProvider, uriLabel, isGreedyLabel);
         });
         return this;
       }
@@ -7108,18 +7108,18 @@ var require_dist_cjs20 = __commonJS({
       }
     };
     var booleanEquals = (value1, value2) => value1 === value2;
-    var getAttrPathList = (path8) => {
-      const parts = path8.split(".");
+    var getAttrPathList = (path9) => {
+      const parts = path9.split(".");
       const pathList = [];
       for (const part of parts) {
         const squareBracketIndex = part.indexOf("[");
         if (squareBracketIndex !== -1) {
           if (part.indexOf("]") !== part.length - 1) {
-            throw new EndpointError(`Path: '${path8}' does not end with ']'`);
+            throw new EndpointError(`Path: '${path9}' does not end with ']'`);
           }
           const arrayIndex = part.slice(squareBracketIndex + 1, -1);
           if (Number.isNaN(parseInt(arrayIndex))) {
-            throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path8}'`);
+            throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path9}'`);
           }
           if (squareBracketIndex !== 0) {
             pathList.push(part.slice(0, squareBracketIndex));
@@ -7131,9 +7131,9 @@ var require_dist_cjs20 = __commonJS({
       }
       return pathList;
     };
-    var getAttr = (value, path8) => getAttrPathList(path8).reduce((acc, index) => {
+    var getAttr = (value, path9) => getAttrPathList(path9).reduce((acc, index) => {
       if (typeof acc !== "object") {
-        throw new EndpointError(`Index '${index}' in '${path8}' not found in '${JSON.stringify(value)}'`);
+        throw new EndpointError(`Index '${index}' in '${path9}' not found in '${JSON.stringify(value)}'`);
       } else if (Array.isArray(acc)) {
         return acc[parseInt(index)];
       }
@@ -7152,8 +7152,8 @@ var require_dist_cjs20 = __commonJS({
             return value;
           }
           if (typeof value === "object" && "hostname" in value) {
-            const { hostname: hostname2, port, protocol: protocol2 = "", path: path8 = "", query: query2 = {} } = value;
-            const url = new URL(`${protocol2}//${hostname2}${port ? `:${port}` : ""}${path8}`);
+            const { hostname: hostname2, port, protocol: protocol2 = "", path: path9 = "", query: query2 = {} } = value;
+            const url = new URL(`${protocol2}//${hostname2}${port ? `:${port}` : ""}${path9}`);
             url.search = Object.entries(query2).map(([k4, v4]) => `${k4}=${v4}`).join("&");
             return url;
           }
@@ -8668,10 +8668,10 @@ ${longDate}
 ${credentialScope}
 ${utilHexEncoding.toHex(hashedRequest)}`;
       }
-      getCanonicalPath({ path: path8 }) {
+      getCanonicalPath({ path: path9 }) {
         if (this.uriEscapePath) {
           const normalizedPathSegments = [];
-          for (const pathSegment of path8.split("/")) {
+          for (const pathSegment of path9.split("/")) {
             if (pathSegment?.length === 0)
               continue;
             if (pathSegment === ".")
@@ -8682,11 +8682,11 @@ ${utilHexEncoding.toHex(hashedRequest)}`;
               normalizedPathSegments.push(pathSegment);
             }
           }
-          const normalizedPath = `${path8?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path8?.endsWith("/") ? "/" : ""}`;
+          const normalizedPath = `${path9?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path9?.endsWith("/") ? "/" : ""}`;
           const doubleEncoded = utilUriEscape.escapeUri(normalizedPath);
           return doubleEncoded.replace(/%2F/g, "/");
         }
-        return path8;
+        return path9;
       }
       validateResolvedCredentials(credentials) {
         if (typeof credentials !== "object" || typeof credentials.accessKeyId !== "string" || typeof credentials.secretAccessKey !== "string") {
@@ -9947,11 +9947,11 @@ var init_SmithyRpcV2CborProtocol = __esm({
           }
         }
         const { service, operation: operation2 } = (0, import_util_middleware5.getSmithyContext)(context);
-        const path8 = `/service/${service}/operation/${operation2}`;
+        const path9 = `/service/${service}/operation/${operation2}`;
         if (request.path.endsWith("/")) {
-          request.path += path8.slice(1);
+          request.path += path9.slice(1);
         } else {
-          request.path += path8;
+          request.path += path9;
         }
         return request;
       }
@@ -14867,15 +14867,15 @@ var require_dist_cjs34 = __commonJS({
     var querystringBuilder = require_dist_cjs14();
     function formatUrl(request) {
       const { port, query: query2 } = request;
-      let { protocol, path: path8, hostname } = request;
+      let { protocol, path: path9, hostname } = request;
       if (protocol && protocol.slice(-1) !== ":") {
         protocol += ":";
       }
       if (port) {
         hostname += `:${port}`;
       }
-      if (path8 && path8.charAt(0) !== "/") {
-        path8 = `/${path8}`;
+      if (path9 && path9.charAt(0) !== "/") {
+        path9 = `/${path9}`;
       }
       let queryString = query2 ? querystringBuilder.buildQueryString(query2) : "";
       if (queryString && queryString[0] !== "?") {
@@ -14891,7 +14891,7 @@ var require_dist_cjs34 = __commonJS({
       if (request.fragment) {
         fragment = `#${request.fragment}`;
       }
-      return `${protocol}//${auth}${hostname}${path8}${queryString}${fragment}`;
+      return `${protocol}//${auth}${hostname}${path9}${queryString}${fragment}`;
     }
     exports2.formatUrl = formatUrl;
   }
@@ -15748,14 +15748,14 @@ var require_readFile = __commonJS({
     var promises_1 = require("node:fs/promises");
     exports2.filePromises = {};
     exports2.fileIntercept = {};
-    var readFile2 = (path8, options) => {
-      if (exports2.fileIntercept[path8] !== void 0) {
-        return exports2.fileIntercept[path8];
+    var readFile2 = (path9, options) => {
+      if (exports2.fileIntercept[path9] !== void 0) {
+        return exports2.fileIntercept[path9];
       }
-      if (!exports2.filePromises[path8] || options?.ignoreCache) {
-        exports2.filePromises[path8] = (0, promises_1.readFile)(path8, "utf8");
+      if (!exports2.filePromises[path9] || options?.ignoreCache) {
+        exports2.filePromises[path9] = (0, promises_1.readFile)(path9, "utf8");
       }
-      return exports2.filePromises[path8];
+      return exports2.filePromises[path9];
     };
     exports2.readFile = readFile2;
   }
@@ -15768,7 +15768,7 @@ var require_dist_cjs42 = __commonJS({
     var getHomeDir = require_getHomeDir();
     var getSSOTokenFilepath = require_getSSOTokenFilepath();
     var getSSOTokenFromFile = require_getSSOTokenFromFile();
-    var path8 = require("path");
+    var path9 = require("path");
     var types2 = require_dist_cjs();
     var readFile2 = require_readFile();
     var ENV_PROFILE = "AWS_PROFILE";
@@ -15790,9 +15790,9 @@ var require_dist_cjs42 = __commonJS({
       ...data2.default && { default: data2.default }
     });
     var ENV_CONFIG_PATH = "AWS_CONFIG_FILE";
-    var getConfigFilepath = () => process.env[ENV_CONFIG_PATH] || path8.join(getHomeDir.getHomeDir(), ".aws", "config");
+    var getConfigFilepath = () => process.env[ENV_CONFIG_PATH] || path9.join(getHomeDir.getHomeDir(), ".aws", "config");
     var ENV_CREDENTIALS_PATH = "AWS_SHARED_CREDENTIALS_FILE";
-    var getCredentialsFilepath = () => process.env[ENV_CREDENTIALS_PATH] || path8.join(getHomeDir.getHomeDir(), ".aws", "credentials");
+    var getCredentialsFilepath = () => process.env[ENV_CREDENTIALS_PATH] || path9.join(getHomeDir.getHomeDir(), ".aws", "credentials");
     var prefixKeyRegex = /^([\w-]+)\s(["'])?([\w-@\+\.%:/]+)\2$/;
     var profileNameBlockList = ["__proto__", "profile __proto__"];
     var parseIni = (iniData) => {
@@ -15847,11 +15847,11 @@ var require_dist_cjs42 = __commonJS({
       const relativeHomeDirPrefix = "~/";
       let resolvedFilepath = filepath;
       if (filepath.startsWith(relativeHomeDirPrefix)) {
-        resolvedFilepath = path8.join(homeDir, filepath.slice(2));
+        resolvedFilepath = path9.join(homeDir, filepath.slice(2));
       }
       let resolvedConfigFilepath = configFilepath;
       if (configFilepath.startsWith(relativeHomeDirPrefix)) {
-        resolvedConfigFilepath = path8.join(homeDir, configFilepath.slice(2));
+        resolvedConfigFilepath = path9.join(homeDir, configFilepath.slice(2));
       }
       const parsedFiles = await Promise.all([
         readFile2.readFile(resolvedConfigFilepath, {
@@ -15890,8 +15890,8 @@ var require_dist_cjs42 = __commonJS({
       getFileRecord() {
         return readFile2.fileIntercept;
       },
-      interceptFile(path9, contents) {
-        readFile2.fileIntercept[path9] = Promise.resolve(contents);
+      interceptFile(path10, contents) {
+        readFile2.fileIntercept[path10] = Promise.resolve(contents);
       },
       getTokenRecord() {
         return getSSOTokenFromFile.tokenIntercept;
@@ -16122,8 +16122,8 @@ var require_dist_cjs44 = __commonJS({
               return endpoint.url.href;
             }
             if ("hostname" in endpoint) {
-              const { protocol, hostname, port, path: path8 } = endpoint;
-              return `${protocol}//${hostname}${port ? ":" + port : ""}${path8}`;
+              const { protocol, hostname, port, path: path9 } = endpoint;
+              return `${protocol}//${hostname}${port ? ":" + port : ""}${path9}`;
             }
           }
           return endpoint;
@@ -19036,7 +19036,7 @@ var require_dist_cjs56 = __commonJS({
     var httpAuthSchemes = (init_httpAuthSchemes2(), __toCommonJS(httpAuthSchemes_exports));
     var propertyProvider = require_dist_cjs24();
     var sharedIniFileLoader = require_dist_cjs42();
-    var fs8 = require("fs");
+    var fs10 = require("fs");
     var fromEnvSigningName = ({ logger: logger2, signingName } = {}) => async () => {
       logger2?.debug?.("@aws-sdk/token-providers - fromEnvSigningName");
       if (!signingName) {
@@ -19082,7 +19082,7 @@ var require_dist_cjs56 = __commonJS({
         throw new propertyProvider.TokenProviderError(`Value not present for '${key}' in SSO Token${forRefresh ? ". Cannot refresh" : ""}. ${REFRESH_MESSAGE}`, false);
       }
     };
-    var { writeFile } = fs8.promises;
+    var { writeFile } = fs10.promises;
     var writeSSOTokenToFile = (id, ssoToken) => {
       const tokenFilepath = sharedIniFileLoader.getSSOTokenFilepath(id);
       const tokenString = JSON.stringify(ssoToken, null, 2);
@@ -28312,6 +28312,48 @@ var init_directory_resolver = __esm({
   }
 });
 
+// src/utils/symlink-utils.js
+async function getEntryType(entry, fullPath) {
+  try {
+    const stats = await import_fs2.promises.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 = import_fs.default.statSync(fullPath);
+    return {
+      isFile: stats.isFile(),
+      isDirectory: stats.isDirectory(),
+      size: stats.size
+    };
+  } catch {
+    return {
+      isFile: entry.isFile(),
+      isDirectory: entry.isDirectory(),
+      size: 0
+    };
+  }
+}
+var import_fs, import_fs2;
+var init_symlink_utils = __esm({
+  "src/utils/symlink-utils.js"() {
+    "use strict";
+    import_fs = __toESM(require("fs"), 1);
+    import_fs2 = require("fs");
+  }
+});
+
 // src/downloader.js
 function sanitizeError(err) {
   try {
@@ -28826,10 +28868,11 @@ async function extractBinary(assetPath, outputDir) {
       const entries = await import_fs_extra2.default.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = import_path2.default.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;
           }
@@ -29042,6 +29085,7 @@ var init_downloader = __esm({
     import_url2 = require("url");
     init_utils2();
     init_directory_resolver();
+    init_symlink_utils();
     exec = (0, import_util3.promisify)(import_child_process.exec);
     REPO_OWNER = "probelabs";
     REPO_NAME = "probe";
@@ -29127,6 +29171,32 @@ var init_utils2 = __esm({
   }
 });
 
+// src/utils/path-validation.js
+async function validateCwdPath(inputPath, defaultPath = process.cwd()) {
+  const targetPath = inputPath || defaultPath;
+  const normalizedPath = import_path4.default.normalize(import_path4.default.resolve(targetPath));
+  try {
+    const stats = await import_fs3.promises.stat(normalizedPath);
+    if (!stats.isDirectory()) {
+      throw new Error(`Path is not a directory: ${normalizedPath}`);
+    }
+  } catch (error2) {
+    if (error2.code === "ENOENT") {
+      throw new Error(`Path does not exist: ${normalizedPath}`);
+    }
+    throw error2;
+  }
+  return normalizedPath;
+}
+var import_path4, import_fs3;
+var init_path_validation = __esm({
+  "src/utils/path-validation.js"() {
+    "use strict";
+    import_path4 = __toESM(require("path"), 1);
+    import_fs3 = require("fs");
+  }
+});
+
 // src/search.js
 async function search(options) {
   if (!options || !options.path) {
@@ -29166,9 +29236,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}`;
@@ -29188,6 +29260,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
@@ -29241,13 +29314,15 @@ Search results: ${resultCount} matches, ${tokenCount} tokens`;
     if (error2.code === "ETIMEDOUT" || error2.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: ${error2.message}
 Binary: ${binaryPath}
-Args: ${args.join(" ")}`;
+Args: ${args.join(" ")}
+Cwd: ${cwd}`;
     throw new Error(errorMessage);
   }
 }
@@ -29258,6 +29333,7 @@ var init_search = __esm({
     import_child_process2 = require("child_process");
     import_util4 = require("util");
     init_utils2();
+    init_path_validation();
     execFileAsync = (0, import_util4.promisify)(import_child_process2.execFile);
     SEARCH_FLAG_MAP = {
       filesOnly: "--files-only",
@@ -29295,8 +29371,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";
@@ -29304,7 +29382,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}`);
     }
@@ -29329,7 +29407,8 @@ async function query(options) {
     return stdout;
   } catch (error2) {
     const errorMessage = `Error executing query command: ${error2.message}
-Command: ${command}`;
+Command: ${command}
+Cwd: ${cwd}`;
     throw new Error(errorMessage);
   }
 }
@@ -29340,6 +29419,7 @@ var init_query = __esm({
     import_child_process3 = require("child_process");
     import_util5 = require("util");
     init_utils2();
+    init_path_validation();
     execAsync = (0, import_util5.promisify)(import_child_process3.exec);
     QUERY_FLAG_MAP = {
       language: "--language",
@@ -29374,6 +29454,7 @@ async function extract(options) {
       cliArgs.push(escapeString(file));
     }
   }
+  const cwd = await validateCwdPath(options.cwd);
   if (process.env.DEBUG === "1") {
     let logMessage = `
 Extract:`;
@@ -29382,6 +29463,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}`;
@@ -29389,25 +29471,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 (error2) {
     const errorMessage = `Error executing extract command: ${error2.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((resolve5, reject2) => {
     const childProcess = (0, import_child_process4.spawn)(binaryPath, ["extract", ...cliArgs], {
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd
     });
     let stdout = "";
     let stderr = "";
@@ -29498,6 +29582,7 @@ var init_extract = __esm({
     import_child_process4 = require("child_process");
     import_util6 = require("util");
     init_utils2();
+    init_path_validation();
     execAsync2 = (0, import_util6.promisify)(import_child_process4.exec);
     EXTRACT_FLAG_MAP = {
       allowTests: "--allow-tests",
@@ -29529,7 +29614,7 @@ async function delegate({
   maxIterations = 30,
   tracer = null,
   parentSessionId = null,
-  path: path8 = null,
+  path: path9 = null,
   provider = null,
   model = null
 }) {
@@ -29569,7 +29654,7 @@ async function delegate({
       maxIterations: remainingIterations,
       debug,
       tracer,
-      path: path8,
+      path: path9,
       // Inherit from parent
       provider,
       // Inherit from parent
@@ -30188,8 +30273,8 @@ var init_parseUtil = __esm({
     init_errors4();
     init_en();
     makeIssue = (params) => {
-      const { data: data2, path: path8, errorMaps, issueData } = params;
-      const fullPath = [...path8, ...issueData.path || []];
+      const { data: data2, path: path9, errorMaps, issueData } = params;
+      const fullPath = [...path9, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -30497,11 +30582,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() {
@@ -34324,15 +34409,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"}`);
@@ -34340,6 +34425,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,
@@ -34367,14 +34454,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"}`);
@@ -34382,6 +34469,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
@@ -34402,22 +34491,16 @@ var init_vercel = __esm({
         inputSchema: extractSchema,
         execute: async ({ targets, input_content, line, end_line, allow_tests, context_lines, format: format2 }) => {
           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");
@@ -34434,6 +34517,7 @@ var init_vercel = __esm({
               }
               extractOptions = {
                 inputFile: tempFilePath,
+                cwd: effectiveCwd,
                 allowTests: allow_tests,
                 contextLines: context_lines,
                 format: effectiveFormat
@@ -34446,6 +34530,7 @@ var init_vercel = __esm({
               }
               extractOptions = {
                 files,
+                cwd: effectiveCwd,
                 allowTests: allow_tests,
                 contextLines: context_lines,
                 format: effectiveFormat
@@ -34474,12 +34559,12 @@ var init_vercel = __esm({
       });
     };
     delegateTool = (options = {}) => {
-      const { debug = false, timeout = 300, defaultPath, allowedFolders } = options;
+      const { debug = false, timeout = 300, cwd, allowedFolders } = options;
       return (0, import_ai.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");
           }
@@ -34495,7 +34580,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") {
@@ -34504,13 +34589,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}`);
             }
           }
@@ -35367,8 +35452,8 @@ async function executeBashCommand(command, options = {}) {
   } = options;
   let cwd = workingDirectory;
   try {
-    cwd = (0, import_path4.resolve)(cwd);
-    if (!(0, import_fs.existsSync)(cwd)) {
+    cwd = (0, import_path5.resolve)(cwd);
+    if (!(0, import_fs4.existsSync)(cwd)) {
       throw new Error(`Working directory does not exist: ${cwd}`);
     }
   } catch (error2) {
@@ -35580,7 +35665,7 @@ function validateExecutionOptions(options = {}) {
   if (options.workingDirectory) {
     if (typeof options.workingDirectory !== "string") {
       errors.push("workingDirectory must be a string");
-    } else if (!(0, import_fs.existsSync)(options.workingDirectory)) {
+    } else if (!(0, import_fs4.existsSync)(options.workingDirectory)) {
       errors.push(`workingDirectory does not exist: ${options.workingDirectory}`);
     }
   }
@@ -35593,31 +35678,31 @@ function validateExecutionOptions(options = {}) {
     warnings
   };
 }
-var import_child_process6, import_path4, import_fs;
+var import_child_process6, import_path5, import_fs4;
 var init_bashExecutor = __esm({
   "src/agent/bashExecutor.js"() {
     "use strict";
     import_child_process6 = require("child_process");
-    import_path4 = require("path");
-    import_fs = require("fs");
+    import_path5 = require("path");
+    import_fs4 = require("fs");
     init_bashCommandUtils();
   }
 });
 
 // src/tools/bash.js
-var import_ai2, import_path5, bashTool;
+var import_ai2, import_path6, bashTool;
 var init_bash = __esm({
   "src/tools/bash.js"() {
     "use strict";
     import_ai2 = require("ai");
-    import_path5 = require("path");
+    import_path6 = require("path");
     init_bashPermissions();
     init_bashExecutor();
     bashTool = (options = {}) => {
       const {
         bashConfig = {},
         debug = false,
-        defaultPath,
+        cwd,
         allowedFolders = []
       } = options;
       const permissionChecker = new BashPermissionChecker({
@@ -35631,8 +35716,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];
@@ -35720,9 +35805,9 @@ For code exploration, try these safe alternatives:
             }
             const workingDir = workingDirectory || getDefaultWorkingDirectory();
             if (allowedFolders && allowedFolders.length > 0) {
-              const resolvedWorkingDir = (0, import_path5.resolve)(workingDir);
+              const resolvedWorkingDir = (0, import_path6.resolve)(workingDir);
               const isAllowed = allowedFolders.some((folder) => {
-                const resolvedFolder = (0, import_path5.resolve)(folder);
+                const resolvedFolder = (0, import_path6.resolve)(folder);
                 return resolvedWorkingDir.startsWith(resolvedFolder);
               });
               if (!isAllowed) {
@@ -35778,33 +35863,33 @@ Command failed with exit code ${result.exitCode}`;
 // src/tools/edit.js
 function isPathAllowed(filePath, allowedFolders) {
   if (!allowedFolders || allowedFolders.length === 0) {
-    const resolvedPath3 = (0, import_path6.resolve)(filePath);
-    const cwd = (0, import_path6.resolve)(process.cwd());
-    return resolvedPath3 === cwd || resolvedPath3.startsWith(cwd + import_path6.sep);
+    const resolvedPath3 = (0, import_path7.resolve)(filePath);
+    const cwd = (0, import_path7.resolve)(process.cwd());
+    return resolvedPath3 === cwd || resolvedPath3.startsWith(cwd + import_path7.sep);
   }
-  const resolvedPath2 = (0, import_path6.resolve)(filePath);
+  const resolvedPath2 = (0, import_path7.resolve)(filePath);
   return allowedFolders.some((folder) => {
-    const allowedPath = (0, import_path6.resolve)(folder);
-    return resolvedPath2 === allowedPath || resolvedPath2.startsWith(allowedPath + import_path6.sep);
+    const allowedPath = (0, import_path7.resolve)(folder);
+    return resolvedPath2 === allowedPath || resolvedPath2.startsWith(allowedPath + import_path7.sep);
   });
 }
 function parseFileToolOptions(options = {}) {
   return {
     debug: options.debug || false,
     allowedFolders: options.allowedFolders || [],
-    defaultPath: options.defaultPath
+    cwd: options.cwd
   };
 }
-var import_ai3, import_fs2, import_path6, import_fs3, editTool, createTool, editDescription, createDescription, editToolDefinition, createToolDefinition;
+var import_ai3, import_fs5, import_path7, import_fs6, editTool, createTool, editDescription, createDescription, editToolDefinition, createToolDefinition;
 var init_edit = __esm({
   "src/tools/edit.js"() {
     "use strict";
     import_ai3 = require("ai");
-    import_fs2 = require("fs");
-    import_path6 = require("path");
-    import_fs3 = require("fs");
+    import_fs5 = require("fs");
+    import_path7 = require("path");
+    import_fs6 = require("fs");
     editTool = (options = {}) => {
-      const { debug, allowedFolders, defaultPath } = parseFileToolOptions(options);
+      const { debug, allowedFolders, cwd } = parseFileToolOptions(options);
       return (0, import_ai3.tool)({
         name: "edit",
         description: `Edit files using exact string replacement (Claude Code style).
@@ -35855,17 +35940,17 @@ 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 resolvedPath2 = (0, import_path6.isAbsolute)(file_path) ? file_path : (0, import_path6.resolve)(defaultPath || process.cwd(), file_path);
+            const resolvedPath2 = (0, import_path7.isAbsolute)(file_path) ? file_path : (0, import_path7.resolve)(cwd || process.cwd(), file_path);
             if (debug) {
               console.error(`[Edit] Attempting to edit file: ${resolvedPath2}`);
             }
             if (!isPathAllowed(resolvedPath2, allowedFolders)) {
               return `Error editing file: Permission denied - ${file_path} is outside allowed directories`;
             }
-            if (!(0, import_fs3.existsSync)(resolvedPath2)) {
+            if (!(0, import_fs6.existsSync)(resolvedPath2)) {
               return `Error editing file: File not found - ${file_path}`;
             }
-            const content = await import_fs2.promises.readFile(resolvedPath2, "utf-8");
+            const content = await import_fs5.promises.readFile(resolvedPath2, "utf-8");
             if (!content.includes(old_string)) {
               return `Error editing file: String not found - the specified old_string was not found in ${file_path}`;
             }
@@ -35882,7 +35967,7 @@ Important:
             if (newContent === content) {
               return `Error editing file: No changes made - old_string and new_string might be the same`;
             }
-            await import_fs2.promises.writeFile(resolvedPath2, newContent, "utf-8");
+            await import_fs5.promises.writeFile(resolvedPath2, newContent, "utf-8");
             const replacedCount = replace_all ? occurrences : 1;
             if (debug) {
               console.error(`[Edit] Successfully edited ${resolvedPath2}, replaced ${replacedCount} occurrence(s)`);
@@ -35896,7 +35981,7 @@ Important:
       });
     };
     createTool = (options = {}) => {
-      const { debug, allowedFolders, defaultPath } = parseFileToolOptions(options);
+      const { debug, allowedFolders, cwd } = parseFileToolOptions(options);
       return (0, import_ai3.tool)({
         name: "create",
         description: `Create new files with specified content.
@@ -35939,20 +36024,20 @@ Important:
             if (content === void 0 || content === null || typeof content !== "string") {
               return `Error creating file: Invalid content - must be a string`;
             }
-            const resolvedPath2 = (0, import_path6.isAbsolute)(file_path) ? file_path : (0, import_path6.resolve)(defaultPath || process.cwd(), file_path);
+            const resolvedPath2 = (0, import_path7.isAbsolute)(file_path) ? file_path : (0, import_path7.resolve)(cwd || process.cwd(), file_path);
             if (debug) {
               console.error(`[Create] Attempting to create file: ${resolvedPath2}`);
             }
             if (!isPathAllowed(resolvedPath2, allowedFolders)) {
               return `Error creating file: Permission denied - ${file_path} is outside allowed directories`;
             }
-            if ((0, import_fs3.existsSync)(resolvedPath2) && !overwrite) {
+            if ((0, import_fs6.existsSync)(resolvedPath2) && !overwrite) {
               return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
             }
-            const dir = (0, import_path6.dirname)(resolvedPath2);
-            await import_fs2.promises.mkdir(dir, { recursive: true });
-            await import_fs2.promises.writeFile(resolvedPath2, content, "utf-8");
-            const action = (0, import_fs3.existsSync)(resolvedPath2) && overwrite ? "overwrote" : "created";
+            const dir = (0, import_path7.dirname)(resolvedPath2);
+            await import_fs5.promises.mkdir(dir, { recursive: true });
+            await import_fs5.promises.writeFile(resolvedPath2, content, "utf-8");
+            const action = (0, import_fs6.existsSync)(resolvedPath2) && overwrite ? "overwrote" : "created";
             const bytes = Buffer.byteLength(content, "utf-8");
             if (debug) {
               console.error(`[Create] Successfully ${action} ${resolvedPath2}`);
@@ -36227,10 +36312,10 @@ async function listFilesByLevel(options) {
     maxFiles = 100,
     respectGitignore = true
   } = options;
-  if (!import_fs4.default.existsSync(directory)) {
+  if (!import_fs7.default.existsSync(directory)) {
     throw new Error(`Directory does not exist: ${directory}`);
   }
-  const gitDirExists = import_fs4.default.existsSync(import_path7.default.join(directory, ".git"));
+  const gitDirExists = import_fs7.default.existsSync(import_path8.default.join(directory, ".git"));
   if (gitDirExists && respectGitignore) {
     try {
       return await listFilesUsingGit(directory, maxFiles);
@@ -36245,8 +36330,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((a4, b4) => {
-    const depthA = a4.split(import_path7.default.sep).length;
-    const depthB = b4.split(import_path7.default.sep).length;
+    const depthA = a4.split(import_path8.default.sep).length;
+    const depthB = b4.split(import_path8.default.sep).length;
     return depthA - depthB;
   });
   return sortedFiles.slice(0, maxFiles);
@@ -36261,19 +36346,25 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   while (queue.length > 0 && result.length < maxFiles) {
     const { dir, level } = queue.shift();
     try {
-      const entries = import_fs4.default.readdirSync(dir, { withFileTypes: true });
-      const files = entries.filter((entry) => entry.isFile());
+      const entries = import_fs7.default.readdirSync(dir, { withFileTypes: true });
+      const files = entries.filter((entry) => {
+        const fullPath = import_path8.default.join(dir, entry.name);
+        return getEntryTypeSync(entry, fullPath).isFile;
+      });
       for (const file of files) {
         if (result.length >= maxFiles) break;
-        const filePath = import_path7.default.join(dir, file.name);
-        const relativePath = import_path7.default.relative(directory, filePath);
+        const filePath = import_path8.default.join(dir, file.name);
+        const relativePath = import_path8.default.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 = import_path8.default.join(dir, entry.name);
+        return getEntryTypeSync(entry, fullPath).isDirectory;
+      });
       for (const subdir of dirs) {
-        const subdirPath = import_path7.default.join(dir, subdir.name);
-        const relativeSubdirPath = import_path7.default.relative(directory, subdirPath);
+        const subdirPath = import_path8.default.join(dir, subdir.name);
+        const relativeSubdirPath = import_path8.default.relative(directory, subdirPath);
         if (shouldIgnore(relativeSubdirPath, ignorePatterns)) continue;
         if (subdir.name === "node_modules" || subdir.name === ".git") continue;
         queue.push({ dir: subdirPath, level: level + 1 });
@@ -36285,12 +36376,12 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   return result;
 }
 function loadGitignorePatterns(directory) {
-  const gitignorePath = import_path7.default.join(directory, ".gitignore");
-  if (!import_fs4.default.existsSync(gitignorePath)) {
+  const gitignorePath = import_path8.default.join(directory, ".gitignore");
+  if (!import_fs7.default.existsSync(gitignorePath)) {
     return [];
   }
   try {
-    const content = import_fs4.default.readFileSync(gitignorePath, "utf8");
+    const content = import_fs7.default.readFileSync(gitignorePath, "utf8");
     return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   } catch (error2) {
     console.error(`Warning: Could not read .gitignore: ${error2.message}`);
@@ -36308,25 +36399,26 @@ function shouldIgnore(filePath, ignorePatterns) {
   }
   return false;
 }
-var import_fs4, import_path7, import_util11, import_child_process7, execAsync3;
+var import_fs7, import_path8, import_util11, import_child_process7, execAsync3;
 var init_file_lister = __esm({
   "src/utils/file-lister.js"() {
     "use strict";
-    import_fs4 = __toESM(require("fs"), 1);
-    import_path7 = __toESM(require("path"), 1);
+    import_fs7 = __toESM(require("fs"), 1);
+    import_path8 = __toESM(require("path"), 1);
     import_util11 = require("util");
     import_child_process7 = require("child_process");
+    init_symlink_utils();
     execAsync3 = (0, import_util11.promisify)(import_child_process7.exec);
   }
 });
 
 // src/agent/simpleTelemetry.js
-var import_fs5, import_path8;
+var import_fs8, import_path9;
 var init_simpleTelemetry = __esm({
   "src/agent/simpleTelemetry.js"() {
     "use strict";
-    import_fs5 = require("fs");
-    import_path8 = require("path");
+    import_fs8 = require("fs");
+    import_path9 = require("path");
   }
 });
 
@@ -37175,7 +37267,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);
@@ -37244,11 +37336,11 @@ var init_esm = __esm({
       return (f4) => f4.length === len && f4 !== "." && f4 !== "..";
     };
     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;
@@ -40163,22 +40255,22 @@ var init_esm3 = __esm({
 });
 
 // node_modules/path-scurry/dist/esm/index.js
-var import_node_path, import_node_url, import_fs6, actualFS, import_promises, realpathSync, defaultFS, fsFromOption, uncDriveRegexp, uncToDrive, eitherSep, UNKNOWN, IFIFO, IFCHR, IFDIR, IFBLK, IFREG, IFLNK, IFSOCK, IFMT, IFMT_UNKNOWN, READDIR_CALLED, LSTAT_CALLED, ENOTDIR, ENOENT, ENOREADLINK, ENOREALPATH, ENOCHILD, TYPEMASK, entToType, normalizeCache, normalize, normalizeNocaseCache, normalizeNocase, ResolveCache, ChildrenCache, setAsCwd, PathBase, PathWin32, PathPosix, PathScurryBase, PathScurryWin32, PathScurryPosix, PathScurryDarwin, Path, PathScurry;
+var import_node_path, import_node_url, import_fs9, actualFS, import_promises, realpathSync, defaultFS, fsFromOption, uncDriveRegexp, uncToDrive, eitherSep, UNKNOWN, IFIFO, IFCHR, IFDIR, IFBLK, IFREG, IFLNK, IFSOCK, IFMT, IFMT_UNKNOWN, READDIR_CALLED, LSTAT_CALLED, ENOTDIR, ENOENT, ENOREADLINK, ENOREALPATH, ENOCHILD, TYPEMASK, entToType, normalizeCache, normalize, normalizeNocaseCache, normalizeNocase, ResolveCache, ChildrenCache, setAsCwd, PathBase, PathWin32, PathPosix, PathScurryBase, PathScurryWin32, PathScurryPosix, PathScurryDarwin, Path, PathScurry;
 var init_esm4 = __esm({
   "node_modules/path-scurry/dist/esm/index.js"() {
     init_esm2();
     import_node_path = require("node:path");
     import_node_url = require("node:url");
-    import_fs6 = require("fs");
+    import_fs9 = require("fs");
     actualFS = __toESM(require("node:fs"), 1);
     import_promises = require("node:fs/promises");
     init_esm3();
-    realpathSync = import_fs6.realpathSync.native;
+    realpathSync = import_fs9.realpathSync.native;
     defaultFS = {
-      lstatSync: import_fs6.lstatSync,
-      readdir: import_fs6.readdir,
-      readdirSync: import_fs6.readdirSync,
-      readlinkSync: import_fs6.readlinkSync,
+      lstatSync: import_fs9.lstatSync,
+      readdir: import_fs9.readdir,
+      readdirSync: import_fs9.readdirSync,
+      readlinkSync: import_fs9.readlinkSync,
       realpathSync,
       promises: {
         lstat: import_promises.lstat,
@@ -40435,12 +40527,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;
@@ -41192,8 +41284,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      getRootString(path8) {
-        return import_node_path.win32.parse(path8).root;
+      getRootString(path9) {
+        return import_node_path.win32.parse(path9).root;
       }
       /**
        * @internal
@@ -41239,8 +41331,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      getRootString(path8) {
-        return path8.startsWith("/") ? "/" : "";
+      getRootString(path9) {
+        return path9.startsWith("/") ? "/" : "";
       }
       /**
        * @internal
@@ -41289,8 +41381,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 = (0, import_node_url.fileURLToPath)(cwd);
         }
@@ -41329,11 +41421,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
@@ -41820,9 +41912,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);
       }
     };
@@ -41848,8 +41940,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
@@ -41877,8 +41969,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
@@ -42197,8 +42289,8 @@ var init_processor = __esm({
       }
       // match, absolute, ifdir
       entries() {
-        return [...this.store.entries()].map(([path8, n4]) => [
-          path8,
+        return [...this.store.entries()].map(([path9, n4]) => [
+          path9,
           !!(n4 & 2),
           !!(n4 & 1)
         ]);
@@ -42411,9 +42503,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;
@@ -42432,11 +42524,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() {
@@ -42651,8 +42743,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(e4) {
         this.matches.add(e4);
@@ -42689,8 +42781,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
@@ -43087,7 +43179,7 @@ function createWrappedTools(baseTools) {
   }
   return wrappedTools;
 }
-var import_child_process8, import_util12, import_crypto3, import_events, import_fs7, import_fs8, import_path9, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
+var import_child_process8, import_util12, import_crypto3, import_events, import_fs10, import_fs11, import_path10, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
 var init_probeTool = __esm({
   "src/agent/probeTool.js"() {
     "use strict";
@@ -43096,10 +43188,11 @@ var init_probeTool = __esm({
     import_util12 = require("util");
     import_crypto3 = require("crypto");
     import_events = require("events");
-    import_fs7 = __toESM(require("fs"), 1);
-    import_fs8 = require("fs");
-    import_path9 = __toESM(require("path"), 1);
+    import_fs10 = __toESM(require("fs"), 1);
+    import_fs11 = require("fs");
+    import_path10 = __toESM(require("path"), 1);
     init_esm5();
+    init_symlink_utils();
     toolCallEmitter = new import_events.EventEmitter();
     activeToolExecutions = /* @__PURE__ */ new Map();
     wrapToolWithEmitter = (tool4, toolName, baseExecute) => {
@@ -43186,17 +43279,17 @@ var init_probeTool = __esm({
       execute: async (params) => {
         const { directory = ".", workingDirectory } = params;
         const baseCwd = workingDirectory || process.cwd();
-        const secureBaseDir = import_path9.default.resolve(baseCwd);
+        const secureBaseDir = import_path10.default.resolve(baseCwd);
         const isDependencyPath = directory.startsWith("/dep/") || directory.startsWith("go:") || directory.startsWith("js:") || directory.startsWith("rust:");
         let targetDir;
-        if (import_path9.default.isAbsolute(directory)) {
-          targetDir = import_path9.default.resolve(directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path9.default.sep) && targetDir !== secureBaseDir) {
+        if (import_path10.default.isAbsolute(directory)) {
+          targetDir = import_path10.default.resolve(directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path10.default.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Cannot access directory outside workspace: ${directory}`);
           }
         } else {
-          targetDir = import_path9.default.resolve(secureBaseDir, directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path9.default.sep) && targetDir !== secureBaseDir) {
+          targetDir = import_path10.default.resolve(secureBaseDir, directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path10.default.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Access denied: ${directory}`);
           }
         }
@@ -43205,7 +43298,7 @@ var init_probeTool = __esm({
           console.log(`[DEBUG] Listing files in directory: ${targetDir}`);
         }
         try {
-          const files = await import_fs8.promises.readdir(targetDir, { withFileTypes: true });
+          const files = await import_fs11.promises.readdir(targetDir, { withFileTypes: true });
           const formatSize = (size) => {
             if (size < 1024) return `${size}B`;
             if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)}K`;
@@ -43213,21 +43306,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 = import_path9.default.join(targetDir, file.name);
-            let size = 0;
-            try {
-              const stats = await import_fs8.promises.stat(fullPath);
-              size = stats.size;
-            } catch (statError) {
-              if (debug) {
-                console.log(`[DEBUG] Could not stat file ${file.name}:`, statError.message);
-              }
-            }
+            const fullPath = import_path10.default.join(targetDir, file.name);
+            const entryType = await getEntryType(file, fullPath);
             return {
               name: file.name,
-              isDirectory,
-              size
+              isDirectory: entryType.isDirectory,
+              size: entryType.size
             };
           }));
           entries.sort((a4, b4) => {
@@ -43259,17 +43343,17 @@ var init_probeTool = __esm({
           throw new Error("Pattern is required for file search");
         }
         const baseCwd = workingDirectory || process.cwd();
-        const secureBaseDir = import_path9.default.resolve(baseCwd);
+        const secureBaseDir = import_path10.default.resolve(baseCwd);
         const isDependencyPath = directory.startsWith("/dep/") || directory.startsWith("go:") || directory.startsWith("js:") || directory.startsWith("rust:");
         let targetDir;
-        if (import_path9.default.isAbsolute(directory)) {
-          targetDir = import_path9.default.resolve(directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path9.default.sep) && targetDir !== secureBaseDir) {
+        if (import_path10.default.isAbsolute(directory)) {
+          targetDir = import_path10.default.resolve(directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path10.default.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Cannot access directory outside workspace: ${directory}`);
           }
         } else {
-          targetDir = import_path9.default.resolve(secureBaseDir, directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path9.default.sep) && targetDir !== secureBaseDir) {
+          targetDir = import_path10.default.resolve(secureBaseDir, directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path10.default.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Access denied: ${directory}`);
           }
         }
@@ -45397,11 +45481,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;
 }
@@ -45415,8 +45499,8 @@ var init_baseGet = __esm({
 });
 
 // node_modules/lodash-es/get.js
-function get2(object, path8, defaultValue) {
-  var result = object == null ? void 0 : baseGet_default(object, path8);
+function get2(object, path9, defaultValue) {
+  var result = object == null ? void 0 : baseGet_default(object, path9);
   return result === void 0 ? defaultValue : result;
 }
 var get_default;
@@ -46779,11 +46863,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;
     }
@@ -46809,8 +46893,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({
@@ -46822,13 +46906,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;
@@ -46861,9 +46945,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;
@@ -46875,8 +46959,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({
@@ -47495,8 +47579,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({
@@ -47702,14 +47786,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;
     }
@@ -47717,7 +47801,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);
@@ -47741,9 +47825,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;
@@ -47767,8 +47851,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;
@@ -50481,12 +50565,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);
     }
@@ -51656,10 +51740,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;
@@ -51703,9 +51787,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;
@@ -51946,10 +52030,10 @@ function initializeArrayOfArrays(size) {
   }
   return result;
 }
-function pathToHashKeys(path8) {
+function pathToHashKeys(path9) {
   let keys2 = [""];
-  for (let i4 = 0; i4 < path8.length; i4++) {
-    const tokType = path8[i4];
+  for (let i4 = 0; i4 < path9.length; i4++) {
+    const tokType = path9[i4];
     const longerKeys = [];
     for (let j4 = 0; j4 < keys2.length; j4++) {
       const currShorterKey = keys2[j4];
@@ -52252,7 +52336,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)) {
@@ -52264,15 +52348,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);
     });
@@ -57747,7 +57831,7 @@ function validateFlowchart(text, options = {}) {
         const byLine = /* @__PURE__ */ new Map();
         const collect = (arr) => {
           for (const e4 of arr || []) {
-            if (e4 && (e4.code === "FL-LABEL-PARENS-UNQUOTED" || e4.code === "FL-LABEL-AT-IN-UNQUOTED")) {
+            if (e4 && (e4.code === "FL-LABEL-PARENS-UNQUOTED" || e4.code === "FL-LABEL-AT-IN-UNQUOTED" || e4.code === "FL-LABEL-QUOTE-IN-UNQUOTED")) {
               const ln = e4.line ?? 0;
               const col = e4.column ?? 1;
               const list2 = byLine.get(ln) || [];
@@ -57828,6 +57912,8 @@ function validateFlowchart(text, options = {}) {
                 const covered = existing.some((r4) => !(endCol < r4.start || startCol > r4.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 });
@@ -57838,6 +57924,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);
+                }
                 i4 = j4;
                 continue;
               } else {
@@ -64869,11 +64960,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;
     }
@@ -64885,8 +64976,8 @@ var require_baseGet = __commonJS({
 var require_get = __commonJS({
   "node_modules/lodash/get.js"(exports2, module2) {
     var baseGet2 = require_baseGet();
-    function get3(object, path8, defaultValue) {
-      var result = object == null ? void 0 : baseGet2(object, path8);
+    function get3(object, path9, defaultValue) {
+      var result = object == null ? void 0 : baseGet2(object, path9);
       return result === void 0 ? defaultValue : result;
     }
     module2.exports = get3;
@@ -64912,11 +65003,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;
         }
@@ -64937,8 +65028,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;
   }
@@ -64956,13 +65047,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 = get3(object, path8);
-        return objValue === void 0 && objValue === srcValue ? hasIn2(object, path8) : baseIsEqual2(srcValue, objValue, COMPARE_PARTIAL_FLAG7 | COMPARE_UNORDERED_FLAG5);
+        var objValue = get3(object, path9);
+        return objValue === void 0 && objValue === srcValue ? hasIn2(object, path9) : baseIsEqual2(srcValue, objValue, COMPARE_PARTIAL_FLAG7 | COMPARE_UNORDERED_FLAG5);
       };
     }
     module2.exports = baseMatchesProperty2;
@@ -64985,9 +65076,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;
@@ -65001,8 +65092,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;
   }
@@ -65064,8 +65155,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;
   }
@@ -67339,14 +67430,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;
         }
@@ -67354,7 +67445,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);
@@ -67375,9 +67466,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;
@@ -67392,8 +67483,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;
@@ -68447,15 +68538,15 @@ var require_parent_dummy_chains = __commonJS({
         var node = g4.node(v4);
         var edgeObj = node.edgeObj;
         var pathData = findPath(g4, 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 (v4 !== edgeObj.w) {
           node = g4.node(v4);
           if (ascending) {
-            while ((pathV = path8[pathIdx]) !== lca && g4.node(pathV).maxRank < node.rank) {
+            while ((pathV = path9[pathIdx]) !== lca && g4.node(pathV).maxRank < node.rank) {
               pathIdx++;
             }
             if (pathV === lca) {
@@ -68463,10 +68554,10 @@ var require_parent_dummy_chains = __commonJS({
             }
           }
           if (!ascending) {
-            while (pathIdx < path8.length - 1 && g4.node(pathV = path8[pathIdx + 1]).minRank <= node.rank) {
+            while (pathIdx < path9.length - 1 && g4.node(pathV = path9[pathIdx + 1]).minRank <= node.rank) {
               pathIdx++;
             }
-            pathV = path8[pathIdx];
+            pathV = path9[pathIdx];
           }
           g4.setParent(v4, pathV);
           v4 = g4.successors(v4)[0];
@@ -70639,8 +70730,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);
         }
@@ -76956,8 +77047,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;
@@ -77156,8 +77247,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;
       }
@@ -80500,7 +80591,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") {
@@ -80538,7 +80629,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  ");
@@ -80861,7 +80952,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;
@@ -80875,14 +80966,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);
@@ -81139,7 +81230,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)`);
@@ -81296,7 +81387,7 @@ ${maidResult.fixed}
     }
     const aiFixingStart = Date.now();
     const mermaidFixer = new MermaidFixingAgent({
-      path: path8,
+      path: path9,
       provider,
       model,
       debug,
@@ -81538,8 +81629,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 = `
 
@@ -81899,11 +81990,11 @@ function loadMCPConfigurationFromPath(configPath) {
   if (!configPath) {
     throw new Error("Config path is required");
   }
-  if (!(0, import_fs9.existsSync)(configPath)) {
+  if (!(0, import_fs12.existsSync)(configPath)) {
     throw new Error(`MCP configuration file not found: ${configPath}`);
   }
   try {
-    const content = (0, import_fs9.readFileSync)(configPath, "utf8");
+    const content = (0, import_fs12.readFileSync)(configPath, "utf8");
     const config = JSON.parse(content);
     if (process.env.DEBUG === "1" || process.env.DEBUG_MCP === "1") {
       console.error(`[MCP DEBUG] Loaded configuration from: ${configPath}`);
@@ -81918,19 +82009,19 @@ function loadMCPConfiguration() {
     // Environment variable path
     process.env.MCP_CONFIG_PATH,
     // Local project paths
-    (0, import_path10.join)(process.cwd(), ".mcp", "config.json"),
-    (0, import_path10.join)(process.cwd(), "mcp.config.json"),
+    (0, import_path11.join)(process.cwd(), ".mcp", "config.json"),
+    (0, import_path11.join)(process.cwd(), "mcp.config.json"),
     // Home directory paths
-    (0, import_path10.join)((0, import_os3.homedir)(), ".config", "probe", "mcp.json"),
-    (0, import_path10.join)((0, import_os3.homedir)(), ".mcp", "config.json"),
+    (0, import_path11.join)((0, import_os3.homedir)(), ".config", "probe", "mcp.json"),
+    (0, import_path11.join)((0, import_os3.homedir)(), ".mcp", "config.json"),
     // Claude-style config location
-    (0, import_path10.join)((0, import_os3.homedir)(), "Library", "Application Support", "Claude", "mcp_config.json")
+    (0, import_path11.join)((0, import_os3.homedir)(), "Library", "Application Support", "Claude", "mcp_config.json")
   ].filter(Boolean);
   let config = null;
   for (const configPath of configPaths) {
-    if ((0, import_fs9.existsSync)(configPath)) {
+    if ((0, import_fs12.existsSync)(configPath)) {
       try {
-        const content = (0, import_fs9.readFileSync)(configPath, "utf8");
+        const content = (0, import_fs12.readFileSync)(configPath, "utf8");
         config = JSON.parse(content);
         if (process.env.DEBUG === "1" || process.env.DEBUG_MCP === "1") {
           console.error(`[MCP DEBUG] Loaded configuration from: ${configPath}`);
@@ -82026,22 +82117,22 @@ function parseEnabledServers(config) {
   }
   return servers;
 }
-var import_fs9, import_path10, import_os3, import_url4, __filename4, __dirname4, DEFAULT_CONFIG;
+var import_fs12, import_path11, import_os3, import_url4, __filename4, __dirname4, DEFAULT_CONFIG;
 var init_config = __esm({
   "src/agent/mcp/config.js"() {
     "use strict";
-    import_fs9 = require("fs");
-    import_path10 = require("path");
+    import_fs12 = require("fs");
+    import_path11 = require("path");
     import_os3 = require("os");
     import_url4 = require("url");
     __filename4 = (0, import_url4.fileURLToPath)("file:///");
-    __dirname4 = (0, import_path10.dirname)(__filename4);
+    __dirname4 = (0, import_path11.dirname)(__filename4);
     DEFAULT_CONFIG = {
       mcpServers: {
         // Example probe server configuration
         "probe-local": {
           command: "node",
-          args: [(0, import_path10.join)(__dirname4, "../../../examples/chat/mcpServer.js")],
+          args: [(0, import_path11.join)(__dirname4, "../../../examples/chat/mcpServer.js")],
           transport: "stdio",
           enabled: false
         },
@@ -84161,12 +84252,12 @@ async function createEnhancedClaudeCLIEngine(options = {}) {
       console.log("[DEBUG] Built-in MCP server started");
       console.log("[DEBUG] MCP URL:", `http://${host}:${port}/mcp`);
     }
-    mcpConfigPath = import_path11.default.join(import_os4.default.tmpdir(), `probe-mcp-${session.id}.json`);
+    mcpConfigPath = import_path12.default.join(import_os4.default.tmpdir(), `probe-mcp-${session.id}.json`);
     const mcpConfig = {
       mcpServers: {
         probe: {
           command: "node",
-          args: [import_path11.default.join(process.cwd(), "mcp-probe-server.js")],
+          args: [import_path12.default.join(process.cwd(), "mcp-probe-server.js")],
           env: {
             PROBE_WORKSPACE: process.cwd(),
             DEBUG: debug ? "true" : "false"
@@ -84535,14 +84626,14 @@ function combinePrompts(systemPrompt, customPrompt, agent) {
   }
   return systemPrompt || "";
 }
-var import_child_process9, import_crypto6, import_promises2, import_path11, import_os4, import_events3;
+var import_child_process9, import_crypto6, import_promises2, import_path12, import_os4, import_events3;
 var init_enhanced_claude_code = __esm({
   "src/agent/engines/enhanced-claude-code.js"() {
     "use strict";
     import_child_process9 = require("child_process");
     import_crypto6 = require("crypto");
     import_promises2 = __toESM(require("fs/promises"), 1);
-    import_path11 = __toESM(require("path"), 1);
+    import_path12 = __toESM(require("path"), 1);
     import_os4 = __toESM(require("os"), 1);
     import_events3 = require("events");
     init_built_in_server();
@@ -84900,7 +84991,7 @@ __export(ProbeAgent_exports, {
   ProbeAgent: () => ProbeAgent
 });
 module.exports = __toCommonJS(ProbeAgent_exports);
-var import_dotenv2, import_anthropic2, import_openai2, import_google2, import_ai5, import_crypto8, import_events4, import_fs10, import_promises3, import_path12, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
+var import_dotenv2, import_anthropic2, import_openai2, import_google2, import_ai5, import_crypto8, import_events4, import_fs13, import_promises3, import_path13, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
     import_dotenv2 = __toESM(require_main(), 1);
@@ -84911,9 +85002,9 @@ var init_ProbeAgent = __esm({
     import_ai5 = require("ai");
     import_crypto8 = require("crypto");
     import_events4 = require("events");
-    import_fs10 = require("fs");
+    import_fs13 = require("fs");
     import_promises3 = require("fs/promises");
-    import_path12 = require("path");
+    import_path13 = require("path");
     init_tokenCounter();
     init_InMemoryStorageAdapter();
     init_HookManager();
@@ -84952,6 +85043,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
@@ -84980,6 +85072,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 || (0, import_crypto8.randomUUID)();
@@ -85001,6 +85094,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();
@@ -85019,6 +85113,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;
@@ -85197,7 +85292,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,
@@ -85235,7 +85331,7 @@ var init_ProbeAgent = __esm({
               if (!imagePath) {
                 throw new Error("Image path is required");
               }
-              const filename = (0, import_path12.basename)(imagePath);
+              const filename = (0, import_path13.basename)(imagePath);
               const extension = filename.toLowerCase().split(".").pop();
               if (!extension || !SUPPORTED_IMAGE_EXTENSIONS.includes(extension)) {
                 throw new Error(`Invalid or unsupported image extension: ${extension}. Supported formats: ${SUPPORTED_IMAGE_EXTENSIONS.join(", ")}`);
@@ -85790,7 +85886,7 @@ var init_ProbeAgent = __esm({
           let resolvedPath2 = imagePath;
           if (!imagePath.includes("/") && !imagePath.includes("\\")) {
             for (const dir of listFilesDirectories) {
-              const potentialPath = (0, import_path12.resolve)(dir, imagePath);
+              const potentialPath = (0, import_path13.resolve)(dir, imagePath);
               const loaded = await this.loadImageIfValid(potentialPath);
               if (loaded) {
                 if (this.debug) {
@@ -85815,7 +85911,7 @@ var init_ProbeAgent = __esm({
         let match2;
         while ((match2 = fileHeaderPattern.exec(content)) !== null) {
           const filePath = match2[1].trim();
-          const dir = (0, import_path12.dirname)(filePath);
+          const dir = (0, import_path13.dirname)(filePath);
           if (dir && dir !== ".") {
             directories.push(dir);
             if (this.debug) {
@@ -85860,17 +85956,17 @@ var init_ProbeAgent = __esm({
           const allowedDirs = this.allowedFolders && this.allowedFolders.length > 0 ? this.allowedFolders : [process.cwd()];
           let absolutePath;
           let isPathAllowed2 = false;
-          if ((0, import_path12.isAbsolute)(imagePath)) {
-            absolutePath = (0, import_path12.normalize)((0, import_path12.resolve)(imagePath));
+          if ((0, import_path13.isAbsolute)(imagePath)) {
+            absolutePath = (0, import_path13.normalize)((0, import_path13.resolve)(imagePath));
             isPathAllowed2 = allowedDirs.some((dir) => {
-              const normalizedDir = (0, import_path12.normalize)((0, import_path12.resolve)(dir));
-              return absolutePath === normalizedDir || absolutePath.startsWith(normalizedDir + import_path12.sep);
+              const normalizedDir = (0, import_path13.normalize)((0, import_path13.resolve)(dir));
+              return absolutePath === normalizedDir || absolutePath.startsWith(normalizedDir + import_path13.sep);
             });
           } else {
             for (const dir of allowedDirs) {
-              const normalizedDir = (0, import_path12.normalize)((0, import_path12.resolve)(dir));
-              const resolvedPath2 = (0, import_path12.normalize)((0, import_path12.resolve)(dir, imagePath));
-              if (resolvedPath2 === normalizedDir || resolvedPath2.startsWith(normalizedDir + import_path12.sep)) {
+              const normalizedDir = (0, import_path13.normalize)((0, import_path13.resolve)(dir));
+              const resolvedPath2 = (0, import_path13.normalize)((0, import_path13.resolve)(dir, imagePath));
+              if (resolvedPath2 === normalizedDir || resolvedPath2.startsWith(normalizedDir + import_path13.sep)) {
                 absolutePath = resolvedPath2;
                 isPathAllowed2 = true;
                 break;
@@ -87048,6 +87144,46 @@ IMPORTANT: When using <attempt_complete>, this must be the ONLY content in your
           } catch (error2) {
             console.error(`[ERROR] Failed to save messages to storage:`, error2);
           }
+          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 (error2) {
+              console.error("[ERROR] Completion prompt failed:", error2);
+              if (this.tracer) {
+                this.tracer.recordEvent("completion_prompt.error", {
+                  "completion_prompt.error": error2.message
+                });
+              }
+            }
+          }
           const reachedMaxIterations = currentIteration >= maxIterations && !completionAttempted;
           if (options.schema && !options._schemaFormatted && !completionAttempted && !reachedMaxIterations) {
             if (this.debug) {
@@ -87514,6 +87650,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,
@@ -87522,6 +87660,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,