@probelabs/probe 0.6.0-rc225 → 0.6.0-rc226

package/build/agent/index.js

@@ -3288,7 +3288,26 @@ var init_error_types = __esm({
 
 // src/utils/path-validation.js
 import path4 from "path";
-import { promises as fs5 } from "fs";
+import { promises as fs5, realpathSync } from "fs";
+function safeRealpath(inputPath) {
+  try {
+    return realpathSync(inputPath);
+  } catch (error) {
+    const normalized = path4.normalize(inputPath);
+    const parts = normalized.split(path4.sep);
+    for (let i = parts.length - 1; i >= 0; i--) {
+      const ancestorPath = parts.slice(0, i).join(path4.sep) || path4.sep;
+      try {
+        const resolvedAncestor = realpathSync(ancestorPath);
+        const remainingParts = parts.slice(i);
+        return path4.join(resolvedAncestor, ...remainingParts);
+      } catch (ancestorError) {
+        continue;
+      }
+    }
+    return normalized;
+  }
+}
 async function validateCwdPath(inputPath, defaultPath = process.cwd()) {
   const targetPath = inputPath || defaultPath;
   const normalizedPath = path4.normalize(path4.resolve(targetPath));
@@ -3321,6 +3340,53 @@ async function validateCwdPath(inputPath, defaultPath = process.cwd()) {
   }
   return normalizedPath;
 }
+function getCommonPrefix(folders) {
+  if (!folders || folders.length === 0) {
+    return process.cwd();
+  }
+  if (folders.length === 1) {
+    return safeRealpath(folders[0]);
+  }
+  const normalized = folders.map((f) => safeRealpath(f));
+  const segments = normalized.map((f) => f.split(path4.sep));
+  const minLen = Math.min(...segments.map((s) => s.length));
+  const commonSegments = [];
+  for (let i = 0; i < minLen; i++) {
+    const segment = segments[0][i];
+    if (segments.every((s) => s[i] === segment)) {
+      commonSegments.push(segment);
+    } else {
+      break;
+    }
+  }
+  if (commonSegments.length === 0) {
+    return normalized[0];
+  }
+  if (commonSegments.length === 1 && /^[a-zA-Z]:$/.test(commonSegments[0])) {
+    return normalized[0];
+  }
+  if (commonSegments.length === 1 && commonSegments[0] === "") {
+    return normalized[0];
+  }
+  return commonSegments.join(path4.sep);
+}
+function toRelativePath(absolutePath, workspaceRoot) {
+  if (!absolutePath || !workspaceRoot) {
+    return absolutePath;
+  }
+  let normalized = safeRealpath(absolutePath);
+  let normalizedRoot = safeRealpath(workspaceRoot);
+  while (normalizedRoot.length > 1 && normalizedRoot.endsWith(path4.sep)) {
+    normalizedRoot = normalizedRoot.slice(0, -1);
+  }
+  if (normalized === normalizedRoot) {
+    return ".";
+  }
+  if (normalized.startsWith(normalizedRoot + path4.sep)) {
+    return path4.relative(normalizedRoot, normalized);
+  }
+  return absolutePath;
+}
 var init_path_validation = __esm({
   "src/utils/path-validation.js"() {
     "use strict";
@@ -4515,6 +4581,7 @@ async function analyzeAll(options) {
     sessionId,
     debug = false,
     cwd,
+    workspaceRoot,
     allowedFolders,
     provider,
     model,
@@ -4527,10 +4594,11 @@ async function analyzeAll(options) {
   if (!question) {
     throw new Error('The "question" parameter is required.');
   }
+  const effectiveWorkspaceRoot = workspaceRoot || cwd || allowedFolders?.[0] || path9;
   const delegateOptions = {
     debug,
     sessionId,
-    path: allowedFolders?.[0] || cwd || path9,
+    path: effectiveWorkspaceRoot,
     allowedFolders,
     provider,
     model,
@@ -8747,29 +8815,33 @@ import { dirname, resolve, isAbsolute, sep } from "path";
 import { existsSync } from "fs";
 function isPathAllowed(filePath, allowedFolders) {
   if (!allowedFolders || allowedFolders.length === 0) {
-    const resolvedPath2 = resolve(filePath);
-    const cwd = resolve(process.cwd());
+    const resolvedPath2 = safeRealpath(filePath);
+    const cwd = safeRealpath(process.cwd());
     return resolvedPath2 === cwd || resolvedPath2.startsWith(cwd + sep);
   }
-  const resolvedPath = resolve(filePath);
+  const resolvedPath = safeRealpath(filePath);
   return allowedFolders.some((folder) => {
-    const allowedPath = resolve(folder);
+    const allowedPath = safeRealpath(folder);
     return resolvedPath === allowedPath || resolvedPath.startsWith(allowedPath + sep);
   });
 }
 function parseFileToolOptions(options = {}) {
+  const allowedFolders = options.allowedFolders || [];
   return {
     debug: options.debug || false,
-    allowedFolders: options.allowedFolders || [],
-    cwd: options.cwd
+    allowedFolders,
+    cwd: options.cwd,
+    // Consistent fallback chain: workspaceRoot > cwd > allowedFolders[0] > process.cwd()
+    workspaceRoot: options.workspaceRoot || options.cwd || allowedFolders.length > 0 && allowedFolders[0] || process.cwd()
   };
 }
 var editTool, createTool, editSchema, createSchema, editDescription, createDescription, editToolDefinition, createToolDefinition;
 var init_edit = __esm({
   "src/tools/edit.js"() {
     "use strict";
+    init_path_validation();
     editTool = (options = {}) => {
-      const { debug, allowedFolders, cwd } = parseFileToolOptions(options);
+      const { debug, allowedFolders, cwd, workspaceRoot } = parseFileToolOptions(options);
       return tool({
         name: "edit",
         description: `Edit files using exact string replacement (Claude Code style).
@@ -8825,7 +8897,8 @@ Important:
               console.error(`[Edit] Attempting to edit file: ${resolvedPath}`);
             }
             if (!isPathAllowed(resolvedPath, allowedFolders)) {
-              return `Error editing file: Permission denied - ${file_path} is outside allowed directories`;
+              const relativePath = toRelativePath(resolvedPath, workspaceRoot);
+              return `Error editing file: Permission denied - ${relativePath} is outside allowed directories`;
             }
             if (!existsSync(resolvedPath)) {
               return `Error editing file: File not found - ${file_path}`;
@@ -8861,7 +8934,7 @@ Important:
       });
     };
     createTool = (options = {}) => {
-      const { debug, allowedFolders, cwd } = parseFileToolOptions(options);
+      const { debug, allowedFolders, cwd, workspaceRoot } = parseFileToolOptions(options);
       return tool({
         name: "create",
         description: `Create new files with specified content.
@@ -8909,7 +8982,8 @@ Important:
               console.error(`[Create] Attempting to create file: ${resolvedPath}`);
             }
             if (!isPathAllowed(resolvedPath, allowedFolders)) {
-              return `Error creating file: Permission denied - ${file_path} is outside allowed directories`;
+              const relativePath = toRelativePath(resolvedPath, workspaceRoot);
+              return `Error creating file: Permission denied - ${relativePath} is outside allowed directories`;
             }
             if (existsSync(resolvedPath) && !overwrite) {
               return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
@@ -10471,7 +10545,7 @@ var init_vercel = __esm({
       });
     };
     delegateTool = (options = {}) => {
-      const { debug = false, timeout = 300, cwd, allowedFolders, enableBash = false, bashConfig, architectureFileName, enableMcp = false, mcpConfig = null, mcpConfigPath = null, delegationManager = null } = options;
+      const { debug = false, timeout = 300, cwd, allowedFolders, workspaceRoot, enableBash = false, bashConfig, architectureFileName, enableMcp = false, mcpConfig = null, mcpConfigPath = null, delegationManager = null } = options;
       return tool2({
         name: "delegate",
         description: delegateDescription,
@@ -10504,8 +10578,8 @@ var init_vercel = __esm({
           if (searchDelegate !== void 0 && typeof searchDelegate !== "boolean") {
             throw new TypeError("searchDelegate must be a boolean if provided");
           }
-          const workspaceRoot = allowedFolders && allowedFolders[0];
-          const effectivePath = path9 || workspaceRoot || cwd;
+          const effectiveWorkspaceRoot = workspaceRoot || allowedFolders && allowedFolders[0];
+          const effectivePath = path9 || effectiveWorkspaceRoot || cwd;
           if (debug) {
             console.error(`Executing delegate with task: "${task.substring(0, 100)}${task.length > 100 ? "..." : ""}"`);
             if (parentSessionId) {
@@ -10542,7 +10616,7 @@ var init_vercel = __esm({
       });
     };
     analyzeAllTool = (options = {}) => {
-      const { sessionId, debug = false, delegationManager = null } = options;
+      const { sessionId, debug = false, delegationManager = null, workspaceRoot } = options;
       return tool2({
         name: "analyze_all",
         description: analyzeAllDescription,
@@ -10561,12 +10635,14 @@ var init_vercel = __esm({
               console.error(`[analyze_all] Question: ${question}`);
               console.error(`[analyze_all] Path: ${searchPath}`);
             }
+            const effectiveWorkspaceRoot = workspaceRoot || options.cwd || options.allowedFolders && options.allowedFolders[0];
             const result = await analyzeAll({
               question,
               path: searchPath,
               sessionId,
               debug,
               cwd: options.cwd,
+              workspaceRoot: effectiveWorkspaceRoot,
               allowedFolders: options.allowedFolders,
               provider: options.provider,
               model: options.model,
@@ -12042,14 +12118,17 @@ var init_bash = __esm({
     "use strict";
     init_bashPermissions();
     init_bashExecutor();
+    init_path_validation();
     bashTool = (options = {}) => {
       const {
         bashConfig = {},
         debug = false,
         cwd,
         allowedFolders = [],
+        workspaceRoot: providedWorkspaceRoot,
         tracer = null
       } = options;
+      const workspaceRoot = providedWorkspaceRoot || cwd || allowedFolders.length > 0 && allowedFolders[0] || process.cwd();
       const permissionChecker = new BashPermissionChecker({
         allow: bashConfig.allow,
         deny: bashConfig.deny,
@@ -12065,6 +12144,9 @@ var init_bash = __esm({
         if (cwd) {
           return cwd;
         }
+        if (workspaceRoot) {
+          return workspaceRoot;
+        }
         if (allowedFolders && allowedFolders.length > 0) {
           return allowedFolders[0];
         }
@@ -12152,13 +12234,15 @@ For code exploration, try these safe alternatives:
             const defaultDir = getDefaultWorkingDirectory();
             const workingDir = workingDirectory ? isAbsolute3(workingDirectory) ? resolve4(workingDirectory) : resolve4(defaultDir, workingDirectory) : defaultDir;
             if (allowedFolders && allowedFolders.length > 0) {
-              const resolvedWorkingDir = resolve4(workingDir);
+              const resolvedWorkingDir = safeRealpath(workingDir);
               const isAllowed = allowedFolders.some((folder) => {
-                const resolvedFolder = resolve4(folder);
+                const resolvedFolder = safeRealpath(folder);
                 return resolvedWorkingDir === resolvedFolder || resolvedWorkingDir.startsWith(resolvedFolder + sep2);
               });
               if (!isAllowed) {
-                return `Error: Working directory "${workingDir}" is not within allowed folders: ${allowedFolders.join(", ")}`;
+                const relativeDir = toRelativePath(workingDir, workspaceRoot);
+                const relativeAllowed = allowedFolders.map((f) => toRelativePath(f, workspaceRoot));
+                return `Error: Working directory "${relativeDir}" is not within allowed folders: ${relativeAllowed.join(", ")}`;
               }
             }
             const executionOptions = {
@@ -16765,18 +16849,18 @@ import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { lstatSync, readdir as readdirCB, readdirSync, readlinkSync, realpathSync as rps } from "fs";
 import * as actualFS from "node:fs";
 import { lstat, readdir, readlink, realpath } from "node:fs/promises";
-var 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 realpathSync2, 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();
     init_esm3();
-    realpathSync = rps.native;
+    realpathSync2 = rps.native;
     defaultFS = {
       lstatSync,
       readdir: readdirCB,
       readdirSync,
       readlinkSync,
-      realpathSync,
+      realpathSync: realpathSync2,
       promises: {
         lstat,
         readdir,
@@ -70171,6 +70255,7 @@ var init_ProbeAgent = __esm({
     init_FallbackManager();
     init_contextCompactor();
     init_error_types();
+    init_path_validation();
     init_outputTruncator();
     init_delegate();
     init_tasks();
@@ -70288,7 +70373,8 @@ var init_ProbeAgent = __esm({
         } else {
           this.allowedFolders = [process.cwd()];
         }
-        this.cwd = options.cwd || null;
+        this.workspaceRoot = getCommonPrefix(this.allowedFolders);
+        this.cwd = options.cwd || this.workspaceRoot;
         this.clientApiProvider = options.provider || null;
         this.clientApiModel = options.model || null;
         this.clientApiKey = null;
@@ -70300,6 +70386,8 @@ var init_ProbeAgent = __esm({
           console.log(`[DEBUG] Maximum tool iterations configured: ${MAX_TOOL_ITERATIONS}`);
           console.log(`[DEBUG] Allow Edit (implement tool): ${this.allowEdit}`);
           console.log(`[DEBUG] Search delegation enabled: ${this.searchDelegate}`);
+          console.log(`[DEBUG] Workspace root: ${this.workspaceRoot}`);
+          console.log(`[DEBUG] Working directory (cwd): ${this.cwd}`);
         }
         this.initializeTools();
         this.history = [];
@@ -70647,8 +70735,9 @@ var init_ProbeAgent = __esm({
         const configOptions = {
           sessionId: this.sessionId,
           debug: this.debug,
-          // Use explicit cwd if set, otherwise fall back to first allowed folder
-          cwd: this.cwd || (this.allowedFolders.length > 0 ? this.allowedFolders[0] : process.cwd()),
+          // Use cwd (which defaults to workspaceRoot in constructor)
+          cwd: this.cwd,
+          workspaceRoot: this.workspaceRoot,
           allowedFolders: this.allowedFolders,
           outline: this.outline,
           searchDelegate: this.searchDelegate,
@@ -71335,16 +71424,16 @@ var init_ProbeAgent = __esm({
           let absolutePath;
           let isPathAllowed2 = false;
           if (isAbsolute5(imagePath)) {
-            absolutePath = normalize2(resolve6(imagePath));
+            absolutePath = safeRealpath(resolve6(imagePath));
             isPathAllowed2 = allowedDirs.some((dir) => {
-              const normalizedDir = normalize2(resolve6(dir));
-              return absolutePath === normalizedDir || absolutePath.startsWith(normalizedDir + sep5);
+              const resolvedDir = safeRealpath(dir);
+              return absolutePath === resolvedDir || absolutePath.startsWith(resolvedDir + sep5);
             });
           } else {
             for (const dir of allowedDirs) {
-              const normalizedDir = normalize2(resolve6(dir));
-              const resolvedPath = normalize2(resolve6(dir, imagePath));
-              if (resolvedPath === normalizedDir || resolvedPath.startsWith(normalizedDir + sep5)) {
+              const resolvedDir = safeRealpath(dir);
+              const resolvedPath = safeRealpath(resolve6(dir, imagePath));
+              if (resolvedPath === resolvedDir || resolvedPath.startsWith(resolvedDir + sep5)) {
                 absolutePath = resolvedPath;
                 isPathAllowed2 = true;
                 break;
@@ -71527,7 +71616,7 @@ var init_ProbeAgent = __esm({
         if (this._architectureContextLoaded) {
           return this.architectureContext;
         }
-        const rootDirectory = this.allowedFolders.length > 0 ? this.allowedFolders[0] : process.cwd();
+        const rootDirectory = this.workspaceRoot || (this.allowedFolders.length > 0 ? this.allowedFolders[0] : process.cwd());
         const configuredName = typeof this.architectureFileName === "string" ? this.architectureFileName.trim() : "";
         const hasConfiguredName = !!configuredName;
         let guidanceCandidates = [];
@@ -71664,6 +71753,9 @@ ${this.architectureContext.content}
 `;
       }
       _getSkillsRepoRoot() {
+        if (this.workspaceRoot) {
+          return resolve6(this.workspaceRoot);
+        }
         if (this.allowedFolders && this.allowedFolders.length > 0) {
           return resolve6(this.allowedFolders[0]);
         }
@@ -71731,7 +71823,7 @@ Workspace: ${this.allowedFolders.join(", ")}`;
 
 # Repository Structure
 `;
-          systemPrompt += `You are working with a repository located at: ${this.allowedFolders[0]}
+          systemPrompt += `You are working with a repository located at: ${this.workspaceRoot}
 
 `;
           systemPrompt += `Here's an overview of the repository structure (showing up to 100 most relevant files):
@@ -71784,7 +71876,7 @@ Workspace: ${this.allowedFolders.join(", ")}`;
 
 # Repository Structure
 `;
-          systemPrompt += `You are working with a repository located at: ${this.allowedFolders[0]}
+          systemPrompt += `You are working with a repository located at: ${this.workspaceRoot}
 
 `;
           systemPrompt += `Here's an overview of the repository structure (showing up to 100 most relevant files):
@@ -72083,21 +72175,34 @@ For MCP tools, use JSON format within the params tag, e.g.:
 `;
           }
         }
-        const searchDirectory = this.allowedFolders.length > 0 ? this.allowedFolders[0] : process.cwd();
+        const searchDirectory = this.workspaceRoot;
         if (this.debug) {
-          console.log(`[DEBUG] Generating file list for base directory: ${searchDirectory}...`);
+          console.log(`[DEBUG] Generating file list for workspace root: ${searchDirectory}...`);
+        }
+        const relativeWorkspaces = this.allowedFolders.map((f) => {
+          const rel = toRelativePath(f, this.workspaceRoot);
+          if (rel && rel !== "." && !rel.startsWith(".") && !rel.startsWith("/")) {
+            return "./" + rel;
+          }
+          return rel;
+        }).filter((f) => f && f !== ".");
+        let workspaceDesc;
+        if (relativeWorkspaces.length === 0) {
+          workspaceDesc = ". (current directory)";
+        } else {
+          workspaceDesc = relativeWorkspaces.join(", ");
         }
         try {
           const files = await listFilesByLevel({
             directory: searchDirectory,
             maxFiles: 100,
             respectGitignore: !process.env.PROBE_NO_GITIGNORE || process.env.PROBE_NO_GITIGNORE === "",
-            cwd: process.cwd()
+            cwd: this.workspaceRoot
           });
           systemMessage += `
 # Repository Structure
 
-You are working with a repository located at: ${searchDirectory}
+You are working with a workspace. Available paths: ${workspaceDesc}
 
 Here's an overview of the repository structure (showing up to 100 most relevant files):
 
@@ -72113,15 +72218,22 @@ ${files}
           systemMessage += `
 # Repository Structure
 
-You are working with a repository located at: ${searchDirectory}
+You are working with a workspace. Available paths: ${workspaceDesc}
 
 `;
         }
         await this.loadArchitectureContext();
         systemMessage += this.getArchitectureSection();
         if (this.allowedFolders.length > 0) {
+          const relativeAllowed = this.allowedFolders.map((f) => {
+            const rel = toRelativePath(f, this.workspaceRoot);
+            if (rel && rel !== "." && !rel.startsWith(".") && !rel.startsWith("/")) {
+              return "./" + rel;
+            }
+            return rel;
+          });
           systemMessage += `
-**Important**: For security reasons, you can only search within these allowed folders: ${this.allowedFolders.join(", ")}
+**Important**: For security reasons, you can only access these paths: ${relativeAllowed.join(", ")}
 
 `;
         }
@@ -72635,6 +72747,7 @@ You are working with a repository located at: ${searchDirectory}
                       console.error(`[DEBUG] ========================================
 `);
                     }
+                    currentMessages.push({ role: "assistant", content: assistantResponseContent });
                     currentMessages.push({ role: "user", content: `<tool_result>
 ${toolResultContent}
 </tool_result>` });
@@ -72655,17 +72768,18 @@ ${toolResultContent}
 `);
                     }
                     const errorXml = formatErrorForAI(error);
+                    currentMessages.push({ role: "assistant", content: assistantResponseContent });
                     currentMessages.push({ role: "user", content: `<tool_result>
 ${errorXml}
 </tool_result>` });
                   }
                 } else if (this.toolImplementations[toolName]) {
                   try {
-                    let resolvedWorkingDirectory = this.cwd || this.allowedFolders && this.allowedFolders[0] || process.cwd();
+                    let resolvedWorkingDirectory = this.workspaceRoot || this.cwd || this.allowedFolders && this.allowedFolders[0] || process.cwd();
                     if (params.workingDirectory) {
-                      const requestedDir = isAbsolute5(params.workingDirectory) ? resolve6(params.workingDirectory) : resolve6(resolvedWorkingDirectory, params.workingDirectory);
+                      const requestedDir = safeRealpath(isAbsolute5(params.workingDirectory) ? resolve6(params.workingDirectory) : resolve6(resolvedWorkingDirectory, params.workingDirectory));
                       const isWithinAllowed = !this.allowedFolders || this.allowedFolders.length === 0 || this.allowedFolders.some((folder) => {
-                        const resolvedFolder = resolve6(folder);
+                        const resolvedFolder = safeRealpath(folder);
                         return requestedDir === resolvedFolder || requestedDir.startsWith(resolvedFolder + sep5);
                       });
                       if (isWithinAllowed) {
@@ -73134,7 +73248,7 @@ Convert your previous response content into actual JSON data that follows this s
                   }
                   const mermaidValidation = await validateAndFixMermaidResponse(finalResult, {
                     debug: this.debug,
-                    path: this.allowedFolders[0],
+                    path: this.workspaceRoot || this.allowedFolders[0],
                     provider: this.clientApiProvider,
                     model: this.model,
                     tracer: this.tracer
@@ -73207,7 +73321,7 @@ Convert your previous response content into actual JSON data that follows this s
                   }
                   const { JsonFixingAgent: JsonFixingAgent2 } = await Promise.resolve().then(() => (init_schemaUtils(), schemaUtils_exports));
                   const jsonFixer = new JsonFixingAgent2({
-                    path: this.allowedFolders[0],
+                    path: this.workspaceRoot || this.allowedFolders[0],
                     provider: this.clientApiProvider,
                     model: this.model,
                     debug: this.debug,
@@ -73276,7 +73390,7 @@ Convert your previous response content into actual JSON data that follows this s
                 }
                 const mermaidValidation = await validateAndFixMermaidResponse(finalResult, {
                   debug: this.debug,
-                  path: this.allowedFolders[0],
+                  path: this.workspaceRoot || this.allowedFolders[0],
                   provider: this.clientApiProvider,
                   model: this.model,
                   tracer: this.tracer
@@ -73408,7 +73522,7 @@ Convert your previous response content into actual JSON data that follows this s
               }
               const finalMermaidValidation = await validateAndFixMermaidResponse(finalResult, {
                 debug: this.debug,
-                path: this.allowedFolders[0],
+                path: this.workspaceRoot || this.allowedFolders[0],
                 provider: this.clientApiProvider,
                 model: this.model,
                 tracer: this.tracer
@@ -73558,8 +73672,7 @@ Convert your previous response content into actual JSON data that follows this s
           allowEdit: this.allowEdit,
           enableDelegate: this.enableDelegate,
           architectureFileName: this.architectureFileName,
-          path: this.allowedFolders[0],
-          // Use first allowed folder as primary path
+          // Pass allowedFolders which will recompute workspaceRoot correctly
           allowedFolders: [...this.allowedFolders],
           cwd: this.cwd,
           // Preserve explicit working directory

package/build/tools/analyzeAll.js

@@ -514,6 +514,7 @@ export async function analyzeAll(options) {
 		sessionId,
 		debug = false,
 		cwd,
+		workspaceRoot,
 		allowedFolders,
 		provider,
 		model,
@@ -527,10 +528,14 @@ export async function analyzeAll(options) {
 		throw new Error('The "question" parameter is required.');
 	}
 
+	// Use workspaceRoot (computed common prefix) for consistent path handling
+	// Consistent fallback chain: workspaceRoot > cwd > allowedFolders[0] > path
+	const effectiveWorkspaceRoot = workspaceRoot || cwd || allowedFolders?.[0] || path;
+
 	const delegateOptions = {
 		debug,
 		sessionId,
-		path: allowedFolders?.[0] || cwd || path,
+		path: effectiveWorkspaceRoot,
 		allowedFolders,
 		provider,
 		model,

package/build/tools/bash.js

@@ -7,6 +7,7 @@ import { tool } from 'ai';
 import { resolve, isAbsolute, sep } from 'path';
 import { BashPermissionChecker } from '../agent/bashPermissions.js';
 import { executeBashCommand, formatExecutionResult, validateExecutionOptions } from '../agent/bashExecutor.js';
+import { toRelativePath, safeRealpath } from '../utils/path-validation.js';
 
 /**
  * Bash tool generator
@@ -32,9 +33,14 @@ export const bashTool = (options = {}) => {
     debug = false,
     cwd,
     allowedFolders = [],
+    workspaceRoot: providedWorkspaceRoot,
     tracer = null
   } = options;
 
+  // Compute workspaceRoot with proper fallback chain
+  // Priority: explicit workspaceRoot > cwd > allowedFolders[0] > process.cwd()
+  const workspaceRoot = providedWorkspaceRoot || cwd || (allowedFolders.length > 0 && allowedFolders[0]) || process.cwd();
+
   // Create permission checker with tracer for telemetry
   const permissionChecker = new BashPermissionChecker({
     allow: bashConfig.allow,
@@ -46,6 +52,7 @@ export const bashTool = (options = {}) => {
   });
 
   // Determine default working directory
+  // Priority: explicit bashConfig.workingDirectory > cwd (which defaults to workspaceRoot) > fallback
   const getDefaultWorkingDirectory = () => {
     if (bashConfig.workingDirectory) {
       return bashConfig.workingDirectory;
@@ -53,6 +60,10 @@ export const bashTool = (options = {}) => {
     if (cwd) {
       return cwd;
     }
+    // Use workspaceRoot (computed common prefix) for consistency with other tools
+    if (workspaceRoot) {
+      return workspaceRoot;
+    }
     if (allowedFolders && allowedFolders.length > 0) {
       return allowedFolders[0];
     }
@@ -154,16 +165,20 @@ For code exploration, try these safe alternatives:
 
         // Validate working directory is within allowed folders if specified
         if (allowedFolders && allowedFolders.length > 0) {
-          const resolvedWorkingDir = resolve(workingDir);
+          // Use safeRealpath to resolve symlinks for security
+          // This prevents symlink bypass attacks (e.g., /tmp -> /private/tmp on macOS)
+          const resolvedWorkingDir = safeRealpath(workingDir);
           const isAllowed = allowedFolders.some(folder => {
-            const resolvedFolder = resolve(folder);
+            const resolvedFolder = safeRealpath(folder);
             // Use exact match OR startsWith with separator to prevent bypass attacks
             // e.g., '/tmp-malicious' should NOT match allowed folder '/tmp'
             return resolvedWorkingDir === resolvedFolder || resolvedWorkingDir.startsWith(resolvedFolder + sep);
           });
 
           if (!isAllowed) {
-            return `Error: Working directory "${workingDir}" is not within allowed folders: ${allowedFolders.join(', ')}`;
+            const relativeDir = toRelativePath(workingDir, workspaceRoot);
+            const relativeAllowed = allowedFolders.map(f => toRelativePath(f, workspaceRoot));
+            return `Error: Working directory "${relativeDir}" is not within allowed folders: ${relativeAllowed.join(', ')}`;
           }
         }