@probelabs/probe 0.6.0-rc224 → 0.6.0-rc226

package/cjs/agent/ProbeAgent.cjs

@@ -32675,6 +32675,25 @@ var init_error_types = __esm({
 });
 
 // src/utils/path-validation.js
+function safeRealpath(inputPath) {
+  try {
+    return (0, import_fs3.realpathSync)(inputPath);
+  } catch (error2) {
+    const normalized = import_path4.default.normalize(inputPath);
+    const parts = normalized.split(import_path4.default.sep);
+    for (let i5 = parts.length - 1; i5 >= 0; i5--) {
+      const ancestorPath = parts.slice(0, i5).join(import_path4.default.sep) || import_path4.default.sep;
+      try {
+        const resolvedAncestor = (0, import_fs3.realpathSync)(ancestorPath);
+        const remainingParts = parts.slice(i5);
+        return import_path4.default.join(resolvedAncestor, ...remainingParts);
+      } catch (ancestorError) {
+        continue;
+      }
+    }
+    return normalized;
+  }
+}
 async function validateCwdPath(inputPath, defaultPath = process.cwd()) {
   const targetPath = inputPath || defaultPath;
   const normalizedPath = import_path4.default.normalize(import_path4.default.resolve(targetPath));
@@ -32707,6 +32726,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((f5) => safeRealpath(f5));
+  const segments = normalized.map((f5) => f5.split(import_path4.default.sep));
+  const minLen = Math.min(...segments.map((s5) => s5.length));
+  const commonSegments = [];
+  for (let i5 = 0; i5 < minLen; i5++) {
+    const segment = segments[0][i5];
+    if (segments.every((s5) => s5[i5] === 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(import_path4.default.sep);
+}
+function toRelativePath(absolutePath, workspaceRoot) {
+  if (!absolutePath || !workspaceRoot) {
+    return absolutePath;
+  }
+  let normalized = safeRealpath(absolutePath);
+  let normalizedRoot = safeRealpath(workspaceRoot);
+  while (normalizedRoot.length > 1 && normalizedRoot.endsWith(import_path4.default.sep)) {
+    normalizedRoot = normalizedRoot.slice(0, -1);
+  }
+  if (normalized === normalizedRoot) {
+    return ".";
+  }
+  if (normalized.startsWith(normalizedRoot + import_path4.default.sep)) {
+    return import_path4.default.relative(normalizedRoot, normalized);
+  }
+  return absolutePath;
+}
 var import_path4, import_fs3;
 var init_path_validation = __esm({
   "src/utils/path-validation.js"() {
@@ -33904,6 +33970,7 @@ async function analyzeAll(options) {
     sessionId,
     debug = false,
     cwd,
+    workspaceRoot,
     allowedFolders,
     provider,
     model,
@@ -33916,10 +33983,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,
@@ -38132,21 +38200,24 @@ var init_zod = __esm({
 // src/tools/edit.js
 function isPathAllowed(filePath, allowedFolders) {
   if (!allowedFolders || allowedFolders.length === 0) {
-    const resolvedPath3 = (0, import_path5.resolve)(filePath);
-    const cwd = (0, import_path5.resolve)(process.cwd());
+    const resolvedPath3 = safeRealpath(filePath);
+    const cwd = safeRealpath(process.cwd());
     return resolvedPath3 === cwd || resolvedPath3.startsWith(cwd + import_path5.sep);
   }
-  const resolvedPath2 = (0, import_path5.resolve)(filePath);
+  const resolvedPath2 = safeRealpath(filePath);
   return allowedFolders.some((folder) => {
-    const allowedPath = (0, import_path5.resolve)(folder);
+    const allowedPath = safeRealpath(folder);
     return resolvedPath2 === allowedPath || resolvedPath2.startsWith(allowedPath + import_path5.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 import_ai, import_fs4, import_path5, import_fs5, editTool, createTool, editSchema, createSchema, editDescription, createDescription, editToolDefinition, createToolDefinition;
@@ -38157,8 +38228,9 @@ var init_edit = __esm({
     import_fs4 = require("fs");
     import_path5 = require("path");
     import_fs5 = require("fs");
+    init_path_validation();
     editTool = (options = {}) => {
-      const { debug, allowedFolders, cwd } = parseFileToolOptions(options);
+      const { debug, allowedFolders, cwd, workspaceRoot } = parseFileToolOptions(options);
       return (0, import_ai.tool)({
         name: "edit",
         description: `Edit files using exact string replacement (Claude Code style).
@@ -38214,7 +38286,8 @@ Important:
               console.error(`[Edit] Attempting to edit file: ${resolvedPath2}`);
             }
             if (!isPathAllowed(resolvedPath2, allowedFolders)) {
-              return `Error editing file: Permission denied - ${file_path} is outside allowed directories`;
+              const relativePath = toRelativePath(resolvedPath2, workspaceRoot);
+              return `Error editing file: Permission denied - ${relativePath} is outside allowed directories`;
             }
             if (!(0, import_fs5.existsSync)(resolvedPath2)) {
               return `Error editing file: File not found - ${file_path}`;
@@ -38250,7 +38323,7 @@ Important:
       });
     };
     createTool = (options = {}) => {
-      const { debug, allowedFolders, cwd } = parseFileToolOptions(options);
+      const { debug, allowedFolders, cwd, workspaceRoot } = parseFileToolOptions(options);
       return (0, import_ai.tool)({
         name: "create",
         description: `Create new files with specified content.
@@ -38298,7 +38371,8 @@ Important:
               console.error(`[Create] Attempting to create file: ${resolvedPath2}`);
             }
             if (!isPathAllowed(resolvedPath2, allowedFolders)) {
-              return `Error creating file: Permission denied - ${file_path} is outside allowed directories`;
+              const relativePath = toRelativePath(resolvedPath2, workspaceRoot);
+              return `Error creating file: Permission denied - ${relativePath} is outside allowed directories`;
             }
             if ((0, import_fs5.existsSync)(resolvedPath2) && !overwrite) {
               return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
@@ -39860,7 +39934,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 (0, import_ai2.tool)({
         name: "delegate",
         description: delegateDescription,
@@ -39893,8 +39967,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) {
@@ -39931,7 +40005,7 @@ var init_vercel = __esm({
       });
     };
     analyzeAllTool = (options = {}) => {
-      const { sessionId, debug = false, delegationManager = null } = options;
+      const { sessionId, debug = false, delegationManager = null, workspaceRoot } = options;
       return (0, import_ai2.tool)({
         name: "analyze_all",
         description: analyzeAllDescription,
@@ -39950,12 +40024,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,
@@ -41432,14 +41508,17 @@ var init_bash = __esm({
     import_path8 = require("path");
     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,
@@ -41455,6 +41534,9 @@ var init_bash = __esm({
         if (cwd) {
           return cwd;
         }
+        if (workspaceRoot) {
+          return workspaceRoot;
+        }
         if (allowedFolders && allowedFolders.length > 0) {
           return allowedFolders[0];
         }
@@ -41542,13 +41624,15 @@ For code exploration, try these safe alternatives:
             const defaultDir = getDefaultWorkingDirectory();
             const workingDir = workingDirectory ? (0, import_path8.isAbsolute)(workingDirectory) ? (0, import_path8.resolve)(workingDirectory) : (0, import_path8.resolve)(defaultDir, workingDirectory) : defaultDir;
             if (allowedFolders && allowedFolders.length > 0) {
-              const resolvedWorkingDir = (0, import_path8.resolve)(workingDir);
+              const resolvedWorkingDir = safeRealpath(workingDir);
               const isAllowed = allowedFolders.some((folder) => {
-                const resolvedFolder = (0, import_path8.resolve)(folder);
+                const resolvedFolder = safeRealpath(folder);
                 return resolvedWorkingDir === resolvedFolder || resolvedWorkingDir.startsWith(resolvedFolder + import_path8.sep);
               });
               if (!isAllowed) {
-                return `Error: Working directory "${workingDir}" is not within allowed folders: ${allowedFolders.join(", ")}`;
+                const relativeDir = toRelativePath(workingDir, workspaceRoot);
+                const relativeAllowed = allowedFolders.map((f5) => toRelativePath(f5, workspaceRoot));
+                return `Error: Working directory "${relativeDir}" is not within allowed folders: ${relativeAllowed.join(", ")}`;
               }
             }
             const executionOptions = {
@@ -45715,7 +45799,7 @@ var init_esm3 = __esm({
 });
 
 // node_modules/path-scurry/dist/esm/index.js
-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 import_node_path, import_node_url, import_fs9, actualFS, import_promises, 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();
@@ -45725,13 +45809,13 @@ var init_esm4 = __esm({
     actualFS = __toESM(require("node:fs"), 1);
     import_promises = require("node:fs/promises");
     init_esm3();
-    realpathSync = import_fs9.realpathSync.native;
+    realpathSync2 = import_fs9.realpathSync.native;
     defaultFS = {
       lstatSync: import_fs9.lstatSync,
       readdir: import_fs9.readdir,
       readdirSync: import_fs9.readdirSync,
       readlinkSync: import_fs9.readlinkSync,
-      realpathSync,
+      realpathSync: realpathSync2,
       promises: {
         lstat: import_promises.lstat,
         readdir: import_promises.readdir,
@@ -49551,11 +49635,12 @@ function createTools(configOptions) {
   return tools2;
 }
 function parseXmlToolCallWithThinking(xmlString, validTools) {
-  const { cleanedXmlString, recoveryResult } = processXmlWithThinkingAndRecovery(xmlString, validTools);
+  const { cleanedXmlString, recoveryResult, thinkingContent } = processXmlWithThinkingAndRecovery(xmlString, validTools);
   if (recoveryResult) {
-    return recoveryResult;
+    return { ...recoveryResult, thinkingContent };
   }
-  return parseXmlToolCall(cleanedXmlString, validTools);
+  const toolCall = parseXmlToolCall(cleanedXmlString, validTools);
+  return toolCall ? { ...toolCall, thinkingContent } : null;
 }
 var import_crypto4, implementToolDefinition, listFilesToolDefinition, searchFilesToolDefinition, listSkillsToolDefinition, useSkillToolDefinition, readImageToolDefinition;
 var init_tools2 = __esm({
@@ -88850,25 +88935,27 @@ function parseXmlMcpToolCall(xmlString, mcpToolNames = []) {
 function parseHybridXmlToolCall(xmlString, nativeTools = [], mcpBridge = null) {
   const nativeResult = parseNativeXmlToolWithThinking(xmlString, nativeTools);
   if (nativeResult) {
-    return { ...nativeResult, type: "native" };
+    const { thinkingContent, ...rest } = nativeResult;
+    return { ...rest, type: "native", thinkingContent };
   }
   if (mcpBridge) {
     const mcpResult = parseXmlMcpToolCall(xmlString, mcpBridge.getToolNames());
     if (mcpResult) {
-      return { ...mcpResult, type: "mcp" };
+      const { thinkingContent } = processXmlWithThinkingAndRecovery(xmlString, []);
+      return { ...mcpResult, type: "mcp", thinkingContent };
     }
   }
   return null;
 }
 function parseNativeXmlToolWithThinking(xmlString, validTools) {
-  const { cleanedXmlString, recoveryResult } = processXmlWithThinkingAndRecovery(xmlString, validTools);
+  const { cleanedXmlString, recoveryResult, thinkingContent } = processXmlWithThinkingAndRecovery(xmlString, validTools);
   if (recoveryResult) {
-    return recoveryResult;
+    return { ...recoveryResult, thinkingContent };
   }
   for (const toolName of validTools) {
     const result = parseNativeXmlTool(cleanedXmlString, toolName);
     if (result) {
-      return result;
+      return { ...result, thinkingContent };
     }
   }
   return null;
@@ -99123,6 +99210,7 @@ var init_ProbeAgent = __esm({
     init_FallbackManager();
     init_contextCompactor();
     init_error_types();
+    init_path_validation();
     init_outputTruncator();
     init_delegate();
     init_tasks();
@@ -99240,7 +99328,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;
@@ -99252,6 +99341,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 = [];
@@ -99329,6 +99420,181 @@ var init_ProbeAgent = __esm({
       _filterMcpTools(mcpToolNames) {
         return mcpToolNames.filter((toolName) => this._isMcpToolAllowed(toolName));
       }
+      /**
+       * Check if tracer is AppTracer (expects sessionId as first param) vs SimpleAppTracer
+       * @returns {boolean} - True if tracer is AppTracer style (requires sessionId)
+       * @private
+       */
+      _isAppTracerStyle() {
+        return this.tracer && typeof this.tracer.sessionSpans !== "undefined";
+      }
+      /**
+       * Record an error classification event for telemetry
+       * Provides unified error recording across all error types
+       * @param {string} errorType - Error type (wrapped_tool, unrecognized_tool, no_tool_call, circuit_breaker)
+       * @param {string} message - Error message
+       * @param {Object} context - Additional context data
+       * @param {number} iteration - Current iteration number
+       * @private
+       */
+      _recordErrorTelemetry(errorType, message, context, iteration) {
+        if (!this.tracer) return;
+        if (this._isAppTracerStyle() && typeof this.tracer.recordErrorClassification === "function") {
+          this.tracer.recordErrorClassification(this.sessionId, iteration, errorType, {
+            message,
+            context
+          });
+        } else if (typeof this.tracer.recordErrorEvent === "function") {
+          this.tracer.recordErrorEvent(errorType, {
+            message,
+            context: { ...context, iteration }
+          });
+        } else {
+          this.tracer.addEvent(`error.${errorType}`, {
+            "error.type": errorType,
+            "error.message": message,
+            "error.recoverable": errorType !== "circuit_breaker",
+            "error.context": JSON.stringify(context).substring(0, 1e3),
+            "iteration": iteration
+          });
+        }
+      }
+      /**
+       * Record AI thinking content for telemetry
+       * @param {string} thinkingContent - The thinking content
+       * @param {number} iteration - Current iteration number
+       * @private
+       */
+      _recordThinkingTelemetry(thinkingContent, iteration) {
+        if (!this.tracer || !thinkingContent) return;
+        if (this._isAppTracerStyle() && typeof this.tracer.recordThinkingContent === "function") {
+          this.tracer.recordThinkingContent(this.sessionId, iteration, thinkingContent);
+        } else if (typeof this.tracer.recordThinkingContent === "function") {
+          this.tracer.recordThinkingContent(thinkingContent, { iteration });
+        } else {
+          this.tracer.addEvent("ai.thinking", {
+            "ai.thinking.content": thinkingContent.substring(0, 5e4),
+            "ai.thinking.length": thinkingContent.length,
+            "iteration": iteration
+          });
+        }
+      }
+      /**
+       * Record AI tool decision for telemetry
+       * @param {string} toolName - The tool name
+       * @param {Object} params - Tool parameters
+       * @param {number} responseLength - Length of AI response
+       * @param {number} iteration - Current iteration number
+       * @private
+       */
+      _recordToolDecisionTelemetry(toolName, params, responseLength, iteration) {
+        if (!this.tracer) return;
+        if (this._isAppTracerStyle() && typeof this.tracer.recordAIToolDecision === "function") {
+          this.tracer.recordAIToolDecision(this.sessionId, iteration, toolName, params);
+        } else if (typeof this.tracer.recordToolDecision === "function") {
+          this.tracer.recordToolDecision(toolName, params, {
+            iteration,
+            "ai.tool_decision.raw_response_length": responseLength
+          });
+        } else {
+          this.tracer.addEvent("ai.tool_decision", {
+            "ai.tool_decision.name": toolName,
+            "ai.tool_decision.params": JSON.stringify(params || {}).substring(0, 2e3),
+            "ai.tool_decision.raw_response_length": responseLength,
+            "iteration": iteration
+          });
+        }
+      }
+      /**
+       * Record tool result for telemetry
+       * @param {string} toolName - The tool name
+       * @param {string|Object} result - Tool result
+       * @param {boolean} success - Whether tool succeeded
+       * @param {number} durationMs - Execution duration in milliseconds
+       * @param {number} iteration - Current iteration number
+       * @private
+       */
+      _recordToolResultTelemetry(toolName, result, success, durationMs, iteration) {
+        if (!this.tracer) return;
+        if (this._isAppTracerStyle() && typeof this.tracer.recordToolResult === "function") {
+          this.tracer.recordToolResult(this.sessionId, iteration, toolName, result, success, durationMs);
+        } else if (typeof this.tracer.recordToolResult === "function") {
+          this.tracer.recordToolResult(toolName, result, success, durationMs, { iteration });
+        } else {
+          const resultStr = typeof result === "string" ? result : JSON.stringify(result || "");
+          this.tracer.addEvent("tool.result", {
+            "tool.name": toolName,
+            "tool.result": resultStr.substring(0, 1e4),
+            "tool.result.length": resultStr.length,
+            "tool.duration_ms": durationMs,
+            "tool.success": success,
+            "iteration": iteration
+          });
+        }
+      }
+      /**
+       * Record MCP tool lifecycle event for telemetry
+       * @param {string} phase - 'start' or 'end'
+       * @param {string} toolName - MCP tool name
+       * @param {Object} params - Tool parameters (for start) or null (for end)
+       * @param {number} iteration - Current iteration number
+       * @param {Object} [endData] - Additional data for end phase (result, success, durationMs, error)
+       * @private
+       */
+      _recordMcpToolTelemetry(phase, toolName, params, iteration, endData = null) {
+        if (!this.tracer) return;
+        if (phase === "start") {
+          if (this._isAppTracerStyle() && typeof this.tracer.recordMcpToolStart === "function") {
+            this.tracer.recordMcpToolStart(this.sessionId, iteration, toolName, "mcp", params);
+          } else if (typeof this.tracer.recordMcpToolStart === "function") {
+            this.tracer.recordMcpToolStart(toolName, "mcp", params, { iteration });
+          } else {
+            this.tracer.addEvent("mcp.tool.start", {
+              "mcp.tool.name": toolName,
+              "mcp.tool.server": "mcp",
+              "mcp.tool.params": JSON.stringify(params || {}).substring(0, 2e3),
+              "iteration": iteration
+            });
+          }
+        } else if (phase === "end" && endData) {
+          const { result, success, durationMs, error: error2 } = endData;
+          if (this._isAppTracerStyle() && typeof this.tracer.recordMcpToolEnd === "function") {
+            this.tracer.recordMcpToolEnd(this.sessionId, iteration, toolName, "mcp", result, success, durationMs, error2);
+          } else if (typeof this.tracer.recordMcpToolEnd === "function") {
+            this.tracer.recordMcpToolEnd(toolName, "mcp", result, success, durationMs, error2, { iteration });
+          } else {
+            const resultStr = typeof result === "string" ? result : JSON.stringify(result || "");
+            this.tracer.addEvent("mcp.tool.end", {
+              "mcp.tool.name": toolName,
+              "mcp.tool.server": "mcp",
+              "mcp.tool.result": resultStr.substring(0, 1e4),
+              "mcp.tool.result.length": resultStr.length,
+              "mcp.tool.duration_ms": durationMs,
+              "mcp.tool.success": success,
+              "mcp.tool.error": error2,
+              "iteration": iteration
+            });
+          }
+        }
+      }
+      /**
+       * Record iteration lifecycle event for telemetry
+       * @param {string} phase - 'end' (start is already handled elsewhere)
+       * @param {number} iteration - Current iteration number
+       * @param {Object} data - Additional iteration data
+       * @private
+       */
+      _recordIterationTelemetry(phase, iteration, data2 = {}) {
+        if (!this.tracer) return;
+        if (typeof this.tracer.recordIterationEvent === "function") {
+          this.tracer.recordIterationEvent(phase, iteration, data2);
+        } else {
+          this.tracer.addEvent(`iteration.${phase}`, {
+            "iteration": iteration,
+            ...data2
+          });
+        }
+      }
       /**
        * Initialize the agent asynchronously (must be called after constructor)
        * This method initializes MCP and merges MCP tools into the tool list, and loads history from storage
@@ -99424,8 +99690,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,
@@ -100112,16 +100379,16 @@ var init_ProbeAgent = __esm({
           let absolutePath;
           let isPathAllowed2 = false;
           if ((0, import_path17.isAbsolute)(imagePath)) {
-            absolutePath = (0, import_path17.normalize)((0, import_path17.resolve)(imagePath));
+            absolutePath = safeRealpath((0, import_path17.resolve)(imagePath));
             isPathAllowed2 = allowedDirs.some((dir) => {
-              const normalizedDir = (0, import_path17.normalize)((0, import_path17.resolve)(dir));
-              return absolutePath === normalizedDir || absolutePath.startsWith(normalizedDir + import_path17.sep);
+              const resolvedDir = safeRealpath(dir);
+              return absolutePath === resolvedDir || absolutePath.startsWith(resolvedDir + import_path17.sep);
             });
           } else {
             for (const dir of allowedDirs) {
-              const normalizedDir = (0, import_path17.normalize)((0, import_path17.resolve)(dir));
-              const resolvedPath2 = (0, import_path17.normalize)((0, import_path17.resolve)(dir, imagePath));
-              if (resolvedPath2 === normalizedDir || resolvedPath2.startsWith(normalizedDir + import_path17.sep)) {
+              const resolvedDir = safeRealpath(dir);
+              const resolvedPath2 = safeRealpath((0, import_path17.resolve)(dir, imagePath));
+              if (resolvedPath2 === resolvedDir || resolvedPath2.startsWith(resolvedDir + import_path17.sep)) {
                 absolutePath = resolvedPath2;
                 isPathAllowed2 = true;
                 break;
@@ -100304,7 +100571,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 = [];
@@ -100441,6 +100708,9 @@ ${this.architectureContext.content}
 `;
       }
       _getSkillsRepoRoot() {
+        if (this.workspaceRoot) {
+          return (0, import_path17.resolve)(this.workspaceRoot);
+        }
         if (this.allowedFolders && this.allowedFolders.length > 0) {
           return (0, import_path17.resolve)(this.allowedFolders[0]);
         }
@@ -100508,7 +100778,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):
@@ -100561,7 +100831,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):
@@ -100860,21 +101130,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((f5) => {
+          const rel = toRelativePath(f5, this.workspaceRoot);
+          if (rel && rel !== "." && !rel.startsWith(".") && !rel.startsWith("/")) {
+            return "./" + rel;
+          }
+          return rel;
+        }).filter((f5) => f5 && f5 !== ".");
+        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):
 
@@ -100890,15 +101173,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((f5) => {
+            const rel = toRelativePath(f5, 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(", ")}
 
 `;
         }
@@ -101283,8 +101573,12 @@ You are working with a repository located at: ${searchDirectory}
             }
             const nativeTools = validTools;
             const parsedTool = this.mcpBridge && !options._disableTools ? parseHybridXmlToolCall(assistantResponseContent, nativeTools, this.mcpBridge) : parseXmlToolCallWithThinking(assistantResponseContent, validTools);
+            if (parsedTool?.thinkingContent) {
+              this._recordThinkingTelemetry(parsedTool.thinkingContent, currentIteration);
+            }
             if (parsedTool) {
               const { toolName, params } = parsedTool;
+              this._recordToolDecisionTelemetry(toolName, params, assistantResponseContent.length, currentIteration);
               if (this.debug) console.log(`[DEBUG] Parsed tool call: ${toolName} with params:`, params);
               if (toolName === "attempt_completion") {
                 completionAttempted = true;
@@ -101361,6 +101655,8 @@ You are working with a repository located at: ${searchDirectory}
               } else {
                 const { type } = parsedTool;
                 if (type === "mcp" && this.mcpBridge && this.mcpBridge.isMcpTool(toolName)) {
+                  const mcpStartTime = Date.now();
+                  this._recordMcpToolTelemetry("start", toolName, params, currentIteration);
                   try {
                     if (this.debug) {
                       console.error(`
@@ -101390,6 +101686,13 @@ You are working with a repository located at: ${searchDirectory}
                     } catch (truncateError) {
                       console.error(`[WARN] Tool output truncation failed: ${truncateError.message}`);
                     }
+                    const mcpDurationMs = Date.now() - mcpStartTime;
+                    this._recordMcpToolTelemetry("end", toolName, null, currentIteration, {
+                      result: toolResultContent,
+                      success: true,
+                      durationMs: mcpDurationMs,
+                      error: null
+                    });
                     if (this.debug) {
                       const preview = toolResultContent.length > 500 ? toolResultContent.substring(0, 500) + "..." : toolResultContent;
                       console.error(`[DEBUG] ========================================`);
@@ -101399,10 +101702,18 @@ 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>` });
                   } catch (error2) {
+                    const mcpDurationMs = Date.now() - mcpStartTime;
+                    this._recordMcpToolTelemetry("end", toolName, null, currentIteration, {
+                      result: null,
+                      success: false,
+                      durationMs: mcpDurationMs,
+                      error: error2.message
+                    });
                     console.error(`Error executing MCP tool ${toolName}:`, error2);
                     if (this.debug) {
                       console.error(`[DEBUG] ========================================`);
@@ -101412,17 +101723,18 @@ ${toolResultContent}
 `);
                     }
                     const errorXml = formatErrorForAI(error2);
+                    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 = (0, import_path17.isAbsolute)(params.workingDirectory) ? (0, import_path17.resolve)(params.workingDirectory) : (0, import_path17.resolve)(resolvedWorkingDirectory, params.workingDirectory);
+                      const requestedDir = safeRealpath((0, import_path17.isAbsolute)(params.workingDirectory) ? (0, import_path17.resolve)(params.workingDirectory) : (0, import_path17.resolve)(resolvedWorkingDirectory, params.workingDirectory));
                       const isWithinAllowed = !this.allowedFolders || this.allowedFolders.length === 0 || this.allowedFolders.some((folder) => {
-                        const resolvedFolder = (0, import_path17.resolve)(folder);
+                        const resolvedFolder = safeRealpath(folder);
                         return requestedDir === resolvedFolder || requestedDir.startsWith(resolvedFolder + import_path17.sep);
                       });
                       if (isWithinAllowed) {
@@ -101494,6 +101806,7 @@ ${errorXml}
                       return await this.toolImplementations[toolName].execute(toolParams);
                     };
                     let toolResult;
+                    const toolStartTime = Date.now();
                     try {
                       if (this.tracer) {
                         toolResult = await this.tracer.withSpan("tool.call", executeToolCall, {
@@ -101504,6 +101817,8 @@ ${errorXml}
                       } else {
                         toolResult = await executeToolCall();
                       }
+                      const toolDurationMs = Date.now() - toolStartTime;
+                      this._recordToolResultTelemetry(toolName, toolResult, true, toolDurationMs, currentIteration);
                       if (this.debug) {
                         const resultPreview = typeof toolResult === "string" ? toolResult.length > 500 ? toolResult.substring(0, 500) + "..." : toolResult : toolResult ? JSON.stringify(toolResult, null, 2).substring(0, 500) + "..." : "No Result";
                         console.error(`[DEBUG] ========================================`);
@@ -101560,6 +101875,20 @@ ${toolResultContent}
                       role: "user",
                       content: toolResultMessage
                     });
+                    if (this.tracer) {
+                      if (typeof this.tracer.recordConversationTurn === "function") {
+                        this.tracer.recordConversationTurn("assistant", assistantResponseContent, {
+                          iteration: currentIteration,
+                          has_tool_call: true,
+                          tool_name: toolName
+                        });
+                        this.tracer.recordConversationTurn("tool_result", toolResultContent, {
+                          iteration: currentIteration,
+                          tool_name: toolName,
+                          tool_success: true
+                        });
+                      }
+                    }
                     if (this.debug) {
                       console.log(`[DEBUG] Tool ${toolName} executed successfully. Result length: ${typeof toolResult === "string" ? toolResult.length : JSON.stringify(toolResult).length}`);
                     }
@@ -101630,6 +101959,7 @@ ${errorXml}
                 if (this.debug) {
                   console.log(`[DEBUG] Detected wrapped tool '${wrappedToolName}' in assistant response - wrong XML format.`);
                 }
+                this._recordErrorTelemetry("wrapped_tool", "Tool call wrapped in markdown", { toolName: wrappedToolName }, currentIteration);
                 const toolError = new ParameterError(
                   `Tool '${wrappedToolName}' found but in WRONG FORMAT - do not wrap tools in other XML tags.`,
                   {
@@ -101655,6 +101985,7 @@ ${formatErrorForAI(toolError)}
                 if (this.debug) {
                   console.log(`[DEBUG] Detected unrecognized tool '${unrecognizedTool}' in assistant response.`);
                 }
+                this._recordErrorTelemetry("unrecognized_tool", `Unknown tool: ${unrecognizedTool}`, { toolName: unrecognizedTool, validTools }, currentIteration);
                 const toolError = new ParameterError(`Tool '${unrecognizedTool}' is not available in this context.`, {
                   suggestion: `Available tools: ${validTools.join(", ")}. Please use one of these tools instead.`
                 });
@@ -101662,6 +101993,7 @@ ${formatErrorForAI(toolError)}
 ${formatErrorForAI(toolError)}
 </tool_result>`;
               } else {
+                this._recordErrorTelemetry("no_tool_call", "AI response did not contain tool call", { responsePreview: assistantResponseContent.substring(0, 500) }, currentIteration);
                 if (currentIteration >= maxIterations) {
                   let cleanedResponse = assistantResponseContent;
                   cleanedResponse = cleanedResponse.replace(/<thinking>[\s\S]*?<\/thinking>/gi, "").trim();
@@ -101737,6 +102069,7 @@ Note: <attempt_complete></attempt_complete> reuses your PREVIOUS assistant messa
                   sameFormatErrorCount++;
                   if (sameFormatErrorCount >= MAX_REPEATED_FORMAT_ERRORS) {
                     const errorDesc = isWrapped ? "wrapped tool format" : unrecognizedTool;
+                    this._recordErrorTelemetry("circuit_breaker", "Format error limit exceeded", { formatErrorCount: sameFormatErrorCount, errorCategory }, currentIteration);
                     console.error(`[ERROR] Format error category '${errorCategory}' repeated ${sameFormatErrorCount} times. Breaking loop early to prevent infinite iteration.`);
                     finalResult = `Error: Unable to complete request. The AI model repeatedly used incorrect tool call format (${errorDesc}). Please try rephrasing your question or using a different model.`;
                     break;
@@ -101750,6 +102083,10 @@ Note: <attempt_complete></attempt_complete> reuses your PREVIOUS assistant messa
                 sameFormatErrorCount = 0;
               }
             }
+            this._recordIterationTelemetry("end", currentIteration, {
+              "iteration.completed": completionAttempted,
+              "iteration.message_count": currentMessages.length
+            });
             if (currentMessages.length > MAX_HISTORY_MESSAGES) {
               const messagesBefore = currentMessages.length;
               const systemMsg = currentMessages[0];
@@ -101866,7 +102203,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
@@ -101939,7 +102276,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,
@@ -102008,7 +102345,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
@@ -102140,7 +102477,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
@@ -102290,8 +102627,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