@probelabs/probe 0.6.0-rc269 → 0.6.0-rc271

package/cjs/agent/ProbeAgent.cjs

@@ -36502,6 +36502,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.",
@@ -36530,7 +36541,7 @@ function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, all
     "Deduplicate targets. Do NOT explain or answer - ONLY return the JSON targets."
   ].join("\n");
 }
-var import_ai, CODE_SEARCH_SCHEMA, searchTool, queryTool, extractTool, delegateTool, analyzeAllTool;
+var import_ai, import_fs4, CODE_SEARCH_SCHEMA, searchTool, queryTool, extractTool, delegateTool, analyzeAllTool;
 var init_vercel = __esm({
   "src/tools/vercel.js"() {
     "use strict";
@@ -36541,6 +36552,7 @@ var init_vercel = __esm({
     init_delegate();
     init_analyzeAll();
     init_common2();
+    import_fs4 = require("fs");
     init_error_types();
     init_hashline();
     CODE_SEARCH_SCHEMA = {
@@ -36666,10 +36678,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_fs4.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_fs4.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_fs4.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
             };
@@ -38314,7 +38363,7 @@ async function executeBashCommand(command, options = {}) {
   let cwd = workingDirectory;
   try {
     cwd = (0, import_path6.resolve)(cwd);
-    if (!(0, import_fs4.existsSync)(cwd)) {
+    if (!(0, import_fs5.existsSync)(cwd)) {
       throw new Error(`Working directory does not exist: ${cwd}`);
     }
   } catch (error2) {
@@ -38570,7 +38619,7 @@ function validateExecutionOptions(options = {}) {
   if (options.workingDirectory) {
     if (typeof options.workingDirectory !== "string") {
       errors.push("workingDirectory must be a string");
-    } else if (!(0, import_fs4.existsSync)(options.workingDirectory)) {
+    } else if (!(0, import_fs5.existsSync)(options.workingDirectory)) {
       errors.push(`workingDirectory does not exist: ${options.workingDirectory}`);
     }
   }
@@ -38583,13 +38632,13 @@ function validateExecutionOptions(options = {}) {
     warnings
   };
 }
-var import_child_process6, import_path6, import_fs4;
+var import_child_process6, import_path6, import_fs5;
 var init_bashExecutor = __esm({
   "src/agent/bashExecutor.js"() {
     "use strict";
     import_child_process6 = require("child_process");
     import_path6 = require("path");
-    import_fs4 = require("fs");
+    import_fs5 = require("fs");
     init_bashCommandUtils();
   }
 });
@@ -39147,7 +39196,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_fs5.promises.readFile(resolvedPath2, "utf-8");
+  const content = await import_fs6.promises.readFile(resolvedPath2, "utf-8");
   const lines = content.split("\n");
   if (position) {
     const refIndent = detectBaseIndent(symbolInfo.code);
@@ -39158,7 +39207,7 @@ Example: <extract><targets>${file_path}#${symbol15}</targets></extract>`;
     } else {
       lines.splice(symbolInfo.startLine - 1, 0, ...newLines, "");
     }
-    await import_fs5.promises.writeFile(resolvedPath2, lines.join("\n"), "utf-8");
+    await import_fs6.promises.writeFile(resolvedPath2, lines.join("\n"), "utf-8");
     if (fileTracker) {
       const updated = await findSymbol(resolvedPath2, symbol15, cwd || process.cwd());
       if (updated) {
@@ -39176,7 +39225,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_fs5.promises.writeFile(resolvedPath2, lines.join("\n"), "utf-8");
+    await import_fs6.promises.writeFile(resolvedPath2, lines.join("\n"), "utf-8");
     if (fileTracker) {
       const updated = await findSymbol(resolvedPath2, symbol15, cwd || process.cwd());
       if (updated) {
@@ -39231,7 +39280,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_fs5.promises.readFile(resolvedPath2, "utf-8");
+  const content = await import_fs6.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.`;
@@ -39260,20 +39309,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_fs5.promises.writeFile(resolvedPath2, fileLines.join("\n"), "utf-8");
+    await import_fs6.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_fs5.promises.writeFile(resolvedPath2, fileLines.join("\n"), "utf-8");
+    await import_fs6.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_fs5.promises.writeFile(resolvedPath2, fileLines.join("\n"), "utf-8");
+    await import_fs6.promises.writeFile(resolvedPath2, fileLines.join("\n"), "utf-8");
     if (fileTracker) await fileTracker.trackFileAfterWrite(resolvedPath2);
     let action;
     if (newLines.length === 0) {
@@ -39286,14 +39335,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_ai3, import_fs5, import_path8, import_fs6, editTool, createTool, multiEditTool, editSchema, createSchema, multiEditSchema, editDescription, createDescription, multiEditDescription, editToolDefinition, createToolDefinition, multiEditToolDefinition;
+var import_ai3, import_fs6, import_path8, import_fs7, editTool, createTool, multiEditTool, editSchema, createSchema, multiEditSchema, editDescription, createDescription, multiEditDescription, editToolDefinition, createToolDefinition, multiEditToolDefinition;
 var init_edit = __esm({
   "src/tools/edit.js"() {
     "use strict";
     import_ai3 = require("ai");
-    import_fs5 = require("fs");
-    import_path8 = require("path");
     import_fs6 = require("fs");
+    import_path8 = require("path");
+    import_fs7 = require("fs");
     init_path_validation();
     init_fuzzyMatch();
     init_symbolEdit();
@@ -39377,7 +39426,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_fs6.existsSync)(resolvedPath2)) {
+            if (!(0, import_fs7.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)) {
@@ -39407,7 +39456,7 @@ Example: <extract><targets>${displayPath}</targets></extract>`;
 Example: <extract><targets>${displayPath}</targets></extract>`;
               }
             }
-            const content = await import_fs5.promises.readFile(resolvedPath2, "utf-8");
+            const content = await import_fs6.promises.readFile(resolvedPath2, "utf-8");
             let matchTarget = old_string;
             let matchStrategy = "exact";
             if (!content.includes(old_string)) {
@@ -39439,7 +39488,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_fs5.promises.writeFile(resolvedPath2, newContent, "utf-8");
+            await import_fs6.promises.writeFile(resolvedPath2, newContent, "utf-8");
             if (options.fileTracker) {
               await options.fileTracker.trackFileAfterWrite(resolvedPath2);
               options.fileTracker.recordTextEdit(resolvedPath2);
@@ -39510,13 +39559,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_fs6.existsSync)(resolvedPath2) && !overwrite) {
+            if ((0, import_fs7.existsSync)(resolvedPath2) && !overwrite) {
               return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
             }
-            const existed = (0, import_fs6.existsSync)(resolvedPath2);
+            const existed = (0, import_fs7.existsSync)(resolvedPath2);
             const dir = (0, import_path8.dirname)(resolvedPath2);
-            await import_fs5.promises.mkdir(dir, { recursive: true });
-            await import_fs5.promises.writeFile(resolvedPath2, content, "utf-8");
+            await import_fs6.promises.mkdir(dir, { recursive: true });
+            await import_fs6.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");
@@ -53822,22 +53871,22 @@ var init_esm3 = __esm({
 });
 
 // node_modules/path-scurry/dist/esm/index.js
-var import_node_path, import_node_url, import_fs7, 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 import_node_path, import_node_url, import_fs8, 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();
     import_node_path = require("node:path");
     import_node_url = require("node:url");
-    import_fs7 = require("fs");
+    import_fs8 = require("fs");
     actualFS = __toESM(require("node:fs"), 1);
     import_promises = require("node:fs/promises");
     init_esm3();
-    realpathSync2 = import_fs7.realpathSync.native;
+    realpathSync2 = import_fs8.realpathSync.native;
     defaultFS = {
-      lstatSync: import_fs7.lstatSync,
-      readdir: import_fs7.readdir,
-      readdirSync: import_fs7.readdirSync,
-      readlinkSync: import_fs7.readlinkSync,
+      lstatSync: import_fs8.lstatSync,
+      readdir: import_fs8.readdir,
+      readdirSync: import_fs8.readdirSync,
+      readlinkSync: import_fs8.readlinkSync,
       realpathSync: realpathSync2,
       promises: {
         lstat: import_promises.lstat,
@@ -57366,10 +57415,10 @@ async function listFilesByLevel(options) {
     maxFiles = 100,
     respectGitignore = true
   } = options;
-  if (!import_fs8.default.existsSync(directory)) {
+  if (!import_fs9.default.existsSync(directory)) {
     throw new Error(`Directory does not exist: ${directory}`);
   }
-  const gitDirExists = import_fs8.default.existsSync(import_path9.default.join(directory, ".git"));
+  const gitDirExists = import_fs9.default.existsSync(import_path9.default.join(directory, ".git"));
   if (gitDirExists && respectGitignore) {
     try {
       return await listFilesUsingGit(directory, maxFiles);
@@ -57400,7 +57449,7 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   while (queue.length > 0 && result.length < maxFiles) {
     const { dir, level } = queue.shift();
     try {
-      const entries = import_fs8.default.readdirSync(dir, { withFileTypes: true });
+      const entries = import_fs9.default.readdirSync(dir, { withFileTypes: true });
       const files = entries.filter((entry) => {
         const fullPath = import_path9.default.join(dir, entry.name);
         return getEntryTypeSync(entry, fullPath).isFile;
@@ -57431,11 +57480,11 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
 }
 function loadGitignorePatterns(directory) {
   const gitignorePath = import_path9.default.join(directory, ".gitignore");
-  if (!import_fs8.default.existsSync(gitignorePath)) {
+  if (!import_fs9.default.existsSync(gitignorePath)) {
     return [];
   }
   try {
-    const content = import_fs8.default.readFileSync(gitignorePath, "utf8");
+    const content = import_fs9.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}`);
@@ -57453,11 +57502,11 @@ function shouldIgnore(filePath, ignorePatterns) {
   }
   return false;
 }
-var import_fs8, import_path9, import_util11, import_child_process7, execAsync3;
+var import_fs9, import_path9, import_util11, import_child_process7, execAsync3;
 var init_file_lister = __esm({
   "src/utils/file-lister.js"() {
     "use strict";
-    import_fs8 = __toESM(require("fs"), 1);
+    import_fs9 = __toESM(require("fs"), 1);
     import_path9 = __toESM(require("path"), 1);
     import_util11 = require("util");
     import_child_process7 = require("child_process");
@@ -57757,11 +57806,11 @@ var init_fileTracker = __esm({
 });
 
 // src/agent/simpleTelemetry.js
-var import_fs9, import_path11;
+var import_fs10, import_path11;
 var init_simpleTelemetry = __esm({
   "src/agent/simpleTelemetry.js"() {
     "use strict";
-    import_fs9 = require("fs");
+    import_fs10 = require("fs");
     import_path11 = require("path");
   }
 });
@@ -57868,7 +57917,7 @@ function createWrappedTools(baseTools) {
   }
   return wrappedTools;
 }
-var import_child_process8, import_util12, import_crypto4, import_events, import_fs10, import_fs11, import_path12, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
+var import_child_process8, import_util12, import_crypto4, import_events, import_fs11, import_fs12, import_path12, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
 var init_probeTool = __esm({
   "src/agent/probeTool.js"() {
     "use strict";
@@ -57877,8 +57926,8 @@ var init_probeTool = __esm({
     import_util12 = require("util");
     import_crypto4 = require("crypto");
     import_events = require("events");
-    import_fs10 = __toESM(require("fs"), 1);
-    import_fs11 = require("fs");
+    import_fs11 = __toESM(require("fs"), 1);
+    import_fs12 = require("fs");
     import_path12 = __toESM(require("path"), 1);
     init_esm5();
     init_symlink_utils();
@@ -57987,7 +58036,7 @@ var init_probeTool = __esm({
           console.log(`[DEBUG] Listing files in directory: ${targetDir}`);
         }
         try {
-          const files = await import_fs11.promises.readdir(targetDir, { withFileTypes: true });
+          const files = await import_fs12.promises.readdir(targetDir, { withFileTypes: true });
           const formatSize = (size) => {
             if (size < 1024) return `${size}B`;
             if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)}K`;
@@ -97834,11 +97883,11 @@ function loadMCPConfigurationFromPath(configPath) {
   if (!configPath) {
     throw new Error("Config path is required");
   }
-  if (!(0, import_fs12.existsSync)(configPath)) {
+  if (!(0, import_fs13.existsSync)(configPath)) {
     throw new Error(`MCP configuration file not found: ${configPath}`);
   }
   try {
-    const content = (0, import_fs12.readFileSync)(configPath, "utf8");
+    const content = (0, import_fs13.readFileSync)(configPath, "utf8");
     const config = JSON.parse(content);
     if (process.env.DEBUG === "1" || process.env.DEBUG_MCP === "1") {
       console.error(`[MCP DEBUG] Loaded configuration from: ${configPath}`);
@@ -97863,9 +97912,9 @@ function loadMCPConfiguration() {
   ].filter(Boolean);
   let config = null;
   for (const configPath of configPaths) {
-    if ((0, import_fs12.existsSync)(configPath)) {
+    if ((0, import_fs13.existsSync)(configPath)) {
       try {
-        const content = (0, import_fs12.readFileSync)(configPath, "utf8");
+        const content = (0, import_fs13.readFileSync)(configPath, "utf8");
         config = JSON.parse(content);
         if (process.env.DEBUG === "1" || process.env.DEBUG_MCP === "1") {
           console.error(`[MCP DEBUG] Loaded configuration from: ${configPath}`);
@@ -97986,11 +98035,11 @@ function parseEnabledServers(config) {
   }
   return servers;
 }
-var import_fs12, import_path13, import_os3, import_url4, __filename4, __dirname5, DEFAULT_TIMEOUT, MAX_TIMEOUT, DEFAULT_CONFIG;
+var import_fs13, import_path13, import_os3, import_url4, __filename4, __dirname5, DEFAULT_TIMEOUT, MAX_TIMEOUT, DEFAULT_CONFIG;
 var init_config = __esm({
   "src/agent/mcp/config.js"() {
     "use strict";
-    import_fs12 = require("fs");
+    import_fs13 = require("fs");
     import_path13 = require("path");
     import_os3 = require("os");
     import_url4 = require("url");
@@ -106085,11 +106134,11 @@ function isSafeEntryName(name14) {
   if (name14.includes("\0")) return false;
   return !name14.includes("/") && !name14.includes("\\");
 }
-var import_fs13, import_promises3, import_path15, DEFAULT_SKILL_DIRS, SKILL_FILE_NAME, SkillRegistry;
+var import_fs14, import_promises3, import_path15, DEFAULT_SKILL_DIRS, SKILL_FILE_NAME, SkillRegistry;
 var init_registry = __esm({
   "src/agent/skills/registry.js"() {
     "use strict";
-    import_fs13 = require("fs");
+    import_fs14 = require("fs");
     import_promises3 = require("fs/promises");
     import_path15 = require("path");
     init_parser7();
@@ -106164,7 +106213,7 @@ var init_registry = __esm({
         return resolvedReal;
       }
       async _scanSkillDir(dirPath) {
-        if (!(0, import_fs13.existsSync)(dirPath)) return [];
+        if (!(0, import_fs14.existsSync)(dirPath)) return [];
         let entries;
         try {
           entries = await (0, import_promises3.readdir)(dirPath, { withFileTypes: true });
@@ -106204,7 +106253,7 @@ var init_registry = __esm({
             }
             continue;
           }
-          if (!(0, import_fs13.existsSync)(skillFilePath)) continue;
+          if (!(0, import_fs14.existsSync)(skillFilePath)) continue;
           const { skill, error: error2 } = await parseSkillFile(skillFilePath, entry.name);
           if (!skill) {
             if (error2) {
@@ -108712,7 +108761,7 @@ __export(ProbeAgent_exports, {
   ProbeAgent: () => ProbeAgent
 });
 module.exports = __toCommonJS(ProbeAgent_exports);
-var import_dotenv2, import_anthropic2, import_openai2, import_google2, import_ai6, import_crypto9, import_events4, import_fs14, import_promises6, import_path18, ENGINE_ACTIVITY_TIMEOUT_DEFAULT, ENGINE_ACTIVITY_TIMEOUT_MIN, ENGINE_ACTIVITY_TIMEOUT_MAX, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
+var import_dotenv2, import_anthropic2, import_openai2, import_google2, import_ai6, import_crypto9, import_events4, import_fs15, import_promises6, import_path18, ENGINE_ACTIVITY_TIMEOUT_DEFAULT, ENGINE_ACTIVITY_TIMEOUT_MIN, ENGINE_ACTIVITY_TIMEOUT_MAX, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
     import_dotenv2 = __toESM(require_main(), 1);
@@ -108723,7 +108772,7 @@ var init_ProbeAgent = __esm({
     import_ai6 = require("ai");
     import_crypto9 = require("crypto");
     import_events4 = require("events");
-    import_fs14 = require("fs");
+    import_fs15 = require("fs");
     import_promises6 = require("fs/promises");
     import_path18 = require("path");
     init_tokenCounter();
@@ -110730,7 +110779,7 @@ var init_ProbeAgent = __esm({
         } else {
           guidanceCandidates = ["agents.md", "claude.md"];
         }
-        if (!(0, import_fs14.existsSync)(rootDirectory)) {
+        if (!(0, import_fs15.existsSync)(rootDirectory)) {
           this._architectureContextLoaded = true;
           return null;
         }
@@ -111502,9 +111551,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
@@ -111517,24 +111567,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_ai6.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) {