cc-reviewer 1.5.1 → 1.5.3

package/dist/adapters/codex.js

@@ -138,16 +138,29 @@ export class CodexAdapter {
                     executionTimeMs: Date.now() - startTime,
                 };
             }
-            // If we used fallback and got minimal data, retry
-            if (usedFallback && attempt < MAX_RETRIES) {
-                const hasMinimalData = output.findings.length === 0 &&
-                    output.agreements.length === 0 &&
-                    output.disagreements.length === 0 &&
-                    output.risk_assessment.summary === 'Unable to parse structured risk assessment';
-                if (hasMinimalData) {
-                    console.error(`[codex] Received incomplete output (fallback parse with no data), retrying...`);
-                    return this.runWithRetry(request, attempt + 1, startTime, 'Received markdown output instead of JSON. Please provide valid JSON output.', result.stdout);
+            // Check for empty/minimal data on any parse path
+            const hasMinimalData = output.findings.length === 0 &&
+                output.agreements.length === 0 &&
+                output.disagreements.length === 0;
+            if (hasMinimalData) {
+                if (attempt < MAX_RETRIES) {
+                    console.error(`[codex] 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 findings, agreements, or disagreements. Please provide substantive review.', result.stdout);
                 }
+                // Final attempt with no data — report failure
+                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,
@@ -236,6 +249,11 @@ export class CodexAdapter {
                 stdio: ['pipe', 'pipe', 'pipe'], // stdin is pipe for prompt delivery
                 env: { ...process.env }
             });
+            // Guard against EPIPE if the child exits before consuming stdin.
+            // Log but don't reject — let the `close` handler capture the real exit code.
+            proc.stdin.on('error', (err) => {
+                console.error(`[codex] stdin error (likely EPIPE): ${err.message}`);
+            });
             // Deliver prompt via stdin
             proc.stdin.write(prompt);
             proc.stdin.end();

package/dist/adapters/gemini.js

@@ -136,17 +136,29 @@ export class GeminiAdapter {
                     executionTimeMs: Date.now() - startTime,
                 };
             }
-            // If output has no substantive data, retry regardless of parse path
-            if (attempt < MAX_RETRIES) {
-                const hasMinimalData = output.findings.length === 0 &&
-                    output.agreements.length === 0 &&
-                    output.disagreements.length === 0;
-                if (hasMinimalData) {
+            // If output has no substantive data, retry or fail
+            const hasMinimalData = output.findings.length === 0 &&
+                output.agreements.length === 0 &&
+                output.disagreements.length === 0;
+            if (hasMinimalData) {
+                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 findings, agreements, or disagreements. Please provide substantive review.', result.stdout);
                 }
+                // Final attempt with no data — report failure
+                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,
@@ -209,12 +221,18 @@ export class GeminiAdapter {
                 '--yolo',
                 '--output-format', 'json', // Force JSON output
                 '--include-directories', workingDir,
+                '-p', '', // Force headless mode; actual prompt delivered via stdin
             ];
             const proc = spawn('gemini', args, {
                 cwd: workingDir,
                 stdio: ['pipe', 'pipe', 'pipe'], // stdin is pipe for prompt delivery
                 env: { ...process.env }
             });
+            // Guard against EPIPE if the child exits before consuming stdin.
+            // Log but don't reject — let the `close` handler capture the real exit code.
+            proc.stdin.on('error', (err) => {
+                console.error(`[gemini] stdin error (likely EPIPE): ${err.message}`);
+            });
             // Deliver prompt via stdin — more stable than args for complex content
             proc.stdin.write(prompt);
             proc.stdin.end();

package/dist/schema.d.ts

@@ -200,6 +200,37 @@ export declare const RiskAssessment: z.ZodObject<{
     mitigations?: string[] | undefined;
 }>;
 export type RiskAssessment = z.infer<typeof RiskAssessment>;
+export declare const UncertaintyResponse: z.ZodObject<{
+    uncertainty_index: z.ZodNumber;
+    verified: z.ZodBoolean;
+    finding: z.ZodString;
+    recommendation: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    verified: boolean;
+    uncertainty_index: number;
+    finding: string;
+    recommendation?: string | undefined;
+}, {
+    verified: boolean;
+    uncertainty_index: number;
+    finding: string;
+    recommendation?: string | undefined;
+}>;
+export type UncertaintyResponse = z.infer<typeof UncertaintyResponse>;
+export declare const QuestionAnswer: z.ZodObject<{
+    question_index: z.ZodNumber;
+    answer: z.ZodString;
+    confidence: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    question_index: number;
+    answer: string;
+    confidence?: number | undefined;
+}, {
+    question_index: number;
+    answer: string;
+    confidence?: number | undefined;
+}>;
+export type QuestionAnswer = z.infer<typeof QuestionAnswer>;
 export declare const ReviewOutput: z.ZodObject<{
     reviewer: z.ZodString;
     timestamp: z.ZodOptional<z.ZodString>;
@@ -348,6 +379,35 @@ export declare const ReviewOutput: z.ZodObject<{
         alternative: string;
         recommendation: "strongly_prefer" | "consider" | "situational" | "informational";
     }>, "many">;
+    uncertainty_responses: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        uncertainty_index: z.ZodNumber;
+        verified: z.ZodBoolean;
+        finding: z.ZodString;
+        recommendation: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        verified: boolean;
+        uncertainty_index: number;
+        finding: string;
+        recommendation?: string | undefined;
+    }, {
+        verified: boolean;
+        uncertainty_index: number;
+        finding: string;
+        recommendation?: string | undefined;
+    }>, "many">>;
+    question_answers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        question_index: z.ZodNumber;
+        answer: z.ZodString;
+        confidence: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        question_index: number;
+        answer: string;
+        confidence?: number | undefined;
+    }, {
+        question_index: number;
+        answer: string;
+        confidence?: number | undefined;
+    }>, "many">>;
     risk_assessment: z.ZodObject<{
         overall_level: z.ZodEnum<["critical", "high", "medium", "low", "minimal"]>;
         score: z.ZodNumber;
@@ -424,6 +484,17 @@ export declare const ReviewOutput: z.ZodObject<{
         mitigations?: string[] | undefined;
     };
     timestamp?: string | undefined;
+    uncertainty_responses?: {
+        verified: boolean;
+        uncertainty_index: number;
+        finding: string;
+        recommendation?: string | undefined;
+    }[] | undefined;
+    question_answers?: {
+        question_index: number;
+        answer: string;
+        confidence?: number | undefined;
+    }[] | undefined;
     files_examined?: string[] | undefined;
     execution_notes?: string | undefined;
 }, {
@@ -481,6 +552,17 @@ export declare const ReviewOutput: z.ZodObject<{
         mitigations?: string[] | undefined;
     };
     timestamp?: string | undefined;
+    uncertainty_responses?: {
+        verified: boolean;
+        uncertainty_index: number;
+        finding: string;
+        recommendation?: string | undefined;
+    }[] | undefined;
+    question_answers?: {
+        question_index: number;
+        answer: string;
+        confidence?: number | undefined;
+    }[] | undefined;
     files_examined?: string[] | undefined;
     execution_notes?: string | undefined;
 }>;

package/dist/schema.js

@@ -94,6 +94,20 @@ export const RiskAssessment = z.object({
     mitigations: z.array(z.string()).optional().describe('Suggested mitigations'),
 });
 // =============================================================================
+// UNCERTAINTY & QUESTION RESPONSES
+// =============================================================================
+export const UncertaintyResponse = z.object({
+    uncertainty_index: z.number().int().positive().describe('1-based index of the uncertainty being addressed'),
+    verified: z.boolean().describe('Whether the uncertainty was verified'),
+    finding: z.string().describe('What the reviewer found'),
+    recommendation: z.string().optional().describe('What CC should do'),
+});
+export const QuestionAnswer = z.object({
+    question_index: z.number().int().positive().describe('1-based index of the question being answered'),
+    answer: z.string().describe('The reviewer answer'),
+    confidence: ConfidenceScore.optional().describe('Confidence in the answer (0-1)'),
+});
+// =============================================================================
 // COMPLETE REVIEW OUTPUT (Single Reviewer)
 // =============================================================================
 export const ReviewOutput = z.object({
@@ -104,6 +118,9 @@ export const ReviewOutput = z.object({
     agreements: z.array(Agreement).describe("Validation of CC's correct assessments"),
     disagreements: z.array(Disagreement).describe("Challenges to CC's claims"),
     alternatives: z.array(Alternative).describe('Alternative approaches to consider'),
+    // Responses to CC's uncertainties and questions
+    uncertainty_responses: z.array(UncertaintyResponse).optional().describe('Responses to CC uncertainties'),
+    question_answers: z.array(QuestionAnswer).optional().describe('Answers to CC questions'),
     // Summary
     risk_assessment: RiskAssessment,
     // Metadata
@@ -211,6 +228,33 @@ export function getReviewOutputJsonSchema() {
                     }
                 }
             },
+            uncertainty_responses: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['uncertainty_index', 'verified', 'finding'],
+                    properties: {
+                        uncertainty_index: { type: 'integer', minimum: 1 },
+                        verified: { type: 'boolean' },
+                        finding: { type: 'string' },
+                        recommendation: { type: 'string' }
+                    }
+                }
+            },
+            question_answers: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['question_index', 'answer'],
+                    properties: {
+                        question_index: { type: 'integer', minimum: 1 },
+                        answer: { type: 'string' },
+                        confidence: { type: 'number', minimum: 0, maximum: 1 }
+                    }
+                }
+            },
             risk_assessment: {
                 type: 'object',
                 additionalProperties: false,
@@ -252,6 +296,13 @@ function normalizeReviewOutput(parsed) {
     normalized.disagreements = normalized.disagreements ?? [];
     normalized.alternatives = normalized.alternatives ?? [];
     normalized.findings = normalized.findings ?? [];
+    // Normalize optional response arrays — drop non-array values
+    if (normalized.uncertainty_responses !== undefined && !Array.isArray(normalized.uncertainty_responses)) {
+        delete normalized.uncertainty_responses;
+    }
+    if (normalized.question_answers !== undefined && !Array.isArray(normalized.question_answers)) {
+        delete normalized.question_answers;
+    }
     // Normalize risk_assessment from simplified formats
     if (!normalized.risk_assessment) {
         const ra = normalized.risk_assessment;

package/dist/tools/feedback.js

@@ -77,6 +77,27 @@ function formatSingleReviewResponse(result, modelName) {
             lines.push('');
         }
     }
+    // Uncertainty Responses
+    if (output.uncertainty_responses && output.uncertainty_responses.length > 0) {
+        lines.push(`### Uncertainty Responses (${output.uncertainty_responses.length})\n`);
+        for (const ur of output.uncertainty_responses) {
+            const icon = ur.verified ? '✓' : '✗';
+            lines.push(`${icon} **Uncertainty #${ur.uncertainty_index}**: ${ur.finding}`);
+            if (ur.recommendation) {
+                lines.push(`  → ${ur.recommendation}`);
+            }
+            lines.push('');
+        }
+    }
+    // Question Answers
+    if (output.question_answers && output.question_answers.length > 0) {
+        lines.push(`### Question Answers (${output.question_answers.length})\n`);
+        for (const qa of output.question_answers) {
+            const confidence = qa.confidence !== undefined ? ` [${Math.round(qa.confidence * 100)}%]` : '';
+            lines.push(`**Q${qa.question_index}**${confidence}: ${qa.answer}`);
+            lines.push('');
+        }
+    }
     // Agreements
     if (output.agreements.length > 0) {
         lines.push(`### Agreements (${output.agreements.length})\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-reviewer",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "MCP server for Claude Code - Get second-opinion feedback from Codex/Gemini CLIs",
   "type": "module",
   "main": "dist/index.js",