cc-reviewer 2.0.0 → 2.1.0

package/dist/adapters/gemini.js

@@ -2,22 +2,20 @@
  * Gemini CLI Adapter
  *
  * Implements the ReviewerAdapter interface for Google's Gemini CLI.
- * Specializes in architecture, design patterns, and large-context analysis.
+ * Returns raw text — no JSON parsing or schema enforcement.
+ * CC handles interpretation of the reviewer's response.
  */
 import { spawn } from 'child_process';
 import { existsSync } from 'fs';
 import { registerAdapter, } from './base.js';
-import { parseReviewOutput, parseLegacyMarkdownOutput, parsePeerOutput, isSubstantiveReview } from '../schema.js';
 import { CliExecutor } from '../executor.js';
 import { GeminiEventDecoder } from '../decoders/index.js';
 import { buildSimpleHandoff, buildHandoffPrompt, buildPeerPrompt, selectRole, } from '../handoff.js';
 // =============================================================================
 // CONFIGURATION
 // =============================================================================
-const COLD_START_TIMEOUT_MS = 300_000; // 5 min — waiting for first JSONL event
-const STREAMING_TIMEOUT_MS = 90_000; // 90s — if events stop mid-stream
+const INACTIVITY_TIMEOUT_MS = 300_000; // 5 min — covers reasoning gaps between tool use
 const MAX_TIMEOUT_MS = 3_600_000; // 60 min absolute max
-const MAX_RETRIES = 2;
 const MAX_BUFFER_SIZE = 1024 * 1024; // 1MB max buffer
 // =============================================================================
 // GEMINI ADAPTER
@@ -31,9 +29,9 @@ export class GeminiAdapter {
             strengths: ['architecture', 'maintainability', 'scalability', 'documentation'],
             weaknesses: ['security'],
             hasFilesystemAccess: true,
-            supportsStructuredOutput: true,
-            maxContextTokens: 2000000, // Gemini has very large context
-            reasoningLevels: undefined, // Gemini doesn't have configurable reasoning
+            supportsStructuredOutput: false,
+            maxContextTokens: 2000000,
+            reasoningLevels: undefined,
         };
     }
     async isAvailable() {
@@ -41,174 +39,42 @@ export class GeminiAdapter {
             const proc = spawn('gemini', ['--version'], {
                 stdio: ['ignore', 'pipe', 'pipe'],
             });
-            proc.on('close', (code) => {
-                resolve(code === 0);
-            });
-            proc.on('error', () => {
-                resolve(false);
-            });
-            // Timeout after 5s
-            setTimeout(() => {
-                proc.kill();
-                resolve(false);
-            }, 5000);
+            proc.on('close', (code) => resolve(code === 0));
+            proc.on('error', () => resolve(false));
+            setTimeout(() => { proc.kill(); resolve(false); }, 5000);
         });
     }
     async runReview(request) {
         const startTime = Date.now();
-        // Validate working directory
         if (!existsSync(request.workingDir)) {
             return {
                 success: false,
-                error: {
-                    type: 'cli_error',
-                    message: `Working directory does not exist: ${request.workingDir}`,
-                },
+                error: { type: 'cli_error', message: `Working directory does not exist: ${request.workingDir}` },
                 suggestion: 'Check that the working directory path is correct',
                 executionTimeMs: Date.now() - startTime,
             };
         }
-        return this.runWithRetry(request, 0, startTime);
-    }
-    async runWithRetry(request, attempt, startTime, previousError, previousOutput) {
         try {
-            // Build the prompt using handoff protocol
             const handoff = buildSimpleHandoff(request.workingDir, request.ccOutput, request.analyzedFiles, request.focusAreas, request.customPrompt);
-            // Select role based on focus areas (Gemini defaults to architect)
             const role = selectRole(request.focusAreas);
-            // Build prompt with retry context if needed
-            let prompt = buildHandoffPrompt({
-                handoff,
-                role,
-                outputFormat: 'json',
-            });
-            // Add retry context if this is a retry attempt
-            if (attempt > 0) {
-                prompt += `\n\n---\n\n# RETRY ATTEMPT ${attempt + 1}\n\n` +
-                    `Previous output had issues: ${previousError}\n` +
-                    `Please fix these issues and provide valid JSON output.\n` +
-                    (previousOutput ? `\nPrevious output (for reference):\n${previousOutput.slice(0, 500)}...` : '');
-            }
-            // Run the CLI
+            const prompt = buildHandoffPrompt({ handoff, role });
             const result = await this.runCli(prompt, request.workingDir);
-            // Handle CLI errors
             if (result.exitCode !== 0) {
                 const error = this.categorizeError(result.stderr);
-                return {
-                    success: false,
-                    error,
-                    suggestion: this.getSuggestion(error),
-                    rawOutput: result.stderr,
-                    executionTimeMs: Date.now() - startTime,
-                };
+                return { success: false, error, suggestion: this.getSuggestion(error), executionTimeMs: Date.now() - startTime };
             }
-            // Handle buffer truncation
-            if (result.truncated) {
+            if (!result.stdout.trim()) {
                 return {
                     success: false,
-                    error: {
-                        type: 'cli_error',
-                        message: 'Output exceeded maximum buffer size (1MB) and was truncated',
-                    },
-                    suggestion: 'Try reviewing a smaller scope with --focus',
+                    error: { type: 'cli_error', message: 'Gemini returned empty response' },
+                    suggestion: 'Try again or use /codex instead',
                     executionTimeMs: Date.now() - startTime,
                 };
             }
-            // Parse the output
-            let output = parseReviewOutput(result.stdout);
-            let usedFallback = false;
-            // If JSON parsing fails, try legacy markdown
-            if (!output) {
-                output = parseLegacyMarkdownOutput(result.stdout, 'gemini');
-                usedFallback = true;
-            }
-            // If no valid output, retry or fail
-            if (!output) {
-                if (attempt < MAX_RETRIES) {
-                    return this.runWithRetry(request, attempt + 1, startTime, 'Output did not match expected JSON schema', result.stdout);
-                }
-                return {
-                    success: false,
-                    error: {
-                        type: 'parse_error',
-                        message: 'Failed to parse reviewer output after retries',
-                        details: { rawOutput: result.stdout.slice(0, 1000) },
-                    },
-                    suggestion: 'The model may not be following the output format. Try a different focus area.',
-                    rawOutput: result.stdout,
-                    executionTimeMs: Date.now() - startTime,
-                };
-            }
-            // Check for empty/minimal output — centralized substance check
-            if (!isSubstantiveReview(output)) {
-                if (attempt < MAX_RETRIES) {
-                    console.error(`[gemini] Received empty output, retrying...`);
-                    return this.runWithRetry(request, attempt + 1, startTime, usedFallback
-                        ? 'Received markdown output instead of JSON. Please provide valid JSON output.'
-                        : 'Output contained no substantive review content. Please provide findings or analysis.', result.stdout);
-                }
-                return {
-                    success: false,
-                    error: {
-                        type: 'parse_error',
-                        message: 'Reviewer returned empty output after retries',
-                        details: { rawOutput: result.stdout.slice(0, 1000) },
-                    },
-                    suggestion: 'The model returned no substantive review. Try a different focus area.',
-                    rawOutput: result.stdout,
-                    executionTimeMs: Date.now() - startTime,
-                };
-            }
-            return {
-                success: true,
-                output,
-                rawOutput: result.stdout,
-                executionTimeMs: Date.now() - startTime,
-            };
+            return { success: true, output: result.stdout, executionTimeMs: Date.now() - startTime };
         }
         catch (error) {
-            const err = error;
-            if (err.code === 'ENOENT') {
-                return {
-                    success: false,
-                    error: {
-                        type: 'cli_not_found',
-                        message: 'Gemini CLI not found',
-                    },
-                    suggestion: 'Install with: npm install -g @google/gemini-cli',
-                    executionTimeMs: Date.now() - startTime,
-                };
-            }
-            if (err.message === 'TIMEOUT') {
-                return {
-                    success: false,
-                    error: {
-                        type: 'timeout',
-                        message: 'No output for 10 minutes - process may be hung',
-                    },
-                    suggestion: 'Try a smaller scope or use --focus',
-                    executionTimeMs: Date.now() - startTime,
-                };
-            }
-            if (err.message === 'MAX_TIMEOUT') {
-                return {
-                    success: false,
-                    error: {
-                        type: 'timeout',
-                        message: 'Task exceeded 60 minute maximum',
-                    },
-                    suggestion: 'Try a smaller scope',
-                    executionTimeMs: Date.now() - startTime,
-                };
-            }
-            return {
-                success: false,
-                error: {
-                    type: 'cli_error',
-                    message: err.message,
-                },
-                executionTimeMs: Date.now() - startTime,
-            };
+            return this.handleException(error, startTime);
         }
     }
     async runPeerRequest(request) {
@@ -221,11 +87,8 @@ export class GeminiAdapter {
                 executionTimeMs: Date.now() - startTime,
             };
         }
-        return this.runPeerWithRetry(request, 0, startTime);
-    }
-    async runPeerWithRetry(request, attempt, startTime, previousError, previousOutput) {
         try {
-            let prompt = buildPeerPrompt({
+            const prompt = buildPeerPrompt({
                 workingDir: request.workingDir,
                 prompt: request.prompt,
                 taskType: request.taskType,
@@ -233,81 +96,36 @@ export class GeminiAdapter {
                 context: request.context,
                 focusAreas: request.focusAreas,
                 customInstructions: request.customPrompt,
-                outputFormat: 'json',
             });
-            if (attempt > 0) {
-                prompt += `\n\n---\n\n# RETRY ATTEMPT ${attempt + 1}\n\n` +
-                    `Previous output had issues: ${previousError}\n` +
-                    `Please fix these issues and provide valid JSON output.\n` +
-                    (previousOutput ? `\nPrevious output (for reference):\n${previousOutput.slice(0, 500)}...` : '');
-            }
             const result = await this.runCli(prompt, request.workingDir);
             if (result.exitCode !== 0) {
                 const error = this.categorizeError(result.stderr);
-                return {
-                    success: false, error,
-                    suggestion: this.getSuggestion(error),
-                    rawOutput: result.stderr,
-                    executionTimeMs: Date.now() - startTime,
-                };
-            }
-            if (result.truncated) {
-                return {
-                    success: false,
-                    error: { type: 'cli_error', message: 'Output exceeded maximum buffer size (1MB)' },
-                    suggestion: 'Try a more focused request',
-                    executionTimeMs: Date.now() - startTime,
-                };
+                return { success: false, error, suggestion: this.getSuggestion(error), executionTimeMs: Date.now() - startTime };
             }
-            const output = parsePeerOutput(result.stdout);
-            if (!output) {
-                if (attempt < MAX_RETRIES) {
-                    return this.runPeerWithRetry(request, attempt + 1, startTime, 'Output did not match expected JSON schema', result.stdout);
-                }
+            if (!result.stdout.trim()) {
                 return {
                     success: false,
-                    error: { type: 'parse_error', message: 'Failed to parse peer output after retries',
-                        details: { rawOutput: result.stdout.slice(0, 1000) } },
-                    suggestion: 'The model may not be following the output format.',
-                    rawOutput: result.stdout,
+                    error: { type: 'cli_error', message: 'Gemini returned empty response' },
+                    suggestion: 'Try again or use /ask-codex instead',
                     executionTimeMs: Date.now() - startTime,
                 };
             }
-            return {
-                success: true, output,
-                rawOutput: result.stdout,
-                executionTimeMs: Date.now() - startTime,
-            };
+            return { success: true, output: result.stdout, executionTimeMs: Date.now() - startTime };
         }
         catch (error) {
-            const err = error;
-            if (err.code === 'ENOENT') {
-                return { success: false, error: { type: 'cli_not_found', message: 'Gemini CLI not found' },
-                    suggestion: 'Install with: npm install -g @google/gemini-cli', executionTimeMs: Date.now() - startTime };
-            }
-            if (err.message === 'TIMEOUT') {
-                return { success: false, error: { type: 'timeout', message: 'No output for 10 minutes' },
-                    suggestion: 'Try a simpler request', executionTimeMs: Date.now() - startTime };
-            }
-            if (err.message === 'MAX_TIMEOUT') {
-                return { success: false, error: { type: 'timeout', message: 'Task exceeded 60 minute maximum' },
-                    suggestion: 'Try a smaller scope', executionTimeMs: Date.now() - startTime };
-            }
-            return { success: false, error: { type: 'cli_error', message: err.message },
-                executionTimeMs: Date.now() - startTime };
+            return this.handleException(error, startTime);
         }
     }
     async runCli(prompt, workingDir) {
         const args = [
             '--yolo',
-            '--output-format', 'stream-json', // JSONL streaming events (was: json)
+            '--output-format', 'stream-json',
             '--include-directories', workingDir,
-            '-p', '', // Headless mode; prompt via stdin
+            '-p', '',
         ];
         const decoder = new GeminiEventDecoder();
         const cliStartTime = Date.now();
-        let firstEventReceived = false;
-        console.error('[gemini] Running review...');
+        console.error('[gemini] Running...');
         decoder.onProgress = (eventType, detail) => {
             const elapsed = Math.round((Date.now() - cliStartTime) / 1000);
             const detailStr = detail ? ` — ${detail}` : '';
@@ -318,15 +136,11 @@ export class GeminiAdapter {
             args,
             cwd: workingDir,
             stdin: prompt,
-            inactivityTimeoutMs: COLD_START_TIMEOUT_MS,
+            inactivityTimeoutMs: INACTIVITY_TIMEOUT_MS,
             maxTimeoutMs: MAX_TIMEOUT_MS,
             maxBufferSize: MAX_BUFFER_SIZE,
             onLine: (line) => {
                 decoder.processLine(line);
-                if (!firstEventReceived) {
-                    firstEventReceived = true;
-                    executor.setInactivityTimeout(STREAMING_TIMEOUT_MS);
-                }
             },
         });
         const result = await executor.run();
@@ -340,46 +154,41 @@ export class GeminiAdapter {
             truncated: result.truncated,
         };
     }
+    handleException(error, startTime) {
+        const err = error;
+        if (err.code === 'ENOENT') {
+            return { success: false, error: { type: 'cli_not_found', message: 'Gemini CLI not found' },
+                suggestion: 'Install with: npm install -g @google/gemini-cli', executionTimeMs: Date.now() - startTime };
+        }
+        if (err.message === 'TIMEOUT') {
+            return { success: false, error: { type: 'timeout', message: 'Gemini timed out — no events received' },
+                suggestion: 'Try a smaller scope or use /codex', executionTimeMs: Date.now() - startTime };
+        }
+        if (err.message === 'MAX_TIMEOUT') {
+            return { success: false, error: { type: 'timeout', message: 'Task exceeded 60 minute maximum' },
+                suggestion: 'Try a smaller scope', executionTimeMs: Date.now() - startTime };
+        }
+        return { success: false, error: { type: 'cli_error', message: err.message }, executionTimeMs: Date.now() - startTime };
+    }
     categorizeError(stderr) {
         const lower = stderr.toLowerCase();
         if (lower.includes('rate limit') || lower.includes('quota')) {
-            return {
-                type: 'rate_limit',
-                message: 'Rate limit or quota exceeded',
-                details: { retryAfterMs: this.parseRetryAfter(stderr) },
-            };
+            return { type: 'rate_limit', message: 'Rate limit or quota exceeded' };
         }
-        if (lower.includes('unauthorized') || lower.includes('authentication') ||
-            lower.includes('api key') || stderr.includes('401') || stderr.includes('403')) {
-            return {
-                type: 'auth_error',
-                message: 'Authentication failed',
-                details: { stderr },
-            };
+        if (lower.includes('unauthorized') || lower.includes('authentication') || lower.includes('api key') || stderr.includes('401') || stderr.includes('403')) {
+            return { type: 'auth_error', message: 'Authentication failed', details: { stderr } };
         }
-        return {
-            type: 'cli_error',
-            message: stderr || 'Unknown error',
-        };
+        return { type: 'cli_error', message: stderr || 'Unknown error' };
     }
     getSuggestion(error) {
         switch (error.type) {
-            case 'rate_limit':
-                return 'Wait and retry, or use /codex instead';
-            case 'auth_error':
-                return 'Run `gemini` and follow auth prompts, or set GEMINI_API_KEY';
-            case 'cli_not_found':
-                return 'Install with: npm install -g @google/gemini-cli';
-            default:
-                return 'Check the error message and try again';
+            case 'rate_limit': return 'Wait and retry, or use /codex instead';
+            case 'auth_error': return 'Run `gemini` and follow auth prompts, or set GEMINI_API_KEY';
+            case 'cli_not_found': return 'Install with: npm install -g @google/gemini-cli';
+            default: return 'Check the error message and try again';
         }
     }
-    parseRetryAfter(errorMessage) {
-        const match = errorMessage.match(/retry[- ]?after[:\s]+(\d+)/i);
-        return match ? parseInt(match[1]) * 1000 : undefined;
-    }
 }
 // Register the adapter
 registerAdapter(new GeminiAdapter());
-// Export for direct use
 export const geminiAdapter = new GeminiAdapter();

package/dist/decoders/codex.d.ts

@@ -42,6 +42,8 @@ export declare class CodexEventDecoder {
     onProgress?: (eventType: string, detail?: string) => void;
     private _finalResponse;
     private _usage;
+    private _error;
+    private _eventCount;
     /**
      * Parse a single JSONL line. Silently skips malformed or empty input.
      */
@@ -56,5 +58,14 @@ export declare class CodexEventDecoder {
      * `null` if no such event has been seen.
      */
     getUsage(): CodexEvent['usage'] | null;
+    /**
+     * Returns the error message from `error` or `turn.failed` events, or `null`.
+     */
+    getError(): string | null;
+    /**
+     * Returns true if events were received but no agent_message was produced.
+     * Combined with a fast exit, this indicates rate limiting or instant rejection.
+     */
+    hasNoOutput(): boolean;
     private _handleEvent;
 }

package/dist/decoders/codex.js

@@ -25,6 +25,10 @@ export class CodexEventDecoder {
     _finalResponse = null;
     // Token usage from the most recently seen turn.completed
     _usage = null;
+    // Error message from error/turn.failed events
+    _error = null;
+    // Count of events received (0 = possible rate limit / instant rejection)
+    _eventCount = 0;
     // =============================================================================
     // PUBLIC API
     // =============================================================================
@@ -63,10 +67,24 @@ export class CodexEventDecoder {
     getUsage() {
         return this._usage;
     }
+    /**
+     * Returns the error message from `error` or `turn.failed` events, or `null`.
+     */
+    getError() {
+        return this._error;
+    }
+    /**
+     * Returns true if events were received but no agent_message was produced.
+     * Combined with a fast exit, this indicates rate limiting or instant rejection.
+     */
+    hasNoOutput() {
+        return this._eventCount > 0 && this._finalResponse === null;
+    }
     // =============================================================================
     // PRIVATE HELPERS
     // =============================================================================
     _handleEvent(event) {
+        this._eventCount++;
         // Track the last agent_message text
         if (event.type === 'item.completed' &&
             event.item?.type === 'agent_message' &&
@@ -77,6 +95,17 @@ export class CodexEventDecoder {
         if (event.type === 'turn.completed' && event.usage != null) {
             this._usage = event.usage;
         }
+        // Capture errors from error/turn.failed events
+        if (event.type === 'error') {
+            this._error = event.message || 'Unknown error from Codex';
+        }
+        if (event.type === 'turn.failed') {
+            this._error = event.error?.message || 'Turn failed';
+        }
+        // Capture error items (e.g. model errors reported as item.completed with type=error)
+        if (event.type === 'item.completed' && event.item?.type === 'error') {
+            this._error = event.item.message || event.item.text || 'Model error';
+        }
         // Notify caller
         this.onProgress?.(event.type, describeEvent(event));
     }

package/dist/handoff.d.ts

@@ -214,10 +214,10 @@ export declare function selectRole(focusAreas?: FocusArea[]): ReviewerRole;
 export interface PromptOptions {
     handoff: Handoff;
     role?: ReviewerRole;
-    outputFormat: 'json' | 'markdown' | 'schema-enforced';
 }
 /**
- * Build the review prompt using minimal, targeted context
+ * Build the review prompt using minimal, targeted context.
+ * No output format constraints — reviewer responds naturally, CC interprets.
  */
 export declare function buildHandoffPrompt(options: PromptOptions): string;
 /**
@@ -237,10 +237,9 @@ export interface PeerPromptOptions {
     context?: string;
     focusAreas?: FocusArea[];
     customInstructions?: string;
-    outputFormat: 'json' | 'schema-enforced';
 }
 /**
  * Build a prompt for general-purpose peer assistance (not review).
- * The peer acts as a collaborative coworker, not a critic.
+ * No output format constraints — peer responds naturally, CC interprets.
  */
 export declare function buildPeerPrompt(options: PeerPromptOptions): string;

package/dist/handoff.js

@@ -154,10 +154,11 @@ export function selectRole(focusAreas) {
     return CHANGE_FOCUSED_REVIEWER;
 }
 /**
- * Build the review prompt using minimal, targeted context
+ * Build the review prompt using minimal, targeted context.
+ * No output format constraints — reviewer responds naturally, CC interprets.
  */
 export function buildHandoffPrompt(options) {
-    const { handoff, outputFormat } = options;
+    const { handoff } = options;
     const role = options.role || selectRole(handoff.focusAreas);
     const sections = [];
     // SECTION 1: ROLE
@@ -197,38 +198,6 @@ ${handoff.decisions.map((d, i) => `${i + 1}. **${d.decision}**
     if (handoff.priorityFiles && handoff.priorityFiles.length > 0) {
         sections.push(`## PRIORITY FILES\n\n${handoff.priorityFiles.map(f => `- \`${f}\``).join('\n')}`);
     }
-    // SECTION 7: OUTPUT FORMAT
-    if (outputFormat === 'schema-enforced') {
-        sections.push(`## OUTPUT FORMAT
-Respond with valid JSON matching the schema. Confidence reflects YOUR certainty.`);
-    }
-    else if (outputFormat === 'json') {
-        sections.push(`## OUTPUT FORMAT
-Respond with valid JSON:
-\`\`\`json
-{
-  "findings": [{
-    "id": "string",
-    "category": "security|performance|correctness|architecture|other",
-    "severity": "critical|high|medium|low|info",
-    "confidence": 0.0-1.0,
-    "title": "string",
-    "description": "string",
-    "location": { "file": "string", "line_start": 0 },
-    "evidence": "code snippet",
-    "suggestion": "string"
-  }],
-  "uncertainty_responses": [{"uncertainty_index": 0, "verified": true, "finding": "string", "recommendation": "string"}],
-  "question_answers": [{"question_index": 0, "answer": "string", "confidence": 0.0-1.0}],
-  "agreements": ["string"],
-  "risk_assessment": { "level": "critical|high|medium|low|minimal", "summary": "string" }
-}
-\`\`\``);
-    }
-    else {
-        sections.push(`## OUTPUT FORMAT
-Structure: ## Findings, ## Uncertainty Responses, ## Question Answers, ## Agreements, ## Risk Assessment.`);
-    }
     return sections.join('\n\n');
 }
 // =============================================================================
@@ -260,10 +229,10 @@ export function enhanceHandoff(handoff, uncertainties, questions, decisions) {
 }
 /**
  * Build a prompt for general-purpose peer assistance (not review).
- * The peer acts as a collaborative coworker, not a critic.
+ * No output format constraints — peer responds naturally, CC interprets.
  */
 export function buildPeerPrompt(options) {
-    const { workingDir, prompt, taskType, relevantFiles, context, focusAreas, customInstructions, outputFormat } = options;
+    const { workingDir, prompt, taskType, relevantFiles, context, focusAreas, customInstructions } = options;
     const role = selectRole(focusAreas);
     const sections = [];
     // SECTION 1: ROLE
@@ -288,26 +257,5 @@ Be direct and actionable.`);
     if (customInstructions) {
         sections.push(`## ADDITIONAL INSTRUCTIONS\n\n${customInstructions}`);
     }
-    // SECTION 6: OUTPUT FORMAT
-    if (outputFormat === 'schema-enforced') {
-        sections.push(`## OUTPUT FORMAT
-Respond with valid JSON matching the schema. Confidence reflects YOUR certainty.`);
-    }
-    else {
-        sections.push(`## OUTPUT FORMAT
-Respond with valid JSON:
-\`\`\`json
-{
-  "responder": "string",
-  "answer": "markdown",
-  "confidence": 0.0-1.0,
-  "key_points": ["string"],
-  "suggested_actions": [{ "action": "string", "priority": "high|medium|low", "file": "string", "rationale": "string" }],
-  "file_references": [{ "path": "string", "lines": "string", "relevance": "string" }],
-  "alternatives": [{ "topic": "string", "current_approach": "string", "alternative": "string", "tradeoffs": { "pros": [], "cons": [] }, "recommendation": "string" }],
-  "execution_notes": "string"
-}
-\`\`\``);
-    }
     return sections.join('\n\n');
 }

package/dist/schema.d.ts

@@ -76,8 +76,8 @@ export declare const ReviewFinding: z.ZodObject<{
         column_start?: number | undefined;
         column_end?: number | undefined;
     } | undefined;
-    evidence?: string | undefined;
     suggestion?: string | undefined;
+    evidence?: string | undefined;
     cwe_id?: string | undefined;
     owasp_category?: string | undefined;
     tags?: string[] | undefined;
@@ -95,8 +95,8 @@ export declare const ReviewFinding: z.ZodObject<{
         column_start?: number | undefined;
         column_end?: number | undefined;
     } | undefined;
-    evidence?: string | undefined;
     suggestion?: string | undefined;
+    evidence?: string | undefined;
     cwe_id?: string | undefined;
     owasp_category?: string | undefined;
     tags?: string[] | undefined;
@@ -279,8 +279,8 @@ export declare const ReviewOutput: z.ZodObject<{
             column_start?: number | undefined;
             column_end?: number | undefined;
         } | undefined;
-        evidence?: string | undefined;
         suggestion?: string | undefined;
+        evidence?: string | undefined;
         cwe_id?: string | undefined;
         owasp_category?: string | undefined;
         tags?: string[] | undefined;
@@ -298,8 +298,8 @@ export declare const ReviewOutput: z.ZodObject<{
             column_start?: number | undefined;
             column_end?: number | undefined;
         } | undefined;
-        evidence?: string | undefined;
         suggestion?: string | undefined;
+        evidence?: string | undefined;
         cwe_id?: string | undefined;
         owasp_category?: string | undefined;
         tags?: string[] | undefined;
@@ -444,8 +444,8 @@ export declare const ReviewOutput: z.ZodObject<{
             column_start?: number | undefined;
             column_end?: number | undefined;
         } | undefined;
-        evidence?: string | undefined;
         suggestion?: string | undefined;
+        evidence?: string | undefined;
         cwe_id?: string | undefined;
         owasp_category?: string | undefined;
         tags?: string[] | undefined;
@@ -512,8 +512,8 @@ export declare const ReviewOutput: z.ZodObject<{
             column_start?: number | undefined;
             column_end?: number | undefined;
         } | undefined;
-        evidence?: string | undefined;
         suggestion?: string | undefined;
+        evidence?: string | undefined;
         cwe_id?: string | undefined;
         owasp_category?: string | undefined;
         tags?: string[] | undefined;