@probelabs/probe 0.6.0-rc269 → 0.6.0-rc271

package/build/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/build/agent/index.js

@@ -9045,6 +9045,7 @@ var init_hashline = __esm({
 
 // src/tools/vercel.js
 import { tool } from "ai";
+import { existsSync } from "fs";
 function normalizeTargets(targets) {
   if (!Array.isArray(targets)) return [];
   const seen = /* @__PURE__ */ new Set();
@@ -9121,6 +9122,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.",
@@ -9284,10 +9296,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 (existsSync(filePart)) {
+                validatedTargets.push(target);
+                continue;
+              }
+              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} \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 (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
             };
@@ -10805,7 +10854,7 @@ var init_bashPermissions = __esm({
 // src/agent/bashExecutor.js
 import { spawn as spawn2 } from "child_process";
 import { resolve as resolve2, join } from "path";
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 function splitCommandComponents(command) {
   const parts = [];
   let current2 = "";
@@ -10935,7 +10984,7 @@ async function executeBashCommand(command, options = {}) {
   let cwd = workingDirectory;
   try {
     cwd = resolve2(cwd);
-    if (!existsSync(cwd)) {
+    if (!existsSync2(cwd)) {
       throw new Error(`Working directory does not exist: ${cwd}`);
     }
   } catch (error) {
@@ -11191,7 +11240,7 @@ function validateExecutionOptions(options = {}) {
   if (options.workingDirectory) {
     if (typeof options.workingDirectory !== "string") {
       errors.push("workingDirectory must be a string");
-    } else if (!existsSync(options.workingDirectory)) {
+    } else if (!existsSync2(options.workingDirectory)) {
       errors.push(`workingDirectory does not exist: ${options.workingDirectory}`);
     }
   }
@@ -11716,7 +11765,7 @@ var init_lineEditHeuristics = __esm({
 import { tool as tool3 } from "ai";
 import { promises as fs6 } from "fs";
 import { dirname, resolve as resolve4, isAbsolute as isAbsolute3, sep as sep2 } from "path";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 function isPathAllowed(filePath, allowedFolders) {
   if (!allowedFolders || allowedFolders.length === 0) {
     const resolvedPath2 = safeRealpath(filePath);
@@ -11994,7 +12043,7 @@ Parameters:
               const relativePath = toRelativePath(resolvedPath, workspaceRoot);
               return `Error editing file: Permission denied - ${relativePath} is outside allowed directories. Use a file path within the project workspace.`;
             }
-            if (!existsSync2(resolvedPath)) {
+            if (!existsSync3(resolvedPath)) {
               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(resolvedPath)) {
@@ -12127,10 +12176,10 @@ Important:
               const relativePath = toRelativePath(resolvedPath, workspaceRoot);
               return `Error creating file: Permission denied - ${relativePath} is outside allowed directories. Use a file path within the project workspace.`;
             }
-            if (existsSync2(resolvedPath) && !overwrite) {
+            if (existsSync3(resolvedPath) && !overwrite) {
               return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
             }
-            const existed = existsSync2(resolvedPath);
+            const existed = existsSync3(resolvedPath);
             const dir = dirname(resolvedPath);
             await fs6.mkdir(dir, { recursive: true });
             await fs6.writeFile(resolvedPath, content, "utf-8");
@@ -30374,7 +30423,7 @@ var init_fileTracker = __esm({
 });
 
 // src/agent/simpleTelemetry.js
-import { existsSync as existsSync3, mkdirSync, createWriteStream } from "fs";
+import { existsSync as existsSync4, mkdirSync, createWriteStream } from "fs";
 import { dirname as dirname2 } from "path";
 function initializeSimpleTelemetryFromOptions(options) {
   const telemetry = new SimpleTelemetry({
@@ -30403,7 +30452,7 @@ var init_simpleTelemetry = __esm({
       initializeFileExporter() {
         try {
           const dir = dirname2(this.filePath);
-          if (!existsSync3(dir)) {
+          if (!existsSync4(dir)) {
             mkdirSync(dir, { recursive: true });
           }
           this.stream = createWriteStream(this.filePath, { flags: "a" });
@@ -70834,7 +70883,7 @@ When troubleshooting:
 });
 
 // src/agent/mcp/config.js
-import { readFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { readFileSync, existsSync as existsSync5, mkdirSync as mkdirSync2, writeFileSync } from "fs";
 import { join as join2, dirname as dirname3 } from "path";
 import { homedir } from "os";
 import { fileURLToPath as fileURLToPath6 } from "url";
@@ -70889,7 +70938,7 @@ function loadMCPConfigurationFromPath(configPath) {
   if (!configPath) {
     throw new Error("Config path is required");
   }
-  if (!existsSync4(configPath)) {
+  if (!existsSync5(configPath)) {
     throw new Error(`MCP configuration file not found: ${configPath}`);
   }
   try {
@@ -70918,7 +70967,7 @@ function loadMCPConfiguration() {
   ].filter(Boolean);
   let config = null;
   for (const configPath of configPaths) {
-    if (existsSync4(configPath)) {
+    if (existsSync5(configPath)) {
       try {
         const content = readFileSync(configPath, "utf8");
         config = JSON.parse(content);
@@ -79122,7 +79171,7 @@ var init_parser7 = __esm({
 });
 
 // src/agent/skills/registry.js
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { readdir as readdir2, readFile as readFile2, realpath as realpath2, lstat as lstat2 } from "fs/promises";
 import { resolve as resolve6, join as join3, isAbsolute as isAbsolute5, sep as sep4, relative } from "path";
 function isPathInside(basePath, targetPath) {
@@ -79215,7 +79264,7 @@ var init_registry = __esm({
         return resolvedReal;
       }
       async _scanSkillDir(dirPath) {
-        if (!existsSync5(dirPath)) return [];
+        if (!existsSync6(dirPath)) return [];
         let entries;
         try {
           entries = await readdir2(dirPath, { withFileTypes: true });
@@ -79255,7 +79304,7 @@ var init_registry = __esm({
             }
             continue;
           }
-          if (!existsSync5(skillFilePath)) continue;
+          if (!existsSync6(skillFilePath)) continue;
           const { skill, error } = await parseSkillFile(skillFilePath, entry.name);
           if (!skill) {
             if (error) {
@@ -81771,7 +81820,7 @@ import { createAmazonBedrock as createAmazonBedrock2 } from "@ai-sdk/amazon-bedr
 import { streamText as streamText2, tool as tool5, stepCountIs, jsonSchema } from "ai";
 import { randomUUID as randomUUID5 } from "crypto";
 import { EventEmitter as EventEmitter5 } from "events";
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { readFile as readFile3, stat, readdir as readdir3 } from "fs/promises";
 import { resolve as resolve7, isAbsolute as isAbsolute6, dirname as dirname5, basename, normalize as normalize2, sep as sep5 } from "path";
 var ENGINE_ACTIVITY_TIMEOUT_DEFAULT, ENGINE_ACTIVITY_TIMEOUT_MIN, ENGINE_ACTIVITY_TIMEOUT_MAX, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
@@ -83782,7 +83831,7 @@ var init_ProbeAgent = __esm({
         } else {
           guidanceCandidates = ["agents.md", "claude.md"];
         }
-        if (!existsSync6(rootDirectory)) {
+        if (!existsSync7(rootDirectory)) {
           this._architectureContextLoaded = true;
           return null;
         }
@@ -84554,9 +84603,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
@@ -84569,24 +84619,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: 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 (error) {
@@ -85308,7 +85400,7 @@ import {
   ListToolsRequestSchema as ListToolsRequestSchema2,
   McpError
 } from "@modelcontextprotocol/sdk/types.js";
-import { readFileSync as readFileSync2, existsSync as existsSync7 } from "fs";
+import { readFileSync as readFileSync2, existsSync as existsSync8 } from "fs";
 import { resolve as resolve8 } from "path";
 
 // src/agent/acp/server.js
@@ -85984,7 +86076,7 @@ function readInputContent(input) {
   if (!input) return null;
   try {
     const resolvedPath = resolve8(input);
-    if (existsSync7(resolvedPath)) {
+    if (existsSync8(resolvedPath)) {
       return readFileSync2(resolvedPath, "utf-8").trim();
     }
   } catch (error) {
@@ -86672,7 +86764,7 @@ async function main() {
         bashConfig.timeout = timeout;
       }
       if (config.bashWorkingDir) {
-        if (!existsSync7(config.bashWorkingDir)) {
+        if (!existsSync8(config.bashWorkingDir)) {
           console.error(`Error: Bash working directory does not exist: ${config.bashWorkingDir}`);
           process.exit(1);
         }

package/build/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
 				};