@probelabs/probe 0.6.0-rc281 → 0.6.0-rc283

package/build/agent/index.js

@@ -9085,6 +9085,48 @@ var init_hashline = __esm({
 // src/tools/vercel.js
 import { tool } from "ai";
 import { existsSync } from "fs";
+function autoQuoteSearchTerms(query2) {
+  if (!query2 || typeof query2 !== "string") return query2;
+  const tokens = [];
+  let i = 0;
+  while (i < query2.length) {
+    if (/\s/.test(query2[i])) {
+      i++;
+      continue;
+    }
+    if (query2[i] === '"') {
+      const end = query2.indexOf('"', i + 1);
+      if (end !== -1) {
+        tokens.push(query2.substring(i, end + 1));
+        i = end + 1;
+      } else {
+        tokens.push(query2.substring(i));
+        break;
+      }
+      continue;
+    }
+    let j = i;
+    while (j < query2.length && !/\s/.test(query2[j]) && query2[j] !== '"') {
+      j++;
+    }
+    tokens.push(query2.substring(i, j));
+    i = j;
+  }
+  const operators = /* @__PURE__ */ new Set(["AND", "OR", "NOT"]);
+  const result = tokens.map((token) => {
+    if (token.startsWith('"')) return token;
+    if (operators.has(token)) return token;
+    const hasUpper = /[A-Z]/.test(token);
+    const hasLower = /[a-z]/.test(token);
+    const hasUnderscore = token.includes("_");
+    const hasMixedCase = hasUpper && hasLower;
+    if (hasMixedCase || hasUnderscore) {
+      return `"${token}"`;
+    }
+    return token;
+  });
+  return result.join(" ");
+}
 function normalizeTargets(targets) {
   if (!Array.isArray(targets)) return [];
   const seen = /* @__PURE__ */ new Set();
@@ -9185,40 +9227,75 @@ function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, all
     "- listFiles: Understand directory structure to find where relevant code might live.",
     "",
     "CRITICAL - How probe search works (do NOT ignore):",
-    "- By default (exact=false), probe ALREADY handles stemming, case-insensitive matching, and camelCase/snake_case splitting.",
+    "- By default (exact=false), probe ALREADY handles stemming, case-insensitive matching, and camelCase/snake_case splitting automatically.",
     '- Searching "allowed_ips" ALREADY matches "AllowedIPs", "allowedIps", "allowed_ips", etc. Do NOT manually try case/style variations.',
     '- Searching "getUserData" ALREADY matches "get", "user", "data" and their variations.',
-    "- NEVER repeat the same search query \u2014 you will get the same results.",
+    "- NEVER repeat the same search query \u2014 you will get the same results. Changing the path does NOT change this.",
     "- NEVER search trivial variations of the same keyword (e.g., AllowedIPs then allowedIps then allowed_ips). This is wasteful \u2014 probe handles it.",
-    "- If a search returns no results, the term likely does not exist in that path. Try a genuinely DIFFERENT keyword or concept, not a variation.",
-    "- If 2-3 consecutive searches return no results for a concept, STOP searching for it and move on.",
+    "- If a search returns no results, the term likely does not exist. Try a genuinely DIFFERENT keyword or concept, not a variation.",
+    "- If 2-3 searches return no results for a concept, STOP searching for it and move on. Do NOT keep retrying.",
+    "",
+    "When to use exact=true:",
+    "- Use exact=true when searching for a KNOWN symbol name (function, type, variable, struct).",
+    "- exact=true matches the literal string only \u2014 no stemming, no splitting.",
+    '- This is ideal for precise lookups: exact=true "ForwardMessage", exact=true "SessionLimiter", exact=true "ThrottleRetryLimit".',
+    "- Do NOT use exact=true for exploratory/conceptual queries \u2014 use the default for those.",
+    "",
+    "Combining searches with OR:",
+    '- Multiple unquoted words use OR logic: rate limit matches files containing EITHER "rate" OR "limit".',
+    `- For known symbol names, quote each term to prevent splitting: '"limitDRL" "limitRedis"' matches either exact symbol.`,
+    '- Without quotes, camelCase like limitDRL gets split into "limit" + "DRL" \u2014 not what you want for symbol lookup.',
+    "- Use OR to search for multiple related symbols in ONE search instead of separate searches.",
+    "- This is much faster than running separate searches sequentially.",
+    `- Example: search '"ForwardMessage" "SessionLimiter"' finds files with either exact symbol in one call.`,
+    `- Example: search '"limitDRL" "doRollingWindowWrite"' finds both rate limiting functions at once.`,
+    '- Use AND only when you need both terms to appear in the same file: "rate AND limit".',
+    "",
+    "Parallel tool calls:",
+    "- When you need to search for INDEPENDENT concepts, call multiple search tools IN PARALLEL (same response).",
+    "- Do NOT wait for one search to finish before starting the next if they are independent.",
+    '- Example: for "rate limiting and session management", call search "rate limiting" AND search "session management" in parallel.',
+    "- Similarly, call multiple extract tools in parallel when verifying different files.",
     "",
     "GOOD search strategy (do this):",
     '  Query: "How does authentication work and how are sessions managed?"',
-    '  \u2192 search "authentication" \u2192 search "session management" (two different concepts)',
+    '  \u2192 search "authentication" + search "session management" IN PARALLEL (two independent concepts)',
     '  Query: "Find the IP allowlist middleware"',
     '  \u2192 search "allowlist middleware" (one search, probe handles IP/ip/Ip variations)',
+    '  Query: "Find ForwardMessage and SessionLimiter"',
+    `  \u2192 search '"ForwardMessage" "SessionLimiter"' (one OR search finds both exact symbols)`,
+    '  OR: search exact=true "ForwardMessage" + search exact=true "SessionLimiter" IN PARALLEL',
+    '  Query: "Find limitDRL and limitRedis functions"',
+    `  \u2192 search '"limitDRL" "limitRedis"' (one OR search, quoted to prevent camelCase splitting)`,
+    '  Query: "Find ThrottleRetryLimit usage"',
+    '  \u2192 search exact=true "ThrottleRetryLimit" (one search, if no results the symbol does not exist \u2014 stop)',
     '  Query: "How does BM25 scoring work with SIMD optimization?"',
-    '  \u2192 search "BM25 scoring" \u2192 search "SIMD optimization" (two different concepts)',
+    '  \u2192 search "BM25 scoring" + search "SIMD optimization" IN PARALLEL (two different concepts)',
     "",
     "BAD search strategy (never do this):",
-    '  \u2192 search "AllowedIPs" \u2192 search "allowedIps" \u2192 search "allowed_ips" (WRONG: these are trivial case variations, probe handles them)',
-    '  \u2192 search "CIDR" \u2192 search "cidr" \u2192 search "Cidr" \u2192 search "*cidr*" (WRONG: same keyword repeated with variations)',
-    '  \u2192 search "error handling" \u2192 search "error handling" \u2192 search "error handling" (WRONG: repeating exact same query)',
+    '  \u2192 search "AllowedIPs" \u2192 search "allowedIps" \u2192 search "allowed_ips" (WRONG: case/style variations, probe handles them)',
+    `  \u2192 search "limitDRL" \u2192 search "LimitDRL" (WRONG: case variation \u2014 combine with OR: '"limitDRL" "limitRedis"')`,
+    '  \u2192 search "throttle_retry_limit" after searching "ThrottleRetryLimit" (WRONG: snake_case variation, probe handles it)',
+    '  \u2192 search "ThrottleRetryLimit" path=tyk \u2192 search "ThrottleRetryLimit" path=gateway \u2192 search "ThrottleRetryLimit" path=apidef (WRONG: same query on different paths \u2014 probe searches recursively)',
+    '  \u2192 search "func (k *RateLimitAndQuotaCheck) handleRateLimitFailure" (WRONG: do not search full function signatures, just use exact=true "handleRateLimitFailure")',
+    '  \u2192 search "ForwardMessage" \u2192 search "ForwardMessage" \u2192 search "ForwardMessage" (WRONG: repeating the exact same query)',
+    '  \u2192 search "authentication" \u2192 wait \u2192 search "session management" \u2192 wait (WRONG: these are independent, run them in parallel)',
     "",
     "Keyword tips:",
     "- Common programming keywords are filtered as stopwords when unquoted: function, class, return, new, struct, impl, var, let, const, etc.",
     '- Avoid searching for these alone \u2014 combine with a specific term (e.g., "middleware function" is fine, "function" alone is too generic).',
     '- To bypass stopword filtering: wrap terms in quotes ("return", "struct") or set exact=true. Both disable stemming and splitting too.',
-    "- Multiple words without operators use OR logic: foo bar = foo OR bar. Use AND explicitly if you need both: foo AND bar.",
     '- camelCase terms are split: getUserData becomes "get", "user", "data" \u2014 so one search covers all naming styles.',
+    '- Do NOT search for full function signatures like "func (r *Type) Method(args)". Just search for the method name with exact=true.',
     "",
     "Strategy:",
-    "1. Analyze the query - identify key concepts, entities, and relationships",
-    "2. Run ONE focused search per concept with the most natural keyword. Trust probe to handle variations.",
-    "3. If a search returns results, use extract to verify relevance",
-    "4. Only try a different keyword if the first one returned irrelevant results (not if it returned no results \u2014 that means the concept is absent)",
-    "5. Combine all relevant targets in your final response",
+    "1. Analyze the query - identify key concepts and group related symbols",
+    `2. Combine related symbols into OR searches: '"symbolA" "symbolB"' finds files with either (quote to prevent splitting)`,
+    "3. Run INDEPENDENT searches in PARALLEL \u2014 do not wait for one to finish before starting another",
+    "4. For known symbol names use exact=true. For concepts use default (exact=false).",
+    "5. If a search returns results, use extract to verify relevance. Run multiple extracts in parallel too.",
+    "6. If a search returns NO results, the term does not exist. Do NOT retry with variations, different paths, or longer strings. Move on.",
+    "7. Combine all relevant targets in your final response",
     "",
     `Query: ${searchQuery}`,
     `Search path(s): ${searchPath}`,
@@ -9277,6 +9354,13 @@ var init_vercel = __esm({
         description: searchDelegate ? searchDelegateDescription : searchDescription,
         inputSchema: searchSchema,
         execute: async ({ query: searchQuery, path: path9, allow_tests, exact, maxTokens: paramMaxTokens, language, session, nextPage }) => {
+          if (!exact && searchQuery) {
+            const originalQuery = searchQuery;
+            searchQuery = autoQuoteSearchTerms(searchQuery);
+            if (debug && searchQuery !== originalQuery) {
+              console.error(`[search] Auto-quoted query: "${originalQuery}" \u2192 "${searchQuery}"`);
+            }
+          }
           const effectiveMaxTokens = paramMaxTokens || maxTokens;
           let searchPaths;
           if (path9) {
@@ -9312,13 +9396,13 @@ var init_vercel = __esm({
             return await search(searchOptions);
           };
           if (!searchDelegate) {
-            const searchKey = `${searchQuery}::${searchPath}::${exact || false}`;
+            const searchKey = `${searchQuery}::${exact || false}`;
             if (!nextPage) {
               if (previousSearches.has(searchKey)) {
                 if (debug) {
-                  console.error(`[DEDUP] Blocked duplicate search: "${searchQuery}" in "${searchPath}"`);
+                  console.error(`[DEDUP] Blocked duplicate search: "${searchQuery}" (path: "${searchPath}")`);
                 }
-                return "DUPLICATE SEARCH BLOCKED: You already searched for this exact query in this path. Do NOT repeat the same search. If you need more results, set nextPage=true with the session ID from the previous search. Otherwise, try a genuinely different keyword, use extract to examine results you already found, or use attempt_completion if you have enough information.";
+                return "DUPLICATE SEARCH BLOCKED: You already searched for this exact query. Changing the path does NOT give different results \u2014 probe searches recursively. Do NOT repeat the same search. Try a genuinely different keyword, use extract to examine results you already found, or use attempt_completion if you have enough information.";
               }
               previousSearches.add(searchKey);
               paginationCounts.set(searchKey, 0);
@@ -9538,6 +9622,36 @@ var init_vercel = __esm({
             } else if (targets) {
               const parsedTargets = parseTargets(targets);
               extractFiles = parsedTargets.map((target) => resolveTargetPath(target, effectiveCwd));
+              if (options.allowedFolders && options.allowedFolders.length > 0) {
+                extractFiles = extractFiles.map((target) => {
+                  const { filePart, suffix } = splitTargetSuffix(target);
+                  if (existsSync(filePart)) return target;
+                  const cwdPrefix = effectiveCwd.endsWith("/") ? effectiveCwd : effectiveCwd + "/";
+                  const relativePart = filePart.startsWith(cwdPrefix) ? filePart.slice(cwdPrefix.length) : null;
+                  if (relativePart) {
+                    for (const folder of options.allowedFolders) {
+                      const candidate = folder + "/" + relativePart;
+                      if (existsSync(candidate)) {
+                        if (debug) console.error(`[extract] Auto-fixed path: ${filePart} \u2192 ${candidate}`);
+                        return candidate + suffix;
+                      }
+                    }
+                  }
+                  for (const folder of options.allowedFolders) {
+                    const folderPrefix = folder.endsWith("/") ? folder : folder + "/";
+                    const wsParent = folderPrefix.replace(/[^/]+\/$/, "");
+                    if (filePart.startsWith(wsParent)) {
+                      const tail = filePart.slice(wsParent.length);
+                      const candidate = folderPrefix + tail;
+                      if (candidate !== filePart && existsSync(candidate)) {
+                        if (debug) console.error(`[extract] Auto-fixed path via workspace: ${filePart} \u2192 ${candidate}`);
+                        return candidate + suffix;
+                      }
+                    }
+                  }
+                  return target;
+                });
+              }
               let effectiveFormat = format;
               if (outline && format === "outline-xml") {
                 effectiveFormat = "xml";

package/build/tools/vercel.js

@@ -14,6 +14,75 @@ import { existsSync } from 'fs';
 import { formatErrorForAI } from '../utils/error-types.js';
 import { annotateOutputWithHashes } from './hashline.js';
 
+/**
+ * Auto-quote search query terms that contain mixed case or underscores.
+ * Unquoted camelCase like "limitDRL" gets split by stemming into "limit" + "DRL".
+ * This wraps such terms in quotes so they match as literal strings.
+ *
+ * Examples:
+ *   "limitDRL limitRedis"    → '"limitDRL" "limitRedis"'
+ *   "ThrottleRetryLimit"     → '"ThrottleRetryLimit"'
+ *   "allowed_ips"            → '"allowed_ips"'
+ *   "rate limit"             → 'rate limit'  (no change, all lowercase)
+ *   '"already quoted"'       → '"already quoted"'  (no change)
+ *   'foo AND bar'            → 'foo AND bar'  (operators preserved)
+ */
+function autoQuoteSearchTerms(query) {
+	if (!query || typeof query !== 'string') return query;
+
+	// Split on whitespace, preserving quoted strings and operators
+	const tokens = [];
+	let i = 0;
+	while (i < query.length) {
+		// Skip whitespace
+		if (/\s/.test(query[i])) {
+			i++;
+			continue;
+		}
+		// Quoted string — keep as-is
+		if (query[i] === '"') {
+			const end = query.indexOf('"', i + 1);
+			if (end !== -1) {
+				tokens.push(query.substring(i, end + 1));
+				i = end + 1;
+			} else {
+				// Unclosed quote — take rest
+				tokens.push(query.substring(i));
+				break;
+			}
+			continue;
+		}
+		// Unquoted token
+		let j = i;
+		while (j < query.length && !/\s/.test(query[j]) && query[j] !== '"') {
+			j++;
+		}
+		tokens.push(query.substring(i, j));
+		i = j;
+	}
+
+	// Boolean operators that should not be quoted
+	const operators = new Set(['AND', 'OR', 'NOT']);
+
+	const result = tokens.map(token => {
+		// Already quoted
+		if (token.startsWith('"')) return token;
+		// Boolean operator
+		if (operators.has(token)) return token;
+		// Check if token needs quoting: has mixed case (upper+lower) or underscores
+		const hasUpper = /[A-Z]/.test(token);
+		const hasLower = /[a-z]/.test(token);
+		const hasUnderscore = token.includes('_');
+		const hasMixedCase = hasUpper && hasLower;
+		if (hasMixedCase || hasUnderscore) {
+			return `"${token}"`;
+		}
+		return token;
+	});
+
+	return result.join(' ');
+}
+
 const CODE_SEARCH_SCHEMA = {
 	type: 'object',
 	properties: {
@@ -144,40 +213,75 @@ function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, all
 		'- listFiles: Understand directory structure to find where relevant code might live.',
 		'',
 		'CRITICAL - How probe search works (do NOT ignore):',
-		'- By default (exact=false), probe ALREADY handles stemming, case-insensitive matching, and camelCase/snake_case splitting.',
+		'- By default (exact=false), probe ALREADY handles stemming, case-insensitive matching, and camelCase/snake_case splitting automatically.',
 		'- Searching "allowed_ips" ALREADY matches "AllowedIPs", "allowedIps", "allowed_ips", etc. Do NOT manually try case/style variations.',
 		'- Searching "getUserData" ALREADY matches "get", "user", "data" and their variations.',
-		'- NEVER repeat the same search query — you will get the same results.',
+		'- NEVER repeat the same search query — you will get the same results. Changing the path does NOT change this.',
 		'- NEVER search trivial variations of the same keyword (e.g., AllowedIPs then allowedIps then allowed_ips). This is wasteful — probe handles it.',
-		'- If a search returns no results, the term likely does not exist in that path. Try a genuinely DIFFERENT keyword or concept, not a variation.',
-		'- If 2-3 consecutive searches return no results for a concept, STOP searching for it and move on.',
+		'- If a search returns no results, the term likely does not exist. Try a genuinely DIFFERENT keyword or concept, not a variation.',
+		'- If 2-3 searches return no results for a concept, STOP searching for it and move on. Do NOT keep retrying.',
+		'',
+		'When to use exact=true:',
+		'- Use exact=true when searching for a KNOWN symbol name (function, type, variable, struct).',
+		'- exact=true matches the literal string only — no stemming, no splitting.',
+		'- This is ideal for precise lookups: exact=true "ForwardMessage", exact=true "SessionLimiter", exact=true "ThrottleRetryLimit".',
+		'- Do NOT use exact=true for exploratory/conceptual queries — use the default for those.',
+		'',
+		'Combining searches with OR:',
+		'- Multiple unquoted words use OR logic: rate limit matches files containing EITHER "rate" OR "limit".',
+		'- For known symbol names, quote each term to prevent splitting: \'"limitDRL" "limitRedis"\' matches either exact symbol.',
+		'- Without quotes, camelCase like limitDRL gets split into "limit" + "DRL" — not what you want for symbol lookup.',
+		'- Use OR to search for multiple related symbols in ONE search instead of separate searches.',
+		'- This is much faster than running separate searches sequentially.',
+		'- Example: search \'"ForwardMessage" "SessionLimiter"\' finds files with either exact symbol in one call.',
+		'- Example: search \'"limitDRL" "doRollingWindowWrite"\' finds both rate limiting functions at once.',
+		'- Use AND only when you need both terms to appear in the same file: "rate AND limit".',
+		'',
+		'Parallel tool calls:',
+		'- When you need to search for INDEPENDENT concepts, call multiple search tools IN PARALLEL (same response).',
+		'- Do NOT wait for one search to finish before starting the next if they are independent.',
+		'- Example: for "rate limiting and session management", call search "rate limiting" AND search "session management" in parallel.',
+		'- Similarly, call multiple extract tools in parallel when verifying different files.',
 		'',
 		'GOOD search strategy (do this):',
 		'  Query: "How does authentication work and how are sessions managed?"',
-		'  → search "authentication" → search "session management" (two different concepts)',
+		'  → search "authentication" + search "session management" IN PARALLEL (two independent concepts)',
 		'  Query: "Find the IP allowlist middleware"',
 		'  → search "allowlist middleware" (one search, probe handles IP/ip/Ip variations)',
+		'  Query: "Find ForwardMessage and SessionLimiter"',
+		'  → search \'"ForwardMessage" "SessionLimiter"\' (one OR search finds both exact symbols)',
+		'  OR: search exact=true "ForwardMessage" + search exact=true "SessionLimiter" IN PARALLEL',
+		'  Query: "Find limitDRL and limitRedis functions"',
+		'  → search \'"limitDRL" "limitRedis"\' (one OR search, quoted to prevent camelCase splitting)',
+		'  Query: "Find ThrottleRetryLimit usage"',
+		'  → search exact=true "ThrottleRetryLimit" (one search, if no results the symbol does not exist — stop)',
 		'  Query: "How does BM25 scoring work with SIMD optimization?"',
-		'  → search "BM25 scoring" → search "SIMD optimization" (two different concepts)',
+		'  → search "BM25 scoring" + search "SIMD optimization" IN PARALLEL (two different concepts)',
 		'',
 		'BAD search strategy (never do this):',
-		'  → search "AllowedIPs" → search "allowedIps" → search "allowed_ips" (WRONG: these are trivial case variations, probe handles them)',
-		'  → search "CIDR" → search "cidr" → search "Cidr" → search "*cidr*" (WRONG: same keyword repeated with variations)',
-		'  → search "error handling" → search "error handling" → search "error handling" (WRONG: repeating exact same query)',
+		'  → search "AllowedIPs" → search "allowedIps" → search "allowed_ips" (WRONG: case/style variations, probe handles them)',
+		'  → search "limitDRL" → search "LimitDRL" (WRONG: case variation — combine with OR: \'"limitDRL" "limitRedis"\')',
+		'  → search "throttle_retry_limit" after searching "ThrottleRetryLimit" (WRONG: snake_case variation, probe handles it)',
+		'  → search "ThrottleRetryLimit" path=tyk → search "ThrottleRetryLimit" path=gateway → search "ThrottleRetryLimit" path=apidef (WRONG: same query on different paths — probe searches recursively)',
+		'  → search "func (k *RateLimitAndQuotaCheck) handleRateLimitFailure" (WRONG: do not search full function signatures, just use exact=true "handleRateLimitFailure")',
+		'  → search "ForwardMessage" → search "ForwardMessage" → search "ForwardMessage" (WRONG: repeating the exact same query)',
+		'  → search "authentication" → wait → search "session management" → wait (WRONG: these are independent, run them in parallel)',
 		'',
 		'Keyword tips:',
 		'- Common programming keywords are filtered as stopwords when unquoted: function, class, return, new, struct, impl, var, let, const, etc.',
 		'- Avoid searching for these alone — combine with a specific term (e.g., "middleware function" is fine, "function" alone is too generic).',
 		'- To bypass stopword filtering: wrap terms in quotes ("return", "struct") or set exact=true. Both disable stemming and splitting too.',
-		'- Multiple words without operators use OR logic: foo bar = foo OR bar. Use AND explicitly if you need both: foo AND bar.',
 		'- camelCase terms are split: getUserData becomes "get", "user", "data" — so one search covers all naming styles.',
+		'- Do NOT search for full function signatures like "func (r *Type) Method(args)". Just search for the method name with exact=true.',
 		'',
 		'Strategy:',
-		'1. Analyze the query - identify key concepts, entities, and relationships',
-		'2. Run ONE focused search per concept with the most natural keyword. Trust probe to handle variations.',
-		'3. If a search returns results, use extract to verify relevance',
-		'4. Only try a different keyword if the first one returned irrelevant results (not if it returned no results — that means the concept is absent)',
-		'5. Combine all relevant targets in your final response',
+		'1. Analyze the query - identify key concepts and group related symbols',
+		'2. Combine related symbols into OR searches: \'"symbolA" "symbolB"\' finds files with either (quote to prevent splitting)',
+		'3. Run INDEPENDENT searches in PARALLEL — do not wait for one to finish before starting another',
+		'4. For known symbol names use exact=true. For concepts use default (exact=false).',
+		'5. If a search returns results, use extract to verify relevance. Run multiple extracts in parallel too.',
+		'6. If a search returns NO results, the term does not exist. Do NOT retry with variations, different paths, or longer strings. Move on.',
+		'7. Combine all relevant targets in your final response',
 		'',
 		`Query: ${searchQuery}`,
 		`Search path(s): ${searchPath}`,
@@ -229,6 +333,16 @@ export const searchTool = (options = {}) => {
 			: searchDescription,
 		inputSchema: searchSchema,
 		execute: async ({ query: searchQuery, path, allow_tests, exact, maxTokens: paramMaxTokens, language, session, nextPage }) => {
+			// Auto-quote mixed-case and underscore terms to prevent unwanted stemming/splitting
+			// Skip when exact=true since that already preserves the literal string
+			if (!exact && searchQuery) {
+				const originalQuery = searchQuery;
+				searchQuery = autoQuoteSearchTerms(searchQuery);
+				if (debug && searchQuery !== originalQuery) {
+					console.error(`[search] Auto-quoted query: "${originalQuery}" → "${searchQuery}"`);
+				}
+			}
+
 			// Use parameter maxTokens if provided, otherwise use the default
 			const effectiveMaxTokens = paramMaxTokens || maxTokens;
 
@@ -274,13 +388,15 @@ export const searchTool = (options = {}) => {
 			if (!searchDelegate) {
 				// Block duplicate non-paginated searches (models sometimes repeat the exact same call)
 				// Allow pagination: only nextPage=true is a legitimate repeat of the same query
-				const searchKey = `${searchQuery}::${searchPath}::${exact || false}`;
+				// Use query+exact as the key (ignore path) to prevent path-hopping evasion
+				// where model searches same term on different subpaths hoping for different results
+				const searchKey = `${searchQuery}::${exact || false}`;
 				if (!nextPage) {
 					if (previousSearches.has(searchKey)) {
 						if (debug) {
-							console.error(`[DEDUP] Blocked duplicate search: "${searchQuery}" in "${searchPath}"`);
+							console.error(`[DEDUP] Blocked duplicate search: "${searchQuery}" (path: "${searchPath}")`);
 						}
-						return 'DUPLICATE SEARCH BLOCKED: You already searched for this exact query in this path. Do NOT repeat the same search. If you need more results, set nextPage=true with the session ID from the previous search. Otherwise, try a genuinely different keyword, use extract to examine results you already found, or use attempt_completion if you have enough information.';
+						return 'DUPLICATE SEARCH BLOCKED: You already searched for this exact query. Changing the path does NOT give different results — probe searches recursively. Do NOT repeat the same search. Try a genuinely different keyword, use extract to examine results you already found, or use attempt_completion if you have enough information.';
 					}
 					previousSearches.add(searchKey);
 					paginationCounts.set(searchKey, 0);
@@ -570,6 +686,50 @@ export const extractTool = (options = {}) => {
 					// Resolve relative paths in targets against cwd
 					extractFiles = parsedTargets.map(target => resolveTargetPath(target, effectiveCwd));
 
+					// Auto-fix: if resolved paths don't exist, try allowedFolders subdirs
+					// Handles when search returns relative paths (e.g., "gateway/file.go") and
+					// model constructs wrong absolute paths (e.g., /workspace/gateway/file.go
+					// instead of /workspace/tyk/gateway/file.go)
+					if (options.allowedFolders && options.allowedFolders.length > 0) {
+						extractFiles = extractFiles.map(target => {
+							const { filePart, suffix } = splitTargetSuffix(target);
+							if (existsSync(filePart)) return target;
+
+							// Try resolving the relative tail against each allowedFolder
+							const cwdPrefix = (effectiveCwd.endsWith('/') ? effectiveCwd : effectiveCwd + '/');
+							const relativePart = filePart.startsWith(cwdPrefix)
+								? filePart.slice(cwdPrefix.length)
+								: null;
+
+							if (relativePart) {
+								for (const folder of options.allowedFolders) {
+									const candidate = folder + '/' + relativePart;
+									if (existsSync(candidate)) {
+										if (debug) console.error(`[extract] Auto-fixed path: ${filePart} → ${candidate}`);
+										return candidate + suffix;
+									}
+								}
+							}
+
+							// Try stripping workspace prefix and resolving against allowedFolders
+							// e.g., /tmp/visor-workspaces/abc/gateway/file.go → try each folder + gateway/file.go
+							for (const folder of options.allowedFolders) {
+								const folderPrefix = folder.endsWith('/') ? folder : folder + '/';
+								const wsParent = folderPrefix.replace(/[^/]+\/$/, '');
+								if (filePart.startsWith(wsParent)) {
+									const tail = filePart.slice(wsParent.length);
+									const candidate = folderPrefix + tail;
+									if (candidate !== filePart && existsSync(candidate)) {
+										if (debug) console.error(`[extract] Auto-fixed path via workspace: ${filePart} → ${candidate}`);
+										return candidate + suffix;
+									}
+								}
+							}
+
+							return target;
+						});
+					}
+
 					// Apply format mapping for outline-xml to xml
 					let effectiveFormat = format;
 					if (outline && format === 'outline-xml') {

package/cjs/agent/ProbeAgent.cjs

@@ -4205,7 +4205,7 @@ var init_NormalizedSchema = __esm({
         if (this.isDocumentSchema()) {
           return member([15, 0], memberName);
         }
-        throw new Error(`@smithy/core/schema - ${this.getName(true)} has no no member=${memberName}.`);
+        throw new Error(`@smithy/core/schema - ${this.getName(true)} has no member=${memberName}.`);
       }
       getMemberSchemas() {
         const buffer = {};
@@ -5996,7 +5996,7 @@ var init_EventStreamSerde = __esm({
             throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
           }
         }
-        const messageSerialization = serializer.flush();
+        const messageSerialization = serializer.flush() ?? new Uint8Array();
         const body = typeof messageSerialization === "string" ? (this.serdeContext?.utf8Decoder ?? import_util_utf8.fromUtf8)(messageSerialization) : messageSerialization;
         return {
           body,
@@ -36463,6 +36463,48 @@ var init_hashline = __esm({
 });
 
 // src/tools/vercel.js
+function autoQuoteSearchTerms(query2) {
+  if (!query2 || typeof query2 !== "string") return query2;
+  const tokens = [];
+  let i5 = 0;
+  while (i5 < query2.length) {
+    if (/\s/.test(query2[i5])) {
+      i5++;
+      continue;
+    }
+    if (query2[i5] === '"') {
+      const end = query2.indexOf('"', i5 + 1);
+      if (end !== -1) {
+        tokens.push(query2.substring(i5, end + 1));
+        i5 = end + 1;
+      } else {
+        tokens.push(query2.substring(i5));
+        break;
+      }
+      continue;
+    }
+    let j5 = i5;
+    while (j5 < query2.length && !/\s/.test(query2[j5]) && query2[j5] !== '"') {
+      j5++;
+    }
+    tokens.push(query2.substring(i5, j5));
+    i5 = j5;
+  }
+  const operators = /* @__PURE__ */ new Set(["AND", "OR", "NOT"]);
+  const result = tokens.map((token) => {
+    if (token.startsWith('"')) return token;
+    if (operators.has(token)) return token;
+    const hasUpper = /[A-Z]/.test(token);
+    const hasLower = /[a-z]/.test(token);
+    const hasUnderscore = token.includes("_");
+    const hasMixedCase = hasUpper && hasLower;
+    if (hasMixedCase || hasUnderscore) {
+      return `"${token}"`;
+    }
+    return token;
+  });
+  return result.join(" ");
+}
 function normalizeTargets(targets) {
   if (!Array.isArray(targets)) return [];
   const seen = /* @__PURE__ */ new Set();
@@ -36563,40 +36605,75 @@ function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, all
     "- listFiles: Understand directory structure to find where relevant code might live.",
     "",
     "CRITICAL - How probe search works (do NOT ignore):",
-    "- By default (exact=false), probe ALREADY handles stemming, case-insensitive matching, and camelCase/snake_case splitting.",
+    "- By default (exact=false), probe ALREADY handles stemming, case-insensitive matching, and camelCase/snake_case splitting automatically.",
     '- Searching "allowed_ips" ALREADY matches "AllowedIPs", "allowedIps", "allowed_ips", etc. Do NOT manually try case/style variations.',
     '- Searching "getUserData" ALREADY matches "get", "user", "data" and their variations.',
-    "- NEVER repeat the same search query \u2014 you will get the same results.",
+    "- NEVER repeat the same search query \u2014 you will get the same results. Changing the path does NOT change this.",
     "- NEVER search trivial variations of the same keyword (e.g., AllowedIPs then allowedIps then allowed_ips). This is wasteful \u2014 probe handles it.",
-    "- If a search returns no results, the term likely does not exist in that path. Try a genuinely DIFFERENT keyword or concept, not a variation.",
-    "- If 2-3 consecutive searches return no results for a concept, STOP searching for it and move on.",
+    "- If a search returns no results, the term likely does not exist. Try a genuinely DIFFERENT keyword or concept, not a variation.",
+    "- If 2-3 searches return no results for a concept, STOP searching for it and move on. Do NOT keep retrying.",
+    "",
+    "When to use exact=true:",
+    "- Use exact=true when searching for a KNOWN symbol name (function, type, variable, struct).",
+    "- exact=true matches the literal string only \u2014 no stemming, no splitting.",
+    '- This is ideal for precise lookups: exact=true "ForwardMessage", exact=true "SessionLimiter", exact=true "ThrottleRetryLimit".',
+    "- Do NOT use exact=true for exploratory/conceptual queries \u2014 use the default for those.",
+    "",
+    "Combining searches with OR:",
+    '- Multiple unquoted words use OR logic: rate limit matches files containing EITHER "rate" OR "limit".',
+    `- For known symbol names, quote each term to prevent splitting: '"limitDRL" "limitRedis"' matches either exact symbol.`,
+    '- Without quotes, camelCase like limitDRL gets split into "limit" + "DRL" \u2014 not what you want for symbol lookup.',
+    "- Use OR to search for multiple related symbols in ONE search instead of separate searches.",
+    "- This is much faster than running separate searches sequentially.",
+    `- Example: search '"ForwardMessage" "SessionLimiter"' finds files with either exact symbol in one call.`,
+    `- Example: search '"limitDRL" "doRollingWindowWrite"' finds both rate limiting functions at once.`,
+    '- Use AND only when you need both terms to appear in the same file: "rate AND limit".',
+    "",
+    "Parallel tool calls:",
+    "- When you need to search for INDEPENDENT concepts, call multiple search tools IN PARALLEL (same response).",
+    "- Do NOT wait for one search to finish before starting the next if they are independent.",
+    '- Example: for "rate limiting and session management", call search "rate limiting" AND search "session management" in parallel.',
+    "- Similarly, call multiple extract tools in parallel when verifying different files.",
     "",
     "GOOD search strategy (do this):",
     '  Query: "How does authentication work and how are sessions managed?"',
-    '  \u2192 search "authentication" \u2192 search "session management" (two different concepts)',
+    '  \u2192 search "authentication" + search "session management" IN PARALLEL (two independent concepts)',
     '  Query: "Find the IP allowlist middleware"',
     '  \u2192 search "allowlist middleware" (one search, probe handles IP/ip/Ip variations)',
+    '  Query: "Find ForwardMessage and SessionLimiter"',
+    `  \u2192 search '"ForwardMessage" "SessionLimiter"' (one OR search finds both exact symbols)`,
+    '  OR: search exact=true "ForwardMessage" + search exact=true "SessionLimiter" IN PARALLEL',
+    '  Query: "Find limitDRL and limitRedis functions"',
+    `  \u2192 search '"limitDRL" "limitRedis"' (one OR search, quoted to prevent camelCase splitting)`,
+    '  Query: "Find ThrottleRetryLimit usage"',
+    '  \u2192 search exact=true "ThrottleRetryLimit" (one search, if no results the symbol does not exist \u2014 stop)',
     '  Query: "How does BM25 scoring work with SIMD optimization?"',
-    '  \u2192 search "BM25 scoring" \u2192 search "SIMD optimization" (two different concepts)',
+    '  \u2192 search "BM25 scoring" + search "SIMD optimization" IN PARALLEL (two different concepts)',
     "",
     "BAD search strategy (never do this):",
-    '  \u2192 search "AllowedIPs" \u2192 search "allowedIps" \u2192 search "allowed_ips" (WRONG: these are trivial case variations, probe handles them)',
-    '  \u2192 search "CIDR" \u2192 search "cidr" \u2192 search "Cidr" \u2192 search "*cidr*" (WRONG: same keyword repeated with variations)',
-    '  \u2192 search "error handling" \u2192 search "error handling" \u2192 search "error handling" (WRONG: repeating exact same query)',
+    '  \u2192 search "AllowedIPs" \u2192 search "allowedIps" \u2192 search "allowed_ips" (WRONG: case/style variations, probe handles them)',
+    `  \u2192 search "limitDRL" \u2192 search "LimitDRL" (WRONG: case variation \u2014 combine with OR: '"limitDRL" "limitRedis"')`,
+    '  \u2192 search "throttle_retry_limit" after searching "ThrottleRetryLimit" (WRONG: snake_case variation, probe handles it)',
+    '  \u2192 search "ThrottleRetryLimit" path=tyk \u2192 search "ThrottleRetryLimit" path=gateway \u2192 search "ThrottleRetryLimit" path=apidef (WRONG: same query on different paths \u2014 probe searches recursively)',
+    '  \u2192 search "func (k *RateLimitAndQuotaCheck) handleRateLimitFailure" (WRONG: do not search full function signatures, just use exact=true "handleRateLimitFailure")',
+    '  \u2192 search "ForwardMessage" \u2192 search "ForwardMessage" \u2192 search "ForwardMessage" (WRONG: repeating the exact same query)',
+    '  \u2192 search "authentication" \u2192 wait \u2192 search "session management" \u2192 wait (WRONG: these are independent, run them in parallel)',
     "",
     "Keyword tips:",
     "- Common programming keywords are filtered as stopwords when unquoted: function, class, return, new, struct, impl, var, let, const, etc.",
     '- Avoid searching for these alone \u2014 combine with a specific term (e.g., "middleware function" is fine, "function" alone is too generic).',
     '- To bypass stopword filtering: wrap terms in quotes ("return", "struct") or set exact=true. Both disable stemming and splitting too.',
-    "- Multiple words without operators use OR logic: foo bar = foo OR bar. Use AND explicitly if you need both: foo AND bar.",
     '- camelCase terms are split: getUserData becomes "get", "user", "data" \u2014 so one search covers all naming styles.',
+    '- Do NOT search for full function signatures like "func (r *Type) Method(args)". Just search for the method name with exact=true.',
     "",
     "Strategy:",
-    "1. Analyze the query - identify key concepts, entities, and relationships",
-    "2. Run ONE focused search per concept with the most natural keyword. Trust probe to handle variations.",
-    "3. If a search returns results, use extract to verify relevance",
-    "4. Only try a different keyword if the first one returned irrelevant results (not if it returned no results \u2014 that means the concept is absent)",
-    "5. Combine all relevant targets in your final response",
+    "1. Analyze the query - identify key concepts and group related symbols",
+    `2. Combine related symbols into OR searches: '"symbolA" "symbolB"' finds files with either (quote to prevent splitting)`,
+    "3. Run INDEPENDENT searches in PARALLEL \u2014 do not wait for one to finish before starting another",
+    "4. For known symbol names use exact=true. For concepts use default (exact=false).",
+    "5. If a search returns results, use extract to verify relevance. Run multiple extracts in parallel too.",
+    "6. If a search returns NO results, the term does not exist. Do NOT retry with variations, different paths, or longer strings. Move on.",
+    "7. Combine all relevant targets in your final response",
     "",
     `Query: ${searchQuery}`,
     `Search path(s): ${searchPath}`,
@@ -36657,6 +36734,13 @@ var init_vercel = __esm({
         description: searchDelegate ? searchDelegateDescription : searchDescription,
         inputSchema: searchSchema,
         execute: async ({ query: searchQuery, path: path9, allow_tests, exact, maxTokens: paramMaxTokens, language, session, nextPage }) => {
+          if (!exact && searchQuery) {
+            const originalQuery = searchQuery;
+            searchQuery = autoQuoteSearchTerms(searchQuery);
+            if (debug && searchQuery !== originalQuery) {
+              console.error(`[search] Auto-quoted query: "${originalQuery}" \u2192 "${searchQuery}"`);
+            }
+          }
           const effectiveMaxTokens = paramMaxTokens || maxTokens;
           let searchPaths;
           if (path9) {
@@ -36692,13 +36776,13 @@ var init_vercel = __esm({
             return await search(searchOptions);
           };
           if (!searchDelegate) {
-            const searchKey = `${searchQuery}::${searchPath}::${exact || false}`;
+            const searchKey = `${searchQuery}::${exact || false}`;
             if (!nextPage) {
               if (previousSearches.has(searchKey)) {
                 if (debug) {
-                  console.error(`[DEDUP] Blocked duplicate search: "${searchQuery}" in "${searchPath}"`);
+                  console.error(`[DEDUP] Blocked duplicate search: "${searchQuery}" (path: "${searchPath}")`);
                 }
-                return "DUPLICATE SEARCH BLOCKED: You already searched for this exact query in this path. Do NOT repeat the same search. If you need more results, set nextPage=true with the session ID from the previous search. Otherwise, try a genuinely different keyword, use extract to examine results you already found, or use attempt_completion if you have enough information.";
+                return "DUPLICATE SEARCH BLOCKED: You already searched for this exact query. Changing the path does NOT give different results \u2014 probe searches recursively. Do NOT repeat the same search. Try a genuinely different keyword, use extract to examine results you already found, or use attempt_completion if you have enough information.";
               }
               previousSearches.add(searchKey);
               paginationCounts.set(searchKey, 0);
@@ -36918,6 +37002,36 @@ var init_vercel = __esm({
             } else if (targets) {
               const parsedTargets = parseTargets(targets);
               extractFiles = parsedTargets.map((target) => resolveTargetPath(target, effectiveCwd));
+              if (options.allowedFolders && options.allowedFolders.length > 0) {
+                extractFiles = extractFiles.map((target) => {
+                  const { filePart, suffix } = splitTargetSuffix(target);
+                  if ((0, import_fs4.existsSync)(filePart)) return target;
+                  const cwdPrefix = effectiveCwd.endsWith("/") ? effectiveCwd : effectiveCwd + "/";
+                  const relativePart = filePart.startsWith(cwdPrefix) ? filePart.slice(cwdPrefix.length) : null;
+                  if (relativePart) {
+                    for (const folder of options.allowedFolders) {
+                      const candidate = folder + "/" + relativePart;
+                      if ((0, import_fs4.existsSync)(candidate)) {
+                        if (debug) console.error(`[extract] Auto-fixed path: ${filePart} \u2192 ${candidate}`);
+                        return candidate + suffix;
+                      }
+                    }
+                  }
+                  for (const folder of options.allowedFolders) {
+                    const folderPrefix = folder.endsWith("/") ? folder : folder + "/";
+                    const wsParent = folderPrefix.replace(/[^/]+\/$/, "");
+                    if (filePart.startsWith(wsParent)) {
+                      const tail = filePart.slice(wsParent.length);
+                      const candidate = folderPrefix + tail;
+                      if (candidate !== filePart && (0, import_fs4.existsSync)(candidate)) {
+                        if (debug) console.error(`[extract] Auto-fixed path via workspace: ${filePart} \u2192 ${candidate}`);
+                        return candidate + suffix;
+                      }
+                    }
+                  }
+                  return target;
+                });
+              }
               let effectiveFormat = format2;
               if (outline && format2 === "outline-xml") {
                 effectiveFormat = "xml";

package/cjs/index.cjs

@@ -6063,7 +6063,7 @@ var init_NormalizedSchema = __esm({
         if (this.isDocumentSchema()) {
           return member([15, 0], memberName);
         }
-        throw new Error(`@smithy/core/schema - ${this.getName(true)} has no no member=${memberName}.`);
+        throw new Error(`@smithy/core/schema - ${this.getName(true)} has no member=${memberName}.`);
       }
       getMemberSchemas() {
         const buffer = {};
@@ -7854,7 +7854,7 @@ var init_EventStreamSerde = __esm({
             throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
           }
         }
-        const messageSerialization = serializer.flush();
+        const messageSerialization = serializer.flush() ?? new Uint8Array();
         const body = typeof messageSerialization === "string" ? (this.serdeContext?.utf8Decoder ?? import_util_utf8.fromUtf8)(messageSerialization) : messageSerialization;
         return {
           body,
@@ -110625,6 +110625,48 @@ var init_hashline = __esm({
 });
 
 // src/tools/vercel.js
+function autoQuoteSearchTerms(query2) {
+  if (!query2 || typeof query2 !== "string") return query2;
+  const tokens = [];
+  let i5 = 0;
+  while (i5 < query2.length) {
+    if (/\s/.test(query2[i5])) {
+      i5++;
+      continue;
+    }
+    if (query2[i5] === '"') {
+      const end = query2.indexOf('"', i5 + 1);
+      if (end !== -1) {
+        tokens.push(query2.substring(i5, end + 1));
+        i5 = end + 1;
+      } else {
+        tokens.push(query2.substring(i5));
+        break;
+      }
+      continue;
+    }
+    let j5 = i5;
+    while (j5 < query2.length && !/\s/.test(query2[j5]) && query2[j5] !== '"') {
+      j5++;
+    }
+    tokens.push(query2.substring(i5, j5));
+    i5 = j5;
+  }
+  const operators = /* @__PURE__ */ new Set(["AND", "OR", "NOT"]);
+  const result = tokens.map((token) => {
+    if (token.startsWith('"')) return token;
+    if (operators.has(token)) return token;
+    const hasUpper = /[A-Z]/.test(token);
+    const hasLower = /[a-z]/.test(token);
+    const hasUnderscore = token.includes("_");
+    const hasMixedCase = hasUpper && hasLower;
+    if (hasMixedCase || hasUnderscore) {
+      return `"${token}"`;
+    }
+    return token;
+  });
+  return result.join(" ");
+}
 function normalizeTargets(targets) {
   if (!Array.isArray(targets)) return [];
   const seen = /* @__PURE__ */ new Set();
@@ -110725,40 +110767,75 @@ function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, all
     "- listFiles: Understand directory structure to find where relevant code might live.",
     "",
     "CRITICAL - How probe search works (do NOT ignore):",
-    "- By default (exact=false), probe ALREADY handles stemming, case-insensitive matching, and camelCase/snake_case splitting.",
+    "- By default (exact=false), probe ALREADY handles stemming, case-insensitive matching, and camelCase/snake_case splitting automatically.",
     '- Searching "allowed_ips" ALREADY matches "AllowedIPs", "allowedIps", "allowed_ips", etc. Do NOT manually try case/style variations.',
     '- Searching "getUserData" ALREADY matches "get", "user", "data" and their variations.',
-    "- NEVER repeat the same search query \u2014 you will get the same results.",
+    "- NEVER repeat the same search query \u2014 you will get the same results. Changing the path does NOT change this.",
     "- NEVER search trivial variations of the same keyword (e.g., AllowedIPs then allowedIps then allowed_ips). This is wasteful \u2014 probe handles it.",
-    "- If a search returns no results, the term likely does not exist in that path. Try a genuinely DIFFERENT keyword or concept, not a variation.",
-    "- If 2-3 consecutive searches return no results for a concept, STOP searching for it and move on.",
+    "- If a search returns no results, the term likely does not exist. Try a genuinely DIFFERENT keyword or concept, not a variation.",
+    "- If 2-3 searches return no results for a concept, STOP searching for it and move on. Do NOT keep retrying.",
+    "",
+    "When to use exact=true:",
+    "- Use exact=true when searching for a KNOWN symbol name (function, type, variable, struct).",
+    "- exact=true matches the literal string only \u2014 no stemming, no splitting.",
+    '- This is ideal for precise lookups: exact=true "ForwardMessage", exact=true "SessionLimiter", exact=true "ThrottleRetryLimit".',
+    "- Do NOT use exact=true for exploratory/conceptual queries \u2014 use the default for those.",
+    "",
+    "Combining searches with OR:",
+    '- Multiple unquoted words use OR logic: rate limit matches files containing EITHER "rate" OR "limit".',
+    `- For known symbol names, quote each term to prevent splitting: '"limitDRL" "limitRedis"' matches either exact symbol.`,
+    '- Without quotes, camelCase like limitDRL gets split into "limit" + "DRL" \u2014 not what you want for symbol lookup.',
+    "- Use OR to search for multiple related symbols in ONE search instead of separate searches.",
+    "- This is much faster than running separate searches sequentially.",
+    `- Example: search '"ForwardMessage" "SessionLimiter"' finds files with either exact symbol in one call.`,
+    `- Example: search '"limitDRL" "doRollingWindowWrite"' finds both rate limiting functions at once.`,
+    '- Use AND only when you need both terms to appear in the same file: "rate AND limit".',
+    "",
+    "Parallel tool calls:",
+    "- When you need to search for INDEPENDENT concepts, call multiple search tools IN PARALLEL (same response).",
+    "- Do NOT wait for one search to finish before starting the next if they are independent.",
+    '- Example: for "rate limiting and session management", call search "rate limiting" AND search "session management" in parallel.',
+    "- Similarly, call multiple extract tools in parallel when verifying different files.",
     "",
     "GOOD search strategy (do this):",
     '  Query: "How does authentication work and how are sessions managed?"',
-    '  \u2192 search "authentication" \u2192 search "session management" (two different concepts)',
+    '  \u2192 search "authentication" + search "session management" IN PARALLEL (two independent concepts)',
     '  Query: "Find the IP allowlist middleware"',
     '  \u2192 search "allowlist middleware" (one search, probe handles IP/ip/Ip variations)',
+    '  Query: "Find ForwardMessage and SessionLimiter"',
+    `  \u2192 search '"ForwardMessage" "SessionLimiter"' (one OR search finds both exact symbols)`,
+    '  OR: search exact=true "ForwardMessage" + search exact=true "SessionLimiter" IN PARALLEL',
+    '  Query: "Find limitDRL and limitRedis functions"',
+    `  \u2192 search '"limitDRL" "limitRedis"' (one OR search, quoted to prevent camelCase splitting)`,
+    '  Query: "Find ThrottleRetryLimit usage"',
+    '  \u2192 search exact=true "ThrottleRetryLimit" (one search, if no results the symbol does not exist \u2014 stop)',
     '  Query: "How does BM25 scoring work with SIMD optimization?"',
-    '  \u2192 search "BM25 scoring" \u2192 search "SIMD optimization" (two different concepts)',
+    '  \u2192 search "BM25 scoring" + search "SIMD optimization" IN PARALLEL (two different concepts)',
     "",
     "BAD search strategy (never do this):",
-    '  \u2192 search "AllowedIPs" \u2192 search "allowedIps" \u2192 search "allowed_ips" (WRONG: these are trivial case variations, probe handles them)',
-    '  \u2192 search "CIDR" \u2192 search "cidr" \u2192 search "Cidr" \u2192 search "*cidr*" (WRONG: same keyword repeated with variations)',
-    '  \u2192 search "error handling" \u2192 search "error handling" \u2192 search "error handling" (WRONG: repeating exact same query)',
+    '  \u2192 search "AllowedIPs" \u2192 search "allowedIps" \u2192 search "allowed_ips" (WRONG: case/style variations, probe handles them)',
+    `  \u2192 search "limitDRL" \u2192 search "LimitDRL" (WRONG: case variation \u2014 combine with OR: '"limitDRL" "limitRedis"')`,
+    '  \u2192 search "throttle_retry_limit" after searching "ThrottleRetryLimit" (WRONG: snake_case variation, probe handles it)',
+    '  \u2192 search "ThrottleRetryLimit" path=tyk \u2192 search "ThrottleRetryLimit" path=gateway \u2192 search "ThrottleRetryLimit" path=apidef (WRONG: same query on different paths \u2014 probe searches recursively)',
+    '  \u2192 search "func (k *RateLimitAndQuotaCheck) handleRateLimitFailure" (WRONG: do not search full function signatures, just use exact=true "handleRateLimitFailure")',
+    '  \u2192 search "ForwardMessage" \u2192 search "ForwardMessage" \u2192 search "ForwardMessage" (WRONG: repeating the exact same query)',
+    '  \u2192 search "authentication" \u2192 wait \u2192 search "session management" \u2192 wait (WRONG: these are independent, run them in parallel)',
     "",
     "Keyword tips:",
     "- Common programming keywords are filtered as stopwords when unquoted: function, class, return, new, struct, impl, var, let, const, etc.",
     '- Avoid searching for these alone \u2014 combine with a specific term (e.g., "middleware function" is fine, "function" alone is too generic).',
     '- To bypass stopword filtering: wrap terms in quotes ("return", "struct") or set exact=true. Both disable stemming and splitting too.',
-    "- Multiple words without operators use OR logic: foo bar = foo OR bar. Use AND explicitly if you need both: foo AND bar.",
     '- camelCase terms are split: getUserData becomes "get", "user", "data" \u2014 so one search covers all naming styles.',
+    '- Do NOT search for full function signatures like "func (r *Type) Method(args)". Just search for the method name with exact=true.',
     "",
     "Strategy:",
-    "1. Analyze the query - identify key concepts, entities, and relationships",
-    "2. Run ONE focused search per concept with the most natural keyword. Trust probe to handle variations.",
-    "3. If a search returns results, use extract to verify relevance",
-    "4. Only try a different keyword if the first one returned irrelevant results (not if it returned no results \u2014 that means the concept is absent)",
-    "5. Combine all relevant targets in your final response",
+    "1. Analyze the query - identify key concepts and group related symbols",
+    `2. Combine related symbols into OR searches: '"symbolA" "symbolB"' finds files with either (quote to prevent splitting)`,
+    "3. Run INDEPENDENT searches in PARALLEL \u2014 do not wait for one to finish before starting another",
+    "4. For known symbol names use exact=true. For concepts use default (exact=false).",
+    "5. If a search returns results, use extract to verify relevance. Run multiple extracts in parallel too.",
+    "6. If a search returns NO results, the term does not exist. Do NOT retry with variations, different paths, or longer strings. Move on.",
+    "7. Combine all relevant targets in your final response",
     "",
     `Query: ${searchQuery}`,
     `Search path(s): ${searchPath}`,
@@ -110819,6 +110896,13 @@ var init_vercel = __esm({
         description: searchDelegate ? searchDelegateDescription : searchDescription,
         inputSchema: searchSchema,
         execute: async ({ query: searchQuery, path: path9, allow_tests, exact, maxTokens: paramMaxTokens, language, session, nextPage }) => {
+          if (!exact && searchQuery) {
+            const originalQuery = searchQuery;
+            searchQuery = autoQuoteSearchTerms(searchQuery);
+            if (debug && searchQuery !== originalQuery) {
+              console.error(`[search] Auto-quoted query: "${originalQuery}" \u2192 "${searchQuery}"`);
+            }
+          }
           const effectiveMaxTokens = paramMaxTokens || maxTokens;
           let searchPaths;
           if (path9) {
@@ -110854,13 +110938,13 @@ var init_vercel = __esm({
             return await search(searchOptions);
           };
           if (!searchDelegate) {
-            const searchKey = `${searchQuery}::${searchPath}::${exact || false}`;
+            const searchKey = `${searchQuery}::${exact || false}`;
             if (!nextPage) {
               if (previousSearches.has(searchKey)) {
                 if (debug) {
-                  console.error(`[DEDUP] Blocked duplicate search: "${searchQuery}" in "${searchPath}"`);
+                  console.error(`[DEDUP] Blocked duplicate search: "${searchQuery}" (path: "${searchPath}")`);
                 }
-                return "DUPLICATE SEARCH BLOCKED: You already searched for this exact query in this path. Do NOT repeat the same search. If you need more results, set nextPage=true with the session ID from the previous search. Otherwise, try a genuinely different keyword, use extract to examine results you already found, or use attempt_completion if you have enough information.";
+                return "DUPLICATE SEARCH BLOCKED: You already searched for this exact query. Changing the path does NOT give different results \u2014 probe searches recursively. Do NOT repeat the same search. Try a genuinely different keyword, use extract to examine results you already found, or use attempt_completion if you have enough information.";
               }
               previousSearches.add(searchKey);
               paginationCounts.set(searchKey, 0);
@@ -111080,6 +111164,36 @@ var init_vercel = __esm({
             } else if (targets) {
               const parsedTargets = parseTargets(targets);
               extractFiles = parsedTargets.map((target) => resolveTargetPath(target, effectiveCwd));
+              if (options.allowedFolders && options.allowedFolders.length > 0) {
+                extractFiles = extractFiles.map((target) => {
+                  const { filePart, suffix } = splitTargetSuffix(target);
+                  if ((0, import_fs11.existsSync)(filePart)) return target;
+                  const cwdPrefix = effectiveCwd.endsWith("/") ? effectiveCwd : effectiveCwd + "/";
+                  const relativePart = filePart.startsWith(cwdPrefix) ? filePart.slice(cwdPrefix.length) : null;
+                  if (relativePart) {
+                    for (const folder of options.allowedFolders) {
+                      const candidate = folder + "/" + relativePart;
+                      if ((0, import_fs11.existsSync)(candidate)) {
+                        if (debug) console.error(`[extract] Auto-fixed path: ${filePart} \u2192 ${candidate}`);
+                        return candidate + suffix;
+                      }
+                    }
+                  }
+                  for (const folder of options.allowedFolders) {
+                    const folderPrefix = folder.endsWith("/") ? folder : folder + "/";
+                    const wsParent = folderPrefix.replace(/[^/]+\/$/, "");
+                    if (filePart.startsWith(wsParent)) {
+                      const tail = filePart.slice(wsParent.length);
+                      const candidate = folderPrefix + tail;
+                      if (candidate !== filePart && (0, import_fs11.existsSync)(candidate)) {
+                        if (debug) console.error(`[extract] Auto-fixed path via workspace: ${filePart} \u2192 ${candidate}`);
+                        return candidate + suffix;
+                      }
+                    }
+                  }
+                  return target;
+                });
+              }
               let effectiveFormat = format2;
               if (outline && format2 === "outline-xml") {
                 effectiveFormat = "xml";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc281",
+  "version": "0.6.0-rc283",
   "description": "Node.js wrapper for the probe code search tool",
   "main": "src/index.js",
   "module": "src/index.js",
@@ -75,7 +75,7 @@
   "dependencies": {
     "@ai-sdk/amazon-bedrock": "^1.0.8",
     "@ai-sdk/anthropic": "^2.0.8",
-    "@ai-sdk/google": "^2.0.14",
+    "@ai-sdk/google": "^3.0.37",
     "@ai-sdk/openai": "^2.0.10",
     "@anthropic-ai/claude-agent-sdk": "^0.1.46",
     "@modelcontextprotocol/sdk": "^1.0.0",

package/src/tools/vercel.js

@@ -14,6 +14,75 @@ import { existsSync } from 'fs';
 import { formatErrorForAI } from '../utils/error-types.js';
 import { annotateOutputWithHashes } from './hashline.js';
 
+/**
+ * Auto-quote search query terms that contain mixed case or underscores.
+ * Unquoted camelCase like "limitDRL" gets split by stemming into "limit" + "DRL".
+ * This wraps such terms in quotes so they match as literal strings.
+ *
+ * Examples:
+ *   "limitDRL limitRedis"    → '"limitDRL" "limitRedis"'
+ *   "ThrottleRetryLimit"     → '"ThrottleRetryLimit"'
+ *   "allowed_ips"            → '"allowed_ips"'
+ *   "rate limit"             → 'rate limit'  (no change, all lowercase)
+ *   '"already quoted"'       → '"already quoted"'  (no change)
+ *   'foo AND bar'            → 'foo AND bar'  (operators preserved)
+ */
+function autoQuoteSearchTerms(query) {
+	if (!query || typeof query !== 'string') return query;
+
+	// Split on whitespace, preserving quoted strings and operators
+	const tokens = [];
+	let i = 0;
+	while (i < query.length) {
+		// Skip whitespace
+		if (/\s/.test(query[i])) {
+			i++;
+			continue;
+		}
+		// Quoted string — keep as-is
+		if (query[i] === '"') {
+			const end = query.indexOf('"', i + 1);
+			if (end !== -1) {
+				tokens.push(query.substring(i, end + 1));
+				i = end + 1;
+			} else {
+				// Unclosed quote — take rest
+				tokens.push(query.substring(i));
+				break;
+			}
+			continue;
+		}
+		// Unquoted token
+		let j = i;
+		while (j < query.length && !/\s/.test(query[j]) && query[j] !== '"') {
+			j++;
+		}
+		tokens.push(query.substring(i, j));
+		i = j;
+	}
+
+	// Boolean operators that should not be quoted
+	const operators = new Set(['AND', 'OR', 'NOT']);
+
+	const result = tokens.map(token => {
+		// Already quoted
+		if (token.startsWith('"')) return token;
+		// Boolean operator
+		if (operators.has(token)) return token;
+		// Check if token needs quoting: has mixed case (upper+lower) or underscores
+		const hasUpper = /[A-Z]/.test(token);
+		const hasLower = /[a-z]/.test(token);
+		const hasUnderscore = token.includes('_');
+		const hasMixedCase = hasUpper && hasLower;
+		if (hasMixedCase || hasUnderscore) {
+			return `"${token}"`;
+		}
+		return token;
+	});
+
+	return result.join(' ');
+}
+
 const CODE_SEARCH_SCHEMA = {
 	type: 'object',
 	properties: {
@@ -144,40 +213,75 @@ function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, all
 		'- listFiles: Understand directory structure to find where relevant code might live.',
 		'',
 		'CRITICAL - How probe search works (do NOT ignore):',
-		'- By default (exact=false), probe ALREADY handles stemming, case-insensitive matching, and camelCase/snake_case splitting.',
+		'- By default (exact=false), probe ALREADY handles stemming, case-insensitive matching, and camelCase/snake_case splitting automatically.',
 		'- Searching "allowed_ips" ALREADY matches "AllowedIPs", "allowedIps", "allowed_ips", etc. Do NOT manually try case/style variations.',
 		'- Searching "getUserData" ALREADY matches "get", "user", "data" and their variations.',
-		'- NEVER repeat the same search query — you will get the same results.',
+		'- NEVER repeat the same search query — you will get the same results. Changing the path does NOT change this.',
 		'- NEVER search trivial variations of the same keyword (e.g., AllowedIPs then allowedIps then allowed_ips). This is wasteful — probe handles it.',
-		'- If a search returns no results, the term likely does not exist in that path. Try a genuinely DIFFERENT keyword or concept, not a variation.',
-		'- If 2-3 consecutive searches return no results for a concept, STOP searching for it and move on.',
+		'- If a search returns no results, the term likely does not exist. Try a genuinely DIFFERENT keyword or concept, not a variation.',
+		'- If 2-3 searches return no results for a concept, STOP searching for it and move on. Do NOT keep retrying.',
+		'',
+		'When to use exact=true:',
+		'- Use exact=true when searching for a KNOWN symbol name (function, type, variable, struct).',
+		'- exact=true matches the literal string only — no stemming, no splitting.',
+		'- This is ideal for precise lookups: exact=true "ForwardMessage", exact=true "SessionLimiter", exact=true "ThrottleRetryLimit".',
+		'- Do NOT use exact=true for exploratory/conceptual queries — use the default for those.',
+		'',
+		'Combining searches with OR:',
+		'- Multiple unquoted words use OR logic: rate limit matches files containing EITHER "rate" OR "limit".',
+		'- For known symbol names, quote each term to prevent splitting: \'"limitDRL" "limitRedis"\' matches either exact symbol.',
+		'- Without quotes, camelCase like limitDRL gets split into "limit" + "DRL" — not what you want for symbol lookup.',
+		'- Use OR to search for multiple related symbols in ONE search instead of separate searches.',
+		'- This is much faster than running separate searches sequentially.',
+		'- Example: search \'"ForwardMessage" "SessionLimiter"\' finds files with either exact symbol in one call.',
+		'- Example: search \'"limitDRL" "doRollingWindowWrite"\' finds both rate limiting functions at once.',
+		'- Use AND only when you need both terms to appear in the same file: "rate AND limit".',
+		'',
+		'Parallel tool calls:',
+		'- When you need to search for INDEPENDENT concepts, call multiple search tools IN PARALLEL (same response).',
+		'- Do NOT wait for one search to finish before starting the next if they are independent.',
+		'- Example: for "rate limiting and session management", call search "rate limiting" AND search "session management" in parallel.',
+		'- Similarly, call multiple extract tools in parallel when verifying different files.',
 		'',
 		'GOOD search strategy (do this):',
 		'  Query: "How does authentication work and how are sessions managed?"',
-		'  → search "authentication" → search "session management" (two different concepts)',
+		'  → search "authentication" + search "session management" IN PARALLEL (two independent concepts)',
 		'  Query: "Find the IP allowlist middleware"',
 		'  → search "allowlist middleware" (one search, probe handles IP/ip/Ip variations)',
+		'  Query: "Find ForwardMessage and SessionLimiter"',
+		'  → search \'"ForwardMessage" "SessionLimiter"\' (one OR search finds both exact symbols)',
+		'  OR: search exact=true "ForwardMessage" + search exact=true "SessionLimiter" IN PARALLEL',
+		'  Query: "Find limitDRL and limitRedis functions"',
+		'  → search \'"limitDRL" "limitRedis"\' (one OR search, quoted to prevent camelCase splitting)',
+		'  Query: "Find ThrottleRetryLimit usage"',
+		'  → search exact=true "ThrottleRetryLimit" (one search, if no results the symbol does not exist — stop)',
 		'  Query: "How does BM25 scoring work with SIMD optimization?"',
-		'  → search "BM25 scoring" → search "SIMD optimization" (two different concepts)',
+		'  → search "BM25 scoring" + search "SIMD optimization" IN PARALLEL (two different concepts)',
 		'',
 		'BAD search strategy (never do this):',
-		'  → search "AllowedIPs" → search "allowedIps" → search "allowed_ips" (WRONG: these are trivial case variations, probe handles them)',
-		'  → search "CIDR" → search "cidr" → search "Cidr" → search "*cidr*" (WRONG: same keyword repeated with variations)',
-		'  → search "error handling" → search "error handling" → search "error handling" (WRONG: repeating exact same query)',
+		'  → search "AllowedIPs" → search "allowedIps" → search "allowed_ips" (WRONG: case/style variations, probe handles them)',
+		'  → search "limitDRL" → search "LimitDRL" (WRONG: case variation — combine with OR: \'"limitDRL" "limitRedis"\')',
+		'  → search "throttle_retry_limit" after searching "ThrottleRetryLimit" (WRONG: snake_case variation, probe handles it)',
+		'  → search "ThrottleRetryLimit" path=tyk → search "ThrottleRetryLimit" path=gateway → search "ThrottleRetryLimit" path=apidef (WRONG: same query on different paths — probe searches recursively)',
+		'  → search "func (k *RateLimitAndQuotaCheck) handleRateLimitFailure" (WRONG: do not search full function signatures, just use exact=true "handleRateLimitFailure")',
+		'  → search "ForwardMessage" → search "ForwardMessage" → search "ForwardMessage" (WRONG: repeating the exact same query)',
+		'  → search "authentication" → wait → search "session management" → wait (WRONG: these are independent, run them in parallel)',
 		'',
 		'Keyword tips:',
 		'- Common programming keywords are filtered as stopwords when unquoted: function, class, return, new, struct, impl, var, let, const, etc.',
 		'- Avoid searching for these alone — combine with a specific term (e.g., "middleware function" is fine, "function" alone is too generic).',
 		'- To bypass stopword filtering: wrap terms in quotes ("return", "struct") or set exact=true. Both disable stemming and splitting too.',
-		'- Multiple words without operators use OR logic: foo bar = foo OR bar. Use AND explicitly if you need both: foo AND bar.',
 		'- camelCase terms are split: getUserData becomes "get", "user", "data" — so one search covers all naming styles.',
+		'- Do NOT search for full function signatures like "func (r *Type) Method(args)". Just search for the method name with exact=true.',
 		'',
 		'Strategy:',
-		'1. Analyze the query - identify key concepts, entities, and relationships',
-		'2. Run ONE focused search per concept with the most natural keyword. Trust probe to handle variations.',
-		'3. If a search returns results, use extract to verify relevance',
-		'4. Only try a different keyword if the first one returned irrelevant results (not if it returned no results — that means the concept is absent)',
-		'5. Combine all relevant targets in your final response',
+		'1. Analyze the query - identify key concepts and group related symbols',
+		'2. Combine related symbols into OR searches: \'"symbolA" "symbolB"\' finds files with either (quote to prevent splitting)',
+		'3. Run INDEPENDENT searches in PARALLEL — do not wait for one to finish before starting another',
+		'4. For known symbol names use exact=true. For concepts use default (exact=false).',
+		'5. If a search returns results, use extract to verify relevance. Run multiple extracts in parallel too.',
+		'6. If a search returns NO results, the term does not exist. Do NOT retry with variations, different paths, or longer strings. Move on.',
+		'7. Combine all relevant targets in your final response',
 		'',
 		`Query: ${searchQuery}`,
 		`Search path(s): ${searchPath}`,
@@ -229,6 +333,16 @@ export const searchTool = (options = {}) => {
 			: searchDescription,
 		inputSchema: searchSchema,
 		execute: async ({ query: searchQuery, path, allow_tests, exact, maxTokens: paramMaxTokens, language, session, nextPage }) => {
+			// Auto-quote mixed-case and underscore terms to prevent unwanted stemming/splitting
+			// Skip when exact=true since that already preserves the literal string
+			if (!exact && searchQuery) {
+				const originalQuery = searchQuery;
+				searchQuery = autoQuoteSearchTerms(searchQuery);
+				if (debug && searchQuery !== originalQuery) {
+					console.error(`[search] Auto-quoted query: "${originalQuery}" → "${searchQuery}"`);
+				}
+			}
+
 			// Use parameter maxTokens if provided, otherwise use the default
 			const effectiveMaxTokens = paramMaxTokens || maxTokens;
 
@@ -274,13 +388,15 @@ export const searchTool = (options = {}) => {
 			if (!searchDelegate) {
 				// Block duplicate non-paginated searches (models sometimes repeat the exact same call)
 				// Allow pagination: only nextPage=true is a legitimate repeat of the same query
-				const searchKey = `${searchQuery}::${searchPath}::${exact || false}`;
+				// Use query+exact as the key (ignore path) to prevent path-hopping evasion
+				// where model searches same term on different subpaths hoping for different results
+				const searchKey = `${searchQuery}::${exact || false}`;
 				if (!nextPage) {
 					if (previousSearches.has(searchKey)) {
 						if (debug) {
-							console.error(`[DEDUP] Blocked duplicate search: "${searchQuery}" in "${searchPath}"`);
+							console.error(`[DEDUP] Blocked duplicate search: "${searchQuery}" (path: "${searchPath}")`);
 						}
-						return 'DUPLICATE SEARCH BLOCKED: You already searched for this exact query in this path. Do NOT repeat the same search. If you need more results, set nextPage=true with the session ID from the previous search. Otherwise, try a genuinely different keyword, use extract to examine results you already found, or use attempt_completion if you have enough information.';
+						return 'DUPLICATE SEARCH BLOCKED: You already searched for this exact query. Changing the path does NOT give different results — probe searches recursively. Do NOT repeat the same search. Try a genuinely different keyword, use extract to examine results you already found, or use attempt_completion if you have enough information.';
 					}
 					previousSearches.add(searchKey);
 					paginationCounts.set(searchKey, 0);
@@ -570,6 +686,50 @@ export const extractTool = (options = {}) => {
 					// Resolve relative paths in targets against cwd
 					extractFiles = parsedTargets.map(target => resolveTargetPath(target, effectiveCwd));
 
+					// Auto-fix: if resolved paths don't exist, try allowedFolders subdirs
+					// Handles when search returns relative paths (e.g., "gateway/file.go") and
+					// model constructs wrong absolute paths (e.g., /workspace/gateway/file.go
+					// instead of /workspace/tyk/gateway/file.go)
+					if (options.allowedFolders && options.allowedFolders.length > 0) {
+						extractFiles = extractFiles.map(target => {
+							const { filePart, suffix } = splitTargetSuffix(target);
+							if (existsSync(filePart)) return target;
+
+							// Try resolving the relative tail against each allowedFolder
+							const cwdPrefix = (effectiveCwd.endsWith('/') ? effectiveCwd : effectiveCwd + '/');
+							const relativePart = filePart.startsWith(cwdPrefix)
+								? filePart.slice(cwdPrefix.length)
+								: null;
+
+							if (relativePart) {
+								for (const folder of options.allowedFolders) {
+									const candidate = folder + '/' + relativePart;
+									if (existsSync(candidate)) {
+										if (debug) console.error(`[extract] Auto-fixed path: ${filePart} → ${candidate}`);
+										return candidate + suffix;
+									}
+								}
+							}
+
+							// Try stripping workspace prefix and resolving against allowedFolders
+							// e.g., /tmp/visor-workspaces/abc/gateway/file.go → try each folder + gateway/file.go
+							for (const folder of options.allowedFolders) {
+								const folderPrefix = folder.endsWith('/') ? folder : folder + '/';
+								const wsParent = folderPrefix.replace(/[^/]+\/$/, '');
+								if (filePart.startsWith(wsParent)) {
+									const tail = filePart.slice(wsParent.length);
+									const candidate = folderPrefix + tail;
+									if (candidate !== filePart && existsSync(candidate)) {
+										if (debug) console.error(`[extract] Auto-fixed path via workspace: ${filePart} → ${candidate}`);
+										return candidate + suffix;
+									}
+								}
+							}
+
+							return target;
+						});
+					}
+
 					// Apply format mapping for outline-xml to xml
 					let effectiveFormat = format;
 					if (outline && format === 'outline-xml') {