@probelabs/visor 0.1.86 → 0.1.88

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-process.env.VISOR_VERSION = '0.1.86';
+process.env.VISOR_VERSION = '0.1.88';
 process.env.PROBE_VERSION = '0.6.0-rc124';
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
@@ -99834,8 +99834,9 @@ class AIReviewService {
     }
     /**
      * Execute AI review using session reuse - reuses an existing ProbeAgent session
+     * @param sessionMode - 'clone' (default) clones history, 'append' shares history
      */
-    async executeReviewWithSessionReuse(prInfo, customPrompt, parentSessionId, schema, checkName) {
+    async executeReviewWithSessionReuse(prInfo, customPrompt, parentSessionId, schema, checkName, sessionMode = 'clone') {
         const startTime = Date.now();
         const timestamp = new Date().toISOString();
         // Get the existing session
@@ -99845,7 +99846,25 @@ class AIReviewService {
         }
         // Build prompt from custom instructions
         const prompt = await this.buildCustomPrompt(prInfo, customPrompt, schema);
-        log(`🔄 Reusing AI session ${parentSessionId} for review...`);
+        // Determine which agent to use based on session mode
+        let agentToUse;
+        let currentSessionId;
+        if (sessionMode === 'clone') {
+            // Clone the session - creates a new agent with copied history
+            currentSessionId = `${parentSessionId}-clone-${Date.now()}`;
+            log(`📋 Cloning AI session ${parentSessionId} → ${currentSessionId}...`);
+            const clonedAgent = await this.sessionRegistry.cloneSession(parentSessionId, currentSessionId);
+            if (!clonedAgent) {
+                throw new Error(`Failed to clone session ${parentSessionId}. Falling back to append mode.`);
+            }
+            agentToUse = clonedAgent;
+        }
+        else {
+            // Append mode - use the same agent instance
+            log(`🔄 Appending to AI session ${parentSessionId} (shared history)...`);
+            agentToUse = existingAgent;
+            currentSessionId = parentSessionId;
+        }
         log(`🔧 Debug: Raw schema parameter: ${JSON.stringify(schema)} (type: ${typeof schema})`);
         log(`Schema type: ${schema || 'none (no schema)'}`);
         let debugInfo;
@@ -99867,8 +99886,8 @@ class AIReviewService {
             };
         }
         try {
-            // Use existing agent's answer method instead of creating new agent
-            const { response, effectiveSchema } = await this.callProbeAgentWithExistingSession(existingAgent, prompt, schema, debugInfo, checkName);
+            // Use the determined agent (cloned or original)
+            const { response, effectiveSchema } = await this.callProbeAgentWithExistingSession(agentToUse, prompt, schema, debugInfo, checkName);
             const processingTime = Date.now() - startTime;
             if (debugInfo) {
                 debugInfo.rawResponse = response;
@@ -99879,6 +99898,11 @@ class AIReviewService {
             if (debugInfo) {
                 result.debug = debugInfo;
             }
+            // Include the session ID in the result for cleanup tracking
+            // Only include if we created a new cloned session
+            if (sessionMode === 'clone' && currentSessionId !== parentSessionId) {
+                result.sessionId = currentSessionId;
+            }
             return result;
         }
         catch (error) {
@@ -99975,7 +99999,8 @@ ${prContext}
     <rule>For INCREMENTAL analysis, ONLY review changes in commit_diff section</rule>
     <rule>For FULL analysis, review all changes in full_diff section</rule>
     <rule>Reference specific XML elements like files_summary, metadata when providing context</rule>
-    <rule>SEVERITY ASSIGNMENT: All severity levels (critical, error, warning, info) should be based on the NEW code being introduced, not on what it fixes. When code INTRODUCES new problems (bugs, vulnerabilities, performance issues, breaking changes), assign appropriate severity (critical/error/warning). When code FIXES or IMPROVES existing issues, use lower severity (info/warning) to acknowledge the improvement. This applies to all issue types: security, performance, style, logic, documentation. The schema provides detailed severity level definitions.</rule>
+    <rule>STRICT OUTPUT POLICY: Report only actual problems, risks, or deficiencies. Do not write praise, congratulations, or celebratory text. Do not create issues that merely restate improvements or say "no action needed".</rule>
+    <rule>SEVERITY ASSIGNMENT: Assign severity ONLY to problems introduced or left unresolved by this change (critical/error/warning/info as appropriate). Do NOT create issue entries solely to acknowledge improvements; if no problems exist, return zero issues.</rule>
   </rules>
 </review_request>`;
         }
@@ -102344,10 +102369,12 @@ class CheckExecutionEngine {
                         //  - command provider execution/transform failures
                         //  - forEach validation/iteration errors
                         //  - fail_if conditions (global or check-specific)
-                        const hasFatalFailure = (depRes.issues || []).some(issue => {
+                        let hasFatalFailure = (depRes.issues || []).some(issue => {
                             const id = issue.ruleId || '';
                             return (id === 'command/execution_error' ||
                                 id.endsWith('/command/execution_error') ||
+                                id === 'command/timeout' ||
+                                id.endsWith('/command/timeout') ||
                                 id === 'command/transform_js_error' ||
                                 id.endsWith('/command/transform_js_error') ||
                                 id === 'command/transform_error' ||
@@ -102358,6 +102385,14 @@ class CheckExecutionEngine {
                                 id.endsWith('_fail_if') ||
                                 id.endsWith('/global_fail_if'));
                         });
+                        // As a fallback, evaluate fail_if on the dependency result now (in case the provider path didn't add issues yet)
+                        if (!hasFatalFailure && config && (config.fail_if || config.checks[depId]?.fail_if)) {
+                            const failIfResults = await this.evaluateFailureConditions(depId, depRes, config);
+                            hasFatalFailure = failIfResults.some(r => r.failed);
+                        }
+                        if (debug) {
+                            log(`🔧 Debug: gating check '${checkName}' against dep '${depId}': wasSkipped=${wasSkipped} hasFatalFailure=${hasFatalFailure}`);
+                        }
                         if (wasSkipped || hasFatalFailure)
                             failedDeps.push(depId);
                     }
@@ -102584,6 +102619,23 @@ class CheckExecutionEngine {
                                 issues: allIssues,
                                 ...(finalOutput !== undefined ? { output: finalOutput } : {}),
                             };
+                            // Evaluate fail_if for aggregated forEach results (applies to the whole check)
+                            if (config && (config.fail_if || checkConfig.fail_if)) {
+                                const failureResults = await this.evaluateFailureConditions(checkName, finalResult, config);
+                                if (failureResults.length > 0) {
+                                    const failureIssues = failureResults
+                                        .filter(f => f.failed)
+                                        .map(f => ({
+                                        file: 'system',
+                                        line: 0,
+                                        ruleId: f.conditionName,
+                                        message: f.message || `Failure condition met: ${f.expression}`,
+                                        severity: (f.severity || 'error'),
+                                        category: 'logic',
+                                    }));
+                                    finalResult.issues = [...(finalResult.issues || []), ...failureIssues];
+                                }
+                            }
                             // 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) {
@@ -102618,12 +102670,31 @@ class CheckExecutionEngine {
                         }
                         // Execute with retry/routing semantics
                         finalResult = await this.executeWithRouting(checkName, checkConfig, provider, providerConfig, prInfo, dependencyResults, sessionInfo, config, dependencyGraph, debug, results);
+                        // Evaluate fail_if for normal (non-forEach) execution
+                        if (config && (config.fail_if || checkConfig.fail_if)) {
+                            const failureResults = await this.evaluateFailureConditions(checkName, finalResult, config);
+                            if (failureResults.length > 0) {
+                                const failureIssues = failureResults
+                                    .filter(f => f.failed)
+                                    .map(f => ({
+                                    file: 'system',
+                                    line: 0,
+                                    ruleId: f.conditionName,
+                                    message: f.message || `Failure condition met: ${f.expression}`,
+                                    severity: (f.severity || 'error'),
+                                    category: 'logic',
+                                }));
+                                finalResult.issues = [...(finalResult.issues || []), ...failureIssues];
+                            }
+                        }
                         // Record normal (non-forEach) execution
                         // Check if this check had fatal errors
                         const hadFatalError = (finalResult.issues || []).some(issue => {
                             const id = issue.ruleId || '';
                             return (id === 'command/execution_error' ||
                                 id.endsWith('/command/execution_error') ||
+                                id === 'command/timeout' ||
+                                id.endsWith('/command/timeout') ||
                                 id === 'command/transform_js_error' ||
                                 id.endsWith('/command/transform_js_error') ||
                                 id === 'command/transform_error' ||
@@ -102646,6 +102717,13 @@ class CheckExecutionEngine {
                         if (debug) {
                             log(`🔧 Debug: Completed check: ${checkName}, issues found: ${(finalResult.issues || []).length}`);
                         }
+                        // Track cloned session IDs for cleanup
+                        if (finalResult.sessionId) {
+                            sessionIds.set(checkName, finalResult.sessionId);
+                            if (debug) {
+                                log(`🔧 Debug: Tracked cloned session for cleanup: ${finalResult.sessionId}`);
+                            }
+                        }
                     }
                     // Add checkName, group, schema, template info and timestamp to issues from config
                     const enrichedIssues = (finalResult.issues || []).map(issue => ({
@@ -105446,6 +105524,24 @@ class ConfigManager {
                 }
             }
         }
+        // Validate session_mode configuration
+        if (checkConfig.session_mode !== undefined) {
+            if (checkConfig.session_mode !== 'clone' && checkConfig.session_mode !== 'append') {
+                errors.push({
+                    field: `checks.${checkName}.session_mode`,
+                    message: `Invalid session_mode value for "${checkName}": must be 'clone' or 'append'`,
+                    value: checkConfig.session_mode,
+                });
+            }
+            // session_mode only makes sense with reuse_ai_session
+            if (!checkConfig.reuse_ai_session) {
+                errors.push({
+                    field: `checks.${checkName}.session_mode`,
+                    message: `Check "${checkName}" has session_mode but no reuse_ai_session. session_mode requires reuse_ai_session to be set.`,
+                    value: checkConfig.session_mode,
+                });
+            }
+        }
         // Validate tags configuration
         if (checkConfig.tags !== undefined) {
             if (!Array.isArray(checkConfig.tags)) {
@@ -106467,26 +106563,37 @@ class FailureConditionEvaluator {
         // Exclude issues from otherFields since we handle it separately
         issues: _issues, // eslint-disable-line @typescript-eslint/no-unused-vars
         ...otherFields } = reviewSummaryWithOutput;
+        // Build output object with safety for array-based outputs (forEach aggregation)
+        const aggregatedOutput = {
+            issues: (issues || []).map(issue => ({
+                file: issue.file,
+                line: issue.line,
+                endLine: issue.endLine,
+                ruleId: issue.ruleId,
+                message: issue.message,
+                severity: issue.severity,
+                category: issue.category,
+                group: issue.group,
+                schema: issue.schema,
+                suggestion: issue.suggestion,
+                replacement: issue.replacement,
+            })),
+            // Include additional schema-specific data from reviewSummary
+            ...otherFields,
+        };
+        if (Array.isArray(extractedOutput)) {
+            // Preserve items array and lift common flags for convenience (e.g., output.error)
+            aggregatedOutput.items = extractedOutput;
+            const anyError = extractedOutput.find(it => it && typeof it === 'object' && it.error);
+            if (anyError && anyError.error !== undefined) {
+                aggregatedOutput.error = anyError.error;
+            }
+        }
+        else if (extractedOutput && typeof extractedOutput === 'object') {
+            Object.assign(aggregatedOutput, extractedOutput);
+        }
         const context = {
-            output: {
-                issues: (issues || []).map(issue => ({
-                    file: issue.file,
-                    line: issue.line,
-                    endLine: issue.endLine,
-                    ruleId: issue.ruleId,
-                    message: issue.message,
-                    severity: issue.severity,
-                    category: issue.category,
-                    group: issue.group,
-                    schema: issue.schema,
-                    suggestion: issue.suggestion,
-                    replacement: issue.replacement,
-                })),
-                // Include additional schema-specific data from reviewSummary
-                ...otherFields,
-                // Spread the extracted output directly (avoid output.output nesting)
-                ...(extractedOutput && typeof extractedOutput === 'object' ? extractedOutput : {}),
-            },
+            output: aggregatedOutput,
             outputs: (() => {
                 if (!previousOutputs)
                     return {};
@@ -106813,6 +106920,11 @@ exports.configSchema = {
                     type: ['string', 'boolean'],
                     description: 'Check name to reuse AI session from, or true to use first dependency (only works with depends_on)',
                 },
+                session_mode: {
+                    type: 'string',
+                    enum: ['clone', 'append'],
+                    description: "How to reuse AI session: 'clone' (default, copy history) or 'append' (share history)",
+                },
                 fail_if: {
                     type: 'string',
                     description: 'Simple fail condition - fails check if expression evaluates to true',
@@ -107939,11 +108051,13 @@ class GitHubCheckService {
                 await this.clearOldAnnotations(owner, repo, prNumber, checkName, currentCommitSha, check_run_id);
             }
             const { conclusion, summary } = this.determineCheckRunConclusion(checkName, failureResults, reviewIssues, executionError);
+            // Filter out system-level issues (fail_if conditions, internal errors)
+            // These should not appear as annotations but affect the check conclusion
+            let filteredIssues = reviewIssues.filter(issue => !(issue.file === 'system' && issue.line === 0));
             // Filter annotations to only include files changed in this commit
             // This prevents old annotations from previous commits showing up in the Files tab
-            let filteredIssues = reviewIssues;
             if (filesChangedInCommit && filesChangedInCommit.length > 0) {
-                filteredIssues = reviewIssues.filter(issue => filesChangedInCommit.some(changedFile => issue.file === changedFile));
+                filteredIssues = filteredIssues.filter(issue => filesChangedInCommit.some(changedFile => issue.file === changedFile));
             }
             const annotations = this.convertIssuesToAnnotations(filteredIssues);
             await this.octokit.rest.checks.update({
@@ -108926,7 +109040,39 @@ async function handleEvent(octokit, inputs, eventName, context, config) {
     if (!owner || !repo) {
         throw new Error('Owner and repo are required');
     }
-    console.log(`Event: ${eventName}, Owner: ${owner}, Repo: ${repo}`);
+    // Determine context type for better logging
+    const isPullRequest = eventName === 'pull_request';
+    const isIssue = eventName === 'issues';
+    const isIssueComment = eventName === 'issue_comment';
+    const isManualCLI = !eventName || eventName === 'unknown';
+    // Map GitHub event to our event trigger format
+    const eventType = mapGitHubEventToTrigger(eventName, context.event?.action);
+    // Enhanced event logging with context
+    if (isManualCLI) {
+        console.log(`🖥️  Mode: Manual CLI`);
+        console.log(`📂 Repository: ${owner}/${repo}`);
+    }
+    else {
+        console.log(`🤖 Mode: GitHub Action`);
+        console.log(`📂 Repository: ${owner}/${repo}`);
+        console.log(`📋 Event: ${eventName}${context.event?.action ? ` (action: ${context.event?.action})` : ''}`);
+        console.log(`🎯 Trigger: ${eventType}`);
+        // Show context-specific information
+        if (isPullRequest) {
+            const prNumber = context.event?.pull_request?.number;
+            console.log(`🔀 Context: Pull Request #${prNumber}`);
+        }
+        else if (isIssue) {
+            const issueNumber = context.event?.issue?.number;
+            console.log(`🎫 Context: Issue #${issueNumber}`);
+        }
+        else if (isIssueComment) {
+            const issueOrPR = context.event?.issue;
+            const isPR = issueOrPR?.pull_request ? true : false;
+            const number = issueOrPR?.number;
+            console.log(`💬 Context: Comment on ${isPR ? 'Pull Request' : 'Issue'} #${number}`);
+        }
+    }
     // Debug: Log the checks that are available in the loaded config
     const allChecks = Object.keys(config.checks || {});
     console.log(`📚 Total checks in loaded config: ${allChecks.length}`);
@@ -108934,8 +109080,6 @@ async function handleEvent(octokit, inputs, eventName, context, config) {
         // Only log check names if there aren't too many
         console.log(`📚 Available checks: ${allChecks.join(', ')}`);
     }
-    // Map GitHub event to our event trigger format
-    const eventType = mapGitHubEventToTrigger(eventName, context.event?.action);
     // Find checks that should run for this event
     let checksToRun = [];
     // First, get all checks that are configured for this event type
@@ -109059,7 +109203,7 @@ async function handleIssueEvent(octokit, owner, repo, context, inputs, config, c
         console.log('Skipping PR-related issue event');
         return;
     }
-    console.log(`Processing issue #${issue.number} event: ${action} with checks: ${checksToRun.join(', ')}`);
+    console.log(`📋 Processing issue #${issue.number} event: ${action} with ${checksToRun.length} check(s): ${checksToRun.join(', ')}`);
     // For issue events, we need to create a PR-like structure for the checks to process
     // This allows us to reuse the existing check infrastructure
     const prInfo = {
@@ -109098,6 +109242,19 @@ async function handleIssueEvent(octokit, owner, repo, context, inputs, config, c
         config, undefined, // outputFormat
         inputs.debug === 'true');
         const { results } = executionResult;
+        // Log execution results for debugging (only in debug mode)
+        if (inputs.debug === 'true') {
+            console.log(`📊 Check execution completed: ${Object.keys(results).length} group(s)`);
+            for (const [group, checks] of Object.entries(results)) {
+                console.log(`   Group "${group}": ${checks.length} check(s)`);
+                for (const check of checks) {
+                    const hasContent = check.content && check.content.trim();
+                    const contentLength = hasContent ? check.content.trim().length : 0;
+                    const issueCount = check.issues?.length || 0;
+                    console.log(`      - ${check.checkName}: ${hasContent ? `${contentLength} chars` : 'empty'}, ${issueCount} issue(s)`);
+                }
+            }
+        }
         // Format and post results as a comment on the issue
         if (Object.keys(results).length > 0) {
             let commentBody = '';
@@ -109109,18 +109266,24 @@ async function handleIssueEvent(octokit, owner, repo, context, inputs, config, c
                     }
                 }
             }
-            commentBody += `\n---\n*Powered by [Visor](https://github.com/probelabs/visor)*`;
-            // Post comment to the issue
-            await octokit.rest.issues.createComment({
-                owner,
-                repo,
-                issue_number: issue.number,
-                body: commentBody,
-            });
-            console.log(`✅ Posted issue assistant results to issue #${issue.number}`);
+            // Only post if there's actual content (not just empty checks)
+            if (commentBody.trim()) {
+                commentBody += `\n---\n*Powered by [Visor](https://github.com/probelabs/visor)*`;
+                // Post comment to the issue
+                await octokit.rest.issues.createComment({
+                    owner,
+                    repo,
+                    issue_number: issue.number,
+                    body: commentBody,
+                });
+                console.log(`✅ Posted issue assistant results to issue #${issue.number}`);
+            }
+            else {
+                console.log('ℹ️ No content to post - all checks returned empty results');
+            }
         }
         else {
-            console.log('No results from issue assistant checks');
+            console.log('⚠️ No results from issue assistant checks');
         }
         // Set outputs for GitHub Actions
         (0, core_1.setOutput)('review-completed', 'true');
@@ -109150,7 +109313,7 @@ async function handleIssueComment(octokit, owner, repo, context, inputs, actionC
             comment.body.includes('*Powered by [Visor](https://probelabs.com/visor)') ||
             comment.body.includes('*Powered by [Visor](https://github.com/probelabs/visor)'));
     if (isVisorBot || hasVisorMarkers) {
-        console.log(`Skipping visor comment to prevent recursion. Author: ${comment.user?.login}, Type: ${comment.user?.type}, Has markers: ${hasVisorMarkers}`);
+        console.log(`✓ Skipping bot's own comment to prevent recursion. Author: ${comment.user?.login}, Type: ${comment.user?.type}, Has markers: ${hasVisorMarkers}`);
         return;
     }
     // Process comments on both issues and PRs
@@ -109577,7 +109740,11 @@ async function createGitHubChecks(octokit, inputs, owner, repo, headSha, checksT
                     console.log(`✅ Created check run for ${checkName}: ${checkRun.url}`);
                 }
                 catch (error) {
-                    console.error(`❌ Failed to create check run for ${checkName}:`, error);
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    // Extract just the meaningful error message without stack trace
+                    const cleanMessage = errorMessage.split('\n')[0].replace('Error: ', '');
+                    console.error(`⚠️  Could not create check run for ${checkName}: ${cleanMessage}`);
+                    console.log('💬 Review will continue using PR comments instead');
                     // Continue with other checks even if one fails
                 }
             }
@@ -109603,7 +109770,10 @@ async function createGitHubChecks(octokit, inputs, owner, repo, headSha, checksT
                 console.log(`✅ Created combined check run: ${checkRun.url}`);
             }
             catch (error) {
-                console.error(`❌ Failed to create combined check run:`, error);
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                const cleanMessage = errorMessage.split('\n')[0].replace('Error: ', '');
+                console.error(`⚠️  Could not create combined check run: ${cleanMessage}`);
+                console.log('💬 Review will continue using PR comments instead');
             }
         }
         return {
@@ -109627,7 +109797,10 @@ async function createGitHubChecks(octokit, inputs, owner, repo, headSha, checksT
             };
         }
         else {
-            console.error('❌ Failed to create GitHub check runs:', error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const cleanMessage = errorMessage.split('\n')[0].replace('Error: ', '');
+            console.error(`⚠️  Could not create GitHub check runs: ${cleanMessage}`);
+            console.log('💬 Review will continue using PR comments instead');
             return {
                 checkRunMap: null,
                 checksApiAvailable: false,
@@ -110280,14 +110453,22 @@ exports.OutputFormatters = void 0;
 const cli_table3_1 = __importDefault(__nccwpck_require__(25832));
 const reviewer_1 = __nccwpck_require__(532);
 class OutputFormatters {
+    // Hard safety limits to prevent pathological table rendering hangs
+    // Can be tuned via env vars if needed
+    static MAX_CELL_CHARS = parseInt(process.env.VISOR_MAX_TABLE_CELL || '4000', 10);
+    static MAX_CODE_LINES = parseInt(process.env.VISOR_MAX_TABLE_CODE_LINES || '120', 10);
+    static WRAP_WIDTH_MESSAGE = 55;
+    static WRAP_WIDTH_MESSAGE_NARROW = 45;
+    static WRAP_WIDTH_CODE = 58; // fits into Message col width ~60
     /**
      * Format analysis results as a table using cli-table3
      */
     static formatAsTable(result, options = {}) {
         const { showDetails = false, groupByCategory = true } = options;
         let output = '';
-        // Calculate metrics from issues once at the top
-        const issues = result.reviewSummary.issues || [];
+        // Filter out system-level issues (fail_if conditions, internal errors)
+        // These should not appear in user-facing output
+        const issues = (result.reviewSummary.issues || []).filter(issue => !(issue.file === 'system' && issue.line === 0));
         const totalIssues = issues.length;
         const criticalIssues = issues.filter(i => i.severity === 'critical').length;
         // Check if this is a code review context
@@ -110314,7 +110495,7 @@ class OutputFormatters {
                 summaryTable.push(['Files Analyzed', result.repositoryInfo.files.length.toString()], ['Total Additions', result.repositoryInfo.totalAdditions.toString()], ['Total Deletions', result.repositoryInfo.totalDeletions.toString()]);
             }
             // Always show execution time and checks executed
-            summaryTable.push(['Execution Time', `${result.executionTime}ms`], ['Checks Executed', result.checksExecuted.join(', ')]);
+            summaryTable.push(['Execution Time', `${result.executionTime}ms`], ['Checks Executed', this.truncateCell(result.checksExecuted.join(', '))]);
             output += 'Analysis Summary\n';
             output += summaryTable.toString() + '\n';
             output += '\n';
@@ -110329,7 +110510,8 @@ class OutputFormatters {
                     const categoryTable = new cli_table3_1.default({
                         head: ['File', 'Line', 'Severity', 'Message'],
                         colWidths: [25, 8, 15, 60],
-                        wordWrap: true,
+                        // We pre-wrap and truncate ourselves to avoid expensive wrap-ansi work
+                        wordWrap: false,
                         style: {
                             head: ['cyan', 'bold'],
                             border: ['grey'],
@@ -110339,25 +110521,24 @@ class OutputFormatters {
                     for (const comment of comments.slice(0, showDetails ? comments.length : 5)) {
                         // Convert comment back to issue to access suggestion/replacement fields
                         const issue = (issues || []).find(i => i.file === comment.file && i.line === comment.line);
-                        let messageContent = this.wrapText(comment.message, 55);
+                        // Pre-wrap and truncate content to keep cli-table3 fast and responsive
+                        let messageContent = this.safeWrapAndTruncate(comment.message, OutputFormatters.WRAP_WIDTH_MESSAGE);
                         // Add suggestion if available
                         if (issue?.suggestion) {
-                            messageContent += '\nSuggestion: ' + this.wrapText(issue.suggestion, 53);
+                            messageContent +=
+                                '\nSuggestion: ' +
+                                    this.safeWrapAndTruncate(issue.suggestion, OutputFormatters.WRAP_WIDTH_MESSAGE - 2);
                         }
                         // Add replacement code if available
                         if (issue?.replacement) {
-                            messageContent +=
-                                '\nCode fix:\n' +
-                                    issue.replacement
-                                        .split('\n')
-                                        .map(line => '  ' + line)
-                                        .join('\n');
+                            const code = this.formatCodeBlock(issue.replacement);
+                            messageContent += '\nCode fix:\n' + code;
                         }
                         categoryTable.push([
                             comment.file,
                             comment.line.toString(),
                             { content: this.formatSeverity(comment.severity), hAlign: 'center' },
-                            messageContent,
+                            this.truncateCell(messageContent),
                         ]);
                     }
                     output += categoryTable.toString() + '\n';
@@ -110372,7 +110553,7 @@ class OutputFormatters {
                 const issuesTable = new cli_table3_1.default({
                     head: ['File', 'Line', 'Category', 'Severity', 'Message'],
                     colWidths: [20, 6, 12, 15, 50],
-                    wordWrap: true,
+                    wordWrap: false,
                     style: {
                         head: ['cyan', 'bold'],
                         border: ['grey'],
@@ -110380,26 +110561,24 @@ class OutputFormatters {
                 });
                 output += 'All Issues\n';
                 for (const issue of issues.slice(0, showDetails ? undefined : 10)) {
-                    let messageContent = this.wrapText(issue.message, 45);
+                    let messageContent = this.safeWrapAndTruncate(issue.message, OutputFormatters.WRAP_WIDTH_MESSAGE_NARROW);
                     // Add suggestion if available
                     if (issue.suggestion) {
-                        messageContent += '\nSuggestion: ' + this.wrapText(issue.suggestion, 43);
+                        messageContent +=
+                            '\nSuggestion: ' +
+                                this.safeWrapAndTruncate(issue.suggestion, OutputFormatters.WRAP_WIDTH_MESSAGE_NARROW - 2);
                     }
                     // Add replacement code if available
                     if (issue.replacement) {
-                        messageContent +=
-                            '\nCode fix:\n' +
-                                issue.replacement
-                                    .split('\n')
-                                    .map(line => '  ' + line)
-                                    .join('\n');
+                        const code = this.formatCodeBlock(issue.replacement);
+                        messageContent += '\nCode fix:\n' + code;
                     }
                     issuesTable.push([
                         this.truncateText(issue.file, 18),
                         issue.line.toString(),
                         issue.category,
                         this.formatSeverity(issue.severity),
-                        messageContent,
+                        this.truncateCell(messageContent),
                     ]);
                 }
                 output += issuesTable.toString() + '\n\n';
@@ -110439,8 +110618,8 @@ class OutputFormatters {
      * Format analysis results as JSON
      */
     static formatAsJSON(result, options = {}) {
-        // Calculate metrics from issues
-        const issues = result.reviewSummary.issues;
+        // Filter out system-level issues (fail_if conditions, internal errors)
+        const issues = (result.reviewSummary.issues || []).filter(issue => !(issue.file === 'system' && issue.line === 0));
         const totalIssues = (0, reviewer_1.calculateTotalIssues)(issues);
         const criticalIssues = (0, reviewer_1.calculateCriticalIssues)(issues);
         const jsonResult = {
@@ -110475,8 +110654,8 @@ class OutputFormatters {
      * Format analysis results as SARIF 2.1.0
      */
     static formatAsSarif(result, _options = {}) {
-        // Get issues from result
-        const issues = result.reviewSummary.issues;
+        // Filter out system-level issues (fail_if conditions, internal errors)
+        const issues = (result.reviewSummary.issues || []).filter(issue => !(issue.file === 'system' && issue.line === 0));
         // Generate unique rule definitions for each issue category
         const rules = [
             {
@@ -110598,8 +110777,8 @@ class OutputFormatters {
     static formatAsMarkdown(result, options = {}) {
         const { showDetails = false, groupByCategory = true } = options;
         let output = '';
-        // Calculate metrics from issues
-        const issues = result.reviewSummary.issues;
+        // Filter out system-level issues (fail_if conditions, internal errors)
+        const issues = (result.reviewSummary.issues || []).filter(issue => !(issue.file === 'system' && issue.line === 0));
         const totalIssues = (0, reviewer_1.calculateTotalIssues)(issues);
         const criticalIssues = (0, reviewer_1.calculateCriticalIssues)(issues);
         // Header with summary
@@ -110876,13 +111055,50 @@ class OutputFormatters {
             else {
                 if (currentLine)
                     lines.push(currentLine);
-                currentLine = word;
+                // Break overly-long words to avoid pathological wrapping in cli-table3
+                if (word.length > width) {
+                    const chunks = word.match(new RegExp(`.{1,${width}}`, 'g')) || [word];
+                    // First chunk becomes current line, the rest are full lines
+                    currentLine = chunks.shift() || '';
+                    for (const chunk of chunks)
+                        lines.push(chunk);
+                }
+                else {
+                    currentLine = word;
+                }
             }
         }
         if (currentLine)
             lines.push(currentLine);
         return lines.join('\n');
     }
+    // Truncate any cell content defensively
+    static truncateCell(text) {
+        if (text.length <= OutputFormatters.MAX_CELL_CHARS)
+            return text;
+        return text.substring(0, OutputFormatters.MAX_CELL_CHARS - 12) + '\n… [truncated]\n';
+    }
+    // Safer wrapper that first wraps, then truncates
+    static safeWrapAndTruncate(text, width) {
+        return this.truncateCell(this.wrapText(text, width));
+    }
+    // Format code blocks with line and width limits to keep rendering fast
+    static formatCodeBlock(code) {
+        const lines = code.split('\n');
+        const limited = lines.slice(0, OutputFormatters.MAX_CODE_LINES).map(line => {
+            // Soft-wrap code lines to avoid cli-table heavy wrapping
+            const chunks = line.match(new RegExp(`.{1,${OutputFormatters.WRAP_WIDTH_CODE}}`, 'g')) || [
+                '',
+            ];
+            return chunks.map(c => '  ' + c).join('\n');
+        });
+        let out = limited.join('\n');
+        // Indicate truncation of extra lines
+        if (lines.length > OutputFormatters.MAX_CODE_LINES) {
+            out += `\n  … [${lines.length - OutputFormatters.MAX_CODE_LINES} more lines truncated]`;
+        }
+        return this.truncateCell(out);
+    }
 }
 exports.OutputFormatters = OutputFormatters;
 
@@ -111535,10 +111751,12 @@ class AICheckProvider extends check_provider_interface_1.CheckProvider {
             let result;
             // Check if we should use session reuse
             if (sessionInfo?.reuseSession && sessionInfo.parentSessionId) {
+                // Get session_mode from config, default to 'clone'
+                const sessionMode = config.session_mode || 'clone';
                 if (aiConfig.debug) {
-                    console.error(`🔄 Debug: Using session reuse with parent session: ${sessionInfo.parentSessionId}`);
+                    console.error(`🔄 Debug: Using session reuse with parent session: ${sessionInfo.parentSessionId} (mode: ${sessionMode})`);
                 }
-                result = await service.executeReviewWithSessionReuse(prInfo, processedPrompt, sessionInfo.parentSessionId, schema, config.checkName);
+                result = await service.executeReviewWithSessionReuse(prInfo, processedPrompt, sessionInfo.parentSessionId, schema, config.checkName, sessionMode);
             }
             else {
                 if (aiConfig.debug) {
@@ -114317,10 +114535,43 @@ exports.PRReviewer = PRReviewer;
 /***/ }),
 
 /***/ 46059:
-/***/ ((__unused_webpack_module, exports) => {
+/***/ (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.SessionRegistry = void 0;
 /**
@@ -114413,6 +114664,59 @@ class SessionRegistry {
     hasSession(sessionId) {
         return this.sessions.has(sessionId);
     }
+    /**
+     * Clone a session with a new session ID
+     * Creates a new ProbeAgent with a copy of the conversation history
+     */
+    async cloneSession(sourceSessionId, newSessionId) {
+        const sourceAgent = this.sessions.get(sourceSessionId);
+        if (!sourceAgent) {
+            console.error(`⚠️  Cannot clone session: ${sourceSessionId} not found`);
+            return undefined;
+        }
+        try {
+            // Access the conversation history from the source agent
+            // ProbeAgent stores history in a private field, we need to access it via 'any'
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const sourceHistory = sourceAgent.conversationHistory || [];
+            // Create a new agent with the same configuration
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const sourceOptions = sourceAgent.options || {};
+            // Import ProbeAgent dynamically to create new instance
+            const { ProbeAgent: ProbeAgentClass } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(83841)));
+            const clonedAgent = new ProbeAgentClass({
+                ...sourceOptions,
+                sessionId: newSessionId,
+            });
+            // Deep copy the conversation history to ensure complete isolation
+            // Use JSON serialization for deep cloning to prevent shared object references
+            if (sourceHistory.length > 0) {
+                try {
+                    // Deep clone the history array and all message objects within it
+                    const deepClonedHistory = JSON.parse(JSON.stringify(sourceHistory));
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    clonedAgent.conversationHistory = deepClonedHistory;
+                    console.error(`📋 Cloned session ${sourceSessionId} → ${newSessionId} (${sourceHistory.length} messages, deep copy)`);
+                }
+                catch (cloneError) {
+                    // Fallback to shallow copy if deep clone fails (e.g., circular references)
+                    console.error(`⚠️  Warning: Deep clone failed for session ${sourceSessionId}, using shallow copy: ${cloneError}`);
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    clonedAgent.conversationHistory = [...sourceHistory];
+                }
+            }
+            else {
+                console.error(`📋 Cloned session ${sourceSessionId} → ${newSessionId} (no history)`);
+            }
+            // Register the cloned session
+            this.registerSession(newSessionId, clonedAgent);
+            return clonedAgent;
+        }
+        catch (error) {
+            console.error(`⚠️  Failed to clone session ${sourceSessionId}: ${error}`);
+            return undefined;
+        }
+    }
     /**
      * Register process exit handlers to cleanup sessions on exit
      */
@@ -231977,7 +232281,7 @@ module.exports = /*#__PURE__*/JSON.parse('{"application/1d-interleaved-parityfec
 /***/ ((module) => {
 
 "use strict";
-module.exports = {"rE":"0.1.86"};
+module.exports = {"rE":"0.1.88"};
 
 /***/ })