@probelabs/visor 0.1.80 → 0.1.82

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-process.env.VISOR_VERSION = '0.1.80';
+process.env.VISOR_VERSION = '0.1.82';
 process.env.PROBE_VERSION = '0.6.0-rc122';
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
@@ -102612,155 +102612,173 @@ class CheckExecutionEngine {
                     if (isForEachDependent && forEachParentName) {
                         // Record forEach preview items
                         this.recordForEachPreview(checkName, forEachItems);
-                        if (debug) {
-                            log(`🔄 Debug: Check "${checkName}" depends on forEach check "${forEachParentName}", executing ${forEachItems.length} times`);
+                        // If the forEach parent returned an empty array, skip this check entirely
+                        if (forEachItems.length === 0) {
+                            if (debug) {
+                                log(`🔄 Debug: Skipping check "${checkName}" - forEach check "${forEachParentName}" returned 0 items`);
+                            }
+                            logger_1.logger.info(`  forEach: no items from "${forEachParentName}", skipping check...`);
+                            // Return a special marker result so that dependent checks can detect the skip
+                            finalResult = {
+                                issues: [],
+                                output: [],
+                            };
+                            // Mark this result as forEach-capable but with empty items
+                            finalResult.isForEach = true;
+                            finalResult.forEachItems = [];
+                            // Skip to the end - don't execute this check
                         }
-                        // Log forEach processing start (non-debug)
-                        logger_1.logger.info(`  forEach: processing ${forEachItems.length} items from "${forEachParentName}"...`);
-                        const allIssues = [];
-                        const allOutputs = [];
-                        const aggregatedContents = [];
-                        // Create task functions (not executed yet) - these will be executed with controlled concurrency
-                        // via executeWithLimitedParallelism to respect maxParallelism setting
-                        const itemTasks = forEachItems.map((item, itemIndex) => async () => {
-                            // Create modified dependency results with current item
-                            // For forEach branching: unwrap ALL forEach parents to create isolated execution branch
-                            const forEachDependencyResults = new Map();
-                            for (const [depName, depResult] of dependencyResults) {
-                                if (forEachParents.includes(depName)) {
-                                    // This is a forEach parent - unwrap its output for this iteration
-                                    const depForEachResult = depResult;
-                                    if (Array.isArray(depForEachResult.output) &&
-                                        depForEachResult.output[itemIndex] !== undefined) {
-                                        // Unwrap to the item at the current index
-                                        const modifiedResult = {
-                                            issues: [],
-                                            output: depForEachResult.output[itemIndex],
-                                        };
-                                        forEachDependencyResults.set(depName, modifiedResult);
-                                        // Also provide -raw access to the full array
-                                        const rawResult = {
-                                            issues: [],
-                                            output: depForEachResult.output,
-                                        };
-                                        forEachDependencyResults.set(`${depName}-raw`, rawResult);
+                        else {
+                            if (debug) {
+                                log(`🔄 Debug: Check "${checkName}" depends on forEach check "${forEachParentName}", executing ${forEachItems.length} times`);
+                            }
+                            // Log forEach processing start (non-debug)
+                            logger_1.logger.info(`  forEach: processing ${forEachItems.length} items from "${forEachParentName}"...`);
+                            const allIssues = [];
+                            const allOutputs = [];
+                            const aggregatedContents = [];
+                            // Create task functions (not executed yet) - these will be executed with controlled concurrency
+                            // via executeWithLimitedParallelism to respect maxParallelism setting
+                            const itemTasks = forEachItems.map((item, itemIndex) => async () => {
+                                // Create modified dependency results with current item
+                                // For forEach branching: unwrap ALL forEach parents to create isolated execution branch
+                                const forEachDependencyResults = new Map();
+                                for (const [depName, depResult] of dependencyResults) {
+                                    if (forEachParents.includes(depName)) {
+                                        // This is a forEach parent - unwrap its output for this iteration
+                                        const depForEachResult = depResult;
+                                        if (Array.isArray(depForEachResult.output) &&
+                                            depForEachResult.output[itemIndex] !== undefined) {
+                                            // Unwrap to the item at the current index
+                                            const modifiedResult = {
+                                                issues: [],
+                                                output: depForEachResult.output[itemIndex],
+                                            };
+                                            forEachDependencyResults.set(depName, modifiedResult);
+                                            // Also provide -raw access to the full array
+                                            const rawResult = {
+                                                issues: [],
+                                                output: depForEachResult.output,
+                                            };
+                                            forEachDependencyResults.set(`${depName}-raw`, rawResult);
+                                        }
+                                        else {
+                                            // Fallback: use the result as-is
+                                            forEachDependencyResults.set(depName, depResult);
+                                        }
                                     }
                                     else {
-                                        // Fallback: use the result as-is
                                         forEachDependencyResults.set(depName, depResult);
                                     }
                                 }
-                                else {
-                                    forEachDependencyResults.set(depName, depResult);
+                                // Evaluate if condition for this forEach item
+                                if (checkConfig.if) {
+                                    // Merge current results with forEach-specific dependency results for condition evaluation
+                                    const conditionResults = new Map(results);
+                                    for (const [depName, depResult] of forEachDependencyResults) {
+                                        conditionResults.set(depName, depResult);
+                                    }
+                                    const shouldRun = await this.evaluateCheckCondition(checkName, checkConfig.if, prInfo, conditionResults, debug);
+                                    if (!shouldRun) {
+                                        if (debug) {
+                                            log(`🔄 Debug: Skipping forEach item ${itemIndex + 1} for check "${checkName}" (if condition evaluated to false)`);
+                                        }
+                                        // Return empty result for skipped items
+                                        return {
+                                            index: itemIndex,
+                                            itemResult: { issues: [] },
+                                            skipped: true,
+                                        };
+                                    }
                                 }
-                            }
-                            // Evaluate if condition for this forEach item
-                            if (checkConfig.if) {
-                                // Merge current results with forEach-specific dependency results for condition evaluation
-                                const conditionResults = new Map(results);
-                                for (const [depName, depResult] of forEachDependencyResults) {
-                                    conditionResults.set(depName, depResult);
+                                if (debug) {
+                                    log(`🔄 Debug: Executing check "${checkName}" for item ${itemIndex + 1}/${forEachItems.length}`);
                                 }
-                                const shouldRun = await this.evaluateCheckCondition(checkName, checkConfig.if, prInfo, conditionResults, debug);
-                                if (!shouldRun) {
+                                // Track iteration start
+                                const iterationStart = this.recordIterationStart(checkName);
+                                // Execute with retry/routing semantics per item
+                                const itemResult = await this.executeWithRouting(checkName, checkConfig, provider, providerConfig, prInfo, forEachDependencyResults, sessionInfo, config, dependencyGraph, debug, results, 
+                                /*foreachContext*/ {
+                                    index: itemIndex,
+                                    total: forEachItems.length,
+                                    parent: forEachParentName,
+                                });
+                                // Record iteration completion
+                                // Check if this iteration had fatal errors
+                                const hadFatalError = (itemResult.issues || []).some(issue => {
+                                    const id = issue.ruleId || '';
+                                    return (id === 'command/execution_error' ||
+                                        id.endsWith('/command/execution_error') ||
+                                        id === 'command/transform_js_error' ||
+                                        id.endsWith('/command/transform_js_error') ||
+                                        id === 'command/transform_error' ||
+                                        id.endsWith('/command/transform_error'));
+                                });
+                                const iterationDuration = (Date.now() - iterationStart) / 1000;
+                                this.recordIterationComplete(checkName, iterationStart, !hadFatalError, // Success if no fatal errors
+                                itemResult.issues || [], itemResult.output);
+                                // Log iteration progress
+                                logger_1.logger.info(`  ✔ ${itemIndex + 1}/${forEachItems.length} (${iterationDuration.toFixed(1)}s)`);
+                                return { index: itemIndex, itemResult };
+                            });
+                            const forEachConcurrency = Math.max(1, Math.min(forEachItems.length, effectiveMaxParallelism));
+                            if (debug && forEachConcurrency > 1) {
+                                log(`🔄 Debug: Limiting forEach concurrency for check "${checkName}" to ${forEachConcurrency}`);
+                            }
+                            const forEachResults = await this.executeWithLimitedParallelism(itemTasks, forEachConcurrency, false);
+                            for (const result of forEachResults) {
+                                if (result.status === 'rejected') {
+                                    // Instead of throwing, record the failure and continue with other iterations
+                                    const error = result.reason;
+                                    const errorMessage = error instanceof Error ? error.message : String(error);
+                                    // Create an error issue for this failed iteration
+                                    allIssues.push({
+                                        ruleId: `${checkName}/forEach/iteration_error`,
+                                        severity: 'error',
+                                        category: 'logic',
+                                        message: `forEach iteration failed: ${errorMessage}`,
+                                        file: '',
+                                        line: 0,
+                                    });
                                     if (debug) {
-                                        log(`🔄 Debug: Skipping forEach item ${itemIndex + 1} for check "${checkName}" (if condition evaluated to false)`);
+                                        log(`🔄 Debug: forEach iteration for check "${checkName}" failed: ${errorMessage}`);
                                     }
-                                    // Return empty result for skipped items
-                                    return {
-                                        index: itemIndex,
-                                        itemResult: { issues: [] },
-                                        skipped: true,
-                                    };
+                                    continue;
                                 }
-                            }
-                            if (debug) {
-                                log(`🔄 Debug: Executing check "${checkName}" for item ${itemIndex + 1}/${forEachItems.length}`);
-                            }
-                            // Track iteration start
-                            const iterationStart = this.recordIterationStart(checkName);
-                            // Execute with retry/routing semantics per item
-                            const itemResult = await this.executeWithRouting(checkName, checkConfig, provider, providerConfig, prInfo, forEachDependencyResults, sessionInfo, config, dependencyGraph, debug, results, 
-                            /*foreachContext*/ {
-                                index: itemIndex,
-                                total: forEachItems.length,
-                                parent: forEachParentName,
-                            });
-                            // Record iteration completion
-                            // Check if this iteration had fatal errors
-                            const hadFatalError = (itemResult.issues || []).some(issue => {
-                                const id = issue.ruleId || '';
-                                return (id === 'command/execution_error' ||
-                                    id.endsWith('/command/execution_error') ||
-                                    id === 'command/transform_js_error' ||
-                                    id.endsWith('/command/transform_js_error') ||
-                                    id === 'command/transform_error' ||
-                                    id.endsWith('/command/transform_error'));
-                            });
-                            const iterationDuration = (Date.now() - iterationStart) / 1000;
-                            this.recordIterationComplete(checkName, iterationStart, !hadFatalError, // Success if no fatal errors
-                            itemResult.issues || [], itemResult.output);
-                            // Log iteration progress
-                            logger_1.logger.info(`  ✔ ${itemIndex + 1}/${forEachItems.length} (${iterationDuration.toFixed(1)}s)`);
-                            return { index: itemIndex, itemResult };
-                        });
-                        const forEachConcurrency = Math.max(1, Math.min(forEachItems.length, effectiveMaxParallelism));
-                        if (debug && forEachConcurrency > 1) {
-                            log(`🔄 Debug: Limiting forEach concurrency for check "${checkName}" to ${forEachConcurrency}`);
-                        }
-                        const forEachResults = await this.executeWithLimitedParallelism(itemTasks, forEachConcurrency, false);
-                        for (const result of forEachResults) {
-                            if (result.status === 'rejected') {
-                                // Instead of throwing, record the failure and continue with other iterations
-                                const error = result.reason;
-                                const errorMessage = error instanceof Error ? error.message : String(error);
-                                // Create an error issue for this failed iteration
-                                allIssues.push({
-                                    ruleId: `${checkName}/forEach/iteration_error`,
-                                    severity: 'error',
-                                    category: 'logic',
-                                    message: `forEach iteration failed: ${errorMessage}`,
-                                    file: '',
-                                    line: 0,
-                                });
-                                if (debug) {
-                                    log(`🔄 Debug: forEach iteration for check "${checkName}" failed: ${errorMessage}`);
+                                // Skip results from skipped items (those that failed if condition)
+                                if (result.value.skipped) {
+                                    continue;
+                                }
+                                const { itemResult } = result.value;
+                                if (itemResult.issues) {
+                                    allIssues.push(...itemResult.issues);
+                                }
+                                const resultWithOutput = itemResult;
+                                if (resultWithOutput.output !== undefined) {
+                                    allOutputs.push(resultWithOutput.output);
+                                }
+                                const itemContent = resultWithOutput.content;
+                                if (typeof itemContent === 'string' && itemContent.trim()) {
+                                    aggregatedContents.push(itemContent.trim());
                                 }
-                                continue;
-                            }
-                            // Skip results from skipped items (those that failed if condition)
-                            if (result.value.skipped) {
-                                continue;
-                            }
-                            const { itemResult } = result.value;
-                            if (itemResult.issues) {
-                                allIssues.push(...itemResult.issues);
                             }
-                            const resultWithOutput = itemResult;
-                            if (resultWithOutput.output !== undefined) {
-                                allOutputs.push(resultWithOutput.output);
+                            const finalOutput = allOutputs.length > 0 ? allOutputs : undefined;
+                            finalResult = {
+                                issues: allIssues,
+                                ...(finalOutput !== undefined ? { output: finalOutput } : {}),
+                            };
+                            // IMPORTANT: Mark this result as forEach-capable so that checks depending on it
+                            // will also iterate over the items (propagate forEach behavior down the chain)
+                            if (allOutputs.length > 0) {
+                                finalResult.isForEach = true;
+                                finalResult.forEachItems = allOutputs;
                             }
-                            const itemContent = resultWithOutput.content;
-                            if (typeof itemContent === 'string' && itemContent.trim()) {
-                                aggregatedContents.push(itemContent.trim());
+                            if (aggregatedContents.length > 0) {
+                                finalResult.content =
+                                    aggregatedContents.join('\n');
                             }
-                        }
-                        const finalOutput = allOutputs.length > 0 ? allOutputs : undefined;
-                        finalResult = {
-                            issues: allIssues,
-                            ...(finalOutput !== undefined ? { output: finalOutput } : {}),
-                        };
-                        // IMPORTANT: Mark this result as forEach-capable so that checks depending on it
-                        // will also iterate over the items (propagate forEach behavior down the chain)
-                        if (allOutputs.length > 0) {
-                            finalResult.isForEach = true;
-                            finalResult.forEachItems = allOutputs;
-                        }
-                        if (aggregatedContents.length > 0) {
-                            finalResult.content =
-                                aggregatedContents.join('\n');
-                        }
-                        log(`🔄 Debug: Completed forEach execution for check "${checkName}", total issues: ${allIssues.length}`);
+                            log(`🔄 Debug: Completed forEach execution for check "${checkName}", total issues: ${allIssues.length}`);
+                        } // End of else block for forEachItems.length > 0
                     }
                     else {
                         // Normal single execution
@@ -102989,19 +103007,6 @@ class CheckExecutionEngine {
                 }
             }
         }
-        // Build and log final execution summary
-        const executionStatistics = this.buildExecutionStatistics();
-        // Show detailed summary table (only if logFn outputs to console)
-        // Skip when output format is JSON/SARIF to avoid polluting structured output
-        // Check if logFn is console.log (not a no-op or console.error)
-        if (logFn === console.log) {
-            this.logExecutionSummary(executionStatistics);
-        }
-        // Add warning if execution stopped early
-        if (shouldStopExecution) {
-            logger_1.logger.info('');
-            logger_1.logger.warn(`⚠️  Execution stopped early due to fail-fast`);
-        }
         if (debug) {
             if (shouldStopExecution) {
                 log(`🛑 Execution stopped early due to fail-fast after processing ${results.size} of ${checks.length} checks`);
@@ -103010,7 +103015,7 @@ class CheckExecutionEngine {
                 log(`✅ Dependency-aware execution completed successfully for all ${results.size} checks`);
             }
         }
-        // Cleanup sessions after execution
+        // Cleanup sessions BEFORE printing summary to avoid mixing debug logs with table output
         if (sessionIds.size > 0 && debug) {
             log(`🧹 Cleaning up ${sessionIds.size} AI sessions...`);
             for (const [checkName, sessionId] of sessionIds) {
@@ -103023,6 +103028,19 @@ class CheckExecutionEngine {
                 }
             }
         }
+        // Build and log final execution summary
+        const executionStatistics = this.buildExecutionStatistics();
+        // Show detailed summary table (only if logFn outputs to console)
+        // Skip when output format is JSON/SARIF to avoid polluting structured output
+        // Check if logFn is console.log (not a no-op or console.error)
+        if (logFn === console.log) {
+            this.logExecutionSummary(executionStatistics);
+        }
+        // Add warning if execution stopped early
+        if (shouldStopExecution) {
+            logger_1.logger.info('');
+            logger_1.logger.warn(`⚠️  Execution stopped early due to fail-fast`);
+        }
         // Aggregate all results
         return this.aggregateDependencyAwareResults(results, dependencyGraph, debug, shouldStopExecution);
     }
@@ -104577,9 +104595,18 @@ async function main() {
         const hasRepositoryError = allResults.some((result) => {
             return result.content.includes('Not a git repository');
         });
-        if (criticalCount > 0 || hasRepositoryError) {
-            process.exit(1);
+        // Cleanup AI sessions before exit to prevent process hanging
+        const { SessionRegistry } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(46059)));
+        const sessionRegistry = SessionRegistry.getInstance();
+        if (sessionRegistry.getActiveSessionIds().length > 0) {
+            logger_1.logger.debug(`🧹 Cleaning up ${sessionRegistry.getActiveSessionIds().length} active AI sessions...`);
+            sessionRegistry.clearAllSessions();
         }
+        // Force exit to prevent hanging from unclosed resources (MCP connections, etc.)
+        // This is necessary because some async resources may not be properly cleaned up
+        // and can keep the event loop alive indefinitely
+        const exitCode = criticalCount > 0 || hasRepositoryError ? 1 : 0;
+        process.exit(exitCode);
     }
     catch (error) {
         // Import error classes dynamically to avoid circular dependencies
@@ -109033,6 +109060,15 @@ async function run() {
             (0, core_1.setFailed)(error instanceof Error ? error.message : 'Unknown error');
         }
     }
+    finally {
+        // Cleanup AI sessions before GitHub Action exits to prevent process hanging
+        const { SessionRegistry } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(46059)));
+        const sessionRegistry = SessionRegistry.getInstance();
+        if (sessionRegistry.getActiveSessionIds().length > 0) {
+            console.log(`🧹 Cleaning up ${sessionRegistry.getActiveSessionIds().length} active AI sessions...`);
+            sessionRegistry.clearAllSessions();
+        }
+    }
 }
 function mapGitHubEventToTrigger(eventName, action) {
     if (!eventName)
@@ -111256,7 +111292,6 @@ const issue_filter_1 = __nccwpck_require__(36879);
 const liquid_extensions_1 = __nccwpck_require__(33042);
 const promises_1 = __importDefault(__nccwpck_require__(91943));
 const path_1 = __importDefault(__nccwpck_require__(16928));
-const claude_code_types_1 = __nccwpck_require__(21710);
 /**
  * AI-powered check provider using probe agent
  */
@@ -111583,53 +111618,6 @@ class AICheckProvider extends check_provider_interface_1.CheckProvider {
             throw new Error(`Failed to render prompt template: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
-    /**
-     * Setup MCP tools based on AI configuration
-     */
-    async setupMcpTools(aiConfig) {
-        const tools = [];
-        // Setup custom MCP servers if configured
-        if (aiConfig.mcpServers) {
-            try {
-                // Import MCP SDK for custom server creation using safe import
-                const mcpModule = await (0, claude_code_types_1.safeImport)('@modelcontextprotocol/sdk');
-                if (!mcpModule) {
-                    console.warn('@modelcontextprotocol/sdk package not found. MCP servers disabled.');
-                    return tools;
-                }
-                const createSdkMcpServer = mcpModule.createSdkMcpServer || mcpModule.default?.createSdkMcpServer;
-                if (typeof createSdkMcpServer === 'function') {
-                    for (const [serverName, serverConfig] of Object.entries(aiConfig.mcpServers)) {
-                        try {
-                            // Create MCP server instance
-                            const server = await createSdkMcpServer({
-                                name: serverName,
-                                command: serverConfig.command,
-                                args: serverConfig.args || [],
-                                env: { ...process.env, ...serverConfig.env },
-                            });
-                            // Add server tools to available tools
-                            const serverTools = (await server.listTools());
-                            tools.push(...serverTools.map(tool => ({
-                                name: tool.name,
-                                server: serverName,
-                            })));
-                        }
-                        catch (serverError) {
-                            console.warn(`Failed to setup MCP server ${serverName}: ${serverError instanceof Error ? serverError.message : 'Unknown error'}`);
-                        }
-                    }
-                }
-                else {
-                    console.warn('createSdkMcpServer function not found in @modelcontextprotocol/sdk. MCP servers disabled.');
-                }
-            }
-            catch (error) {
-                console.warn(`Failed to import MCP SDK: ${error instanceof Error ? error.message : 'Unknown error'}. MCP servers disabled.`);
-            }
-        }
-        return tools;
-    }
     async execute(prInfo, config, _dependencyResults, sessionInfo) {
         // Apply environment configuration if present
         if (config.env) {
@@ -111693,15 +111681,12 @@ class AICheckProvider extends check_provider_interface_1.CheckProvider {
         if (config.ai?.mcpServers) {
             Object.assign(mcpServers, config.ai.mcpServers);
         }
-        // Setup MCP tools if any servers are configured
+        // Pass MCP server config directly to AI service
         if (Object.keys(mcpServers).length > 0) {
-            // Pass raw server config to AI service so it can enable MCP in ProbeAgent
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             aiConfig.mcpServers = mcpServers;
-            // Optional: attempt to enumerate tools for debug visibility (not required for functionality)
-            const mcpConfig = { mcpServers };
-            const mcpTools = await this.setupMcpTools(mcpConfig);
             if (aiConfig.debug) {
-                console.error(`🔧 Debug: AI check MCP configured with ${Object.keys(mcpServers).length} servers; discovered ${mcpTools.length} tools`);
+                console.error(`🔧 Debug: AI check MCP configured with ${Object.keys(mcpServers).length} servers`);
             }
         }
         // Process prompt with Liquid templates and file loading
@@ -112115,59 +112100,6 @@ class ClaudeCodeCheckProvider extends check_provider_interface_1.CheckProvider {
             throw new Error(`Failed to initialize Claude Code SDK: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
-    /**
-     * Setup MCP tools based on configuration
-     */
-    async setupMcpTools(config) {
-        const tools = [];
-        // Add allowed tools
-        if (config.allowedTools) {
-            for (const toolName of config.allowedTools) {
-                tools.push({ name: toolName });
-            }
-        }
-        // Setup custom MCP servers if configured
-        if (config.mcpServers) {
-            try {
-                // Import MCP SDK for custom server creation using safe import
-                const mcpModule = await (0, claude_code_types_1.safeImport)('@modelcontextprotocol/sdk');
-                if (!mcpModule) {
-                    console.warn('@modelcontextprotocol/sdk package not found. MCP servers disabled.');
-                    return tools;
-                }
-                const createSdkMcpServer = mcpModule.createSdkMcpServer || mcpModule.default?.createSdkMcpServer;
-                if (typeof createSdkMcpServer === 'function') {
-                    for (const [serverName, serverConfig] of Object.entries(config.mcpServers)) {
-                        try {
-                            // Create MCP server instance
-                            const server = await createSdkMcpServer({
-                                name: serverName,
-                                command: serverConfig.command,
-                                args: serverConfig.args || [],
-                                env: { ...process.env, ...serverConfig.env },
-                            });
-                            // Add server tools to available tools
-                            const serverTools = (await server.listTools());
-                            tools.push(...serverTools.map(tool => ({
-                                name: tool.name,
-                                server: serverName,
-                            })));
-                        }
-                        catch (serverError) {
-                            console.warn(`Failed to setup MCP server ${serverName}: ${serverError instanceof Error ? serverError.message : 'Unknown error'}`);
-                        }
-                    }
-                }
-                else {
-                    console.warn('createSdkMcpServer function not found in @modelcontextprotocol/sdk. MCP servers disabled.');
-                }
-            }
-            catch (error) {
-                console.warn(`Failed to import MCP SDK: ${error instanceof Error ? error.message : 'Unknown error'}. MCP servers disabled.`);
-            }
-        }
-        return tools;
-    }
     /**
      * Group files by their file extension for template context
      */
@@ -112432,16 +112364,22 @@ class ClaudeCodeCheckProvider extends check_provider_interface_1.CheckProvider {
         try {
             // Initialize Claude Code client
             const client = await this.initializeClaudeCodeClient();
-            // Setup MCP tools
-            const tools = await this.setupMcpTools(claudeCodeConfig);
-            // Prepare query object
+            // Prepare query object with MCP servers passed directly to SDK
             const query = {
                 query: processedPrompt,
-                tools: tools.length > 0 ? tools : undefined,
                 maxTurns: claudeCodeConfig.maxTurns || 5,
                 systemPrompt: claudeCodeConfig.systemPrompt,
                 subagent: claudeCodeConfig.subagent,
             };
+            // Add allowed tools if specified
+            if (claudeCodeConfig.allowedTools && claudeCodeConfig.allowedTools.length > 0) {
+                query.tools = claudeCodeConfig.allowedTools.map(name => ({ name }));
+            }
+            // Pass MCP servers directly to the SDK - let it handle spawning and tool discovery
+            if (claudeCodeConfig.mcpServers && Object.keys(claudeCodeConfig.mcpServers).length > 0) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                query.mcpServers = claudeCodeConfig.mcpServers;
+            }
             // Execute query with Claude Code
             let response;
             if (sessionInfo?.reuseSession && sessionInfo.parentSessionId) {
@@ -112475,7 +112413,6 @@ class ClaudeCodeCheckProvider extends check_provider_interface_1.CheckProvider {
                 sessionId: response.session_id,
                 turnCount: response.turn_count,
                 usage: response.usage,
-                toolsUsed: tools.map(t => t.name),
             };
             // Apply issue suppression filtering
             const suppressionEnabled = config.suppressionEnabled !== false;
@@ -114522,7 +114459,11 @@ exports.SessionRegistry = void 0;
 class SessionRegistry {
     static instance;
     sessions = new Map();
-    constructor() { }
+    exitHandlerRegistered = false;
+    constructor() {
+        // Register process exit handlers to cleanup sessions
+        this.registerExitHandlers();
+    }
     /**
      * Get the singleton instance of SessionRegistry
      */
@@ -114555,7 +114496,19 @@ class SessionRegistry {
     unregisterSession(sessionId) {
         if (this.sessions.has(sessionId)) {
             console.error(`🗑️  Unregistering AI session: ${sessionId}`);
+            const agent = this.sessions.get(sessionId);
             this.sessions.delete(sessionId);
+            // Cleanup the ProbeAgent instance to prevent hanging processes
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (agent && typeof agent.cleanup === 'function') {
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    agent.cleanup();
+                }
+                catch (error) {
+                    console.error(`⚠️  Warning: Failed to cleanup ProbeAgent: ${error}`);
+                }
+            }
         }
     }
     /**
@@ -114563,6 +114516,19 @@ class SessionRegistry {
      */
     clearAllSessions() {
         console.error(`🧹 Clearing all AI sessions (${this.sessions.size} sessions)`);
+        // Cleanup each ProbeAgent instance before clearing
+        for (const [, agent] of this.sessions.entries()) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (agent && typeof agent.cleanup === 'function') {
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    agent.cleanup();
+                }
+                catch {
+                    // Silent fail during bulk cleanup
+                }
+            }
+        }
         this.sessions.clear();
     }
     /**
@@ -114577,6 +114543,51 @@ class SessionRegistry {
     hasSession(sessionId) {
         return this.sessions.has(sessionId);
     }
+    /**
+     * Register process exit handlers to cleanup sessions on exit
+     */
+    registerExitHandlers() {
+        if (this.exitHandlerRegistered) {
+            return;
+        }
+        const cleanupAndExit = (signal) => {
+            if (this.sessions.size > 0) {
+                console.error(`\n🧹 [${signal}] Cleaning up ${this.sessions.size} active AI sessions...`);
+                this.clearAllSessions();
+            }
+        };
+        // Handle normal process exit
+        process.on('exit', () => {
+            if (this.sessions.size > 0) {
+                console.error(`🧹 [exit] Cleaning up ${this.sessions.size} active AI sessions...`);
+                // Note: async operations won't complete here, but sync cleanup methods will
+                for (const [, agent] of this.sessions.entries()) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    if (agent && typeof agent.cleanup === 'function') {
+                        try {
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            agent.cleanup();
+                        }
+                        catch {
+                            // Silent fail on exit
+                        }
+                    }
+                }
+                this.sessions.clear();
+            }
+        });
+        // Handle SIGINT (Ctrl+C)
+        process.on('SIGINT', () => {
+            cleanupAndExit('SIGINT');
+            process.exit(0);
+        });
+        // Handle SIGTERM
+        process.on('SIGTERM', () => {
+            cleanupAndExit('SIGTERM');
+            process.exit(0);
+        });
+        this.exitHandlerRegistered = true;
+    }
 }
 exports.SessionRegistry = SessionRegistry;
 
@@ -228810,7 +228821,7 @@ module.exports = /*#__PURE__*/JSON.parse('{"application/1d-interleaved-parityfec
 /***/ ((module) => {
 
 "use strict";
-module.exports = {"rE":"0.1.80"};
+module.exports = {"rE":"0.1.82"};
 
 /***/ })