@probelabs/probe 0.6.0-rc283 → 0.6.0-rc285

package/build/agent/index.js

@@ -4393,7 +4393,7 @@ Instructions:
 - Format as a structured list if multiple items found
 - If nothing relevant is found in this chunk, respond with "No relevant items found in this chunk."
 - Do NOT summarize the code - extract the specific information requested
-- When done, use the attempt_completion tool with your answer as the result.`;
+- When done, provide your final answer directly.`;
   try {
     const result = await delegate({
       task,
@@ -4455,7 +4455,7 @@ async function aggregateResults(chunkResults2, aggregation, extractionPrompt, op
 ${stripResultTags(r.result)}`).join("\n\n");
   const completionNote = `
 
-When done, use the attempt_completion tool with your answer as the result.`;
+When done, provide your final answer directly.`;
   const aggregationPrompts = {
     summarize: `Synthesize these analyses into a comprehensive summary. Combine related findings, remove redundancy, and present a coherent overview.
 
@@ -4549,7 +4549,7 @@ For example, if looking for customer data:
 STEP 3: CREATE THE FINAL PLAN
 Based on your experiments, output the BEST search strategy.
 
-Use attempt_completion with this EXACT format:
+Provide your answer in this EXACT format:
 
 SEARCH_QUERY: <the query that WORKED in your experiments - use OR for multiple terms>
 AGGREGATION: <summarize | list_unique | count | group_by>
@@ -4615,7 +4615,7 @@ Your answer should:
 
 Format your response as a well-structured document that fully answers: "${question}"
 
-When done, use the attempt_completion tool with your answer as the result.`;
+When done, provide your final answer directly.`;
   try {
     const result = await delegate({
       task: synthesisTask,
@@ -8893,6 +8893,34 @@ function createMessagePreview(message, charsPerSide = 200) {
   const end = message.substring(message.length - charsPerSide);
   return `${start}...${end}`;
 }
+function detectStuckResponse(response) {
+  if (!response || typeof response !== "string") {
+    return false;
+  }
+  const stuckPatterns = [
+    /\bi\s+cannot\s+proceed\b/i,
+    /\bi\s+can['']t\s+(?:proceed|continue|move\s+forward)\b/i,
+    /\bunable\s+to\s+(?:proceed|continue|complete)\b/i,
+    /\bblocked\b.*\b(?:proceed|continue)\b/i,
+    /\bneed\s+(?:the|an?)\s+\w+(?:\s+\w+)?\s+to\s+(?:proceed|continue)\b/i,
+    /\brequire[sd]?\s+(?:the|an?)\s+\w+\b.*\bto\s+(?:proceed|continue)\b/i,
+    /\bmissing\s+(?:required|necessary|essential)\b/i,
+    /\bdeadlock\b/i,
+    /\bwe\s+are\s+in\s+a\s+loop\b/i,
+    /\bstuck\s+in\s+a\s+loop\b/i,
+    /\bi\s+(?:have|['']ve)\s+(?:explained|stated|mentioned)\s+(?:this|the\s+situation|it)\s+(?:multiple|several)\s+times\b/i,
+    /\bi\s+(?:cannot|can['']t|could\s+not|couldn['']t)\s+(?:find|locate|get|retrieve|obtain)\s+(?:the|this|that|an?)\b/i,
+    /\bno\s+way\s+to\s+(?:find|get|obtain|retrieve)\b/i,
+    /\bi\s+(?:have|['']ve)\s+exhausted\s+(?:all|my)\s+(?:available\s+)?(?:options|methods|approaches)\b/i,
+    /\bneither\s+of\s+these\s+methods\b/i
+  ];
+  for (const pattern of stuckPatterns) {
+    if (pattern.test(response)) {
+      return true;
+    }
+  }
+  return false;
+}
 function parseTargets(targets) {
   if (!targets || typeof targets !== "string") {
     return [];
@@ -9402,7 +9430,7 @@ var init_vercel = __esm({
                 if (debug) {
                   console.error(`[DEDUP] Blocked duplicate search: "${searchQuery}" (path: "${searchPath}")`);
                 }
-                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.";
+                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.";
               }
               previousSearches.add(searchKey);
               paginationCounts.set(searchKey, 0);
@@ -9413,7 +9441,7 @@ var init_vercel = __esm({
                 if (debug) {
                   console.error(`[DEDUP] Blocked excessive pagination (page ${pageCount}/${MAX_PAGES_PER_QUERY}): "${searchQuery}" in "${searchPath}"`);
                 }
-                return `PAGINATION LIMIT REACHED: You have already retrieved ${MAX_PAGES_PER_QUERY} pages of results for this query. You have enough results \u2014 use extract to examine specific files, or use attempt_completion to return your findings.`;
+                return `PAGINATION LIMIT REACHED: You have already retrieved ${MAX_PAGES_PER_QUERY} pages of results for this query. You have enough results \u2014 use extract to examine specific files, or provide your final answer with your findings.`;
               }
             }
             try {
@@ -9452,7 +9480,7 @@ var init_vercel = __esm({
               bashConfig: null,
               architectureFileName: options.architectureFileName || null,
               promptType: "code-searcher",
-              allowedTools: ["search", "extract", "listFiles", "attempt_completion"],
+              allowedTools: ["search", "extract", "listFiles"],
               searchDelegate: false,
               schema: CODE_SEARCH_SCHEMA,
               parentAbortSignal: options.parentAbortSignal || null
@@ -31946,7 +31974,7 @@ For each pending/in_progress task, either:
 - Complete it: call task tool with action="complete", id="task-X"
 - Cancel it: call task tool with action="update", id="task-X", status="cancelled"
 
-After all tasks are resolved, call attempt_completion again.`;
+After all tasks are resolved, provide your final answer.`;
 }
 function createTaskTool(options = {}) {
   const { taskManager, tracer, debug = false } = options;
@@ -32196,13 +32224,13 @@ Tasks = logical units of work, not files or steps.
 
 1. **Plan**: Call task tool with action="create" and a tasks array up front
 2. **Execute**: Update status to "in_progress" / "completed" as you work. Add, split, or cancel tasks as you learn more.
-3. **Finish**: All tasks must be "completed" or "cancelled" before calling attempt_completion.
+3. **Finish**: All tasks must be "completed" or "cancelled" before providing your final answer.
 
 ## Rules
 
 - Dependencies are enforced: a task cannot start until its dependencies are completed
 - Circular dependencies are rejected
-- attempt_completion is blocked while tasks remain unresolved
+- Completion is blocked while tasks remain unresolved
 `;
   }
 });
@@ -69068,68 +69096,9 @@ var require_ajv = __commonJS({
 });
 
 // src/agent/schemaUtils.js
-var schemaUtils_exports = {};
-__export(schemaUtils_exports, {
-  JsonFixingAgent: () => JsonFixingAgent,
-  MermaidFixingAgent: () => MermaidFixingAgent,
-  cleanSchemaResponse: () => cleanSchemaResponse,
-  createJsonCorrectionPrompt: () => createJsonCorrectionPrompt,
-  createMermaidCorrectionPrompt: () => createMermaidCorrectionPrompt,
-  createSchemaDefinitionCorrectionPrompt: () => createSchemaDefinitionCorrectionPrompt,
-  decodeHtmlEntities: () => decodeHtmlEntities2,
-  extractMermaidFromJson: () => extractMermaidFromJson,
-  extractMermaidFromMarkdown: () => extractMermaidFromMarkdown,
-  generateExampleFromSchema: () => generateExampleFromSchema,
-  generateSchemaInstructions: () => generateSchemaInstructions,
-  isJsonSchema: () => isJsonSchema,
-  isJsonSchemaDefinition: () => isJsonSchemaDefinition,
-  isMermaidSchema: () => isMermaidSchema,
-  isSimpleTextWrapperSchema: () => isSimpleTextWrapperSchema,
-  processSchemaResponse: () => processSchemaResponse,
-  replaceMermaidDiagramsInJson: () => replaceMermaidDiagramsInJson,
-  replaceMermaidDiagramsInMarkdown: () => replaceMermaidDiagramsInMarkdown,
-  sanitizeMarkdownEscapesInJson: () => sanitizeMarkdownEscapesInJson,
-  tryAutoWrapForSimpleSchema: () => tryAutoWrapForSimpleSchema,
-  tryExtractValidJsonPrefix: () => tryExtractValidJsonPrefix,
-  tryMaidAutoFix: () => tryMaidAutoFix,
-  validateAndFixMermaidResponse: () => validateAndFixMermaidResponse,
-  validateJsonResponse: () => validateJsonResponse,
-  validateMermaidDiagram: () => validateMermaidDiagram,
-  validateMermaidResponse: () => validateMermaidResponse,
-  validateXmlResponse: () => validateXmlResponse
-});
-function generateExampleFromSchema(schema, options = {}) {
-  const { debug = false } = options;
-  try {
-    const parsedSchema = typeof schema === "string" ? JSON.parse(schema) : schema;
-    if (parsedSchema.type !== "object" || !parsedSchema.properties) {
-      return null;
-    }
-    const exampleObj = {};
-    for (const [key, value] of Object.entries(parsedSchema.properties)) {
-      if (value.type === "boolean") {
-        exampleObj[key] = false;
-      } else if (value.type === "number") {
-        exampleObj[key] = 0;
-      } else if (value.type === "string") {
-        exampleObj[key] = value.description || "your answer here";
-      } else if (value.type === "array") {
-        exampleObj[key] = [];
-      } else {
-        exampleObj[key] = {};
-      }
-    }
-    return exampleObj;
-  } catch (e) {
-    if (debug) {
-      console.error("[DEBUG] generateExampleFromSchema: Failed to parse schema:", e.message);
-    }
-    return null;
-  }
-}
 function generateSchemaInstructions(schema, options = {}) {
   const { debug = false } = options;
-  let instructions = "\n\nIMPORTANT: When you provide your final answer using attempt_completion, you MUST format it as valid JSON matching this schema:\n\n";
+  let instructions = "\n\nIMPORTANT: When you provide your final answer, you MUST format it as valid JSON matching this schema:\n\n";
   try {
     const parsedSchema = typeof schema === "string" ? JSON.parse(schema) : schema;
     instructions += `${JSON.stringify(parsedSchema, null, 2)}
@@ -69143,7 +69112,7 @@ function generateSchemaInstructions(schema, options = {}) {
 
 `;
   }
-  instructions += "Your response inside attempt_completion must be ONLY valid JSON - no plain text, no explanations, no markdown.\n\nIMPORTANT: First complete the requested analysis/task thoroughly, then provide your final answer in the JSON format above.";
+  instructions += "Your final response must be ONLY valid JSON - no plain text, no explanations, no markdown.\n\nIMPORTANT: First complete the requested analysis/task thoroughly, then provide your final answer in the JSON format above.";
   return instructions;
 }
 function enforceNoAdditionalProperties(schema) {
@@ -69840,18 +69809,18 @@ function createJsonCorrectionPrompt(invalidResponse, schema, errorOrValidation,
   const strengthLevels = [
     {
       prefix: "CRITICAL JSON ERROR:",
-      instruction: "You MUST fix this and respond using attempt_completion with ONLY valid JSON as the result.",
-      emphasis: "Use attempt_completion with ONLY the corrected JSON in the result field. No explanatory text, no markdown, no code blocks."
+      instruction: "You MUST fix this and respond with ONLY valid JSON.",
+      emphasis: "Respond with ONLY the corrected JSON. No explanatory text, no markdown, no code blocks."
     },
     {
       prefix: "URGENT - JSON PARSING FAILED:",
-      instruction: "This is your second chance. Use attempt_completion with valid JSON that can be parsed by JSON.parse().",
-      emphasis: "ABSOLUTELY NO explanatory text or formatting. Use attempt_completion with ONLY raw JSON in the result."
+      instruction: "This is your second chance. Respond with valid JSON that can be parsed by JSON.parse().",
+      emphasis: "ABSOLUTELY NO explanatory text or formatting. Respond with ONLY raw JSON."
     },
     {
       prefix: "FINAL ATTEMPT - CRITICAL JSON ERROR:",
-      instruction: "This is the final retry. You MUST use attempt_completion with ONLY raw JSON in the result field.",
-      emphasis: 'CORRECT: <attempt_completion><result>{"key": "value"}</result></attempt_completion>\nWRONG: Here is the JSON: {"key": "value"}\nWRONG: ```json{"key": "value"}```'
+      instruction: "This is the final retry. You MUST respond with ONLY raw JSON.",
+      emphasis: 'CORRECT: {"key": "value"}\nWRONG: Here is the JSON: {"key": "value"}\nWRONG: ```json{"key": "value"}```'
     }
   ];
   const level = Math.min(retryCount, strengthLevels.length - 1);
@@ -69905,28 +69874,6 @@ ${currentLevel.example}
 Return ONLY the JSON data object/array that follows the schema structure. NO schema definitions, NO explanations, NO markdown formatting.`;
   return prompt;
 }
-function isMermaidSchema(schema) {
-  if (!schema || typeof schema !== "string") {
-    return false;
-  }
-  const trimmedSchema = schema.trim().toLowerCase();
-  const mermaidIndicators = [
-    trimmedSchema.includes("mermaid"),
-    trimmedSchema.includes("diagram"),
-    trimmedSchema.includes("flowchart"),
-    trimmedSchema.includes("sequence"),
-    trimmedSchema.includes("gantt"),
-    trimmedSchema.includes("pie chart"),
-    trimmedSchema.includes("state diagram"),
-    trimmedSchema.includes("class diagram"),
-    trimmedSchema.includes("entity relationship"),
-    trimmedSchema.includes("user journey"),
-    trimmedSchema.includes("git graph"),
-    trimmedSchema.includes("requirement diagram"),
-    trimmedSchema.includes("c4 context")
-  ];
-  return mermaidIndicators.some((indicator) => indicator);
-}
 function extractMermaidFromJson(response) {
   if (!response || typeof response !== "string") {
     return { diagrams: [], jsonPaths: [], parsedJson: null };
@@ -70058,28 +70005,6 @@ ${modifiedJsonString}
   }
   return modifiedJsonString;
 }
-function replaceMermaidDiagramsInMarkdown(originalResponse, correctedDiagrams) {
-  if (!originalResponse || typeof originalResponse !== "string") {
-    return originalResponse;
-  }
-  if (!correctedDiagrams || correctedDiagrams.length === 0) {
-    return originalResponse;
-  }
-  const hasJsonDiagrams = correctedDiagrams.some((d) => d.isInJson);
-  if (hasJsonDiagrams) {
-    return replaceMermaidDiagramsInJson(originalResponse, correctedDiagrams);
-  }
-  let modifiedResponse = originalResponse;
-  const sortedDiagrams = [...correctedDiagrams].sort((a, b) => b.startIndex - a.startIndex);
-  for (const diagram of sortedDiagrams) {
-    const attributesStr = diagram.attributes ? ` ${diagram.attributes}` : "";
-    const newCodeBlock = `\`\`\`mermaid${attributesStr}
-${diagram.content}
-\`\`\``;
-    modifiedResponse = modifiedResponse.slice(0, diagram.startIndex) + newCodeBlock + modifiedResponse.slice(diagram.endIndex);
-  }
-  return modifiedResponse;
-}
 function replaceSingleMermaidDiagramInResponse(response, originalDiagram, newContent) {
   if (!originalDiagram) {
     return response;
@@ -70164,45 +70089,6 @@ async function validateMermaidResponse(response) {
     errors: errors.length > 0 ? errors : void 0
   };
 }
-function createMermaidCorrectionPrompt(invalidResponse, schema, errors, diagrams) {
-  let prompt = `Your previous response contains invalid Mermaid diagrams that cannot be parsed. Here's what you returned:
-
-${invalidResponse}
-
-Validation Errors:`;
-  errors.forEach((error, index) => {
-    prompt += `
-${index + 1}. ${error}`;
-  });
-  if (diagrams && diagrams.length > 0) {
-    prompt += `
-
-Diagram Details:`;
-    diagrams.forEach((diagramResult, index) => {
-      if (!diagramResult.isValid) {
-        prompt += `
-
-Diagram ${index + 1}:`;
-        const diagramContent = diagramResult.content || diagramResult.diagram || "";
-        prompt += `
-- Content: ${diagramContent.substring(0, 100)}${diagramContent.length > 100 ? "..." : ""}`;
-        prompt += `
-- Error: ${diagramResult.error}`;
-        if (diagramResult.detailedError && diagramResult.detailedError !== diagramResult.error) {
-          prompt += `
-- Details: ${diagramResult.detailedError}`;
-        }
-      }
-    });
-  }
-  prompt += `
-
-Please correct your response to include valid Mermaid diagrams that match this schema:
-${schema}
-
-Ensure all Mermaid diagrams are properly formatted within \`\`\`mermaid code blocks and follow correct Mermaid syntax.`;
-  return prompt;
-}
 async function tryMaidAutoFix(diagramContent, options = {}) {
   const { debug = false } = options;
   try {
@@ -70512,7 +70398,7 @@ async function validateAndFixMermaidResponse(response, options = {}) {
     };
   }
 }
-var import_ajv, HTML_ENTITY_MAP, sessionIdCounter, JsonFixingAgent, MermaidFixingAgent;
+var import_ajv, HTML_ENTITY_MAP, sessionIdCounter, MermaidFixingAgent;
 var init_schemaUtils = __esm({
   "src/agent/schemaUtils.js"() {
     "use strict";
@@ -70530,172 +70416,6 @@ var init_schemaUtils = __esm({
       "&nbsp;": " "
     };
     sessionIdCounter = 0;
-    JsonFixingAgent = class {
-      constructor(options = {}) {
-        this.ProbeAgent = null;
-        this.options = {
-          sessionId: options.sessionId || `json-fixer-${Date.now()}-${sessionIdCounter++}`,
-          path: options.path || process.cwd(),
-          provider: options.provider,
-          model: options.model,
-          debug: options.debug,
-          tracer: options.tracer,
-          // Set to false since we're only fixing JSON syntax, not implementing code
-          allowEdit: false
-        };
-      }
-      /**
-       * Get the specialized prompt for JSON fixing
-       */
-      getJsonFixingPrompt() {
-        return `You are a world-class JSON syntax correction specialist. Your expertise lies in analyzing and fixing JSON syntax errors while preserving the original data structure and intent.
-
-CORE RESPONSIBILITIES:
-- Analyze JSON for syntax errors and structural issues
-- Fix syntax errors while maintaining the original data's semantic meaning
-- Ensure JSON follows proper RFC 8259 specification
-- Handle all JSON structures: objects, arrays, primitives, nested structures
-
-JSON SYNTAX RULES:
-1. **Property names**: Must be enclosed in double quotes
-2. **String values**: Must use double quotes (not single quotes)
-3. **Numbers**: Can be integers or decimals, no quotes needed
-4. **Booleans**: true or false (lowercase, no quotes)
-5. **Null**: null (lowercase, no quotes)
-6. **Arrays**: Comma-separated values in square brackets [...]
-7. **Objects**: Comma-separated key-value pairs in curly braces {...}
-8. **No trailing commas**: Last item in array/object must not have a trailing comma
-9. **Escape sequences**: Special characters must be escaped (\\n, \\t, \\", \\\\, etc.)
-
-COMMON ERRORS TO FIX:
-1. **Unquoted property names**: {name: "value"} \u2192 {"name": "value"}
-2. **Single quotes**: {'key': 'value'} \u2192 {"key": "value"}
-3. **Trailing commas**: {"a": 1,} \u2192 {"a": 1}
-4. **Unquoted strings**: {key: value} \u2192 {"key": "value"}
-5. **Missing commas**: {"a": 1 "b": 2} \u2192 {"a": 1, "b": 2}
-6. **Extra commas**: {"a": 1,, "b": 2} \u2192 {"a": 1, "b": 2}
-7. **Unclosed brackets/braces**: {"key": "value" \u2192 {"key": "value"}
-8. **Invalid escape sequences**: Fix or remove
-9. **Comments**: Remove // or /* */ comments (not allowed in JSON)
-10. **Undefined values**: Replace undefined with null
-
-FIXING METHODOLOGY:
-1. **Identify the error location** from the error message
-2. **Analyze the context** around the error
-3. **Apply the appropriate fix** based on JSON syntax rules
-4. **Preserve data intent** - never change the meaning of the data
-5. **Validate the result** - ensure it's parseable JSON
-
-CRITICAL RULES:
-- ALWAYS output only the corrected JSON
-- NEVER add explanations, comments, or additional text
-- NEVER wrap in markdown code blocks (no \`\`\`json)
-- PRESERVE the original data structure and values
-- FIX only syntax errors, don't modify the data itself
-- ENSURE the output is valid, parseable JSON
-
-When presented with broken JSON, analyze it thoroughly and provide the corrected version that maintains the original intent while fixing all syntax issues.`;
-      }
-      /**
-       * Initialize the ProbeAgent if not already done
-       */
-      async initializeAgent() {
-        if (!this.ProbeAgent) {
-          const { ProbeAgent: ProbeAgent2 } = await Promise.resolve().then(() => (init_ProbeAgent(), ProbeAgent_exports));
-          this.ProbeAgent = ProbeAgent2;
-        }
-        if (!this.agent) {
-          this.agent = new this.ProbeAgent({
-            sessionId: this.options.sessionId,
-            customPrompt: this.getJsonFixingPrompt(),
-            path: this.options.path,
-            provider: this.options.provider,
-            model: this.options.model,
-            debug: this.options.debug,
-            tracer: this.options.tracer,
-            allowEdit: this.options.allowEdit,
-            maxIterations: 5,
-            // Allow multiple iterations for JSON fixing
-            disableJsonValidation: true
-            // CRITICAL: Disable JSON validation in nested agent to prevent infinite recursion
-          });
-        }
-        return this.agent;
-      }
-      /**
-       * Fix invalid JSON using the specialized agent
-       * @param {string} invalidJson - The broken JSON string
-       * @param {string} schema - The original schema for context
-       * @param {Object} validationResult - Validation result with error details
-       * @param {number} attemptNumber - Current attempt number (for logging)
-       * @returns {Promise<string>} - The corrected JSON
-       */
-      async fixJson(invalidJson, schema, validationResult, attemptNumber = 1) {
-        await this.initializeAgent();
-        let errorContext = validationResult.error;
-        if (validationResult.enhancedError) {
-          errorContext = validationResult.enhancedError;
-        }
-        let schemaErrorDetails = "";
-        if (validationResult.errorSummary) {
-          schemaErrorDetails = `
-
-Schema Validation Errors:
-${validationResult.errorSummary}`;
-        } else if (validationResult.schemaErrors && validationResult.schemaErrors.length > 0) {
-          const errors = validationResult.schemaErrors.map((err) => {
-            const path9 = err.instancePath || "(root)";
-            return `  ${path9}: ${err.message}`;
-          }).join("\n");
-          schemaErrorDetails = `
-
-Schema Validation Errors:
-${errors}`;
-        }
-        const prompt = `Fix the following invalid JSON.
-
-Error: ${errorContext}${schemaErrorDetails}
-
-Invalid JSON:
-${invalidJson}
-
-Expected schema structure:
-${schema}
-
-${schemaErrorDetails ? "CRITICAL: Pay special attention to the schema validation errors above. The JSON may be syntactically valid but does not conform to the required schema. Make sure to:\n- Include all required fields\n- Use correct data types\n- Remove any additional properties not defined in the schema (if additionalProperties is false)\n- Ensure all values match their schema constraints\n\n" : ""}Provide only the corrected JSON without any markdown formatting or explanations.`;
-        try {
-          if (this.options.debug) {
-            console.log(`[DEBUG] JSON fixing: Attempt ${attemptNumber} to fix JSON with separate agent`);
-          }
-          const result = await this.agent.answer(prompt, []);
-          const cleaned = cleanSchemaResponse(result);
-          if (this.options.debug) {
-            console.log(`[DEBUG] JSON fixing: Agent returned ${cleaned.length} chars`);
-          }
-          return cleaned;
-        } catch (error) {
-          if (this.options.debug) {
-            console.error(`[DEBUG] JSON fixing failed: ${error.message}`);
-          }
-          throw new Error(`Failed to fix JSON: ${error.message}`);
-        }
-      }
-      /**
-       * Get token usage information from the specialized agent
-       * @returns {Object} - Token usage statistics
-       */
-      getTokenUsage() {
-        return this.agent ? this.agent.getTokenUsage() : null;
-      }
-      /**
-       * Cancel any ongoing operations
-       */
-      cancel() {
-        if (this.agent) {
-          this.agent.cancel();
-        }
-      }
-    };
     MermaidFixingAgent = class {
       constructor(options = {}) {
         this.ProbeAgent = null;
@@ -70939,7 +70659,7 @@ When reviewing code:
       "code-review-template": `You are going to perform code review according to provided user rules. Ensure to review only code provided in diff and latest commit, if provided. However you still need to fully understand how modified code works, and read dependencies if something is not clear.`,
       "engineer": `You are a senior engineer focused on software architecture and design.
 Before jumping on the task you first analyse the user request in detail, and try to provide an elegant and concise solution.
-If the solution is clear, you can jump to implementation right away. If not, ask the user a clarification question by calling the attempt_completion tool with the required details.
+If the solution is clear, you can jump to implementation right away. If not, ask the user a clarification question with the required details.
 
 # Tone and Style
 - Be concise and direct. Explain your approach briefly before implementing, then let the code speak for itself.
@@ -70962,7 +70682,7 @@ If the solution is clear, you can jump to implementation right away. If not, ask
 When the request has **multiple distinct goals** (e.g. "Fix bug A AND add feature B"), use the task tool to track them:
 - Call the task tool with action="create" and a tasks array. Each task must have an "id" field.
 - Update task status to "in_progress" when starting and "completed" when done.
-- All tasks must be completed or cancelled before calling attempt_completion.
+- All tasks must be completed or cancelled before providing your final answer.
 - Stay flexible \u2014 add, remove, or reorganize tasks as your understanding changes.
 
 Do NOT create tasks for single-goal requests, even complex ones. Multiple internal steps for one goal (search, read, analyze, implement) do not need tasks.
@@ -80219,9 +79939,15 @@ function messageContainsCompletion(msg) {
   }
   if (Array.isArray(msg.content)) {
     if (msg.content.some((p) => p.type === "tool-call" && p.toolName === "attempt_completion")) return true;
+    const hasToolCalls = msg.content.some((p) => p.type === "tool-call");
+    const hasText = msg.content.some((p) => p.type === "text" && p.text?.trim());
+    if (!hasToolCalls && hasText) return true;
   }
   const text = typeof msg.content === "string" ? msg.content : "";
-  return text.includes("attempt_completion");
+  if (text.includes("attempt_completion")) return true;
+  const hasNoToolCalls = !Array.isArray(msg.toolInvocations) && !Array.isArray(msg.tool_calls);
+  if (hasNoToolCalls && text.trim().length > 0) return true;
+  return false;
 }
 function identifyMessageSegments(messages) {
   const segments = [];
@@ -81988,7 +81714,7 @@ import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
 import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
 import { createGoogleGenerativeAI as createGoogleGenerativeAI2 } from "@ai-sdk/google";
 import { createAmazonBedrock as createAmazonBedrock2 } from "@ai-sdk/amazon-bedrock";
-import { streamText as streamText2, tool as tool5, stepCountIs, jsonSchema } from "ai";
+import { streamText as streamText2, tool as tool5, stepCountIs, jsonSchema, Output } from "ai";
 import { randomUUID as randomUUID5 } from "crypto";
 import { EventEmitter as EventEmitter5 } from "events";
 import { existsSync as existsSync7 } from "fs";
@@ -82002,8 +81728,8 @@ function debugTruncate(s, limit = 200) {
 function debugLogToolResults(toolResults) {
   if (!toolResults || toolResults.length === 0) return;
   for (const tr of toolResults) {
-    const argsStr = JSON.stringify(tr.args || {});
-    const resultStr = typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result || "");
+    const argsStr = tr.args != null ? JSON.stringify(tr.args) : "<no args>";
+    const resultStr = tr.result != null ? typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result) : "<no result>";
     console.log(`[DEBUG]   tool: ${tr.toolName} | args: ${debugTruncate(argsStr)} | result: ${debugTruncate(resultStr)}`);
   }
 }
@@ -82099,7 +81825,7 @@ var init_ProbeAgent = __esm({
        * @param {Array<Object>} [options.fallback.providers] - List of provider configurations for custom fallback
        * @param {boolean} [options.fallback.stopOnSuccess=true] - Stop on first success
        * @param {number} [options.fallback.maxTotalAttempts=10] - Maximum total attempts across all providers
-       * @param {string} [options.completionPrompt] - Custom prompt to run after attempt_completion for validation/review (runs before mermaid/JSON validation)
+       * @param {string} [options.completionPrompt] - Custom prompt to run after completion for validation/review (runs before mermaid/JSON validation)
        * @param {number} [options.maxOutputTokens] - Maximum tokens for tool output before truncation (default: 20000, can also be set via PROBE_MAX_OUTPUT_TOKENS env var)
        * @param {number} [options.requestTimeout] - Timeout in ms for AI requests (default: 120000 or REQUEST_TIMEOUT env var). Used to abort hung requests.
        * @param {number} [options.maxOperationTimeout] - Maximum timeout in ms for the entire operation including all retries and fallbacks (default: 300000 or MAX_OPERATION_TIMEOUT env var). This is the absolute maximum time for streamTextWithRetryAndFallback.
@@ -83251,12 +82977,11 @@ var init_ProbeAgent = __esm({
        * - Delegate tool param injection
        *
        * @param {Object} options - Options from the answer() call
-       * @param {Function} onComplete - Callback when attempt_completion is called (receives result string)
        * @param {Object} context - Execution context { maxIterations, currentMessages }
        * @returns {Object} Tools object for streamText()
        * @private
        */
-      _buildNativeTools(options, onComplete, context = {}) {
+      _buildNativeTools(options, context = {}) {
         const { maxIterations = 30 } = context;
         const nativeTools = {};
         const isToolAllowed = (toolName) => this.allowedTools.isEnabled(toolName);
@@ -83406,16 +83131,6 @@ var init_ProbeAgent = __esm({
           });
         };
         if (options._disableTools) {
-          nativeTools.attempt_completion = tool5({
-            description: "Signal task completion and provide the final result to the user",
-            inputSchema: external_exports.object({
-              result: external_exports.string().describe("The final result to present to the user")
-            }),
-            execute: async ({ result }) => {
-              onComplete(result);
-              return result;
-            }
-          });
           return nativeTools;
         }
         for (const [toolName, toolImpl] of Object.entries(this.toolImplementations)) {
@@ -83426,28 +83141,6 @@ var init_ProbeAgent = __esm({
             nativeTools[toolName] = wrapTool(toolName, schema, description, toolImpl.execute);
           }
         }
-        nativeTools.attempt_completion = tool5({
-          description: "Signal task completion and provide the final result to the user",
-          inputSchema: external_exports.object({
-            result: external_exports.string().describe("The final result to present to the user")
-          }),
-          execute: async ({ result }) => {
-            if (this.enableTasks && this.taskManager && this.taskManager.hasIncompleteTasks()) {
-              const incompleteTasks = this.taskManager.getIncompleteTasks();
-              const highIterationCount = (context.currentIteration || 0) > maxIterations * 0.7;
-              if (!highIterationCount) {
-                const taskSummary = this.taskManager.getTaskSummary();
-                const blockedMessage = createTaskCompletionBlockedMessage(taskSummary);
-                if (this.debug) {
-                  console.log("[DEBUG] Task checkpoint: Blocking completion due to incomplete tasks");
-                }
-                return blockedMessage;
-              }
-            }
-            onComplete(result);
-            return result;
-          }
-        });
         if (this.mcpBridge && !options._disableTools) {
           const mcpTools = this.mcpBridge.getVercelTools(this._filterMcpTools(this.mcpBridge.getToolNames()));
           for (const [name, mcpTool] of Object.entries(mcpTools)) {
@@ -84331,7 +84024,7 @@ Follow these instructions carefully:
 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, use the attempt_completion tool to provide the final result.
+5. Once the task is fully completed, provide your final answer directly as text.
 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:
@@ -84509,7 +84202,7 @@ You are working with a workspace. Available paths: ${workspaceDesc}
           });
           const systemMessage = await this.getSystemMessage();
           let userMessage = { role: "user", content: message.trim() };
-          if (options.schema && !options._schemaFormatted) {
+          if (options.schema && !options._schemaFormatted && !options._disableTools) {
             const schemaInstructions = generateSchemaInstructions(options.schema, { debug: this.debug });
             userMessage.content = message.trim() + schemaInstructions;
           }
@@ -84542,7 +84235,6 @@ You are working with a workspace. Available paths: ${workspaceDesc}
             ];
           }
           let currentIteration = 0;
-          let completionAttempted = false;
           let finalResult = "I was unable to complete your request due to reaching the maximum number of tool iterations.";
           const baseMaxIterations = options._maxIterationsOverride || this.maxIterations || MAX_TOOL_ITERATIONS;
           const maxIterations = options._maxIterationsOverride ? baseMaxIterations : options.schema ? baseMaxIterations + 4 : baseMaxIterations;
@@ -84658,12 +84350,8 @@ You are working with a workspace. Available paths: ${workspaceDesc}
               console.log(`[DEBUG] Schema provided, using extended iteration limit: ${maxIterations} (base: ${baseMaxIterations})`);
             }
           }
-          let completionResult = null;
           const toolContext = { maxIterations, currentIteration: 0, currentMessages };
-          const tools2 = this._buildNativeTools(options, (result) => {
-            completionResult = result;
-            completionAttempted = true;
-          }, toolContext);
+          const tools2 = this._buildNativeTools(options, toolContext);
           if (this.debug) {
             const toolNames = Object.keys(tools2);
             console.log(`[DEBUG] Agent tools registered (${toolNames.length}): ${toolNames.join(", ")}`);
@@ -84677,6 +84365,8 @@ You are working with a workspace. Available paths: ${workspaceDesc}
               maxResponseTokens = 32e3;
             }
           }
+          let completionPromptInjected = false;
+          let preCompletionResult = null;
           let compactionAttempted = false;
           while (true) {
             try {
@@ -84685,19 +84375,103 @@ You are working with a workspace. Available paths: ${workspaceDesc}
                 model: this.provider ? this.provider(this.model) : this.model,
                 messages: messagesForAI,
                 tools: tools2,
-                stopWhen: stepCountIs(maxIterations),
+                stopWhen: ({ steps }) => {
+                  if (steps.length >= maxIterations) return true;
+                  const lastStep = steps[steps.length - 1];
+                  const modelWantsToStop = lastStep?.finishReason === "stop" && (!lastStep?.toolCalls || lastStep.toolCalls.length === 0);
+                  if (modelWantsToStop) {
+                    if (this.enableTasks && this.taskManager?.hasIncompleteTasks()) {
+                      const highIterationCount = steps.length > maxIterations * 0.7;
+                      if (!highIterationCount) return false;
+                    }
+                    if (this.completionPrompt && !options._completionPromptProcessed && !completionPromptInjected) {
+                      preCompletionResult = lastStep.text || null;
+                      return false;
+                    }
+                  }
+                  let trailingNoTool = 0;
+                  for (let i = steps.length - 1; i >= 0; i--) {
+                    if (!steps[i].toolCalls?.length) trailingNoTool++;
+                    else break;
+                  }
+                  if (trailingNoTool >= 5) return true;
+                  if (trailingNoTool >= 3) {
+                    const recentTexts = steps.slice(-3).map((s) => s.text);
+                    if (recentTexts.every((t) => t && t === recentTexts[0])) return true;
+                    if (recentTexts.every((t) => detectStuckResponse(t))) return true;
+                  }
+                  return false;
+                },
+                prepareStep: ({ steps, stepNumber }) => {
+                  if (stepNumber === maxIterations - 1) {
+                    return {
+                      toolChoice: "none"
+                    };
+                  }
+                  const lastStep = steps[steps.length - 1];
+                  const modelJustStopped = lastStep?.finishReason === "stop" && (!lastStep?.toolCalls || lastStep.toolCalls.length === 0);
+                  if (modelJustStopped) {
+                    if (this.enableTasks && this.taskManager?.hasIncompleteTasks()) {
+                      const taskSummary = this.taskManager.getTaskSummary();
+                      const blockedMessage = createTaskCompletionBlockedMessage(taskSummary);
+                      return {
+                        userMessage: blockedMessage
+                      };
+                    }
+                    if (this.completionPrompt && !options._completionPromptProcessed && !completionPromptInjected) {
+                      completionPromptInjected = true;
+                      const resultToReview = lastStep.text || preCompletionResult || "";
+                      if (this.debug) {
+                        console.log("[DEBUG] Injecting completion prompt into main loop via prepareStep...");
+                      }
+                      if (this.tracer) {
+                        this.tracer.recordEvent("completion_prompt.started", {
+                          "completion_prompt.original_result_length": resultToReview.length
+                        });
+                      }
+                      const completionPromptMessage = `${this.completionPrompt}
+
+Here is the result to review:
+<result>
+${resultToReview}
+</result>
+
+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
+                      };
+                    }
+                  }
+                  return void 0;
+                },
                 maxTokens: maxResponseTokens,
                 temperature: 0.3,
-                onStepFinish: ({ toolResults, text, finishReason, usage }) => {
+                onStepFinish: (stepResult) => {
+                  const { toolResults, toolCalls, text, reasoningText, finishReason, usage } = stepResult;
                   currentIteration++;
                   toolContext.currentIteration = currentIteration;
                   if (this.tracer) {
-                    this.tracer.addEvent("iteration.step", {
+                    const stepEvent = {
                       "iteration": currentIteration,
                       "max_iterations": maxIterations,
                       "finish_reason": finishReason,
                       "has_tool_calls": !!(toolResults && toolResults.length > 0)
-                    });
+                    };
+                    if (text) {
+                      stepEvent["ai.text"] = text.substring(0, 1e4);
+                      stepEvent["ai.text.length"] = text.length;
+                    }
+                    if (reasoningText) {
+                      stepEvent["ai.reasoning"] = reasoningText.substring(0, 1e4);
+                      stepEvent["ai.reasoning.length"] = reasoningText.length;
+                    }
+                    if (toolCalls && toolCalls.length > 0) {
+                      stepEvent["ai.tool_calls"] = toolCalls.map((tc) => ({
+                        name: tc.toolName,
+                        args: JSON.stringify(tc.args || {}).substring(0, 2e3)
+                      }));
+                    }
+                    this.tracer.addEvent("iteration.step", stepEvent);
                   }
                   if (usage) {
                     this.tokenCounter.recordUsage(usage);
@@ -84707,10 +84481,32 @@ You are working with a workspace. Available paths: ${workspaceDesc}
                   }
                   if (this.debug) {
                     console.log(`[DEBUG] Step ${currentIteration}/${maxIterations} finished (reason: ${finishReason}, tools: ${toolResults?.length || 0})`);
+                    if (text) {
+                      console.log(`[DEBUG]   model text: ${debugTruncate(text)}`);
+                    }
+                    if (reasoningText) {
+                      console.log(`[DEBUG]   reasoning: ${debugTruncate(reasoningText)}`);
+                    }
                     debugLogToolResults(toolResults);
                   }
                 }
               };
+              const hasActiveTools = Object.keys(tools2).length > 0;
+              if (options.schema && !hasActiveTools) {
+                try {
+                  const parsedSchema = typeof options.schema === "string" ? JSON.parse(options.schema) : options.schema;
+                  if (isJsonSchema(options.schema)) {
+                    streamOptions.output = Output.object({ schema: jsonSchema(parsedSchema) });
+                    if (this.debug) {
+                      console.log(`[DEBUG] Native JSON schema output enabled (no active tools)`);
+                    }
+                  }
+                } catch (e) {
+                  if (this.debug) {
+                    console.log(`[DEBUG] Failed to set native JSON schema output: ${e.message}`);
+                  }
+                }
+              }
               const providerOpts = this._buildThinkingProviderOptions(maxResponseTokens);
               if (providerOpts) {
                 streamOptions.providerOptions = providerOpts;
@@ -84720,7 +84516,7 @@ You are working with a workspace. Available paths: ${workspaceDesc}
                 const 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, completion=${!!completionResult}`);
+                  console.log(`[DEBUG] streamText completed: ${steps?.length || 0} steps, finalText=${finalText?.length || 0} chars`);
                 }
                 const usage = await result.usage;
                 if (usage) {
@@ -84744,18 +84540,24 @@ You are working with a workspace. Available paths: ${workspaceDesc}
               } else {
                 aiResult = await executeAIRequest();
               }
-              if (completionResult) {
-                finalResult = completionResult;
-                if (options.onStream && finalResult) {
-                  const chunkSize = 50;
-                  for (let i = 0; i < finalResult.length; i += chunkSize) {
-                    const chunk = finalResult.slice(i, Math.min(i + chunkSize, finalResult.length));
-                    options.onStream(chunk);
+              if (options.schema && streamOptions.output) {
+                try {
+                  const outputObject = await aiResult.result.output;
+                  if (outputObject) {
+                    finalResult = JSON.stringify(outputObject);
+                  } else if (aiResult.finalText) {
+                    finalResult = aiResult.finalText;
+                  }
+                } catch (e) {
+                  if (this.debug) {
+                    console.log(`[DEBUG] Native JSON output failed, falling back to text: ${e.message}`);
+                  }
+                  if (aiResult.finalText) {
+                    finalResult = aiResult.finalText;
                   }
                 }
               } else if (aiResult.finalText) {
                 finalResult = aiResult.finalText;
-                completionAttempted = true;
               }
               const resultMessages = await aiResult.result.response?.messages;
               if (resultMessages) {
@@ -84763,6 +84565,75 @@ You are working with a workspace. Available paths: ${workspaceDesc}
                   currentMessages.push(msg);
                 }
               }
+              if (this.completionPrompt && !options._completionPromptProcessed && !completionPromptInjected && finalResult) {
+                completionPromptInjected = true;
+                preCompletionResult = finalResult;
+                if (this.debug) {
+                  console.log("[DEBUG] Injecting completion prompt as post-streamText follow-up pass...");
+                }
+                if (this.tracer) {
+                  this.tracer.recordEvent("completion_prompt.started", {
+                    "completion_prompt.original_result_length": finalResult.length
+                  });
+                }
+                const completionPromptMessage = `${this.completionPrompt}
+
+Here is the result to review:
+<result>
+${finalResult}
+</result>
+
+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: stepCountIs(completionMaxIterations),
+                  maxTokens: maxResponseTokens,
+                  temperature: 0.3,
+                  onStepFinish: ({ toolResults, text, finishReason, usage }) => {
+                    if (usage) {
+                      this.tokenCounter.recordUsage(usage);
+                    }
+                    if (options.onStream && text) {
+                      options.onStream(text);
+                    }
+                    if (this.debug) {
+                      console.log(`[DEBUG] Completion prompt step finished (reason: ${finishReason}, tools: ${toolResults?.length || 0})`);
+                    }
+                  }
+                };
+                const providerOpts2 = this._buildThinkingProviderOptions(maxResponseTokens);
+                if (providerOpts2) {
+                  completionStreamOptions.providerOptions = providerOpts2;
+                }
+                try {
+                  const cpResult = await this.streamTextWithRetryAndFallback(completionStreamOptions);
+                  const cpFinalText = await cpResult.text;
+                  const cpUsage = await cpResult.usage;
+                  if (cpUsage) {
+                    this.tokenCounter.recordUsage(cpUsage, cpResult.experimental_providerMetadata);
+                  }
+                  const cpMessages = await cpResult.response?.messages;
+                  if (cpMessages) {
+                    for (const msg of cpMessages) {
+                      currentMessages.push(msg);
+                    }
+                  }
+                  if (cpFinalText && cpFinalText.trim().length > 0) {
+                    finalResult = cpFinalText;
+                  }
+                  if (this.debug) {
+                    console.log(`[DEBUG] Completion prompt follow-up produced ${cpFinalText?.length || 0} chars (using ${cpFinalText && cpFinalText.trim().length > 0 ? "updated" : "original"} result)`);
+                  }
+                } catch (cpError) {
+                  if (this.debug) {
+                    console.log(`[DEBUG] Completion prompt follow-up failed: ${cpError.message}, keeping original result`);
+                  }
+                }
+              }
               break;
             } catch (error) {
               if (!compactionAttempted && handleContextLimitError) {
@@ -84792,17 +84663,13 @@ You are working with a workspace. Available paths: ${workspaceDesc}
                   continue;
                 }
               }
-              if (completionResult) {
-                finalResult = completionResult;
-                break;
-              }
               console.error(`Error during streamText:`, error);
               finalResult = `Error: Failed to get response from AI model. ${error.message}`;
               throw new Error(finalResult);
             }
           }
-          if (currentIteration >= maxIterations && !completionAttempted) {
-            console.warn(`[WARN] Max tool iterations (${maxIterations}) reached for session ${this.sessionId}. Returning current error state.`);
+          if (currentIteration >= maxIterations) {
+            console.warn(`[WARN] Max tool iterations (${maxIterations}) reached for session ${this.sessionId}.`);
           }
           this.history = currentMessages.map((msg) => ({ ...msg }));
           if (this.history.length > MAX_HISTORY_MESSAGES) {
@@ -84825,279 +84692,17 @@ You are working with a workspace. Available paths: ${workspaceDesc}
           } catch (error) {
             console.error(`[ERROR] Failed to save messages to storage:`, error);
           }
-          if (completionAttempted && this.completionPrompt && !options._completionPromptProcessed) {
-            if (this.debug) {
-              console.log("[DEBUG] Running completion prompt as continuation of current session...");
-            }
-            try {
-              const originalResult = finalResult;
-              if (this.tracer) {
-                this.tracer.recordEvent("completion_prompt.started", {
-                  "completion_prompt.original_result_length": finalResult?.length || 0
-                });
-              }
-              const completionPromptMessage = `${this.completionPrompt}
-
-Here is the result to review:
-<result>
-${finalResult}
-</result>
-
-Double-check your response based on the criteria above. If everything looks good, respond with your previous answer exactly as-is using attempt_completion. If something needs to be fixed or is missing, do it now, then respond with the COMPLETE updated answer (everything you did in total, not just the fix) using attempt_completion.`;
-              currentMessages.push({ role: "user", content: completionPromptMessage });
-              completionResult = null;
-              completionAttempted = false;
-              const completionMaxIterations = 5;
-              const completionStreamOptions = {
-                model: this.provider ? this.provider(this.model) : this.model,
-                messages: this.prepareMessagesWithImages(currentMessages),
-                tools: tools2,
-                stopWhen: stepCountIs(completionMaxIterations),
-                maxTokens: maxResponseTokens,
-                temperature: 0.3,
-                onStepFinish: ({ toolResults, text, finishReason, usage }) => {
-                  if (usage) {
-                    this.tokenCounter.recordUsage(usage);
-                  }
-                  if (options.onStream && text) {
-                    options.onStream(text);
-                  }
-                  if (this.debug) {
-                    console.log(`[DEBUG] Completion prompt step finished (reason: ${finishReason}, tools: ${toolResults?.length || 0})`);
-                    debugLogToolResults(toolResults);
-                  }
-                }
-              };
-              const providerOpts = this._buildThinkingProviderOptions(maxResponseTokens);
-              if (providerOpts) {
-                completionStreamOptions.providerOptions = providerOpts;
-              }
-              const cpResult = await this.streamTextWithRetryAndFallback(completionStreamOptions);
-              const cpFinalText = await cpResult.text;
-              const cpUsage = await cpResult.usage;
-              if (cpUsage) {
-                this.tokenCounter.recordUsage(cpUsage, cpResult.experimental_providerMetadata);
-              }
-              const cpMessages = await cpResult.response?.messages;
-              if (cpMessages) {
-                for (const msg of cpMessages) {
-                  currentMessages.push(msg);
-                }
-              }
-              if (completionResult) {
-                finalResult = completionResult;
-                completionAttempted = true;
-              } else if (cpFinalText && cpFinalText.trim().length > 0) {
-                finalResult = cpFinalText;
-                completionAttempted = true;
-              } else {
-                finalResult = originalResult;
-                completionAttempted = true;
-                if (this.debug) {
-                  console.log("[DEBUG] Completion prompt returned empty result, keeping original.");
-                }
-              }
-              if (this.debug) {
-                console.log(`[DEBUG] Completion prompt finished. Final result length: ${finalResult?.length || 0}`);
-              }
-              if (this.tracer) {
-                this.tracer.recordEvent("completion_prompt.completed", {
-                  "completion_prompt.final_result_length": finalResult?.length || 0,
-                  "completion_prompt.used_original": finalResult === originalResult
-                });
-              }
-            } catch (error) {
-              console.error("[ERROR] Completion prompt failed:", error);
-              if (this.tracer) {
-                this.tracer.recordEvent("completion_prompt.error", {
-                  "completion_prompt.error": error.message
-                });
-              }
-            }
+          if (completionPromptInjected && this.tracer) {
+            this.tracer.recordEvent("completion_prompt.completed", {
+              "completion_prompt.final_result_length": finalResult?.length || 0,
+              "completion_prompt.used_original": preCompletionResult && finalResult === preCompletionResult
+            });
           }
-          const reachedMaxIterations = currentIteration >= maxIterations && !completionAttempted;
-          if (options.schema && !options._schemaFormatted && !completionAttempted && !reachedMaxIterations) {
-            if (this.debug) {
-              console.log("[DEBUG] Schema provided, applying automatic formatting...");
-            }
-            try {
-              const schemaPrompt = `CRITICAL: You MUST respond with ONLY valid JSON DATA that conforms to this schema structure. DO NOT return the schema definition itself.
-
-Schema to follow (this is just the structure - provide ACTUAL DATA):
-${options.schema}
-
-REQUIREMENTS:
-- Return ONLY the JSON object/array with REAL DATA that matches the schema structure
-- DO NOT return the schema definition itself (no "$schema", "$id", "type", "properties", etc.)
-- NO additional text, explanations, or markdown formatting
-- NO code blocks or backticks
-- The JSON must be parseable by JSON.parse()
-- Fill in actual values that make sense based on your previous response content
-
-EXAMPLE:
-If schema defines {type: "object", properties: {name: {type: "string"}, age: {type: "number"}}}
-Return: {"name": "John Doe", "age": 25}
-NOT: {"type": "object", "properties": {"name": {"type": "string"}}}
-
-Convert your previous response content into actual JSON data that follows this schema structure.`;
-              finalResult = await this.answer(schemaPrompt, [], {
-                ...options,
-                _schemaFormatted: true,
-                _completionPromptProcessed: true
-                // Prevent cascading completion prompts in retry calls
-              });
-              if (!this.disableMermaidValidation) {
-                try {
-                  if (this.debug) {
-                    console.log(`[DEBUG] Mermaid validation: Starting enhanced mermaid validation...`);
-                  }
-                  if (this.tracer) {
-                    this.tracer.recordMermaidValidationEvent("schema_processing_started", {
-                      "mermaid_validation.context": "schema_processing",
-                      "mermaid_validation.response_length": finalResult.length
-                    });
-                  }
-                  const mermaidValidation = await validateAndFixMermaidResponse(finalResult, {
-                    debug: this.debug,
-                    path: this.workspaceRoot || this.allowedFolders[0],
-                    provider: this.clientApiProvider,
-                    model: this.model,
-                    tracer: this.tracer
-                  });
-                  if (mermaidValidation.wasFixed) {
-                    finalResult = mermaidValidation.fixedResponse;
-                    if (this.debug) {
-                      console.log(`[DEBUG] Mermaid validation: Diagrams successfully fixed`);
-                      if (mermaidValidation.performanceMetrics) {
-                        const metrics = mermaidValidation.performanceMetrics;
-                        console.log(`[DEBUG] Mermaid validation: Performance - total: ${metrics.totalTimeMs}ms, AI fixing: ${metrics.aiFixingTimeMs}ms`);
-                        console.log(`[DEBUG] Mermaid validation: Results - ${metrics.diagramsFixed}/${metrics.diagramsProcessed} diagrams fixed`);
-                      }
-                      if (mermaidValidation.fixingResults) {
-                        mermaidValidation.fixingResults.forEach((fixResult, index) => {
-                          if (fixResult.wasFixed) {
-                            const method = fixResult.fixedWithHtmlDecoding ? "HTML entity decoding" : "AI correction";
-                            const time = fixResult.aiFixingTimeMs ? ` in ${fixResult.aiFixingTimeMs}ms` : "";
-                            console.log(`[DEBUG] Mermaid validation: Fixed diagram ${fixResult.diagramIndex + 1} with ${method}${time}`);
-                            console.log(`[DEBUG] Mermaid validation: Original error: ${fixResult.originalError}`);
-                          } else {
-                            console.log(`[DEBUG] Mermaid validation: Failed to fix diagram ${fixResult.diagramIndex + 1}: ${fixResult.fixingError}`);
-                          }
-                        });
-                      }
-                    }
-                  } else if (this.debug) {
-                    console.log(`[DEBUG] Mermaid validation: No fixes needed or fixes unsuccessful`);
-                    if (mermaidValidation.diagrams?.length > 0) {
-                      console.log(`[DEBUG] Mermaid validation: Found ${mermaidValidation.diagrams.length} diagrams, all valid: ${mermaidValidation.isValid}`);
-                    }
-                  }
-                } catch (error) {
-                  if (this.debug) {
-                    console.log(`[DEBUG] Mermaid validation: Process failed with error: ${error.message}`);
-                    console.log(`[DEBUG] Mermaid validation: Stack trace: ${error.stack}`);
-                  }
-                }
-              } else if (this.debug) {
-                console.log(`[DEBUG] Mermaid validation: Skipped due to disableMermaidValidation option`);
-              }
-              finalResult = cleanSchemaResponse(finalResult);
-              if (isJsonSchema(options.schema)) {
-                if (this.debug) {
-                  console.log(`[DEBUG] JSON validation: Starting validation process for schema response`);
-                  console.log(`[DEBUG] JSON validation: Cleaned response length: ${finalResult.length} chars`);
-                }
-                if (this.tracer) {
-                  this.tracer.recordJsonValidationEvent("started", {
-                    "json_validation.response_length": finalResult.length,
-                    "json_validation.schema_type": "JSON"
-                  });
-                }
-                let validation = validateJsonResponse(finalResult, { debug: this.debug, schema: options.schema });
-                let retryCount = 0;
-                const maxRetries = 3;
-                if (validation.isValid && isJsonSchemaDefinition(finalResult, { debug: this.debug })) {
-                  if (this.debug) {
-                    console.log(`[DEBUG] JSON validation: Response is a JSON schema definition instead of data, needs correction...`);
-                  }
-                  validation = {
-                    isValid: false,
-                    error: "Response is a JSON schema definition instead of actual data",
-                    enhancedError: "Response is a JSON schema definition instead of actual data. Please return data that conforms to the schema, not the schema itself."
-                  };
-                }
-                if (!validation.isValid) {
-                  if (this.debug) {
-                    console.log(`[DEBUG] JSON validation: Starting separate JsonFixingAgent session...`);
-                  }
-                  const { JsonFixingAgent: JsonFixingAgent2 } = await Promise.resolve().then(() => (init_schemaUtils(), schemaUtils_exports));
-                  const jsonFixer = new JsonFixingAgent2({
-                    path: this.workspaceRoot || this.allowedFolders[0],
-                    provider: this.clientApiProvider,
-                    model: this.model,
-                    debug: this.debug,
-                    tracer: this.tracer
-                  });
-                  let currentResult = finalResult;
-                  let currentValidation = validation;
-                  while (!currentValidation.isValid && retryCount < maxRetries) {
-                    if (this.debug) {
-                      console.log(`[DEBUG] JSON validation: Validation failed (attempt ${retryCount + 1}/${maxRetries}):`, currentValidation.error);
-                      console.log(`[DEBUG] JSON validation: Invalid response sample: ${currentResult.substring(0, 300)}${currentResult.length > 300 ? "..." : ""}`);
-                    }
-                    try {
-                      currentResult = await jsonFixer.fixJson(
-                        currentResult,
-                        options.schema,
-                        currentValidation,
-                        retryCount + 1
-                      );
-                      currentValidation = validateJsonResponse(currentResult, { debug: this.debug, schema: options.schema });
-                      retryCount++;
-                      if (this.debug) {
-                        if (!currentValidation.isValid && retryCount < maxRetries) {
-                          console.log(`[DEBUG] JSON validation: Still invalid after correction ${retryCount}, retrying...`);
-                          console.log(`[DEBUG] JSON validation: Corrected response sample: ${currentResult.substring(0, 300)}${currentResult.length > 300 ? "..." : ""}`);
-                        } else if (currentValidation.isValid) {
-                          console.log(`[DEBUG] JSON validation: Successfully corrected after ${retryCount} attempts with JsonFixingAgent`);
-                        }
-                      }
-                    } catch (error) {
-                      if (this.debug) {
-                        console.error(`[DEBUG] JSON validation: JsonFixingAgent error on attempt ${retryCount + 1}:`, error.message);
-                      }
-                      break;
-                    }
-                  }
-                  finalResult = currentResult;
-                  validation = currentValidation;
-                  if (!validation.isValid && this.debug) {
-                    console.log(`[DEBUG] JSON validation: Still invalid after ${maxRetries} correction attempts with JsonFixingAgent:`, validation.error);
-                    console.log(`[DEBUG] JSON validation: Final invalid response: ${finalResult.substring(0, 500)}${finalResult.length > 500 ? "..." : ""}`);
-                  } else if (validation.isValid && this.debug) {
-                    console.log(`[DEBUG] JSON validation: Final validation successful`);
-                  }
-                }
-                if (this.tracer) {
-                  this.tracer.recordJsonValidationEvent("completed", {
-                    "json_validation.success": validation.isValid,
-                    "json_validation.retry_count": retryCount,
-                    "json_validation.max_retries": maxRetries,
-                    "json_validation.final_response_length": finalResult.length,
-                    "json_validation.error": validation.isValid ? null : validation.error
-                  });
-                }
-              }
-            } catch (error) {
-              console.error("[ERROR] Schema formatting failed:", error);
-            }
-          } else if (reachedMaxIterations && options.schema && this.debug) {
-            console.log("[DEBUG] Skipping schema formatting due to max iterations reached without completion");
-          } else if (completionAttempted && options.schema && !options._schemaFormatted && !options._skipValidation) {
+          if (options.schema && !options._schemaFormatted && !options._skipValidation) {
             try {
               if (!this.disableMermaidValidation) {
                 if (this.debug) {
-                  console.log(`[DEBUG] Mermaid validation: Validating attempt_completion result BEFORE schema cleaning...`);
+                  console.log(`[DEBUG] Mermaid validation: Validating result BEFORE schema cleaning...`);
                 }
                 const mermaidValidation = await validateAndFixMermaidResponse(finalResult, {
                   debug: this.debug,
@@ -85109,55 +84714,51 @@ Convert your previous response content into actual JSON data that follows this s
                 if (mermaidValidation.wasFixed) {
                   finalResult = mermaidValidation.fixedResponse;
                   if (this.debug) {
-                    console.log(`[DEBUG] Mermaid validation: attempt_completion diagrams fixed`);
+                    console.log(`[DEBUG] Mermaid validation: Diagrams fixed`);
                     if (mermaidValidation.performanceMetrics) {
                       console.log(`[DEBUG] Mermaid validation: Fixed in ${mermaidValidation.performanceMetrics.totalTimeMs}ms`);
                     }
                   }
                 } else if (this.debug) {
-                  console.log(`[DEBUG] Mermaid validation: attempt_completion result validation completed (no fixes needed)`);
+                  console.log(`[DEBUG] Mermaid validation: Completed (no fixes needed)`);
                 }
               } else if (this.debug) {
-                console.log(`[DEBUG] Mermaid validation: Skipped for attempt_completion result due to disableMermaidValidation option`);
+                console.log(`[DEBUG] Mermaid validation: Skipped due to disableMermaidValidation option`);
               }
               finalResult = cleanSchemaResponse(finalResult);
               if (isJsonSchema(options.schema)) {
                 if (this.debug) {
-                  console.log(`[DEBUG] JSON validation: Starting validation process for attempt_completion result`);
+                  console.log(`[DEBUG] JSON validation: Starting validation process`);
                   console.log(`[DEBUG] JSON validation: Response length: ${finalResult.length} chars`);
                 }
                 if (this.tracer) {
-                  this.tracer.recordJsonValidationEvent("attempt_completion_started", {
+                  this.tracer.recordJsonValidationEvent("started", {
                     "json_validation.response_length": finalResult.length,
-                    "json_validation.schema_type": "JSON",
-                    "json_validation.context": "attempt_completion"
+                    "json_validation.schema_type": "JSON"
                   });
                 }
-                let validation = validateJsonResponse(finalResult, { debug: this.debug });
+                let validation = validateJsonResponse(finalResult, { debug: this.debug, schema: options.schema });
                 let retryCount = 0;
                 const maxRetries = 3;
                 if (validation.isValid && isJsonSchemaDefinition(finalResult, { debug: this.debug })) {
                   if (this.debug) {
-                    console.log(`[DEBUG] JSON validation: attempt_completion response is a JSON schema definition instead of data, correcting...`);
+                    console.log(`[DEBUG] JSON validation: Response is a JSON schema definition instead of data, correcting...`);
                   }
                   const schemaDefinitionPrompt = createSchemaDefinitionCorrectionPrompt(
                     finalResult,
                     options.schema,
                     0
                   );
-                  const { schema: _unusedSchema1, ...schemaDefCorrectionOptions } = options;
                   finalResult = await this.answer(schemaDefinitionPrompt, [], {
-                    ...schemaDefCorrectionOptions,
+                    ...options,
                     _schemaFormatted: true,
                     _skipValidation: true,
-                    // Skip validation in recursive correction calls to prevent loops
+                    _disableTools: true,
                     _completionPromptProcessed: true,
-                    // Prevent cascading completion prompts in retry calls
                     _maxIterationsOverride: 3
-                    // Correction should complete in 1-2 iterations (issue #447)
                   });
                   finalResult = cleanSchemaResponse(finalResult);
-                  validation = validateJsonResponse(finalResult);
+                  validation = validateJsonResponse(finalResult, { debug: this.debug, schema: options.schema });
                   retryCount = 1;
                 }
                 if (!validation.isValid) {
@@ -85167,20 +84768,16 @@ Convert your previous response content into actual JSON data that follows this s
                       console.log(`[DEBUG] JSON validation: Auto-wrapped plain text for simple schema`);
                     }
                     finalResult = autoWrapped;
-                    validation = validateJsonResponse(finalResult, { debug: this.debug });
+                    validation = validateJsonResponse(finalResult, { debug: this.debug, schema: options.schema });
                   }
                 }
                 while (!validation.isValid && retryCount < maxRetries) {
                   if (this.debug) {
-                    console.log(`[DEBUG] JSON validation: attempt_completion validation failed (attempt ${retryCount + 1}/${maxRetries}):`, validation.error);
-                    console.log(`[DEBUG] JSON validation: Invalid response sample: ${finalResult.substring(0, 300)}${finalResult.length > 300 ? "..." : ""}`);
+                    console.log(`[DEBUG] JSON validation: Validation failed (attempt ${retryCount + 1}/${maxRetries}):`, validation.error);
                   }
                   let correctionPrompt;
                   try {
                     if (isJsonSchemaDefinition(finalResult, { debug: this.debug })) {
-                      if (this.debug) {
-                        console.log(`[DEBUG] JSON validation: attempt_completion response is still a schema definition, using specialized correction`);
-                      }
                       correctionPrompt = createSchemaDefinitionCorrectionPrompt(
                         finalResult,
                         options.schema,
@@ -85202,47 +84799,43 @@ Convert your previous response content into actual JSON data that follows this s
                       retryCount
                     );
                   }
-                  const { schema: _unusedSchema2, ...correctionOptions } = options;
                   finalResult = await this.answer(correctionPrompt, [], {
-                    ...correctionOptions,
+                    ...options,
                     _schemaFormatted: true,
                     _skipValidation: true,
-                    // Skip validation in recursive correction calls to prevent loops
                     _disableTools: true,
-                    // Only allow attempt_completion - prevent AI from using search/query tools
                     _completionPromptProcessed: true,
-                    // Prevent cascading completion prompts in retry calls
                     _maxIterationsOverride: 3
-                    // Correction should complete in 1-2 iterations (issue #447)
                   });
                   finalResult = cleanSchemaResponse(finalResult);
-                  validation = validateJsonResponse(finalResult, { debug: this.debug });
+                  validation = validateJsonResponse(finalResult, { debug: this.debug, schema: options.schema });
                   retryCount++;
                   if (this.debug) {
                     if (validation.isValid) {
-                      console.log(`[DEBUG] JSON validation: attempt_completion correction successful on attempt ${retryCount}`);
+                      console.log(`[DEBUG] JSON validation: Correction successful on attempt ${retryCount}`);
                     } else {
-                      console.log(`[DEBUG] JSON validation: attempt_completion correction failed on attempt ${retryCount}: ${validation.error}`);
+                      console.log(`[DEBUG] JSON validation: Correction failed on attempt ${retryCount}: ${validation.error}`);
                     }
                   }
                 }
                 if (this.tracer) {
-                  this.tracer.recordJsonValidationEvent("attempt_completion_completed", {
+                  this.tracer.recordJsonValidationEvent("completed", {
                     "json_validation.success": validation.isValid,
                     "json_validation.retry_count": retryCount,
-                    "json_validation.final_response_length": finalResult.length
+                    "json_validation.max_retries": maxRetries,
+                    "json_validation.final_response_length": finalResult.length,
+                    "json_validation.error": validation.isValid ? null : validation.error
                   });
                 }
                 if (!validation.isValid && this.debug) {
-                  console.log(`[DEBUG] JSON validation: attempt_completion result validation failed after ${maxRetries} attempts: ${validation.error}`);
-                  console.log(`[DEBUG] JSON validation: Final attempt_completion response: ${finalResult.substring(0, 500)}${finalResult.length > 500 ? "..." : ""}`);
+                  console.log(`[DEBUG] JSON validation: Failed after ${maxRetries} attempts: ${validation.error}`);
                 } else if (validation.isValid && this.debug) {
-                  console.log(`[DEBUG] JSON validation: attempt_completion result validation successful`);
+                  console.log(`[DEBUG] JSON validation: Final validation successful`);
                 }
               }
             } catch (error) {
               if (this.debug) {
-                console.log(`[DEBUG] attempt_completion result cleanup failed: ${error.message}`);
+                console.log(`[DEBUG] Schema validation/cleanup failed: ${error.message}`);
               }
             }
           }
@@ -86418,7 +86011,9 @@ function parseArgs() {
     disableDefaultBashAllow: false,
     disableDefaultBashDeny: false,
     // Native thinking/reasoning effort
-    thinkingEffort: null
+    thinkingEffort: null,
+    // Completion prompt for post-completion validation/review
+    completionPrompt: null
   };
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -86452,6 +86047,8 @@ function parseArgs() {
       config.architectureFileName = args[++i];
     } else if (arg === "--schema" && i + 1 < args.length) {
       config.schema = args[++i];
+    } else if (arg === "--completion-prompt" && i + 1 < args.length) {
+      config.completionPrompt = args[++i];
     } else if (arg === "--provider" && i + 1 < args.length) {
       config.provider = args[++i];
     } else if (arg === "--model" && i + 1 < args.length) {
@@ -86538,6 +86135,7 @@ Options:
   --system-prompt <text|file>      Custom system prompt (text or file path)
   --architecture-file <name>       Architecture context filename in repo root (defaults to AGENTS.md with CLAUDE.md fallback; ARCHITECTURE.md is always included when present)
   --schema <schema|file>           Output schema (JSON, XML, any format - text or file path)
+  --completion-prompt <text>       Post-completion review prompt (validates/enriches the answer)
   --provider <name>                Force AI provider: anthropic, openai, google
   --model <name>                   Override model name
   --allow-edit                     Enable code modification capabilities (edit + create tools)
@@ -87040,7 +86638,8 @@ async function main() {
       enableTasks: config.enableTasks,
       thinkingEffort: config.thinkingEffort,
       searchDelegateProvider: config.searchDelegateProvider,
-      searchDelegateModel: config.searchDelegateModel
+      searchDelegateModel: config.searchDelegateModel,
+      completionPrompt: config.completionPrompt
     };
     const agent = new ProbeAgent(agentConfig2);
     await agent.initialize();