feat: make review readiness verification-aware

Track verification health in persisted review summaries and surface stale PR reviews as needs re-review so merge readiness stays accurate across lifecycle updates and incremental PR workflows.

Made-with: Cursor

Author: haasonsaas

TODO.md

@@ -37,9 +37,9 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 
 11. [x] Track unresolved vs resolved findings for PR reviews as a first-class lifecycle state.
 12. [ ] Add review completeness metrics: total findings, acknowledged findings, fixed findings, stale findings.
-13. [ ] Compute merge-readiness summaries for GitHub PR reviews using severity, unresolved count, and verification state.
+13. [x] Compute merge-readiness summaries for GitHub PR reviews using severity, unresolved count, and verification state.
 14. [ ] Add stale-review detection when new commits land after the latest completed review.
-15. [ ] Show "needs re-review" state in review detail and history pages for incremental PR workflows.
+15. [x] Show "needs re-review" state in review detail and history pages for incremental PR workflows.
 16. [ ] Distinguish informational findings from blocking findings in lifecycle and readiness calculations.
 17. [ ] Add "critical blockers" summary cards for unresolved `Error` and `Warning` comments.
 18. [ ] Add per-PR readiness timelines showing when a review became mergeable.
@@ -156,4 +156,5 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 - [x] Productize the learning loop in Analytics with reaction coverage and acceptance trends.
 - [x] Surface repository rule sources and pattern repository sources in Settings.
 - [x] Ship first-pass finding lifecycle state and lightweight merge readiness through the backend, API, CLI summaries, and review UI.
+- [x] Make merge readiness verification-aware and surface stale PR reviews as needs re-review in history/detail views.
 - [ ] Commit and push each validated checkpoint before moving to the next epic.

src/core/comment.rs

@@ -27,13 +27,17 @@ use ordering::{
 #[cfg(test)]
 use std::path::PathBuf;
 use suggestions::generate_code_suggestion;
-use summary::generate_summary as build_review_summary;
+use summary::{
+    apply_review_runtime_state as apply_review_runtime_summary_state,
+    apply_verification as apply_verification_summary, generate_summary as build_review_summary,
+    inherit_review_state as inherit_review_summary_state,
+};
 use tags::extract_tags;
 
 pub use identity::compute_comment_id;
 pub use types::{
     Category, CodeSuggestion, Comment, CommentStatus, FixEffort, MergeReadiness, RawComment,
-    ReviewSummary, Severity,
+    ReviewSummary, ReviewVerificationState, ReviewVerificationSummary, Severity,
 };
 
 pub struct CommentSynthesizer;
@@ -56,6 +60,24 @@ impl CommentSynthesizer {
         build_review_summary(comments)
     }
 
+    pub fn inherit_review_state(
+        summary: ReviewSummary,
+        previous: Option<&ReviewSummary>,
+    ) -> ReviewSummary {
+        inherit_review_summary_state(summary, previous)
+    }
+
+    pub fn apply_verification(
+        summary: ReviewSummary,
+        verification: ReviewVerificationSummary,
+    ) -> ReviewSummary {
+        apply_verification_summary(summary, verification)
+    }
+
+    pub fn apply_runtime_review_state(summary: ReviewSummary, stale_review: bool) -> ReviewSummary {
+        apply_review_runtime_summary_state(summary, stale_review)
+    }
+
     fn process_raw_comment(raw: RawComment) -> Result<Comment> {
         let lower = raw.content.to_lowercase();
         let severity = raw

src/core/comment/summary.rs

@@ -1,6 +1,9 @@
 use std::collections::{HashMap, HashSet};
 
-use super::{Category, Comment, CommentStatus, MergeReadiness, ReviewSummary, Severity};
+use super::{
+    Category, Comment, CommentStatus, MergeReadiness, ReviewSummary, ReviewVerificationState,
+    ReviewVerificationSummary, Severity,
+};
 
 pub(super) fn generate_summary(comments: &[Comment]) -> ReviewSummary {
     let mut by_severity = HashMap::new();
@@ -49,11 +52,58 @@ pub(super) fn generate_summary(comments: &[Comment]) -> ReviewSummary {
         resolved_comments,
         dismissed_comments,
         open_blockers,
-        merge_readiness: if open_blockers == 0 {
-            MergeReadiness::Ready
-        } else {
-            MergeReadiness::NeedsAttention
-        },
+        merge_readiness: default_merge_readiness(open_blockers),
+        verification: ReviewVerificationSummary::default(),
+        readiness_reasons: Vec::new(),
+    }
+}
+
+pub(super) fn inherit_review_state(
+    mut summary: ReviewSummary,
+    previous: Option<&ReviewSummary>,
+) -> ReviewSummary {
+    if let Some(previous) = previous {
+        summary.verification = previous.verification.clone();
+    }
+    apply_review_runtime_state(summary, false)
+}
+
+pub(super) fn apply_verification(
+    mut summary: ReviewSummary,
+    verification: ReviewVerificationSummary,
+) -> ReviewSummary {
+    summary.verification = verification;
+    apply_review_runtime_state(summary, false)
+}
+
+pub(super) fn apply_review_runtime_state(
+    mut summary: ReviewSummary,
+    stale_review: bool,
+) -> ReviewSummary {
+    let mut reasons = Vec::new();
+    if matches!(
+        summary.verification.state,
+        ReviewVerificationState::Inconclusive
+    ) {
+        reasons.push("verification was inconclusive or fail-open; rerun this review".to_string());
+    }
+    if stale_review {
+        reasons.push("a newer review exists for this pull request".to_string());
+    }
+    summary.readiness_reasons = reasons;
+    summary.merge_readiness = if !summary.readiness_reasons.is_empty() {
+        MergeReadiness::NeedsReReview
+    } else {
+        default_merge_readiness(summary.open_blockers)
+    };
+    summary
+}
+
+fn default_merge_readiness(open_blockers: usize) -> MergeReadiness {
+    if open_blockers == 0 {
+        MergeReadiness::Ready
+    } else {
+        MergeReadiness::NeedsAttention
     }
 }
 
@@ -202,4 +252,51 @@ mod tests {
         assert_eq!(summary.merge_readiness, MergeReadiness::Ready);
         assert!(summary.recommendations.is_empty());
     }
+
+    #[test]
+    fn summary_needs_rereview_when_verification_is_inconclusive() {
+        let comments = vec![make_comment(
+            "open-warning",
+            Severity::Warning,
+            Category::Bug,
+            CommentStatus::Open,
+        )];
+
+        let summary = apply_verification(
+            generate_summary(&comments),
+            ReviewVerificationSummary {
+                state: ReviewVerificationState::Inconclusive,
+                judge_count: 1,
+                required_votes: 1,
+                warning_count: 1,
+                filtered_comments: 0,
+                abstained_comments: 1,
+            },
+        );
+
+        assert_eq!(summary.merge_readiness, MergeReadiness::NeedsReReview);
+        assert_eq!(
+            summary.verification.state,
+            ReviewVerificationState::Inconclusive
+        );
+        assert_eq!(summary.readiness_reasons.len(), 1);
+    }
+
+    #[test]
+    fn stale_review_forces_needs_rereview_even_without_blockers() {
+        let comments = vec![make_comment(
+            "resolved-warning",
+            Severity::Warning,
+            Category::Bug,
+            CommentStatus::Resolved,
+        )];
+
+        let summary = apply_review_runtime_state(generate_summary(&comments), true);
+        assert_eq!(summary.open_blockers, 0);
+        assert_eq!(summary.merge_readiness, MergeReadiness::NeedsReReview);
+        assert_eq!(
+            summary.readiness_reasons,
+            vec!["a newer review exists for this pull request".to_string()]
+        );
+    }
 }

src/core/comment/types.rs

@@ -51,6 +51,10 @@ pub struct ReviewSummary {
     pub open_blockers: usize,
     #[serde(default)]
     pub merge_readiness: MergeReadiness,
+    #[serde(default)]
+    pub verification: ReviewVerificationSummary,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub readiness_reasons: Vec<String>,
 }
 
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
@@ -85,15 +89,51 @@ impl CommentStatus {
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
 pub enum MergeReadiness {
     Ready,
-    #[default]
     NeedsAttention,
+    #[default]
+    NeedsReReview,
 }
 
 impl std::fmt::Display for MergeReadiness {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             MergeReadiness::Ready => write!(f, "Ready"),
             MergeReadiness::NeedsAttention => write!(f, "Needs attention"),
+            MergeReadiness::NeedsReReview => write!(f, "Needs re-review"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
+pub struct ReviewVerificationSummary {
+    #[serde(default)]
+    pub state: ReviewVerificationState,
+    #[serde(default)]
+    pub judge_count: usize,
+    #[serde(default)]
+    pub required_votes: usize,
+    #[serde(default)]
+    pub warning_count: usize,
+    #[serde(default)]
+    pub filtered_comments: usize,
+    #[serde(default)]
+    pub abstained_comments: usize,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
+pub enum ReviewVerificationState {
+    #[default]
+    NotApplicable,
+    Verified,
+    Inconclusive,
+}
+
+impl std::fmt::Display for ReviewVerificationState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ReviewVerificationState::NotApplicable => write!(f, "Not applicable"),
+            ReviewVerificationState::Verified => write!(f, "Verified"),
+            ReviewVerificationState::Inconclusive => write!(f, "Inconclusive"),
         }
     }
 }

src/output/format.rs

@@ -91,6 +91,26 @@ pub fn format_as_markdown(comments: &[core::Comment], rule_priority: &[String])
         "⛔ **Open Blockers:** {}\n\n",
         summary.open_blockers
     ));
+    output.push_str(&format!(
+        "🧪 **Verification:** {}",
+        summary.verification.state
+    ));
+    if summary.verification.judge_count > 0 {
+        output.push_str(&format!(
+            " (votes {}/{}, warnings {})",
+            summary.verification.required_votes,
+            summary.verification.judge_count,
+            summary.verification.warning_count
+        ));
+    }
+    output.push_str("\n\n");
+    if !summary.readiness_reasons.is_empty() {
+        output.push_str("### Review State\n\n");
+        for reason in &summary.readiness_reasons {
+            output.push_str(&format!("- {}\n", reason));
+        }
+        output.push('\n');
+    }
 
     // Severity breakdown
     output.push_str("### Issues by Severity\n\n");
@@ -287,6 +307,26 @@ pub fn format_smart_review_output(
         "⛔ **Open Blockers:** {}\n\n",
         summary.open_blockers
     ));
+    output.push_str(&format!(
+        "🧪 **Verification:** {}",
+        summary.verification.state
+    ));
+    if summary.verification.judge_count > 0 {
+        output.push_str(&format!(
+            " (votes {}/{}, warnings {})",
+            summary.verification.required_votes,
+            summary.verification.judge_count,
+            summary.verification.warning_count
+        ));
+    }
+    output.push_str("\n\n");
+    if !summary.readiness_reasons.is_empty() {
+        output.push_str("### 🔁 Review State\n\n");
+        for reason in &summary.readiness_reasons {
+            output.push_str(&format!("- {}\n", reason));
+        }
+        output.push('\n');
+    }
 
     if let Some(pr_summary) = pr_summary {
         output.push_str(&format_pr_summary_section(pr_summary));
@@ -863,6 +903,8 @@ mod tests {
             dismissed_comments: 0,
             open_blockers: 2,
             merge_readiness: crate::core::comment::MergeReadiness::NeedsAttention,
+            verification: crate::core::comment::ReviewVerificationSummary::default(),
+            readiness_reasons: Vec::new(),
         };
         let comments = vec![
             build_test_comment(

src/review/mod.rs

@@ -33,6 +33,8 @@ pub use rule_helpers::{
     apply_rule_overrides, build_pr_summary_comment_body, inject_rule_context, load_review_rules,
     normalize_rule_id, summarize_rule_hits,
 };
+#[allow(unused_imports)]
+pub(crate) use verification::summarize_review_verification;
 
 // Used by sibling modules (commands, output) and their tests
 #[allow(unused_imports)]

src/review/rule_helpers/reporting/summary.rs

@@ -23,6 +23,22 @@ pub fn build_pr_summary_comment_body(
         summary.open_comments, summary.resolved_comments, summary.dismissed_comments
     ));
     body.push_str(&format!("- Open blockers: {}\n", summary.open_blockers));
+    body.push_str(&format!("- Verification: {}", summary.verification.state));
+    if summary.verification.judge_count > 0 {
+        body.push_str(&format!(
+            " (votes {}/{}, warnings {})",
+            summary.verification.required_votes,
+            summary.verification.judge_count,
+            summary.verification.warning_count
+        ));
+    }
+    body.push('\n');
+    if !summary.readiness_reasons.is_empty() {
+        body.push_str("- Review state:\n");
+        for reason in &summary.readiness_reasons {
+            body.push_str(&format!("  - {}\n", reason));
+        }
+    }
 
     if summary.total_comments == 0 {
         body.push_str("\nNo issues detected in this PR by DiffScope.\n");

src/review/verification.rs

@@ -56,6 +56,41 @@ pub struct VerificationReport {
     pub judges: Vec<VerificationJudgeRun>,
 }
 
+pub(crate) fn summarize_review_verification(
+    report: Option<&VerificationReport>,
+    warnings: &[String],
+) -> crate::core::comment::ReviewVerificationSummary {
+    let warning_count = warnings.len();
+    match report {
+        Some(report) => crate::core::comment::ReviewVerificationSummary {
+            state: if warning_count > 0 {
+                crate::core::comment::ReviewVerificationState::Inconclusive
+            } else {
+                crate::core::comment::ReviewVerificationState::Verified
+            },
+            judge_count: report.judge_count,
+            required_votes: report.required_votes,
+            warning_count,
+            filtered_comments: report
+                .judges
+                .iter()
+                .map(|judge| judge.filtered_comments)
+                .sum(),
+            abstained_comments: report
+                .judges
+                .iter()
+                .map(|judge| judge.abstained_comments)
+                .sum(),
+        },
+        None if warning_count > 0 => crate::core::comment::ReviewVerificationSummary {
+            state: crate::core::comment::ReviewVerificationState::Inconclusive,
+            warning_count,
+            ..Default::default()
+        },
+        None => crate::core::comment::ReviewVerificationSummary::default(),
+    }
+}
+
 const VERIFICATION_BATCH_SIZE: usize = 6;
 
 #[derive(Debug, Clone)]