review logic changed to achieve consensus accurately

Author: bishalprasad321

__tests__/review-orchestrator.test.ts

@@ -2,7 +2,7 @@ import { ReviewOrchestrator } from "../src/review/review-orchestrator";
 import { ReviewerOpinion } from "../src/utils/types";
 
 describe("ReviewOrchestrator", () => {
-  it("treats a 2-of-3 reviewer agreement as consensus", () => {
+  it("requires unanimous agreement (all 3) for consensus in early rounds", () => {
     const orchestrator = new ReviewOrchestrator("test-key", {
       reviewerModels: [
         "gemini-2.5-flash",
@@ -52,6 +52,64 @@ describe("ReviewOrchestrator", () => {
       }
     ).evaluateConsensus(opinions);
 
+    // With 2-of-3 agreement (not unanimous), consensus is NOT achieved
+    expect(result).toEqual({
+      isConsensus: false,
+      decision: "COMMENT",
+    });
+  });
+
+  it("achieves consensus when all 3 reviewers agree", () => {
+    const orchestrator = new ReviewOrchestrator("test-key", {
+      reviewerModels: [
+        "gemini-2.5-flash",
+        "gemini-2.5-flash-lite",
+        "gemini-2.0-flash",
+      ],
+      judgeModel: "gemini-2.5-pro",
+      maxConsensusRounds: 3,
+    });
+
+    const opinions: ReviewerOpinion[] = [
+      {
+        reviewerId: "Reviewer_1",
+        modelName: "gemini-2.5-flash",
+        decision: "APPROVE",
+        reasoning: "Looks good.",
+        findings: [],
+        summary: "Summary",
+        timestamp: new Date().toISOString(),
+      },
+      {
+        reviewerId: "Reviewer_2",
+        modelName: "gemini-2.5-flash-lite",
+        decision: "APPROVE",
+        reasoning: "Looks good.",
+        findings: [],
+        summary: "Summary",
+        timestamp: new Date().toISOString(),
+      },
+      {
+        reviewerId: "Reviewer_3",
+        modelName: "gemini-2.0-flash",
+        decision: "APPROVE",
+        reasoning: "No issues found.",
+        findings: [],
+        summary: "Summary",
+        timestamp: new Date().toISOString(),
+      },
+    ];
+
+    const result = (
+      orchestrator as unknown as {
+        evaluateConsensus: (input: ReviewerOpinion[]) => {
+          isConsensus: boolean;
+          decision: string;
+        };
+      }
+    ).evaluateConsensus(opinions);
+
+    // All 3 agree on APPROVE
     expect(result).toEqual({
       isConsensus: true,
       decision: "APPROVE",

dist/index.js

@@ -1370,16 +1370,27 @@ RESPOND ONLY WITH THE JSON OBJECT. NO OTHER TEXT.`;
     extractResponseText(response) {
         if (this.provider === "groq") {
             const groqResponse = response;
-            const openAIText = groqResponse.choices
-                ?.map((choice) => choice.text || choice.message?.content || "")
-                .join("");
-            if (openAIText) {
-                return openAIText.trim();
+            // Try OpenAI-compatible chat/completions format first
+            if (groqResponse.choices && Array.isArray(groqResponse.choices)) {
+                const openAIText = groqResponse.choices
+                    .map((choice) => choice.text || choice.message?.content || "")
+                    .join("")
+                    .trim();
+                if (openAIText) {
+                    return openAIText;
+                }
+            }
+            // Fallback to legacy Groq format
+            if (groqResponse.output && Array.isArray(groqResponse.output)) {
+                const groqText = groqResponse.output
+                    .map((out) => out.content?.map((item) => item.text || "").join(""))
+                    .join("")
+                    .trim();
+                if (groqText) {
+                    return groqText;
+                }
             }
-            const groqText = groqResponse.output
-                ?.map((out) => out.content?.map((item) => item.text || "").join(""))
-                .join("") || "";
-            return groqText.trim();
+            return "";
         }
         const geminiResponse = response;
         const text = geminiResponse.candidates?.[0]?.content?.parts
@@ -2167,8 +2178,8 @@ class ReviewOrchestrator {
                 allRounds.push(round_data);
                 break; // Exit loop, consensus achieved
             }
-            // Step 3: Opinions differ - call judge model
-            this.logger.warn(`❌ No consensus yet. Reviewers differ:${opinions
+            // Step 3: Opinions differ - call judge model to guide next round
+            this.logger.warn(`❌ No full consensus yet. Reviewers differ:${opinions
                 .map((o) => ` ${o.reviewerId}:${o.decision}`)
                 .join(",")}`);
             const judgeDecision = await this.llmClient.callJudgeModel(this.judgeModel, opinions, context, round);
@@ -2181,19 +2192,41 @@ class ReviewOrchestrator {
                 needsRetry: round < this.maxConsensusRounds,
             };
             allRounds.push(round_data);
-            // If this is the last round or judge is confident, use judge's decision
-            if (round === this.maxConsensusRounds || judgeDecision.confidence > 0.8) {
-                finalDecision = judgeDecision.decision;
-                finalReasoning = judgeDecision.reasoning;
-                if (round === this.maxConsensusRounds) {
-                    this.logger.warn(`⚠️ Max consensus rounds reached. Using judge's final decision.`);
+            // If this is the last round, use fallback strategy
+            if (round === this.maxConsensusRounds) {
+                this.logger.warn(`⚠️ Max consensus rounds reached. Applying fallback decision strategy...`);
+                // First, check if we can use judge's decision if confident
+                if (judgeDecision.confidence > 0.8) {
+                    finalDecision = judgeDecision.decision;
+                    finalReasoning = judgeDecision.reasoning;
+                    this.logger.success(`✅ Using judge's high-confidence final decision: ${judgeDecision.decision}`);
                 }
                 else {
-                    this.logger.success(`✅ Judge achieved high-confidence consensus in round ${round}`);
+                    // Otherwise, fall back to majority consensus among reviewers
+                    const majority = this.evaluateMajorityConsensus(opinions);
+                    if (majority.hasMajority) {
+                        finalDecision = majority.decision;
+                        const agreeingReviewers = opinions.filter((o) => o.decision === majority.decision);
+                        finalReasoning = `${agreeingReviewers.length} of 3 reviewers agreed on **${majority.decision}** after ${round} rounds (fallback to majority)`;
+                        this.logger.success(`✅ Using majority consensus on final round: ${majority.decision}`);
+                    }
+                    else {
+                        // Last resort: use judge's decision
+                        finalDecision = judgeDecision.decision;
+                        finalReasoning = judgeDecision.reasoning;
+                        this.logger.warn(`⚠️ No majority found. Using judge's decision as final fallback: ${judgeDecision.decision}`);
+                    }
                 }
                 break;
             }
-            this.logger.warn(`⏳ Low judge confidence (${(judgeDecision.confidence * 100).toFixed(0)}%). Requesting another review round...`);
+            // Before final round: only stop if judge is very confident
+            if (judgeDecision.confidence > 0.9) {
+                finalDecision = judgeDecision.decision;
+                finalReasoning = judgeDecision.reasoning;
+                this.logger.success(`✅ Judge achieved very high-confidence consensus in round ${round}: ${judgeDecision.decision}`);
+                break;
+            }
+            this.logger.warn(`⏳ Judge confidence is ${(judgeDecision.confidence * 100).toFixed(0)}%. Requesting another review round to reach consensus...`);
         }
         // Step 4: Consolidate findings
         const inlineFindings = this.consolidateFindings(allOpinions);
@@ -2254,12 +2287,33 @@ class ReviewOrchestrator {
     /**
      * Evaluate if consensus is achieved
      *
-     * Consensus = a majority (2 of 3) reviewers agree on the same decision
+     * Consensus = ALL 3 reviewers agree on the same decision (unanimous).
+     * This ensures reviewers are truly on the same page before concluding.
      */
     evaluateConsensus(opinions) {
         if (opinions.length !== 3) {
             return { isConsensus: false, decision: "COMMENT" };
         }
+        // Check if all 3 reviewers have the same decision
+        const firstDecision = opinions[0].decision;
+        const allAgree = opinions.every((o) => o.decision === firstDecision);
+        if (allAgree) {
+            return {
+                isConsensus: true,
+                decision: firstDecision,
+            };
+        }
+        return { isConsensus: false, decision: "COMMENT" };
+    }
+    /**
+     * Evaluate if a majority consensus is reached (fallback for final round)
+     *
+     * Majority = 2 of 3 reviewers agree on the same decision
+     */
+    evaluateMajorityConsensus(opinions) {
+        if (opinions.length !== 3) {
+            return { hasMajority: false, decision: "COMMENT" };
+        }
         const decisionCounts = opinions.reduce((counts, opinion) => {
             counts[opinion.decision] += 1;
             return counts;
@@ -2271,11 +2325,11 @@ class ReviewOrchestrator {
         const majorityEntry = Object.entries(decisionCounts).find(([, count]) => count >= 2);
         if (majorityEntry) {
             return {
-                isConsensus: true,
+                hasMajority: true,
                 decision: majorityEntry[0],
             };
         }
-        return { isConsensus: false, decision: "COMMENT" };
+        return { hasMajority: false, decision: "COMMENT" };
     }
     /**
      * Format reasoning when a consensus is reached

dist/index.js.map

@@ -702,18 +702,29 @@ RESPOND ONLY WITH THE JSON OBJECT. NO OTHER TEXT.`;
   private extractResponseText(response: LLMResponse): string {
     if (this.provider === "groq") {
       const groqResponse = response as GroqResponse;
-      const openAIText = groqResponse.choices
-        ?.map((choice) => choice.text || choice.message?.content || "")
-        .join("");
+      // Try OpenAI-compatible chat/completions format first
+      if (groqResponse.choices && Array.isArray(groqResponse.choices)) {
+        const openAIText = groqResponse.choices
+          .map((choice) => choice.text || choice.message?.content || "")
+          .join("")
+          .trim();
+        if (openAIText) {
+          return openAIText;
+        }
+      }
 
-      if (openAIText) {
-        return openAIText.trim();
+      // Fallback to legacy Groq format
+      if (groqResponse.output && Array.isArray(groqResponse.output)) {
+        const groqText = groqResponse.output
+          .map((out) => out.content?.map((item) => item.text || "").join(""))
+          .join("")
+          .trim();
+        if (groqText) {
+          return groqText;
+        }
       }
 
-      const groqText = groqResponse.output
-        ?.map((out) => out.content?.map((item) => item.text || "").join(""))
-        .join("") || "";
-      return groqText.trim();
+      return "";
     }
 
     const geminiResponse = response as GeminiResponse;
@@ -853,8 +864,8 @@ RESPOND ONLY WITH THE JSON OBJECT. NO OTHER TEXT.`;
         const models = Array.isArray(data.data)
           ? (data.data as Array<Record<string, unknown>>)
           : Array.isArray(data.models)
-          ? (data.models as Array<Record<string, unknown>>)
-          : [];
+            ? (data.models as Array<Record<string, unknown>>)
+            : [];
 
         for (const model of models) {
           const modelName = this.normalizeModelName(
@@ -872,7 +883,9 @@ RESPOND ONLY WITH THE JSON OBJECT. NO OTHER TEXT.`;
           FALLBACK_MODELS.groq.reviewer.forEach((model) =>
             availableModels.add(model)
           );
-          FALLBACK_MODELS.groq.judge.forEach((model) => availableModels.add(model));
+          FALLBACK_MODELS.groq.judge.forEach((model) =>
+            availableModels.add(model)
+          );
         }
 
         this.availableGenerateContentModels = availableModels;