@probelabs/visor 0.1.38 → 0.1.40

package/dist/index.js

@@ -93923,9 +93923,6 @@ class AIReviewService {
                                 category: 'logic',
                             },
                         ],
-                        suggestions: [
-                            'Configure API keys in your GitHub repository secrets or environment variables',
-                        ],
                         debug: debugInfo,
                     };
                 }
@@ -93962,7 +93959,6 @@ class AIReviewService {
                             category: 'logic',
                         },
                     ],
-                    suggestions: ['Check AI service configuration and API key validity'],
                     debug: debugInfo,
                 };
             }
@@ -94034,9 +94030,6 @@ class AIReviewService {
                             category: 'logic',
                         },
                     ],
-                    suggestions: [
-                        'Check session reuse configuration and ensure parent check completed successfully',
-                    ],
                     debug: debugInfo,
                 };
             }
@@ -94577,23 +94570,18 @@ ${prInfo.fullDiff ? this.escapeXml(prInfo.fullDiff) : ''}
             // Handle plain schema or no schema - no JSON parsing, return response as-is
             if (_schema === 'plain' || !_schema) {
                 log(`📋 ${_schema === 'plain' ? 'Plain' : 'No'} schema detected - returning raw response without JSON parsing`);
-                // Strip common XML wrapper tags that AI might add when given XML-formatted prompts
-                let cleanedResponse = response.trim();
-                // Remove <result>...</result> tags if present
-                cleanedResponse = cleanedResponse
-                    .replace(/^<result>\s*/i, '')
-                    .replace(/\s*<\/result>$/i, '');
-                // Remove <response>...</response> tags if present
-                cleanedResponse = cleanedResponse
-                    .replace(/^<response>\s*/i, '')
-                    .replace(/\s*<\/response>$/i, '');
-                // Remove <answer>...</answer> tags if present
-                cleanedResponse = cleanedResponse
-                    .replace(/^<answer>\s*/i, '')
-                    .replace(/\s*<\/answer>$/i, '');
+                // For plain schema, return the raw response as an issue
                 return {
-                    issues: [],
-                    suggestions: [cleanedResponse.trim()],
+                    issues: [
+                        {
+                            file: 'AI_RESPONSE',
+                            line: 1,
+                            ruleId: 'ai/raw_response',
+                            message: response,
+                            severity: 'info',
+                            category: 'documentation',
+                        },
+                    ],
                     debug: debugInfo,
                 };
             }
@@ -94615,9 +94603,6 @@ ${prInfo.fullDiff ? this.escapeXml(prInfo.fullDiff) : ''}
                         console.error('🚫 AI refused to analyze - returning empty result');
                         return {
                             issues: [],
-                            suggestions: [
-                                'AI was unable to analyze this code. Please check the content or try again.',
-                            ],
                         };
                     }
                     // Try to extract JSON using improved method with proper bracket matching
@@ -94634,24 +94619,33 @@ ${prInfo.fullDiff ? this.escapeXml(prInfo.fullDiff) : ''}
                             // Check if response is plain text and doesn't contain structured data
                             if (!response.includes('{') && !response.includes('}')) {
                                 log('🔧 Plain text response detected, creating structured fallback...');
-                                const isNoChanges = response.toLowerCase().includes('no') &&
-                                    (response.toLowerCase().includes('changes') ||
-                                        response.toLowerCase().includes('code'));
                                 reviewData = {
-                                    issues: [],
-                                    suggestions: isNoChanges
-                                        ? ['No code changes detected in this analysis']
-                                        : [
-                                            `AI response: ${response.substring(0, 200)}${response.length > 200 ? '...' : ''}`,
-                                        ],
+                                    issues: [
+                                        {
+                                            file: 'AI_RESPONSE',
+                                            line: 1,
+                                            ruleId: 'ai/raw_response',
+                                            message: response,
+                                            severity: 'info',
+                                            category: 'documentation',
+                                        },
+                                    ],
                                 };
                             }
                             else {
-                                // Fallback: treat the entire response as a suggestion
+                                // Fallback: treat the entire response as an issue
                                 log('🔧 Creating fallback response from non-JSON content...');
                                 reviewData = {
-                                    issues: [],
-                                    suggestions: [response.trim()],
+                                    issues: [
+                                        {
+                                            file: 'AI_RESPONSE',
+                                            line: 1,
+                                            ruleId: 'ai/raw_response',
+                                            message: response,
+                                            severity: 'info',
+                                            category: 'documentation',
+                                        },
+                                    ],
                                 };
                             }
                         }
@@ -94660,8 +94654,16 @@ ${prInfo.fullDiff ? this.escapeXml(prInfo.fullDiff) : ''}
                         // No JSON found at all - treat as plain text response
                         log('🔧 No JSON found in response, treating as plain text...');
                         reviewData = {
-                            issues: [],
-                            suggestions: [response.trim()],
+                            issues: [
+                                {
+                                    file: 'AI_RESPONSE',
+                                    line: 1,
+                                    ruleId: 'ai/raw_response',
+                                    message: response,
+                                    severity: 'info',
+                                    category: 'documentation',
+                                },
+                            ],
                         };
                     }
                 }
@@ -94671,7 +94673,6 @@ ${prInfo.fullDiff ? this.escapeXml(prInfo.fullDiff) : ''}
             log(`📊 Overall score: ${0}`);
             log(`📋 Total issues: ${reviewData.issues?.length || 0}`);
             log(`🚨 Critical issues: ${reviewData.issues?.filter((i) => i.severity === 'critical').length || 0}`);
-            log(`💡 Suggestions count: ${Array.isArray(reviewData.suggestions) ? reviewData.suggestions.length : 0}`);
             log(`💬 Comments count: ${Array.isArray(reviewData.issues) ? reviewData.issues.length : 0}`);
             // Process issues from the simplified format
             const processedIssues = Array.isArray(reviewData.issues)
@@ -94693,7 +94694,6 @@ ${prInfo.fullDiff ? this.escapeXml(prInfo.fullDiff) : ''}
             // Validate and convert to ReviewSummary format
             const result = {
                 issues: processedIssues,
-                suggestions: Array.isArray(reviewData.suggestions) ? reviewData.suggestions : [],
             };
             // Log issue counts
             const criticalCount = (result.issues || []).filter(i => i.severity === 'critical').length;
@@ -95395,12 +95395,9 @@ class CheckExecutionEngine {
                 continue;
             // Extract issues for this check
             const checkIssues = (reviewSummary.issues || []).filter(issue => issue.ruleId?.startsWith(`${checkName}/`));
-            // Extract suggestions for this check
-            const checkSuggestions = (reviewSummary.suggestions || []).filter(suggestion => suggestion.startsWith(`[${checkName}]`));
             // Create a mini ReviewSummary for this check
             const checkSummary = {
                 issues: checkIssues,
-                suggestions: checkSuggestions,
                 debug: reviewSummary.debug,
             };
             // Render content for this check
@@ -95514,12 +95511,7 @@ class CheckExecutionEngine {
         }
         else if (schema === 'plain') {
             // Plain schema - return raw content directly
-            // Strip [checkName] prefixes from suggestions before joining
-            const cleanedSuggestions = (reviewSummary.suggestions || []).map(suggestion => {
-                // Remove [checkName] prefix if present
-                return suggestion.replace(/^\[[^\]]+\]\s*/, '');
-            });
-            return (reviewSummary.issues?.[0]?.message || '') + (cleanedSuggestions.join('\n\n') || '');
+            return reviewSummary.issues?.[0]?.message || '';
         }
         else {
             // Use built-in schema template
@@ -95534,7 +95526,6 @@ class CheckExecutionEngine {
         const templateData = {
             issues: reviewSummary.issues || [],
             checkName: checkName,
-            suggestions: reviewSummary.suggestions || [],
         };
         const rendered = await liquid.parseAndRender(templateContent, templateData);
         return rendered.trim();
@@ -95597,7 +95588,6 @@ class CheckExecutionEngine {
                         category: 'logic',
                     },
                 ],
-                suggestions: [],
             };
         }
         // Build dependency graph
@@ -95614,7 +95604,6 @@ class CheckExecutionEngine {
                         category: 'logic',
                     },
                 ],
-                suggestions: [],
             };
         }
         // Log execution plan
@@ -95623,8 +95612,7 @@ class CheckExecutionEngine {
         // Execute checks level by level
         const results = new Map();
         const sessionRegistry = (__nccwpck_require__(46059).SessionRegistry).getInstance();
-        const provider = this.providerRegistry.getProviderOrThrow('ai');
-        this.setProviderWebhookContext(provider);
+        // Note: We'll get the provider dynamically per check, not a single one for all
         const sessionIds = new Map(); // checkName -> sessionId
         let shouldStopExecution = false;
         for (let levelIndex = 0; levelIndex < dependencyGraph.executionOrder.length && !shouldStopExecution; levelIndex++) {
@@ -95668,20 +95656,28 @@ class CheckExecutionEngine {
                                 error: null,
                                 result: {
                                     issues: [],
-                                    suggestions: [`Check '${checkName}' was skipped - condition not met`],
                                 },
                             };
                         }
                     }
+                    // Get the appropriate provider for this check type
+                    const providerType = checkConfig.type || 'ai';
+                    const provider = this.providerRegistry.getProviderOrThrow(providerType);
+                    this.setProviderWebhookContext(provider);
                     // Create provider config for this specific check
                     const providerConfig = {
-                        type: 'ai',
+                        type: providerType,
                         prompt: checkConfig.prompt,
+                        exec: checkConfig.exec,
                         focus: checkConfig.focus || this.mapCheckNameToFocus(checkName),
                         schema: checkConfig.schema,
                         group: checkConfig.group,
                         checkName: checkName, // Add checkName for sessionID
                         eventContext: prInfo.eventContext, // Pass event context for templates
+                        transform: checkConfig.transform,
+                        level: checkConfig.level,
+                        message: checkConfig.message,
+                        env: checkConfig.env,
                         ai: {
                             timeout: timeout || 600000,
                             debug: debug,
@@ -95690,9 +95686,19 @@ class CheckExecutionEngine {
                     };
                     // Pass results from dependencies if needed
                     const dependencyResults = new Map();
+                    let isForEachDependent = false;
+                    let forEachItems = [];
+                    let forEachParentName;
                     for (const depId of checkConfig.depends_on || []) {
                         if (results.has(depId)) {
-                            dependencyResults.set(depId, results.get(depId));
+                            const depResult = results.get(depId);
+                            dependencyResults.set(depId, depResult);
+                            // Check if this dependency has forEach enabled
+                            if (depResult.isForEach && depResult.forEachItems) {
+                                isForEachDependent = true;
+                                forEachItems = depResult.forEachItems;
+                                forEachParentName = depId;
+                            }
                         }
                     }
                     // Determine if we should use session reuse
@@ -95721,10 +95727,54 @@ class CheckExecutionEngine {
                         // Add session ID to provider config
                         providerConfig.sessionId = currentSessionId;
                     }
-                    const result = await provider.execute(prInfo, providerConfig, dependencyResults, sessionInfo);
-                    log(`🔧 Debug: Completed check: ${checkName}, issues found: ${(result.issues || []).length}`);
+                    // Handle forEach dependent execution
+                    let finalResult;
+                    if (isForEachDependent && forEachParentName) {
+                        log(`🔄 Debug: Check "${checkName}" depends on forEach check "${forEachParentName}", executing ${forEachItems.length} times`);
+                        const allIssues = [];
+                        const allOutputs = [];
+                        // Execute check for each item in the forEach array
+                        for (let itemIndex = 0; itemIndex < forEachItems.length; itemIndex++) {
+                            const item = forEachItems[itemIndex];
+                            // Create modified dependency results with current item
+                            const forEachDependencyResults = new Map();
+                            for (const [depName, depResult] of dependencyResults) {
+                                if (depName === forEachParentName) {
+                                    // Replace the forEach parent's output with the current item
+                                    const modifiedResult = {
+                                        ...depResult,
+                                        output: item,
+                                    };
+                                    forEachDependencyResults.set(depName, modifiedResult);
+                                }
+                                else {
+                                    forEachDependencyResults.set(depName, depResult);
+                                }
+                            }
+                            log(`🔄 Debug: Executing check "${checkName}" for item ${itemIndex + 1}/${forEachItems.length}`);
+                            const itemResult = await provider.execute(prInfo, providerConfig, forEachDependencyResults, sessionInfo);
+                            // Collect issues from each iteration
+                            if (itemResult.issues) {
+                                allIssues.push(...itemResult.issues);
+                            }
+                            // Collect outputs from each iteration
+                            if (itemResult.output) {
+                                allOutputs.push(itemResult.output);
+                            }
+                        }
+                        finalResult = {
+                            issues: allIssues,
+                            output: allOutputs.length > 0 ? allOutputs : undefined,
+                        };
+                        log(`🔄 Debug: Completed forEach execution for check "${checkName}", total issues: ${allIssues.length}`);
+                    }
+                    else {
+                        // Normal single execution
+                        finalResult = await provider.execute(prInfo, providerConfig, dependencyResults, sessionInfo);
+                        log(`🔧 Debug: Completed check: ${checkName}, issues found: ${(finalResult.issues || []).length}`);
+                    }
                     // Add group, schema, template info and timestamp to issues from config
-                    const enrichedIssues = (result.issues || []).map(issue => ({
+                    const enrichedIssues = (finalResult.issues || []).map(issue => ({
                         ...issue,
                         ruleId: `${checkName}/${issue.ruleId}`,
                         group: checkConfig.group,
@@ -95733,7 +95783,7 @@ class CheckExecutionEngine {
                         timestamp: Date.now(),
                     }));
                     const enrichedResult = {
-                        ...result,
+                        ...finalResult,
                         issues: enrichedIssues,
                     };
                     return {
@@ -95758,8 +95808,34 @@ class CheckExecutionEngine {
             for (let i = 0; i < levelResults.length; i++) {
                 const checkName = executionGroup.parallel[i];
                 const result = levelResults[i];
+                const checkConfig = config.checks[checkName];
                 if (result.status === 'fulfilled' && result.value.result && !result.value.error) {
-                    results.set(checkName, result.value.result);
+                    const reviewResult = result.value.result;
+                    // Handle forEach logic - process array outputs
+                    if (checkConfig?.forEach && reviewResult.output) {
+                        let outputArray = reviewResult.output;
+                        // Ensure output is an array
+                        if (!Array.isArray(outputArray)) {
+                            // Try to parse as JSON if it's a string
+                            if (typeof outputArray === 'string') {
+                                try {
+                                    const parsed = JSON.parse(outputArray);
+                                    outputArray = Array.isArray(parsed) ? parsed : [parsed];
+                                }
+                                catch {
+                                    outputArray = [outputArray];
+                                }
+                            }
+                            else {
+                                outputArray = [outputArray];
+                            }
+                        }
+                        log(`🔄 Debug: Check "${checkName}" has forEach enabled, processing ${outputArray.length} items`);
+                        // Store the array for iteration by dependent checks
+                        reviewResult.forEachItems = outputArray;
+                        reviewResult.isForEach = true;
+                    }
+                    results.set(checkName, reviewResult);
                 }
                 else {
                     // Store error result for dependency tracking
@@ -95781,7 +95857,6 @@ class CheckExecutionEngine {
                                 replacement: undefined,
                             },
                         ],
-                        suggestions: [],
                     };
                     results.set(checkName, errorSummary);
                     // Check if we should stop execution due to fail-fast
@@ -95879,7 +95954,6 @@ class CheckExecutionEngine {
                             error: null,
                             result: {
                                 issues: [],
-                                suggestions: [`Check '${checkName}' was skipped - condition not met`],
                             },
                         };
                     }
@@ -96001,7 +96075,6 @@ class CheckExecutionEngine {
      */
     aggregateDependencyAwareResults(results, dependencyGraph, debug, stoppedEarly) {
         const aggregatedIssues = [];
-        const aggregatedSuggestions = [];
         const debugInfo = [];
         // Add execution plan info
         const stats = dependency_resolver_1.DependencyResolver.getExecutionStats(dependencyGraph);
@@ -96035,13 +96108,8 @@ class CheckExecutionEngine {
                 }
                 // Issues are already prefixed and enriched with group/schema info
                 aggregatedIssues.push(...(result.issues || []));
-                // Add suggestions with check name prefix
-                const prefixedSuggestions = (result.suggestions || []).map(suggestion => `[${checkName}] ${suggestion}`);
-                aggregatedSuggestions.push(...prefixedSuggestions);
             }
         }
-        // Add summary information
-        aggregatedSuggestions.unshift(...debugInfo);
         console.error(`🔧 Debug: Aggregated ${aggregatedIssues.length} issues from ${results.size} dependency-aware checks`);
         // Apply issue suppression filtering
         const suppressionEnabled = this.config?.output?.suppressionEnabled !== false;
@@ -96086,25 +96154,20 @@ class CheckExecutionEngine {
         }
         return {
             issues: filteredIssues,
-            suggestions: aggregatedSuggestions,
             debug: aggregatedDebug,
         };
     }
     /**
      * Aggregate results from parallel check execution (legacy method)
      */
-    aggregateParallelResults(results, checkNames, debug, stoppedEarly) {
+    aggregateParallelResults(results, checkNames, debug, _stoppedEarly) {
         const aggregatedIssues = [];
-        const aggregatedSuggestions = [];
         const debugInfo = [];
-        let successfulChecks = 0;
-        let failedChecks = 0;
         results.forEach((result, index) => {
             const checkName = checkNames[index];
             if (result.status === 'fulfilled') {
                 const checkResult = result.value;
                 if (checkResult.error) {
-                    failedChecks++;
                     const log = console.error;
                     log(`🔧 Debug: Check ${checkName} failed: ${checkResult.error}`);
                     debugInfo.push(`❌ Check "${checkName}" failed: ${checkResult.error}`);
@@ -96130,18 +96193,13 @@ class CheckExecutionEngine {
                     });
                 }
                 else if (checkResult.result) {
-                    successfulChecks++;
                     console.error(`🔧 Debug: Check ${checkName} succeeded with ${(checkResult.result.issues || []).length} issues`);
                     debugInfo.push(`✅ Check "${checkName}" completed: ${(checkResult.result.issues || []).length} issues found`);
                     // Issues are already prefixed and enriched with group/schema info
                     aggregatedIssues.push(...(checkResult.result.issues || []));
-                    // Add suggestions with check name prefix
-                    const prefixedSuggestions = (checkResult.result.suggestions || []).map(suggestion => `[${checkName}] ${suggestion}`);
-                    aggregatedSuggestions.push(...prefixedSuggestions);
                 }
             }
             else {
-                failedChecks++;
                 const errorMessage = result.reason instanceof Error ? result.reason.message : String(result.reason);
                 const log = console.error;
                 log(`🔧 Debug: Check ${checkName} promise rejected: ${errorMessage}`);
@@ -96167,11 +96225,6 @@ class CheckExecutionEngine {
                 });
             }
         });
-        // Add summary information
-        debugInfo.unshift(stoppedEarly
-            ? `🛑 Parallel execution stopped early (fail-fast): ${successfulChecks} successful, ${failedChecks} failed`
-            : `🔍 Parallel execution completed: ${successfulChecks} successful, ${failedChecks} failed`);
-        aggregatedSuggestions.unshift(...debugInfo);
         console.error(`🔧 Debug: Aggregated ${aggregatedIssues.length} issues from ${results.length} checks`);
         // Apply issue suppression filtering
         const suppressionEnabled = this.config?.output?.suppressionEnabled !== false;
@@ -96273,7 +96326,6 @@ class CheckExecutionEngine {
         }
         return {
             issues: filteredIssues,
-            suggestions: aggregatedSuggestions,
             debug: aggregatedDebug,
         };
     }
@@ -96384,7 +96436,6 @@ class CheckExecutionEngine {
                         replacement: undefined,
                     },
                 ],
-                suggestions: [`Error: ${errorMessage}`],
             },
             executionTime,
             timestamp,
@@ -96599,7 +96650,7 @@ class CheckExecutionEngine {
             try {
                 const checkIssues = issuesByCheck.get(checkName) || [];
                 // Evaluate failure conditions for this specific check
-                const failureResults = await this.evaluateFailureConditions(checkName, { issues: checkIssues, suggestions: [] }, options.config);
+                const failureResults = await this.evaluateFailureConditions(checkName, { issues: checkIssues }, options.config);
                 await this.githubCheckService.completeCheckRun(options.githubChecks.owner, options.githubChecks.repo, checkRun.id, checkName, failureResults, checkIssues);
                 console.log(`✅ Completed ${checkName} check with ${checkIssues.length} issues`);
             }
@@ -96875,7 +96926,6 @@ async function main() {
                     issues: Object.values(groupedResults)
                         .flatMap((r) => r.map((check) => check.issues || []).flat())
                         .flat(),
-                    suggestions: [],
                 },
                 executionTime: 0,
                 timestamp: new Date().toISOString(),
@@ -96891,7 +96941,6 @@ async function main() {
                     issues: Object.values(groupedResults)
                         .flatMap((r) => r.map((check) => check.issues || []).flat())
                         .flat(),
-                    suggestions: [], // Suggestions are now embedded in issues
                 },
                 executionTime: 0,
                 timestamp: new Date().toISOString(),
@@ -96907,7 +96956,6 @@ async function main() {
                     issues: Object.values(groupedResults)
                         .flatMap((r) => r.map((check) => check.issues || []).flat())
                         .flat(),
-                    suggestions: [], // Suggestions are now embedded in issues
                 },
                 executionTime: 0,
                 timestamp: new Date().toISOString(),
@@ -97355,7 +97403,7 @@ class ConfigManager {
     validCheckTypes = [
         'ai',
         'claude-code',
-        'tool',
+        'command',
         'http',
         'http_input',
         'http_client',
@@ -97701,11 +97749,11 @@ class ConfigManager {
                 message: `Invalid check configuration for "${checkName}": missing prompt (required for AI checks)`,
             });
         }
-        // Tool checks require exec field
-        if (checkConfig.type === 'tool' && !checkConfig.exec) {
+        // Command checks require exec field
+        if (checkConfig.type === 'command' && !checkConfig.exec) {
             errors.push({
                 field: `checks.${checkName}.exec`,
-                message: `Invalid check configuration for "${checkName}": missing exec field (required for tool checks)`,
+                message: `Invalid check configuration for "${checkName}": missing exec field (required for command checks)`,
             });
         }
         // HTTP output checks require url and body fields
@@ -98331,7 +98379,6 @@ class FailureConditionEvaluator {
             // Required output property (empty for if conditions)
             output: {
                 issues: [],
-                suggestions: [],
             },
             // Utility metadata
             metadata: {
@@ -98473,7 +98520,7 @@ class FailureConditionEvaluator {
             // Extract context variables
             const output = context.output || {};
             const issues = output.issues || [];
-            const suggestions = output.suggestions || [];
+            const suggestions = [];
             // Backward compatibility: provide metadata for transition period
             // TODO: Remove after all configurations are updated
             const metadata = context.metadata || {
@@ -98584,7 +98631,7 @@ class FailureConditionEvaluator {
      * Build the evaluation context for expressions
      */
     buildEvaluationContext(checkName, checkSchema, checkGroup, reviewSummary, previousOutputs) {
-        const { issues, suggestions, debug } = reviewSummary;
+        const { issues, debug } = reviewSummary;
         const context = {
             output: {
                 issues: (issues || []).map(issue => ({
@@ -98600,7 +98647,6 @@ class FailureConditionEvaluator {
                     suggestion: issue.suggestion,
                     replacement: issue.replacement,
                 })),
-                suggestions,
                 // Include additional schema-specific data from reviewSummary
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 ...reviewSummary, // Pass through any additional fields
@@ -100743,7 +100789,6 @@ async function completeIndividualChecks(checkService, owner, repo, checkRunMap,
             // Create a ReviewSummary for this check's issues
             const checkReviewSummary = {
                 issues: checkIssues,
-                suggestions: [],
             };
             // Determine which fail_if to use: check-specific overrides global
             const effectiveFailIf = checkFailIf || globalFailIf;
@@ -100791,7 +100836,6 @@ async function completeCombinedCheck(checkService, owner, repo, checkRunMap, gro
         // Create a combined ReviewSummary with all issues
         const combinedReviewSummary = {
             issues: allIssues,
-            suggestions: [],
         };
         // Evaluate global fail_if for the combined check
         const globalFailIf = config?.fail_if;
@@ -101137,22 +101181,6 @@ class OutputFormatters {
         else {
             output += 'No issues found!\n\n';
         }
-        // Suggestions table
-        if ((result.reviewSummary.suggestions || []).length > 0) {
-            const suggestionsTable = new cli_table3_1.default({
-                head: ['#', 'Suggestion'],
-                colWidths: [5, 70],
-                style: {
-                    head: ['cyan', 'bold'],
-                    border: ['grey'],
-                },
-            });
-            output += 'Suggestions\n';
-            (result.reviewSummary.suggestions || []).forEach((suggestion, index) => {
-                suggestionsTable.push([(index + 1).toString(), this.wrapText(suggestion, 65)]);
-            });
-            output += suggestionsTable.toString() + '\n\n';
-        }
         // Files table (if requested)
         if (options.includeFiles && result.repositoryInfo.files.length > 0) {
             const filesTable = new cli_table3_1.default({
@@ -101210,7 +101238,6 @@ class OutputFormatters {
             issues: options.groupByCategory
                 ? this.groupCommentsByCategory((0, reviewer_1.convertIssuesToComments)(issues || []))
                 : issues || [],
-            suggestions: result.reviewSummary.suggestions || [],
             files: options.includeFiles ? result.repositoryInfo.files : undefined,
             debug: result.debug, // Include debug information when available
             failureConditions: result.failureConditions || [], // Include failure condition results
@@ -101507,14 +101534,6 @@ class OutputFormatters {
             output += `## No Issues Found\n\n`;
             output += `Great job! No issues were detected in the analyzed code.\n\n`;
         }
-        // Suggestions
-        if ((result.reviewSummary.suggestions || []).length > 0) {
-            output += `## Recommendations\n\n`;
-            (result.reviewSummary.suggestions || []).forEach((suggestion, index) => {
-                output += `${index + 1}. ${suggestion}\n`;
-            });
-            output += '\n';
-        }
         // Files (if requested)
         if (options.includeFiles && result.repositoryInfo.files.length > 0) {
             output += `## Files Changed\n\n`;
@@ -102196,9 +102215,8 @@ class AICheckProvider extends check_provider_interface_1.CheckProvider {
                         styleIssues: result.issues?.filter(i => i.category === 'style') || [],
                         logicIssues: result.issues?.filter(i => i.category === 'logic') || [],
                         documentationIssues: result.issues?.filter(i => i.category === 'documentation') || [],
-                        // All issues and suggestions
+                        // All issues
                         issues: result.issues || [],
-                        suggestions: result.suggestions || [],
                         // Debug information if available
                         debug: result.debug,
                         // Raw data for advanced use
@@ -102437,13 +102455,13 @@ exports.AICheckProvider = AICheckProvider;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.CheckProviderRegistry = void 0;
 const ai_check_provider_1 = __nccwpck_require__(98901);
-const tool_check_provider_1 = __nccwpck_require__(70477);
 const http_check_provider_1 = __nccwpck_require__(31115);
 const http_input_provider_1 = __nccwpck_require__(74423);
 const http_client_provider_1 = __nccwpck_require__(36270);
 const noop_check_provider_1 = __nccwpck_require__(53003);
 const log_check_provider_1 = __nccwpck_require__(24903);
 const claude_code_check_provider_1 = __nccwpck_require__(17985);
+const command_check_provider_1 = __nccwpck_require__(11878);
 /**
  * Registry for managing check providers
  */
@@ -102469,7 +102487,7 @@ class CheckProviderRegistry {
     registerDefaultProviders() {
         // Register all built-in providers
         this.register(new ai_check_provider_1.AICheckProvider());
-        this.register(new tool_check_provider_1.ToolCheckProvider());
+        this.register(new command_check_provider_1.CommandCheckProvider());
         this.register(new http_check_provider_1.HttpCheckProvider());
         this.register(new http_input_provider_1.HttpInputProvider());
         this.register(new http_client_provider_1.HttpClientProvider());
@@ -103008,7 +103026,6 @@ class ClaudeCodeCheckProvider extends check_provider_interface_1.CheckProvider {
                         documentationIssues: result.issues?.filter(i => i.category === 'documentation') || [],
                         // All issues and suggestions
                         issues: result.issues || [],
-                        suggestions: result.suggestions || [],
                         // Debug information if available
                         debug: result.debug,
                         // Raw data for advanced use
@@ -103034,14 +103051,12 @@ class ClaudeCodeCheckProvider extends check_provider_interface_1.CheckProvider {
             // Convert to ReviewSummary format
             return {
                 issues: parsed.issues || [],
-                suggestions: parsed.suggestions || [],
             };
         }
         catch {
             // If not JSON, treat as plain text comment
             return {
                 issues: [],
-                suggestions: [],
             };
         }
     }
@@ -103256,6 +103271,244 @@ async function safeImport(moduleName) {
 }
 
 
+/***/ }),
+
+/***/ 11878:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.CommandCheckProvider = void 0;
+const check_provider_interface_1 = __nccwpck_require__(14131);
+const liquidjs_1 = __nccwpck_require__(48694);
+/**
+ * Check provider that executes shell commands and captures their output
+ * Supports JSON parsing and integration with forEach functionality
+ */
+class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
+    liquid;
+    constructor() {
+        super();
+        this.liquid = new liquidjs_1.Liquid({
+            cache: false,
+            strictFilters: false,
+            strictVariables: false,
+        });
+    }
+    getName() {
+        return 'command';
+    }
+    getDescription() {
+        return 'Execute shell commands and capture output for processing';
+    }
+    async validateConfig(config) {
+        if (!config || typeof config !== 'object') {
+            return false;
+        }
+        const cfg = config;
+        // Must have exec specified
+        if (!cfg.exec || typeof cfg.exec !== 'string') {
+            return false;
+        }
+        return true;
+    }
+    async execute(prInfo, config, dependencyResults) {
+        const command = config.exec;
+        const transform = config.transform;
+        // Prepare template context for Liquid rendering
+        const templateContext = {
+            pr: {
+                number: prInfo.number,
+                title: prInfo.title,
+                author: prInfo.author,
+                branch: prInfo.head,
+                base: prInfo.base,
+            },
+            files: prInfo.files,
+            fileCount: prInfo.files.length,
+            outputs: this.buildOutputContext(dependencyResults),
+            env: this.getSafeEnvironmentVariables(),
+        };
+        try {
+            // Render the command with Liquid templates if needed
+            let renderedCommand = command;
+            if (command.includes('{{') || command.includes('{%')) {
+                renderedCommand = await this.liquid.parseAndRender(command, templateContext);
+            }
+            // Prepare environment variables - convert all to strings
+            const scriptEnv = {};
+            for (const [key, value] of Object.entries(process.env)) {
+                if (value !== undefined) {
+                    scriptEnv[key] = value;
+                }
+            }
+            if (config.env) {
+                for (const [key, value] of Object.entries(config.env)) {
+                    if (value !== undefined && value !== null) {
+                        scriptEnv[key] = String(value);
+                    }
+                }
+            }
+            // Execute the script using dynamic import to avoid Jest issues
+            const { exec } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(35317)));
+            const { promisify } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(39023)));
+            const execAsync = promisify(exec);
+            const { stdout, stderr } = await execAsync(renderedCommand, {
+                env: scriptEnv,
+                timeout: 60000, // 60 second timeout
+                maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+            });
+            if (stderr && process.env.DEBUG) {
+                console.error(`Command stderr: ${stderr}`);
+            }
+            // Try to parse output as JSON
+            let output = stdout.trim();
+            try {
+                // Attempt to parse as JSON
+                const parsed = JSON.parse(stdout.trim());
+                output = parsed;
+            }
+            catch {
+                // If not JSON, keep as string
+                output = stdout.trim();
+            }
+            // Apply transform if specified
+            let finalOutput = output;
+            if (transform) {
+                try {
+                    const transformContext = {
+                        ...templateContext,
+                        output,
+                    };
+                    const rendered = await this.liquid.parseAndRender(transform, transformContext);
+                    // Try to parse the transformed result as JSON
+                    try {
+                        finalOutput = JSON.parse(rendered.trim());
+                    }
+                    catch {
+                        finalOutput = rendered.trim();
+                    }
+                }
+                catch (error) {
+                    return {
+                        issues: [
+                            {
+                                file: 'command',
+                                line: 0,
+                                ruleId: 'command/transform_error',
+                                message: `Failed to apply transform: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                                severity: 'error',
+                                category: 'logic',
+                            },
+                        ],
+                    };
+                }
+            }
+            // Return the output as part of the review summary
+            // The output will be available to dependent checks
+            return {
+                issues: [],
+                output: finalOutput,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                issues: [
+                    {
+                        file: 'command',
+                        line: 0,
+                        ruleId: 'command/execution_error',
+                        message: `Command execution failed: ${errorMessage}`,
+                        severity: 'error',
+                        category: 'logic',
+                    },
+                ],
+            };
+        }
+    }
+    buildOutputContext(dependencyResults) {
+        if (!dependencyResults) {
+            return {};
+        }
+        const outputs = {};
+        for (const [checkName, result] of dependencyResults) {
+            if (result.output !== undefined) {
+                outputs[checkName] = result.output;
+            }
+            else {
+                outputs[checkName] = {
+                    issueCount: result.issues?.length || 0,
+                    issues: result.issues || [],
+                };
+            }
+        }
+        return outputs;
+    }
+    getSafeEnvironmentVariables() {
+        const safeVars = {};
+        const allowedPrefixes = ['CI_', 'GITHUB_', 'RUNNER_', 'NODE_', 'npm_', 'PATH', 'HOME', 'USER'];
+        for (const [key, value] of Object.entries(process.env)) {
+            if (value !== undefined && allowedPrefixes.some(prefix => key.startsWith(prefix))) {
+                safeVars[key] = value;
+            }
+        }
+        // Add current working directory
+        safeVars['PWD'] = process.cwd();
+        return safeVars;
+    }
+    getSupportedConfigKeys() {
+        return ['type', 'exec', 'transform', 'env', 'depends_on', 'on', 'if', 'group', 'forEach'];
+    }
+    async isAvailable() {
+        // Command provider is always available as long as we can execute commands
+        return true;
+    }
+    getRequirements() {
+        return [
+            'Valid shell command to execute',
+            'Shell environment available',
+            'Optional: Transform template for processing output',
+        ];
+    }
+}
+exports.CommandCheckProvider = CommandCheckProvider;
+
+
 /***/ }),
 
 /***/ 31115:
@@ -103422,7 +103675,6 @@ class HttpCheckProvider extends check_provider_interface_1.CheckProvider {
             : [];
         return {
             issues,
-            suggestions: Array.isArray(response.suggestions) ? response.suggestions : [],
         };
     }
     createErrorResult(url, error) {
@@ -103441,7 +103693,6 @@ class HttpCheckProvider extends check_provider_interface_1.CheckProvider {
                     replacement: undefined,
                 },
             ],
-            suggestions: [`Webhook ${url} failed: ${errorMessage}`],
         };
     }
     validateSeverity(severity) {
@@ -103602,16 +103853,14 @@ class HttpClientProvider extends check_provider_interface_1.CheckProvider {
                                 category: 'logic',
                             },
                         ],
-                        suggestions: [],
                     };
                 }
             }
-            // Return the fetched data as suggestions for dependent checks to access
+            // Return the fetched data as a custom field for dependent checks to access
             return {
                 issues: [],
-                suggestions: [
-                    typeof processedData === 'string' ? processedData : JSON.stringify(processedData),
-                ],
+                // Add custom data field that will be passed through to dependent checks
+                data: processedData,
             };
         }
         catch (error) {
@@ -103626,7 +103875,6 @@ class HttpClientProvider extends check_provider_interface_1.CheckProvider {
                         category: 'logic',
                     },
                 ],
-                suggestions: [],
             };
         }
     }
@@ -103781,7 +104029,6 @@ class HttpInputProvider extends check_provider_interface_1.CheckProvider {
         if (!webhookData) {
             return {
                 issues: [],
-                suggestions: [`Waiting for webhook data on endpoint: ${endpoint}`],
             };
         }
         // Apply transformation if specified
@@ -103813,15 +104060,15 @@ class HttpInputProvider extends check_provider_interface_1.CheckProvider {
                             category: 'logic',
                         },
                     ],
-                    suggestions: [],
                 };
             }
         }
-        // Return the processed data as suggestions for dependent checks to access
-        // We encode the data as JSON in a suggestion so it can be accessed via outputs
+        // Return the processed data as a custom field for dependent checks to access
+        // This will be available in outputs for dependent checks
         return {
             issues: [],
-            suggestions: [JSON.stringify(processedData)],
+            // Add custom data field that will be passed through
+            data: processedData,
         };
     }
     getWebhookData(endpoint) {
@@ -103917,9 +104164,14 @@ class LogCheckProvider extends check_provider_interface_1.CheckProvider {
         const renderedMessage = await this.liquid.parseAndRender(message, templateContext);
         // Build the log output
         const logOutput = this.formatLogOutput(level, renderedMessage, templateContext, includePrContext, includeDependencies, includeMetadata);
+        // Output to console based on log level
+        const logFn = level === 'error' ? console.error : level === 'warn' ? console.warn : console.log;
+        logFn(logOutput);
+        // Return with the log content as custom data for dependent checks
         return {
-            issues: [], // Log provider doesn't generate issues
-            suggestions: [logOutput], // Put formatted log output as the primary suggestion
+            issues: [],
+            // Add log output as custom field
+            logOutput,
         };
     }
     buildTemplateContext(prInfo, dependencyResults, includePrContext = true, includeDependencies = true, includeMetadata = true) {
@@ -103952,9 +104204,8 @@ class LogCheckProvider extends check_provider_interface_1.CheckProvider {
             for (const [checkName, result] of dependencyResults.entries()) {
                 dependencies[checkName] = {
                     issueCount: result.issues?.length || 0,
-                    suggestionCount: result.suggestions?.length || 0,
+                    suggestionCount: 0,
                     issues: result.issues || [],
-                    suggestions: result.suggestions || [],
                 };
             }
             context.dependencies = dependencies;
@@ -104097,7 +104348,6 @@ class NoopCheckProvider extends check_provider_interface_1.CheckProvider {
         // It exists purely for command orchestration and dependency triggering
         return {
             issues: [],
-            suggestions: [],
         };
     }
     getSupportedConfigKeys() {
@@ -104117,193 +104367,6 @@ class NoopCheckProvider extends check_provider_interface_1.CheckProvider {
 exports.NoopCheckProvider = NoopCheckProvider;
 
 
-/***/ }),
-
-/***/ 70477:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ToolCheckProvider = void 0;
-const check_provider_interface_1 = __nccwpck_require__(14131);
-const issue_filter_1 = __nccwpck_require__(36879);
-const child_process_1 = __nccwpck_require__(35317);
-const liquidjs_1 = __nccwpck_require__(48694);
-/**
- * Check provider that executes external tools and commands with Liquid template support
- * Supports both simple commands and complex templated execution with stdin
- */
-class ToolCheckProvider extends check_provider_interface_1.CheckProvider {
-    liquid;
-    constructor() {
-        super();
-        this.liquid = new liquidjs_1.Liquid({
-            strictVariables: false,
-            strictFilters: false,
-        });
-    }
-    getName() {
-        return 'tool';
-    }
-    getDescription() {
-        return 'Execute external code analysis tools (ESLint, Prettier, etc.)';
-    }
-    async validateConfig(config) {
-        if (!config || typeof config !== 'object') {
-            return false;
-        }
-        const cfg = config;
-        // Type must be 'tool'
-        if (cfg.type !== 'tool') {
-            return false;
-        }
-        // Must have exec specified for tool execution
-        if (typeof cfg.exec !== 'string' || !cfg.exec) {
-            return false;
-        }
-        return true;
-    }
-    async execute(prInfo, config, _dependencyResults, _sessionInfo) {
-        const execTemplate = config.exec;
-        const stdinTemplate = config.stdin;
-        // Prepare template context
-        const templateContext = {
-            pr: {
-                number: prInfo.number,
-                title: prInfo.title,
-                body: prInfo.body,
-                author: prInfo.author,
-                base: prInfo.base,
-                head: prInfo.head,
-                totalAdditions: prInfo.totalAdditions,
-                totalDeletions: prInfo.totalDeletions,
-            },
-            files: prInfo.files.map(f => ({
-                filename: f.filename,
-                status: f.status,
-                additions: f.additions,
-                deletions: f.deletions,
-                changes: f.changes,
-                patch: f.patch,
-            })),
-            // Add convenience arrays for common use cases
-            filenames: prInfo.files.map(f => f.filename),
-            config: config, // Allow access to config values in templates
-        };
-        // Render the command template
-        const renderedCommand = await this.liquid.parseAndRender(execTemplate, templateContext);
-        // Render stdin if provided
-        let renderedStdin;
-        if (stdinTemplate) {
-            renderedStdin = await this.liquid.parseAndRender(stdinTemplate, templateContext);
-        }
-        // Execute the tool
-        const output = await this.executeCommand(renderedCommand.trim(), renderedStdin);
-        // Parse tool output (this would be customized per tool)
-        const comments = this.parseToolOutput(output, renderedCommand);
-        const issues = comments.map(comment => ({
-            file: comment.file,
-            line: comment.line,
-            endLine: undefined,
-            ruleId: `tool/${comment.category}`,
-            message: comment.message,
-            severity: comment.severity,
-            category: comment.category,
-            suggestion: undefined,
-            replacement: undefined,
-        }));
-        // Apply issue suppression filtering
-        const suppressionEnabled = config.suppressionEnabled !== false;
-        const issueFilter = new issue_filter_1.IssueFilter(suppressionEnabled);
-        const filteredIssues = issueFilter.filterIssues(issues, process.cwd());
-        return {
-            issues: filteredIssues,
-            suggestions: this.generateSuggestions(comments, renderedCommand),
-        };
-    }
-    async executeCommand(command, stdin) {
-        return new Promise((resolve, reject) => {
-            // Parse command and arguments (handle quoted arguments)
-            const parts = command.match(/(?:[^\s"]+|"[^"]*")+/g) || [command];
-            const cmd = parts[0];
-            const args = parts.slice(1).map(arg => arg.replace(/^"(.*)"$/, '$1'));
-            const child = (0, child_process_1.spawn)(cmd, args, {
-                shell: false,
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            let output = '';
-            let error = '';
-            child.stdout.on('data', data => {
-                output += data.toString();
-            });
-            child.stderr.on('data', data => {
-                error += data.toString();
-            });
-            // Send stdin data if provided
-            if (stdin) {
-                child.stdin.write(stdin);
-                child.stdin.end();
-            }
-            child.on('close', _code => {
-                // Many tools return non-zero on issues found
-                resolve(output || error);
-            });
-            child.on('error', err => {
-                reject(new Error(`Failed to execute ${cmd}: ${err.message}`));
-            });
-        });
-    }
-    parseToolOutput(output, _command) {
-        const comments = [];
-        // This is a simplified parser - real implementation would handle specific tool formats
-        const lines = output.split('\n');
-        for (const line of lines) {
-            // Example: file.js:10:5: error: Missing semicolon
-            const match = line.match(/^(.+?):(\d+):(\d+):\s*(critical|error|warning|info):\s*(.+)$/);
-            if (match) {
-                const severity = match[4];
-                comments.push({
-                    file: match[1],
-                    line: parseInt(match[2]),
-                    message: match[5],
-                    severity: severity,
-                    category: 'style',
-                });
-            }
-        }
-        return comments;
-    }
-    generateSuggestions(comments, command) {
-        const suggestions = [];
-        if (comments.length > 0) {
-            suggestions.push(`Fix ${comments.length} issues found by ${command}`);
-            const errorCount = comments.filter(c => c.severity === 'error').length;
-            if (errorCount > 0) {
-                suggestions.push(`Priority: Fix ${errorCount} errors before merging`);
-            }
-        }
-        return suggestions;
-    }
-    getSupportedConfigKeys() {
-        return ['type', 'exec', 'command', 'stdin', 'timeout', 'workingDirectory'];
-    }
-    async isAvailable() {
-        // Check if common tools are available
-        // In a real implementation, this would check for specific tools based on config
-        return true;
-    }
-    getRequirements() {
-        return [
-            'External tool must be installed (e.g., eslint, prettier)',
-            'Tool must be accessible in PATH',
-            'Appropriate configuration files for the tool',
-        ];
-    }
-}
-exports.ToolCheckProvider = ToolCheckProvider;
-
-
 /***/ }),
 
 /***/ 532:
@@ -104355,7 +104418,7 @@ const ai_review_service_1 = __nccwpck_require__(51796);
 // Test utility function - Convert old ReviewSummary to new GroupedCheckResults format
 // This is for backward compatibility with tests only
 function convertReviewSummaryToGroupedResults(reviewSummary, checkName = 'test-check', groupName = 'default') {
-    // Create a simple content string from issues and suggestions
+    // Create a simple content string from issues
     let content = '';
     if (reviewSummary.issues && reviewSummary.issues.length > 0) {
         content += `## Issues Found (${reviewSummary.issues.length})\n\n`;
@@ -104364,12 +104427,6 @@ function convertReviewSummaryToGroupedResults(reviewSummary, checkName = 'test-c
         });
         content += '\n';
     }
-    if (reviewSummary.suggestions && reviewSummary.suggestions.length > 0) {
-        content += `## Suggestions\n\n`;
-        reviewSummary.suggestions.forEach(suggestion => {
-            content += `- ${suggestion}\n`;
-        });
-    }
     if (!content) {
         content = 'No issues found.';
     }
@@ -126287,13 +126344,19 @@ For GitHub-compatible mermaid diagrams, avoid single quotes and parentheses in n
 
 **Rules:**
 - NO single quotes in any node labels: 'text' \u2192 "text" or text
-- NO parentheses in square brackets: [Text (detail)] \u2192 [Text - detail]
+- NO parentheses in square brackets: [Text (detail)] \u2192 [Text - detail]  
 - NO complex expressions in diamonds: {a && b} \u2192 {condition}
+- NO HTML tags in node labels: [<pre>code</pre>] \u2192 ["code block"] or [Code Block]
 - USE single quotes for styles and classes: classDef highlight fill:'#ff9999'
+- CRITICAL: When using quotes in node labels, place them INSIDE the brackets: ["quoted text"], NOT [quoted text"]
 
 **Examples:**
 - \u2705 [Load Config] ["Run command"] {Valid?}
+- \u2705 ["depends_on: [generate-items]"] (correct quote placement)
+- \u2705 ["Code Block"] (clean text instead of HTML)
 - \u274C [Load (config)] [Run 'command'] {isValid('x')}
+- \u274C [depends_on: [generate-items"] (incorrect quote placement - quote ends inside bracket)
+- \u274C [<pre>depends_on: [generate-items]</pre>] (HTML tags in node labels)
 
 **Diagram Type Selection:**
 
@@ -129221,7 +129284,7 @@ Examples:
 </extract>
 
 <attempt_completion>
-<result>The configuration is loaded from src/config.js lines 15-25 which contains the database settings.</result>
+The configuration is loaded from src/config.js lines 15-25 which contains the database settings.
 </attempt_completion>
 
 # Special Case: Quick Completion
@@ -129248,7 +129311,7 @@ I need to find code related to error handling in the search module. The most app
 6. Wait for the tool execution result, which will be provided in the next message (within a <tool_result> block).
 7. Analyze the tool result and decide the next step. If more tool calls are needed, repeat steps 2-6.
 8. If the task is fully complete and all previous steps were successful, use the \`<attempt_completion>\` tool to provide the final answer. This is the ONLY way to finish the task.
-9. If you cannot proceed (e.g., missing information, invalid request), explain the issue clearly before using \`<attempt_completion>\` with an appropriate message in the \`<result>\` tag.
+9. If you cannot proceed (e.g., missing information, invalid request), use \`<attempt_completion>\` to explain the issue clearly with an appropriate message directly inside the tags.
 10. If your previous response was already correct and complete, you may use \`<attempt_complete>\` as a shorthand.
 
 Available Tools: