@probelabs/probe 0.6.0-rc288 → 0.6.0-rc290

package/cjs/index.cjs

@@ -1944,7 +1944,8 @@ var init_search = __esm({
       session: "--session",
       timeout: "--timeout",
       language: "--language",
-      format: "--format"
+      format: "--format",
+      lsp: "--lsp"
     };
   }
 });
@@ -2180,7 +2181,8 @@ var init_extract = __esm({
       allowTests: "--allow-tests",
       contextLines: "--context",
       format: "--format",
-      inputFile: "--input-file"
+      inputFile: "--input-file",
+      lsp: "--lsp"
     };
   }
 });
@@ -73070,26 +73072,46 @@ var init_prompts = __esm({
 CRITICAL - You are READ-ONLY:
 You must NEVER create, modify, delete, or write files. You are strictly an exploration and analysis tool. If asked to make changes, implement features, fix bugs, or modify a PR, refuse and explain that file modifications must be done by the engineer tool \u2014 your role is only to investigate code and answer questions. Do not attempt workarounds using bash commands (echo, cat, tee, sed, etc.) to write files.
 
+CRITICAL - ALWAYS search before answering:
+You must NEVER answer questions about the codebase from memory or general knowledge. ALWAYS use the search and extract tools first to find the actual code, then base your answer ONLY on what you found. Even if you think you know the answer, you MUST verify it against the actual code. Your answers must be grounded in code evidence, not assumptions.
+
 When exploring code:
 - Provide clear, concise explanations based on user request
 - Find and highlight the most relevant code snippets, if required
-- Trace function calls and data flow through the system
+- Trace function calls and data flow through the system \u2014 follow the FULL call chain, not just the entry point
 - Try to understand the user's intent and provide relevant information
 - Understand high level picture
 - Balance detail with clarity in your explanations
+- Search using SYNONYMS and alternative terms \u2014 code naming often differs from the concept name (e.g., "authentication" might be named verify_credentials, check_token, validate_session)
+- When you find a key function, look at what it CALLS and what CALLS it to discover the complete picture
+- Before answering, ask yourself: "Did I cover all the major components? Are there related subsystems I missed?" If yes, do one more search round.
 
 When providing answers:
+- Be EXHAUSTIVE: cover ALL components you discovered, not just the main ones. If you found 10 related files, discuss all 10, not just the top 3. Users want the complete picture.
+- After drafting your answer, do a self-check: "What did I find in my searches that I haven't mentioned yet?" Add any missing components.
+- Include data structures, configuration options, and error handling \u2014 not just the happy path.
 - Always include a "References" section at the end of your response
 - List all relevant source code locations you found during exploration
 - Use the format: file_path:line_number or file_path#symbol_name
 - Group references by file when multiple locations are from the same file
 - Include brief descriptions of what each reference contains`,
-      "code-searcher": `You are ProbeChat Code Searcher, a specialized AI assistant focused ONLY on locating relevant code. Your sole job is to find and return ALL relevant code locations. Do NOT answer questions or explain anything.
+      "code-searcher": `You are ProbeChat Code Explorer & Searcher. Your job is to EXPLORE the codebase to find ALL relevant code locations for the query, then return them as JSON targets.
+
+You think like a code explorer \u2014 you understand that codebases have layers:
+- Core implementations (algorithms, data structures)
+- Middleware/integration layers (request handlers, interceptors)
+- Configuration and storage backends
+- Scoping mechanisms (per-user, per-org, per-tenant, global)
+- Supporting utilities and helpers
 
 When searching:
-- Use only the search tool
-- Run additional searches only if needed to capture all relevant locations
-- Prefer specific, focused queries
+- Search for the MAIN concept first, then think: "what RELATED subsystems would a real codebase have?"
+- Use extract to READ the code you find \u2014 look for function calls, type references, and imports that point to OTHER relevant code
+- If you find middleware, check: are there org-level or tenant-level variants?
+- If you find algorithms, check: are there different storage backends?
+- Search results are paginated \u2014 if results look relevant, call nextPage=true to check for more files
+- Stop paginating when results become irrelevant or you see "All results retrieved"
+- Search using SYNONYMS \u2014 code naming differs from concepts (e.g., "rate limiting" \u2192 throttle, quota, limiter, bucket)
 
 Output format (MANDATORY):
 - Return ONLY valid JSON with a single top-level key: "targets"
@@ -73099,7 +73121,8 @@ Output format (MANDATORY):
   - "path/to/file.ext:line"
   - "path/to/file.ext:start-end"
 - Prefer #SymbolName when a function/class name is clear; otherwise use line numbers
-- Deduplicate targets and keep them concise`,
+- Deduplicate targets and keep them concise
+- Aim for 5-15 targets covering ALL aspects of the query`,
       "architect": `You are ProbeChat Architect, a specialized AI assistant focused on software architecture and design. Your primary function is to help users understand, analyze, and design software systems using the provided code analysis tools.
 
 When analyzing code:
@@ -98753,9 +98776,9 @@ Workspace: ${this.allowedFolders.join(", ")}`;
 Follow these instructions carefully:
 1. Analyze the user's request.
 2. Use the available tools step-by-step to fulfill the request.
-3. You should always prefer the search tool for code-related questions.${this.searchDelegate ? " Ask natural language questions \u2014 the search subagent handles keyword formulation and returns extracted code blocks. Use extract only to expand context or read full files." : " Search handles stemming and case variations automatically \u2014 do NOT try keyword variations manually. Read full files only if really necessary."}
-4. Ensure to get really deep and understand the full picture before answering.
-5. Once the task is fully completed, provide your final answer directly as text.
+3. You MUST use the search tool before answering ANY code-related question. NEVER answer from memory or general knowledge \u2014 your answers must be grounded in actual code found via search/extract.${this.searchDelegate ? " Ask natural language questions \u2014 the search subagent handles keyword formulation and returns extracted code blocks. Use extract only to expand context or read full files." : " Search handles stemming and case variations automatically \u2014 do NOT try keyword variations manually. Read full files only if really necessary."}
+4. Ensure to get really deep and understand the full picture before answering. Follow call chains \u2014 if function A calls B, search for B too. Look for related subsystems (e.g., if asked about rate limiting, also check for quota, throttling, smoothing).
+5. Once the task is fully completed, provide your final answer directly as text. Always cite specific files and line numbers as evidence. Do NOT output planning or thinking text \u2014 go straight to the answer.
 6. ${this.searchDelegate ? "Ask clear, specific questions when searching. Each search should target a distinct concept or question." : "Prefer concise and focused search queries. Use specific keywords and phrases to narrow down results."}
 7. NEVER use bash for code exploration (no grep, cat, find, head, tail, awk, sed) \u2014 always use search and extract tools instead. Bash is only for system operations like building, running tests, or git commands.${this.allowEdit ? `
 7. When modifying files, choose the appropriate tool:
@@ -99141,6 +99164,22 @@ You are working with a workspace. Available paths: ${workspaceDesc}
                     if (recentTexts.every((t) => t && t === recentTexts[0])) return true;
                     if (recentTexts.every((t) => detectStuckResponse(t))) return true;
                   }
+                  if (steps.length >= 3) {
+                    const last3 = steps.slice(-3);
+                    const allHaveTools = last3.every((s) => s.toolCalls?.length === 1);
+                    if (allHaveTools) {
+                      const signatures = last3.map((s) => {
+                        const tc = s.toolCalls[0];
+                        return `${tc.toolName}::${JSON.stringify(tc.args ?? tc.input)}`;
+                      });
+                      if (signatures[0] === signatures[1] && signatures[1] === signatures[2]) {
+                        if (this.debug) {
+                          console.log(`[DEBUG] Circuit breaker: 3 consecutive identical tool calls detected (${last3[0].toolCalls[0].toolName}), forcing stop`);
+                        }
+                        return true;
+                      }
+                    }
+                  }
                   return false;
                 },
                 prepareStep: ({ steps, stepNumber }) => {
@@ -99149,6 +99188,22 @@ You are working with a workspace. Available paths: ${workspaceDesc}
                       toolChoice: "none"
                     };
                   }
+                  if (steps.length >= 2) {
+                    const last2 = steps.slice(-2);
+                    if (last2.every((s) => s.toolCalls?.length === 1)) {
+                      const tc1 = last2[0].toolCalls[0];
+                      const tc2 = last2[1].toolCalls[0];
+                      const sig1 = `${tc1.toolName}::${JSON.stringify(tc1.args ?? tc1.input)}`;
+                      const sig2 = `${tc2.toolName}::${JSON.stringify(tc2.args ?? tc2.input)}`;
+                      if (sig1 === sig2) {
+                        if (this.debug) {
+                          console.log(`[DEBUG] prepareStep: 2 consecutive identical tool calls (${tc1.toolName}), forcing toolChoice=none`);
+                          console.log(`[DEBUG]   sig: ${sig1.substring(0, 200)}`);
+                        }
+                        return { toolChoice: "none" };
+                      }
+                    }
+                  }
                   const lastStep = steps[steps.length - 1];
                   const modelJustStopped = lastStep?.finishReason === "stop" && (!lastStep?.toolCalls || lastStep.toolCalls.length === 0);
                   if (modelJustStopped) {
@@ -99179,7 +99234,9 @@ ${resultToReview}
 
 Double-check your response based on the criteria above. If everything looks good, respond with your previous answer exactly as-is. 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).`;
                       return {
-                        userMessage: completionPromptMessage
+                        userMessage: completionPromptMessage,
+                        toolChoice: "none"
+                        // Force text-only review — no tool calls
                       };
                     }
                   }
@@ -99221,7 +99278,11 @@ Double-check your response based on the criteria above. If everything looks good
                     options.onStream(text);
                   }
                   if (this.debug) {
-                    console.log(`[DEBUG] Step ${currentIteration}/${maxIterations} finished (reason: ${finishReason}, tools: ${toolResults?.length || 0})`);
+                    const toolSummary = toolCalls?.length ? toolCalls.map((tc) => {
+                      const args = tc.args ? JSON.stringify(tc.args) : "";
+                      return args ? `${tc.toolName}(${debugTruncate(args, 120)})` : tc.toolName;
+                    }).join(", ") : "none";
+                    console.log(`[DEBUG] Step ${currentIteration}/${maxIterations} finished (reason: ${finishReason}, tools: [${toolSummary}])`);
                     if (text) {
                       console.log(`[DEBUG]   model text: ${debugTruncate(text)}`);
                     }
@@ -99254,9 +99315,15 @@ Double-check your response based on the criteria above. If everything looks good
               }
               const executeAIRequest = async () => {
                 const result = await this.streamTextWithRetryAndFallback(streamOptions);
-                const finalText = await result.text;
+                const steps = await result.steps;
+                let finalText;
+                if (steps && steps.length > 1) {
+                  const lastStepText = steps[steps.length - 1].text;
+                  finalText = lastStepText || await result.text;
+                } else {
+                  finalText = await result.text;
+                }
                 if (this.debug) {
-                  const steps = await result.steps;
                   console.log(`[DEBUG] streamText completed: ${steps?.length || 0} steps, finalText=${finalText?.length || 0} chars`);
                 }
                 const usage = await result.usage;
@@ -99326,12 +99393,12 @@ ${finalResult}
 
 Double-check your response based on the criteria above. If everything looks good, respond with your previous answer exactly as-is. 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).`;
                 currentMessages.push({ role: "user", content: completionPromptMessage });
-                const completionMaxIterations = 5;
                 const completionStreamOptions = {
                   model: this.provider ? this.provider(this.model) : this.model,
                   messages: this.prepareMessagesWithImages(currentMessages),
                   tools: tools2,
-                  stopWhen: (0, import_ai4.stepCountIs)(completionMaxIterations),
+                  toolChoice: "none",
+                  // Force text-only response — no tool calls during review
                   maxTokens: maxResponseTokens,
                   temperature: 0.3,
                   onStepFinish: ({ toolResults, text, finishReason, usage }) => {
@@ -101000,11 +101067,9 @@ function autoQuoteSearchTerms(query2) {
   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) {
+    const hasCaseTransition = /[a-z][A-Z]/.test(token) || /[A-Z]{2,}[a-z]/.test(token);
+    if (hasCaseTransition || hasUnderscore) {
       return `"${token}"`;
     }
     return token;
@@ -101119,7 +101184,7 @@ function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, all
     "Break down complex queries into multiple searches to cover all aspects.",
     "",
     "Available tools:",
-    "- search: Find code matching keywords or patterns. Run multiple searches for different aspects of complex queries.",
+    "- search: Find code matching keywords or patterns. Results are paginated \u2014 use nextPage=true when results are relevant to get more. Run multiple searches for different aspects.",
     "- extract: Verify code snippets to ensure targets are actually relevant before including them.",
     "- listFiles: Understand directory structure to find where relevant code might live.",
     "",
@@ -101140,13 +101205,14 @@ function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, all
     "",
     "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.`,
+    `- IMPORTANT: Multiple quoted terms use AND logic by default: '"RateLimit" "middleware"' requires BOTH in the same file.`,
+    `- To search for ANY of several quoted symbols, use the explicit OR operator: '"ForwardMessage" OR "SessionLimiter"'.`,
     '- 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".',
+    `- Example: search '"ForwardMessage" OR "SessionLimiter"' finds files with either exact symbol in one call.`,
+    `- Example: search '"limitDRL" OR "doRollingWindowWrite"' finds both rate limiting functions at once.`,
+    "- Use AND (or just put quoted terms together) when you need both terms in the same file.",
     "",
     "Parallel tool calls:",
     "- When you need to search for INDEPENDENT concepts, call multiple search tools IN PARALLEL (same response).",
@@ -101160,10 +101226,10 @@ function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, all
     '  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)`,
+    `  \u2192 search '"ForwardMessage" OR "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)`,
+    `  \u2192 search '"limitDRL" OR "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?"',
@@ -101171,7 +101237,7 @@ function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, all
     "",
     "BAD search strategy (never do this):",
     '  \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 "limitDRL" \u2192 search "LimitDRL" (WRONG: case variation \u2014 combine with OR: '"limitDRL" OR "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")',
@@ -101184,15 +101250,34 @@ function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, all
     '- To bypass stopword filtering: wrap terms in quotes ("return", "struct") or set exact=true. Both disable stemming and splitting too.',
     '- 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.',
+    '- Do NOT search for file names (e.g., "sliding_log.go"). Use listFiles to discover files by name.',
+    "",
+    "PAGINATION:",
+    "- Search results are paginated (~20k tokens per page).",
+    "- If your search returned relevant files, call the same query with nextPage=true to check for more.",
+    '- Keep paginating while results stay relevant. Stop when results are off-topic or "All results retrieved".',
+    "",
+    "WHEN TO STOP:",
+    "- After you have explored the main concept AND related subsystems.",
+    "- Once you have 5-15 targets covering different aspects of the query.",
+    '- If you get a "DUPLICATE SEARCH BLOCKED" message, move on.',
     "",
     "Strategy:",
-    "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",
+    "1. Analyze the query \u2014 identify key concepts, then brainstorm SYNONYMS and alternative terms for each.",
+    '   Code naming often differs from the concept: "authentication" \u2192 verify, credentials, login, auth;',
+    '   "rate limiting" \u2192 throttle, quota, limiter, bucket; "error handling" \u2192 catch, recover, panic.',
+    "   Think about what a developer would NAME the function/struct/variable, not just the concept.",
+    "2. Run INDEPENDENT searches in PARALLEL \u2014 search for the main concept AND synonyms simultaneously.",
+    "   After each search, check if results are relevant. If yes, call nextPage=true for more results.",
+    `3. Combine related symbols into OR searches: '"symbolA" OR "symbolB"' finds files with either.`,
     "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",
+    "5. After your first round of searches, READ the extracted code and look for connected code:",
+    "   - Function calls to other important functions \u2192 include those targets.",
+    "   - Type references and imports \u2192 include type definitions.",
+    "   - Registered handlers/middleware \u2192 include all registered items.",
+    "6. If a search returns results, use extract to verify relevance. Run multiple extracts in parallel too.",
+    "7. If a search returns NO results, the term does not exist. Do NOT retry with variations. Move on.",
+    "8. Once you have enough targets (typically 5-15), output your final JSON answer immediately.",
     "",
     `Query: ${searchQuery}`,
     `Search path(s): ${searchPath}`,
@@ -101201,7 +101286,9 @@ function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, all
     'Return ONLY valid JSON: {"targets": ["path/to/file.ext#Symbol", "path/to/file.ext:line", "path/to/file.ext:start-end"]}',
     'IMPORTANT: Use ABSOLUTE file paths in targets (e.g., "/full/path/to/file.ext#Symbol"). If you only have relative paths, make them relative to the search path above.',
     "Prefer #Symbol when a function/class name is clear; otherwise use line numbers.",
-    "Deduplicate targets. Do NOT explain or answer - ONLY return the JSON targets."
+    "Deduplicate targets. Do NOT explain or answer - ONLY return the JSON targets.",
+    "",
+    "Remember: if your search returned relevant results, use nextPage=true to check for more before outputting."
   ].join("\n");
 }
 var import_ai5, import_fs11, CODE_SEARCH_SCHEMA, searchTool, queryTool, extractTool, delegateTool, analyzeAllTool;
@@ -101246,6 +101333,7 @@ var init_vercel = __esm({
         return result;
       };
       const previousSearches = /* @__PURE__ */ new Set();
+      let consecutiveDupBlocks = 0;
       const paginationCounts = /* @__PURE__ */ new Map();
       const MAX_PAGES_PER_QUERY = 3;
       return (0, import_ai5.tool)({
@@ -101298,12 +101386,17 @@ var init_vercel = __esm({
             const searchKey = `${searchQuery}::${exact || false}`;
             if (!nextPage) {
               if (previousSearches.has(searchKey)) {
+                consecutiveDupBlocks++;
                 if (debug) {
-                  console.error(`[DEDUP] Blocked duplicate search: "${searchQuery}" (path: "${searchPath}")`);
+                  console.error(`[DEDUP] Blocked duplicate search (${consecutiveDupBlocks}x): "${searchQuery}" (path: "${searchPath}")`);
+                }
+                if (consecutiveDupBlocks >= 3) {
+                  return "STOP. You have been blocked " + consecutiveDupBlocks + " times for repeating searches. You MUST output your final JSON answer NOW with whatever targets you have found. Do NOT call any more tools.";
                 }
-                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 provide your final answer if you have enough information.";
+                return "DUPLICATE SEARCH BLOCKED (" + consecutiveDupBlocks + "x). You already searched for this. Do NOT repeat \u2014 probe searches recursively across all paths. Either: (1) use extract on results you already found, (2) try a COMPLETELY different keyword, or (3) output your final answer NOW.";
               }
               previousSearches.add(searchKey);
+              consecutiveDupBlocks = 0;
               paginationCounts.set(searchKey, 0);
             } else {
               const pageCount = (paginationCounts.get(searchKey) || 0) + 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc288",
+  "version": "0.6.0-rc290",
   "description": "Node.js wrapper for the probe code search tool",
   "main": "src/index.js",
   "module": "src/index.js",
@@ -49,6 +49,7 @@
   ],
   "scripts": {
     "postinstall": "node scripts/postinstall.js",
+    "prepare": "npm run build:mcp",
     "build:mcp": "node scripts/build-mcp.cjs",
     "build:agent": "node scripts/build-agent.cjs",
     "build:types": "echo 'TypeScript definitions already manually created'",

package/src/agent/ProbeAgent.js

@@ -2976,9 +2976,9 @@ ${extractGuidance2}
 Follow these instructions carefully:
 1. Analyze the user's request.
 2. Use the available tools step-by-step to fulfill the request.
-3. You should always prefer the search tool for code-related questions.${this.searchDelegate ? ' Ask natural language questions — the search subagent handles keyword formulation and returns extracted code blocks. Use extract only to expand context or read full files.' : ' Search handles stemming and case variations automatically — do NOT try keyword variations manually. Read full files only if really necessary.'}
-4. Ensure to get really deep and understand the full picture before answering.
-5. Once the task is fully completed, provide your final answer directly as text.
+3. You MUST use the search tool before answering ANY code-related question. NEVER answer from memory or general knowledge — your answers must be grounded in actual code found via search/extract.${this.searchDelegate ? ' Ask natural language questions — the search subagent handles keyword formulation and returns extracted code blocks. Use extract only to expand context or read full files.' : ' Search handles stemming and case variations automatically — do NOT try keyword variations manually. Read full files only if really necessary.'}
+4. Ensure to get really deep and understand the full picture before answering. Follow call chains — if function A calls B, search for B too. Look for related subsystems (e.g., if asked about rate limiting, also check for quota, throttling, smoothing).
+5. Once the task is fully completed, provide your final answer directly as text. Always cite specific files and line numbers as evidence. Do NOT output planning or thinking text — go straight to the answer.
 6. ${this.searchDelegate ? 'Ask clear, specific questions when searching. Each search should target a distinct concept or question.' : 'Prefer concise and focused search queries. Use specific keywords and phrases to narrow down results.'}
 7. NEVER use bash for code exploration (no grep, cat, find, head, tail, awk, sed) — always use search and extract tools instead. Bash is only for system operations like building, running tests, or git commands.${this.allowEdit ? `
 7. When modifying files, choose the appropriate tool:
@@ -3483,6 +3483,24 @@ Follow these instructions carefully:
                 if (recentTexts.every(t => detectStuckResponse(t))) return true;
               }
 
+              // Circuit breaker: repeated identical tool calls (e.g. model ignores dedup message)
+              if (steps.length >= 3) {
+                const last3 = steps.slice(-3);
+                const allHaveTools = last3.every(s => s.toolCalls?.length === 1);
+                if (allHaveTools) {
+                  const signatures = last3.map(s => {
+                    const tc = s.toolCalls[0];
+                    return `${tc.toolName}::${JSON.stringify(tc.args ?? tc.input)}`;
+                  });
+                  if (signatures[0] === signatures[1] && signatures[1] === signatures[2]) {
+                    if (this.debug) {
+                      console.log(`[DEBUG] Circuit breaker: 3 consecutive identical tool calls detected (${last3[0].toolCalls[0].toolName}), forcing stop`);
+                    }
+                    return true;
+                  }
+                }
+              }
+
               return false;
             },
             prepareStep: ({ steps, stepNumber }) => {
@@ -3493,6 +3511,24 @@ Follow these instructions carefully:
                 };
               }
 
+              // Force text-only response after 2 consecutive identical tool calls
+              if (steps.length >= 2) {
+                const last2 = steps.slice(-2);
+                if (last2.every(s => s.toolCalls?.length === 1)) {
+                  const tc1 = last2[0].toolCalls[0];
+                  const tc2 = last2[1].toolCalls[0];
+                  const sig1 = `${tc1.toolName}::${JSON.stringify(tc1.args ?? tc1.input)}`;
+                  const sig2 = `${tc2.toolName}::${JSON.stringify(tc2.args ?? tc2.input)}`;
+                  if (sig1 === sig2) {
+                    if (this.debug) {
+                      console.log(`[DEBUG] prepareStep: 2 consecutive identical tool calls (${tc1.toolName}), forcing toolChoice=none`);
+                      console.log(`[DEBUG]   sig: ${sig1.substring(0, 200)}`);
+                    }
+                    return { toolChoice: 'none' };
+                  }
+                }
+              }
+
               const lastStep = steps[steps.length - 1];
               const modelJustStopped = lastStep?.finishReason === 'stop'
                 && (!lastStep?.toolCalls || lastStep.toolCalls.length === 0);
@@ -3532,7 +3568,8 @@ ${resultToReview}
 Double-check your response based on the criteria above. If everything looks good, respond with your previous answer exactly as-is. 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).`;
 
                   return {
-                    userMessage: completionPromptMessage
+                    userMessage: completionPromptMessage,
+                    toolChoice: 'none' // Force text-only review — no tool calls
                   };
                 }
               }
@@ -3585,7 +3622,13 @@ Double-check your response based on the criteria above. If everything looks good
               }
 
               if (this.debug) {
-                console.log(`[DEBUG] Step ${currentIteration}/${maxIterations} finished (reason: ${finishReason}, tools: ${toolResults?.length || 0})`);
+                const toolSummary = toolCalls?.length
+                  ? toolCalls.map(tc => {
+                      const args = tc.args ? JSON.stringify(tc.args) : '';
+                      return args ? `${tc.toolName}(${debugTruncate(args, 120)})` : tc.toolName;
+                    }).join(', ')
+                  : 'none';
+                console.log(`[DEBUG] Step ${currentIteration}/${maxIterations} finished (reason: ${finishReason}, tools: [${toolSummary}])`);
                 if (text) {
                   console.log(`[DEBUG]   model text: ${debugTruncate(text)}`);
                 }
@@ -3627,11 +3670,20 @@ Double-check your response based on the criteria above. If everything looks good
           const executeAIRequest = async () => {
             const result = await this.streamTextWithRetryAndFallback(streamOptions);
 
-            // Collect the final text
-            const finalText = await result.text;
+            // Use only the last step's text as the final answer.
+            // result.text concatenates ALL steps (including intermediate planning text),
+            // but the user should only see the final answer from the last step.
+            const steps = await result.steps;
+            let finalText;
+            if (steps && steps.length > 1) {
+              // Multi-step: use last step's text (the actual answer after tool calls)
+              const lastStepText = steps[steps.length - 1].text;
+              finalText = lastStepText || await result.text;
+            } else {
+              finalText = await result.text;
+            }
 
             if (this.debug) {
-              const steps = await result.steps;
               console.log(`[DEBUG] streamText completed: ${steps?.length || 0} steps, finalText=${finalText?.length || 0} chars`);
             }
 
@@ -3726,12 +3778,11 @@ Double-check your response based on the criteria above. If everything looks good
 
             currentMessages.push({ role: 'user', content: completionPromptMessage });
 
-            const completionMaxIterations = 5;
             const completionStreamOptions = {
               model: this.provider ? this.provider(this.model) : this.model,
               messages: this.prepareMessagesWithImages(currentMessages),
               tools,
-              stopWhen: stepCountIs(completionMaxIterations),
+              toolChoice: 'none', // Force text-only response — no tool calls during review
               maxTokens: maxResponseTokens,
               temperature: 0.3,
               onStepFinish: ({ toolResults, text, finishReason, usage }) => {

package/src/agent/shared/prompts.js

@@ -8,27 +8,47 @@ export const predefinedPrompts = {
 CRITICAL - You are READ-ONLY:
 You must NEVER create, modify, delete, or write files. You are strictly an exploration and analysis tool. If asked to make changes, implement features, fix bugs, or modify a PR, refuse and explain that file modifications must be done by the engineer tool — your role is only to investigate code and answer questions. Do not attempt workarounds using bash commands (echo, cat, tee, sed, etc.) to write files.
 
+CRITICAL - ALWAYS search before answering:
+You must NEVER answer questions about the codebase from memory or general knowledge. ALWAYS use the search and extract tools first to find the actual code, then base your answer ONLY on what you found. Even if you think you know the answer, you MUST verify it against the actual code. Your answers must be grounded in code evidence, not assumptions.
+
 When exploring code:
 - Provide clear, concise explanations based on user request
 - Find and highlight the most relevant code snippets, if required
-- Trace function calls and data flow through the system
+- Trace function calls and data flow through the system — follow the FULL call chain, not just the entry point
 - Try to understand the user's intent and provide relevant information
 - Understand high level picture
 - Balance detail with clarity in your explanations
+- Search using SYNONYMS and alternative terms — code naming often differs from the concept name (e.g., "authentication" might be named verify_credentials, check_token, validate_session)
+- When you find a key function, look at what it CALLS and what CALLS it to discover the complete picture
+- Before answering, ask yourself: "Did I cover all the major components? Are there related subsystems I missed?" If yes, do one more search round.
 
 When providing answers:
+- Be EXHAUSTIVE: cover ALL components you discovered, not just the main ones. If you found 10 related files, discuss all 10, not just the top 3. Users want the complete picture.
+- After drafting your answer, do a self-check: "What did I find in my searches that I haven't mentioned yet?" Add any missing components.
+- Include data structures, configuration options, and error handling — not just the happy path.
 - Always include a "References" section at the end of your response
 - List all relevant source code locations you found during exploration
 - Use the format: file_path:line_number or file_path#symbol_name
 - Group references by file when multiple locations are from the same file
 - Include brief descriptions of what each reference contains`,
 
-  'code-searcher': `You are ProbeChat Code Searcher, a specialized AI assistant focused ONLY on locating relevant code. Your sole job is to find and return ALL relevant code locations. Do NOT answer questions or explain anything.
+  'code-searcher': `You are ProbeChat Code Explorer & Searcher. Your job is to EXPLORE the codebase to find ALL relevant code locations for the query, then return them as JSON targets.
+
+You think like a code explorer — you understand that codebases have layers:
+- Core implementations (algorithms, data structures)
+- Middleware/integration layers (request handlers, interceptors)
+- Configuration and storage backends
+- Scoping mechanisms (per-user, per-org, per-tenant, global)
+- Supporting utilities and helpers
 
 When searching:
-- Use only the search tool
-- Run additional searches only if needed to capture all relevant locations
-- Prefer specific, focused queries
+- Search for the MAIN concept first, then think: "what RELATED subsystems would a real codebase have?"
+- Use extract to READ the code you find — look for function calls, type references, and imports that point to OTHER relevant code
+- If you find middleware, check: are there org-level or tenant-level variants?
+- If you find algorithms, check: are there different storage backends?
+- Search results are paginated — if results look relevant, call nextPage=true to check for more files
+- Stop paginating when results become irrelevant or you see "All results retrieved"
+- Search using SYNONYMS — code naming differs from concepts (e.g., "rate limiting" → throttle, quota, limiter, bucket)
 
 Output format (MANDATORY):
 - Return ONLY valid JSON with a single top-level key: "targets"
@@ -38,7 +58,8 @@ Output format (MANDATORY):
   - "path/to/file.ext:line"
   - "path/to/file.ext:start-end"
 - Prefer #SymbolName when a function/class name is clear; otherwise use line numbers
-- Deduplicate targets and keep them concise`,
+- Deduplicate targets and keep them concise
+- Aim for 5-15 targets covering ALL aspects of the query`,
 
   'architect': `You are ProbeChat Architect, a specialized AI assistant focused on software architecture and design. Your primary function is to help users understand, analyze, and design software systems using the provided code analysis tools.
 

package/src/extract.js

@@ -18,7 +18,8 @@ const EXTRACT_FLAG_MAP = {
 	allowTests: '--allow-tests',
 	contextLines: '--context',
 	format: '--format',
-	inputFile: '--input-file'
+	inputFile: '--input-file',
+	lsp: '--lsp'
 };
 
 /**
@@ -31,7 +32,8 @@ const EXTRACT_FLAG_MAP = {
  * @param {string} [options.cwd] - Working directory for resolving relative file paths
  * @param {boolean} [options.allowTests] - Include test files
  * @param {number} [options.contextLines] - Number of context lines to include
- * @param {string} [options.format] - Output format ('markdown', 'plain', 'json', 'xml', 'color', 'outline-xml', 'outline-diff')
+ * @param {string} [options.format] - Output format ('markdown', 'plain', 'json')
+ * @param {boolean} [options.lsp] - Use LSP (Language Server Protocol) for call hierarchy and reference graphs
  * @param {Object} [options.binaryOptions] - Options for getting the binary
  * @param {boolean} [options.binaryOptions.forceDownload] - Force download even if binary exists
  * @param {string} [options.binaryOptions.version] - Specific version to download