@probelabs/probe 0.6.0-rc269 → 0.6.0-rc271

package/cjs/index.cjs

@@ -108797,9 +108797,10 @@ You are working with a workspace. Available paths: ${workspaceDesc}
           }
           if (completionAttempted && this.completionPrompt && !options._completionPromptProcessed) {
             if (this.debug) {
-              console.log("[DEBUG] Running completion prompt for post-completion validation/review...");
+              console.log("[DEBUG] Running completion prompt as continuation of current session...");
             }
             try {
+              const originalResult = finalResult;
               if (this.tracer) {
                 this.tracer.recordEvent("completion_prompt.started", {
                   "completion_prompt.original_result_length": finalResult?.length || 0
@@ -108812,24 +108813,66 @@ Here is the result to review:
 ${finalResult}
 </result>
 
-After reviewing, provide your final answer using attempt_completion.`;
-              const savedOutputItems = this._outputBuffer ? [...this._outputBuffer.items] : [];
-              const savedExtractedBlocks = this._extractedRawBlocks ? [...this._extractedRawBlocks] : [];
-              const completionResult2 = await this.answer(completionPromptMessage, [], {
-                ...options,
-                _completionPromptProcessed: true
-              });
-              if (this._outputBuffer) {
-                this._outputBuffer.items = savedOutputItems;
+Double-check your response based on the criteria above. If everything looks good, respond with your previous answer exactly as-is using attempt_completion. If something needs to be fixed or is missing, do it now, then respond with the COMPLETE updated answer (everything you did in total, not just the fix) using attempt_completion.`;
+              currentMessages.push({ role: "user", content: completionPromptMessage });
+              completionResult = null;
+              completionAttempted = false;
+              const completionMaxIterations = 5;
+              const completionStreamOptions = {
+                model: this.provider ? this.provider(this.model) : this.model,
+                messages: this.prepareMessagesWithImages(currentMessages),
+                tools: tools2,
+                stopWhen: (0, import_ai4.stepCountIs)(completionMaxIterations),
+                maxTokens: maxResponseTokens,
+                temperature: 0.3,
+                onStepFinish: ({ toolResults, text, finishReason, usage }) => {
+                  if (usage) {
+                    this.tokenCounter.recordUsage(usage);
+                  }
+                  if (options.onStream && text) {
+                    options.onStream(text);
+                  }
+                  if (this.debug) {
+                    console.log(`[DEBUG] Completion prompt step finished (reason: ${finishReason}, tools: ${toolResults?.length || 0})`);
+                  }
+                }
+              };
+              const providerOpts = this._buildThinkingProviderOptions(maxResponseTokens);
+              if (providerOpts) {
+                completionStreamOptions.providerOptions = providerOpts;
+              }
+              const cpResult = await this.streamTextWithRetryAndFallback(completionStreamOptions);
+              const cpFinalText = await cpResult.text;
+              const cpUsage = await cpResult.usage;
+              if (cpUsage) {
+                this.tokenCounter.recordUsage(cpUsage, cpResult.experimental_providerMetadata);
+              }
+              const cpMessages = await cpResult.response?.messages;
+              if (cpMessages) {
+                for (const msg of cpMessages) {
+                  currentMessages.push(msg);
+                }
+              }
+              if (completionResult) {
+                finalResult = completionResult;
+                completionAttempted = true;
+              } else if (cpFinalText && cpFinalText.trim().length > 0) {
+                finalResult = cpFinalText;
+                completionAttempted = true;
+              } else {
+                finalResult = originalResult;
+                completionAttempted = true;
+                if (this.debug) {
+                  console.log("[DEBUG] Completion prompt returned empty result, keeping original.");
+                }
               }
-              this._extractedRawBlocks = savedExtractedBlocks;
-              finalResult = completionResult2;
               if (this.debug) {
-                console.log(`[DEBUG] Completion prompt finished. New result length: ${finalResult?.length || 0}`);
+                console.log(`[DEBUG] Completion prompt finished. Final result length: ${finalResult?.length || 0}`);
               }
               if (this.tracer) {
                 this.tracer.recordEvent("completion_prompt.completed", {
-                  "completion_prompt.final_result_length": finalResult?.length || 0
+                  "completion_prompt.final_result_length": finalResult?.length || 0,
+                  "completion_prompt.used_original": finalResult === originalResult
                 });
               }
             } catch (error2) {
@@ -110587,6 +110630,17 @@ function parseDelegatedTargets(rawResponse) {
   }
   return normalizeTargets(fallbackTargetsFromText(trimmed));
 }
+function splitTargetSuffix(target) {
+  const searchStart = target.length > 2 && target[1] === ":" && /[a-zA-Z]/.test(target[0]) ? 2 : 0;
+  const colonIdx = target.indexOf(":", searchStart);
+  const hashIdx = target.indexOf("#");
+  if (colonIdx !== -1 && (hashIdx === -1 || colonIdx < hashIdx)) {
+    return { filePart: target.substring(0, colonIdx), suffix: target.substring(colonIdx) };
+  } else if (hashIdx !== -1) {
+    return { filePart: target.substring(0, hashIdx), suffix: target.substring(hashIdx) };
+  }
+  return { filePart: target, suffix: "" };
+}
 function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, allowTests }) {
   return [
     "You are a code-search subagent. Your job is to find ALL relevant code locations for the given query.",
@@ -110615,7 +110669,7 @@ function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, all
     "Deduplicate targets. Do NOT explain or answer - ONLY return the JSON targets."
   ].join("\n");
 }
-var import_ai5, CODE_SEARCH_SCHEMA, searchTool, queryTool, extractTool, delegateTool, analyzeAllTool;
+var import_ai5, import_fs11, CODE_SEARCH_SCHEMA, searchTool, queryTool, extractTool, delegateTool, analyzeAllTool;
 var init_vercel = __esm({
   "src/tools/vercel.js"() {
     "use strict";
@@ -110626,6 +110680,7 @@ var init_vercel = __esm({
     init_delegate();
     init_analyzeAll();
     init_common2();
+    import_fs11 = require("fs");
     init_error_types();
     init_hashline();
     CODE_SEARCH_SCHEMA = {
@@ -110751,10 +110806,47 @@ var init_vercel = __esm({
               }
               return fallbackResult;
             }
+            const delegateBase = options.allowedFolders?.[0] || options.cwd || ".";
             const resolutionBase = searchPaths[0] || options.cwd || ".";
-            const resolvedTargets = targets.map((target) => resolveTargetPath(target, resolutionBase));
+            const resolvedTargets = targets.map((target) => resolveTargetPath(target, delegateBase));
+            const validatedTargets = [];
+            for (const target of resolvedTargets) {
+              const { filePart, suffix } = splitTargetSuffix(target);
+              if ((0, import_fs11.existsSync)(filePart)) {
+                validatedTargets.push(target);
+                continue;
+              }
+              let fixed = false;
+              const parts = filePart.split("/").filter(Boolean);
+              for (let i5 = 0; i5 < parts.length - 1; i5++) {
+                if (parts[i5] === parts[i5 + 1]) {
+                  const candidate = "/" + [...parts.slice(0, i5), ...parts.slice(i5 + 1)].join("/");
+                  if ((0, import_fs11.existsSync)(candidate)) {
+                    validatedTargets.push(candidate + suffix);
+                    if (debug) console.error(`[search-delegate] Fixed doubled path segment: ${filePart} \u2192 ${candidate}`);
+                    fixed = true;
+                    break;
+                  }
+                }
+              }
+              if (fixed) continue;
+              for (const altBase of [resolutionBase, options.cwd].filter(Boolean)) {
+                if (altBase === delegateBase) continue;
+                const altResolved = resolveTargetPath(target, altBase);
+                const { filePart: altFile } = splitTargetSuffix(altResolved);
+                if ((0, import_fs11.existsSync)(altFile)) {
+                  validatedTargets.push(altResolved);
+                  if (debug) console.error(`[search-delegate] Resolved with alt base: ${filePart} \u2192 ${altFile}`);
+                  fixed = true;
+                  break;
+                }
+              }
+              if (fixed) continue;
+              if (debug) console.error(`[search-delegate] Warning: target may not exist: ${filePart}`);
+              validatedTargets.push(target);
+            }
             const extractOptions = {
-              files: resolvedTargets,
+              files: validatedTargets,
               cwd: resolutionBase,
               allowTests: allow_tests ?? true
             };
@@ -111307,7 +111399,7 @@ Example: <edit><file_path>${file_path}</file_path><symbol>${allMatches[0].qualif
 Example: <extract><targets>${file_path}#${symbol15}</targets></extract>`;
     }
   }
-  const content = await import_fs11.promises.readFile(resolvedPath2, "utf-8");
+  const content = await import_fs12.promises.readFile(resolvedPath2, "utf-8");
   const lines = content.split("\n");
   if (position) {
     const refIndent = detectBaseIndent(symbolInfo.code);
@@ -111318,7 +111410,7 @@ Example: <extract><targets>${file_path}#${symbol15}</targets></extract>`;
     } else {
       lines.splice(symbolInfo.startLine - 1, 0, ...newLines, "");
     }
-    await import_fs11.promises.writeFile(resolvedPath2, lines.join("\n"), "utf-8");
+    await import_fs12.promises.writeFile(resolvedPath2, lines.join("\n"), "utf-8");
     if (fileTracker) {
       const updated = await findSymbol(resolvedPath2, symbol15, cwd || process.cwd());
       if (updated) {
@@ -111336,7 +111428,7 @@ Example: <extract><targets>${file_path}#${symbol15}</targets></extract>`;
     const reindented = reindent(new_string, originalIndent);
     const newLines = reindented.split("\n");
     lines.splice(symbolInfo.startLine - 1, symbolInfo.endLine - symbolInfo.startLine + 1, ...newLines);
-    await import_fs11.promises.writeFile(resolvedPath2, lines.join("\n"), "utf-8");
+    await import_fs12.promises.writeFile(resolvedPath2, lines.join("\n"), "utf-8");
     if (fileTracker) {
       const updated = await findSymbol(resolvedPath2, symbol15, cwd || process.cwd());
       if (updated) {
@@ -111391,7 +111483,7 @@ async function handleLineEdit({ resolvedPath: resolvedPath2, file_path, start_li
   if (position !== void 0 && position !== null && position !== "before" && position !== "after") {
     return 'Error editing file: Invalid position - must be "before" or "after". Use position="before" to insert before the line, or position="after" to insert after it.';
   }
-  const content = await import_fs11.promises.readFile(resolvedPath2, "utf-8");
+  const content = await import_fs12.promises.readFile(resolvedPath2, "utf-8");
   const fileLines = content.split("\n");
   if (startLine > fileLines.length) {
     return `Error editing file: Line ${startLine} is beyond file length (${fileLines.length} lines). Use 'extract' to read the current file content.`;
@@ -111420,20 +111512,20 @@ async function handleLineEdit({ resolvedPath: resolvedPath2, file_path, start_li
   const newLines = cleaned === "" ? [] : cleaned.split("\n");
   if (position === "after") {
     fileLines.splice(startLine, 0, ...newLines);
-    await import_fs11.promises.writeFile(resolvedPath2, fileLines.join("\n"), "utf-8");
+    await import_fs12.promises.writeFile(resolvedPath2, fileLines.join("\n"), "utf-8");
     if (fileTracker) await fileTracker.trackFileAfterWrite(resolvedPath2);
     const action = `${newLines.length} line${newLines.length !== 1 ? "s" : ""} inserted after line ${startLine}`;
     return buildLineEditResponse(file_path, startLine, startLine, newLines.length, fileLines, startLine, action, modifications);
   } else if (position === "before") {
     fileLines.splice(startLine - 1, 0, ...newLines);
-    await import_fs11.promises.writeFile(resolvedPath2, fileLines.join("\n"), "utf-8");
+    await import_fs12.promises.writeFile(resolvedPath2, fileLines.join("\n"), "utf-8");
     if (fileTracker) await fileTracker.trackFileAfterWrite(resolvedPath2);
     const action = `${newLines.length} line${newLines.length !== 1 ? "s" : ""} inserted before line ${startLine}`;
     return buildLineEditResponse(file_path, startLine, startLine, newLines.length, fileLines, startLine - 1, action, modifications);
   } else {
     const replacedCount = endLine - startLine + 1;
     fileLines.splice(startLine - 1, replacedCount, ...newLines);
-    await import_fs11.promises.writeFile(resolvedPath2, fileLines.join("\n"), "utf-8");
+    await import_fs12.promises.writeFile(resolvedPath2, fileLines.join("\n"), "utf-8");
     if (fileTracker) await fileTracker.trackFileAfterWrite(resolvedPath2);
     let action;
     if (newLines.length === 0) {
@@ -111446,14 +111538,14 @@ async function handleLineEdit({ resolvedPath: resolvedPath2, file_path, start_li
     return buildLineEditResponse(file_path, startLine, endLine, newLines.length, fileLines, startLine - 1, action, modifications);
   }
 }
-var import_ai6, import_fs11, import_path16, import_fs12, editTool, createTool, multiEditTool, editSchema, createSchema, multiEditSchema, editDescription, createDescription, multiEditDescription, editToolDefinition, createToolDefinition, multiEditToolDefinition;
+var import_ai6, import_fs12, import_path16, import_fs13, editTool, createTool, multiEditTool, editSchema, createSchema, multiEditSchema, editDescription, createDescription, multiEditDescription, editToolDefinition, createToolDefinition, multiEditToolDefinition;
 var init_edit = __esm({
   "src/tools/edit.js"() {
     "use strict";
     import_ai6 = require("ai");
-    import_fs11 = require("fs");
-    import_path16 = require("path");
     import_fs12 = require("fs");
+    import_path16 = require("path");
+    import_fs13 = require("fs");
     init_path_validation();
     init_fuzzyMatch();
     init_symbolEdit();
@@ -111537,7 +111629,7 @@ Parameters:
               const relativePath = toRelativePath(resolvedPath2, workspaceRoot);
               return `Error editing file: Permission denied - ${relativePath} is outside allowed directories. Use a file path within the project workspace.`;
             }
-            if (!(0, import_fs12.existsSync)(resolvedPath2)) {
+            if (!(0, import_fs13.existsSync)(resolvedPath2)) {
               return `Error editing file: File not found - ${file_path}. Verify the path is correct and the file exists. Use 'search' to find files by name, or 'create' to make a new file.`;
             }
             if (options.fileTracker && !options.fileTracker.isFileSeen(resolvedPath2)) {
@@ -111567,7 +111659,7 @@ Example: <extract><targets>${displayPath}</targets></extract>`;
 Example: <extract><targets>${displayPath}</targets></extract>`;
               }
             }
-            const content = await import_fs11.promises.readFile(resolvedPath2, "utf-8");
+            const content = await import_fs12.promises.readFile(resolvedPath2, "utf-8");
             let matchTarget = old_string;
             let matchStrategy = "exact";
             if (!content.includes(old_string)) {
@@ -111599,7 +111691,7 @@ Example: <extract><targets>${displayPath}</targets></extract>`;
             if (newContent === content) {
               return `Error editing file: No changes made - the replacement result is identical to the original. Verify that old_string and new_string are actually different. If fuzzy matching was used, the matched text may already equal new_string.`;
             }
-            await import_fs11.promises.writeFile(resolvedPath2, newContent, "utf-8");
+            await import_fs12.promises.writeFile(resolvedPath2, newContent, "utf-8");
             if (options.fileTracker) {
               await options.fileTracker.trackFileAfterWrite(resolvedPath2);
               options.fileTracker.recordTextEdit(resolvedPath2);
@@ -111670,13 +111762,13 @@ Important:
               const relativePath = toRelativePath(resolvedPath2, workspaceRoot);
               return `Error creating file: Permission denied - ${relativePath} is outside allowed directories. Use a file path within the project workspace.`;
             }
-            if ((0, import_fs12.existsSync)(resolvedPath2) && !overwrite) {
+            if ((0, import_fs13.existsSync)(resolvedPath2) && !overwrite) {
               return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
             }
-            const existed = (0, import_fs12.existsSync)(resolvedPath2);
+            const existed = (0, import_fs13.existsSync)(resolvedPath2);
             const dir = (0, import_path16.dirname)(resolvedPath2);
-            await import_fs11.promises.mkdir(dir, { recursive: true });
-            await import_fs11.promises.writeFile(resolvedPath2, content, "utf-8");
+            await import_fs12.promises.mkdir(dir, { recursive: true });
+            await import_fs12.promises.writeFile(resolvedPath2, content, "utf-8");
             if (options.fileTracker) await options.fileTracker.trackFileAfterWrite(resolvedPath2);
             const action = existed && overwrite ? "overwrote" : "created";
             const bytes = Buffer.byteLength(content, "utf-8");
@@ -112318,10 +112410,10 @@ async function listFilesByLevel(options) {
     maxFiles = 100,
     respectGitignore = true
   } = options;
-  if (!import_fs13.default.existsSync(directory)) {
+  if (!import_fs14.default.existsSync(directory)) {
     throw new Error(`Directory does not exist: ${directory}`);
   }
-  const gitDirExists = import_fs13.default.existsSync(import_path17.default.join(directory, ".git"));
+  const gitDirExists = import_fs14.default.existsSync(import_path17.default.join(directory, ".git"));
   if (gitDirExists && respectGitignore) {
     try {
       return await listFilesUsingGit(directory, maxFiles);
@@ -112352,7 +112444,7 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   while (queue.length > 0 && result.length < maxFiles) {
     const { dir, level } = queue.shift();
     try {
-      const entries = import_fs13.default.readdirSync(dir, { withFileTypes: true });
+      const entries = import_fs14.default.readdirSync(dir, { withFileTypes: true });
       const files = entries.filter((entry) => {
         const fullPath = import_path17.default.join(dir, entry.name);
         return getEntryTypeSync(entry, fullPath).isFile;
@@ -112383,11 +112475,11 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
 }
 function loadGitignorePatterns(directory) {
   const gitignorePath = import_path17.default.join(directory, ".gitignore");
-  if (!import_fs13.default.existsSync(gitignorePath)) {
+  if (!import_fs14.default.existsSync(gitignorePath)) {
     return [];
   }
   try {
-    const content = import_fs13.default.readFileSync(gitignorePath, "utf8");
+    const content = import_fs14.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}`);
@@ -112405,11 +112497,11 @@ function shouldIgnore(filePath, ignorePatterns) {
   }
   return false;
 }
-var import_fs13, import_path17, import_util12, import_child_process10, execAsync3;
+var import_fs14, import_path17, import_util12, import_child_process10, execAsync3;
 var init_file_lister = __esm({
   "src/utils/file-lister.js"() {
     "use strict";
-    import_fs13 = __toESM(require("fs"), 1);
+    import_fs14 = __toESM(require("fs"), 1);
     import_path17 = __toESM(require("path"), 1);
     import_util12 = require("util");
     import_child_process10 = require("child_process");
@@ -112428,11 +112520,11 @@ function initializeSimpleTelemetryFromOptions(options) {
   });
   return telemetry;
 }
-var import_fs14, import_path18, SimpleTelemetry, SimpleAppTracer;
+var import_fs15, import_path18, SimpleTelemetry, SimpleAppTracer;
 var init_simpleTelemetry = __esm({
   "src/agent/simpleTelemetry.js"() {
     "use strict";
-    import_fs14 = require("fs");
+    import_fs15 = require("fs");
     import_path18 = require("path");
     SimpleTelemetry = class {
       constructor(options = {}) {
@@ -112448,10 +112540,10 @@ var init_simpleTelemetry = __esm({
       initializeFileExporter() {
         try {
           const dir = (0, import_path18.dirname)(this.filePath);
-          if (!(0, import_fs14.existsSync)(dir)) {
-            (0, import_fs14.mkdirSync)(dir, { recursive: true });
+          if (!(0, import_fs15.existsSync)(dir)) {
+            (0, import_fs15.mkdirSync)(dir, { recursive: true });
           }
-          this.stream = (0, import_fs14.createWriteStream)(this.filePath, { flags: "a" });
+          this.stream = (0, import_fs15.createWriteStream)(this.filePath, { flags: "a" });
           this.stream.on("error", (error2) => {
             console.error(`[SimpleTelemetry] Stream error: ${error2.message}`);
           });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc269",
+  "version": "0.6.0-rc271",
   "description": "Node.js wrapper for the probe code search tool",
   "main": "src/index.js",
   "module": "src/index.js",

package/src/agent/ProbeAgent.js

@@ -3582,23 +3582,24 @@ Follow these instructions carefully:
         // Continue even if storage fails
       }
 
-      // Completion prompt handling - run a follow-up prompt after attempt_completion for validation/review
-      // This runs BEFORE mermaid validation and JSON schema validation
-      // Skip if we're already in a completion prompt follow-up call or if no completion prompt is configured
+      // Completion prompt handling - inject one more user message into the existing conversation
+      // This continues the SAME agentic session (same tools, same TaskManager, same history)
+      // rather than spawning a recursive this.answer() call which would reset state
       if (completionAttempted && this.completionPrompt && !options._completionPromptProcessed) {
         if (this.debug) {
-          console.log('[DEBUG] Running completion prompt for post-completion validation/review...');
+          console.log('[DEBUG] Running completion prompt as continuation of current session...');
         }
 
         try {
-          // Record completion prompt start in telemetry
+          const originalResult = finalResult;
+
           if (this.tracer) {
             this.tracer.recordEvent('completion_prompt.started', {
               'completion_prompt.original_result_length': finalResult?.length || 0
             });
           }
 
-          // Create the completion prompt with the current result as context
+          // Append completion prompt as a user message to the existing conversation
           const completionPromptMessage = `${this.completionPrompt}
 
 Here is the result to review:
@@ -3606,34 +3607,82 @@ Here is the result to review:
 ${finalResult}
 </result>
 
-After reviewing, provide your final answer using attempt_completion.`;
+Double-check your response based on the criteria above. If everything looks good, respond with your previous answer exactly as-is using attempt_completion. If something needs to be fixed or is missing, do it now, then respond with the COMPLETE updated answer (everything you did in total, not just the fix) using attempt_completion.`;
 
-          // Make a follow-up call with the completion prompt
-          // Pass _completionPromptProcessed to prevent infinite loops
-          // Save output buffers — the recursive answer() must not destroy DSL output() content
-          const savedOutputItems = this._outputBuffer ? [...this._outputBuffer.items] : [];
-          const savedExtractedBlocks = this._extractedRawBlocks ? [...this._extractedRawBlocks] : [];
-          const completionResult = await this.answer(completionPromptMessage, [], {
-            ...options,
-            _completionPromptProcessed: true
-          });
-          // Restore output buffers so the parent call can append them to the final result
-          if (this._outputBuffer) {
-            this._outputBuffer.items = savedOutputItems;
+          currentMessages.push({ role: 'user', content: completionPromptMessage });
+
+          // Reset completion tracking for the follow-up turn
+          completionResult = null;
+          completionAttempted = false;
+
+          // Run one more streamText pass with the same tools and conversation context
+          // Give a small number of extra iterations for the follow-up
+          const completionMaxIterations = 5;
+          const completionStreamOptions = {
+            model: this.provider ? this.provider(this.model) : this.model,
+            messages: this.prepareMessagesWithImages(currentMessages),
+            tools,
+            stopWhen: stepCountIs(completionMaxIterations),
+            maxTokens: maxResponseTokens,
+            temperature: 0.3,
+            onStepFinish: ({ toolResults, text, finishReason, usage }) => {
+              if (usage) {
+                this.tokenCounter.recordUsage(usage);
+              }
+              if (options.onStream && text) {
+                options.onStream(text);
+              }
+              if (this.debug) {
+                console.log(`[DEBUG] Completion prompt step finished (reason: ${finishReason}, tools: ${toolResults?.length || 0})`);
+              }
+            }
+          };
+
+          const providerOpts = this._buildThinkingProviderOptions(maxResponseTokens);
+          if (providerOpts) {
+            completionStreamOptions.providerOptions = providerOpts;
+          }
+
+          const cpResult = await this.streamTextWithRetryAndFallback(completionStreamOptions);
+          const cpFinalText = await cpResult.text;
+          const cpUsage = await cpResult.usage;
+          if (cpUsage) {
+            this.tokenCounter.recordUsage(cpUsage, cpResult.experimental_providerMetadata);
+          }
+
+          // Append follow-up messages to conversation history
+          const cpMessages = await cpResult.response?.messages;
+          if (cpMessages) {
+            for (const msg of cpMessages) {
+              currentMessages.push(msg);
+            }
           }
-          this._extractedRawBlocks = savedExtractedBlocks;
 
-          // Update finalResult with the result from the completion prompt
-          finalResult = completionResult;
+          // Use new completion result if the agent called attempt_completion again,
+          // otherwise keep the original result (the follow-up may have just done side-effects)
+          if (completionResult) {
+            finalResult = completionResult;
+            completionAttempted = true;
+          } else if (cpFinalText && cpFinalText.trim().length > 0) {
+            finalResult = cpFinalText;
+            completionAttempted = true;
+          } else {
+            // Follow-up produced nothing useful — keep the original
+            finalResult = originalResult;
+            completionAttempted = true;
+            if (this.debug) {
+              console.log('[DEBUG] Completion prompt returned empty result, keeping original.');
+            }
+          }
 
           if (this.debug) {
-            console.log(`[DEBUG] Completion prompt finished. New result length: ${finalResult?.length || 0}`);
+            console.log(`[DEBUG] Completion prompt finished. Final result length: ${finalResult?.length || 0}`);
           }
 
-          // Record completion prompt completion in telemetry
           if (this.tracer) {
             this.tracer.recordEvent('completion_prompt.completed', {
-              'completion_prompt.final_result_length': finalResult?.length || 0
+              'completion_prompt.final_result_length': finalResult?.length || 0,
+              'completion_prompt.used_original': finalResult === originalResult
             });
           }
         } catch (error) {

package/src/tools/vercel.js

@@ -10,6 +10,7 @@ import { extract } from '../extract.js';
 import { delegate } from '../delegate.js';
 import { analyzeAll } from './analyzeAll.js';
 import { searchSchema, querySchema, extractSchema, delegateSchema, analyzeAllSchema, searchDescription, queryDescription, extractDescription, delegateDescription, analyzeAllDescription, parseTargets, parseAndResolvePaths, resolveTargetPath } from './common.js';
+import { existsSync } from 'fs';
 import { formatErrorForAI } from '../utils/error-types.js';
 import { annotateOutputWithHashes } from './hashline.js';
 
@@ -118,6 +119,18 @@ function parseDelegatedTargets(rawResponse) {
 	return normalizeTargets(fallbackTargetsFromText(trimmed));
 }
 
+function splitTargetSuffix(target) {
+	const searchStart = (target.length > 2 && target[1] === ':' && /[a-zA-Z]/.test(target[0])) ? 2 : 0;
+	const colonIdx = target.indexOf(':', searchStart);
+	const hashIdx = target.indexOf('#');
+	if (colonIdx !== -1 && (hashIdx === -1 || colonIdx < hashIdx)) {
+		return { filePart: target.substring(0, colonIdx), suffix: target.substring(colonIdx) };
+	} else if (hashIdx !== -1) {
+		return { filePart: target.substring(0, hashIdx), suffix: target.substring(hashIdx) };
+	}
+	return { filePart: target, suffix: '' };
+}
+
 function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, allowTests }) {
 	return [
 		'You are a code-search subagent. Your job is to find ALL relevant code locations for the given query.',
@@ -286,13 +299,61 @@ export const searchTool = (options = {}) => {
 					return fallbackResult;
 				}
 
-				// Resolve relative paths against the actual search directory, not the general cwd.
-				// The delegate returns paths relative to where the search was performed (searchPaths[0]),
-				// which may differ from options.cwd when the user specifies a path parameter.
+				// The delegate runs from workspace root (allowedFolders[0] or cwd), NOT from searchPaths[0].
+				// It returns paths relative to that workspace root. Resolve against the same base.
+				const delegateBase = options.allowedFolders?.[0] || options.cwd || '.';
 				const resolutionBase = searchPaths[0] || options.cwd || '.';
-				const resolvedTargets = targets.map(target => resolveTargetPath(target, resolutionBase));
+				const resolvedTargets = targets.map(target => resolveTargetPath(target, delegateBase));
+
+				// Auto-fix: detect and repair invalid paths (doubled segments, AI hallucinations)
+				const validatedTargets = [];
+				for (const target of resolvedTargets) {
+					const { filePart, suffix } = splitTargetSuffix(target);
+
+					// 1. Path exists as-is
+					if (existsSync(filePart)) {
+						validatedTargets.push(target);
+						continue;
+					}
+
+					// 2. Detect doubled directory segments: /ws/proj/proj/src → /ws/proj/src
+					let fixed = false;
+					const parts = filePart.split('/').filter(Boolean);
+					for (let i = 0; i < parts.length - 1; i++) {
+						if (parts[i] === parts[i + 1]) {
+							const candidate = '/' + [...parts.slice(0, i), ...parts.slice(i + 1)].join('/');
+							if (existsSync(candidate)) {
+								validatedTargets.push(candidate + suffix);
+								if (debug) console.error(`[search-delegate] Fixed doubled path segment: ${filePart} → ${candidate}`);
+								fixed = true;
+								break;
+							}
+						}
+					}
+					if (fixed) continue;
+
+					// 3. Try resolving against alternative bases (searchPaths[0], cwd)
+					for (const altBase of [resolutionBase, options.cwd].filter(Boolean)) {
+						if (altBase === delegateBase) continue;
+						const altResolved = resolveTargetPath(target, altBase);
+						const { filePart: altFile } = splitTargetSuffix(altResolved);
+						if (existsSync(altFile)) {
+							validatedTargets.push(altResolved);
+							if (debug) console.error(`[search-delegate] Resolved with alt base: ${filePart} → ${altFile}`);
+							fixed = true;
+							break;
+						}
+					}
+					if (fixed) continue;
+
+					// 4. Keep target anyway (probe binary will report the error)
+					//    but log a warning
+					if (debug) console.error(`[search-delegate] Warning: target may not exist: ${filePart}`);
+					validatedTargets.push(target);
+				}
+
 				const extractOptions = {
-					files: resolvedTargets,
+					files: validatedTargets,
 					cwd: resolutionBase,
 					allowTests: allow_tests ?? true
 				};