feat(review): cache verifier decisions across PR reruns

Author: haasonsaas

TODO.md

@@ -55,7 +55,7 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 25. [x] Add a handoff contract from reviewer findings to fix agents with rule IDs, evidence, and suggested diffs.
 26. [x] Persist loop-level telemetry: iterations, fixes attempted, findings cleared, findings reopened.
 27. [x] Add "challenge the finding" verification loops where a validator tries to falsify a suspected issue before keeping it.
-28. [ ] Add caching between iterations so repeated codebase retrieval and verification runs are cheaper.
+28. [x] Add caching between iterations so repeated codebase retrieval and verification runs are cheaper.
 29. [x] Allow loop policies to differ by profile: conservative auditor, high-autonomy fixer, or report-only.
 30. [x] Add eval fixtures specifically for loop convergence and reopened-issue regressions.
 

src/review/mod.rs

@@ -23,7 +23,9 @@ pub use filters::apply_review_filters;
 pub use pipeline::{
     build_review_guidance, build_symbol_index, extract_symbols_from_diff, filter_comments_for_diff,
     review_diff_content, review_diff_content_raw, review_diff_content_raw_with_progress,
-    review_diff_content_with_repo, ProgressCallback, ProgressUpdate,
+    review_diff_content_raw_with_progress_and_verification_reuse,
+    review_diff_content_raw_with_verification_reuse, review_diff_content_with_repo,
+    ProgressCallback, ProgressUpdate,
 };
 #[allow(unused_imports)]
 pub(crate) use pipeline::{describe_review_pipeline_graph, describe_review_postprocess_graph};
@@ -36,6 +38,8 @@ pub use rule_helpers::{
 };
 #[allow(unused_imports)]
 pub(crate) use verification::summarize_review_verification;
+#[allow(unused_imports)]
+pub(crate) use verification::VerificationReuseCache;
 
 // Used by sibling modules (commands, output) and their tests
 #[allow(unused_imports)]

src/review/pipeline.rs

@@ -69,7 +69,23 @@ pub async fn review_diff_content_raw(
     config: config::Config,
     repo_path: &Path,
 ) -> Result<ReviewResult> {
-    review_diff_content_raw_with_progress(diff_content, config, repo_path, None).await
+    review_diff_content_raw_internal(diff_content, config, repo_path, None, None).await
+}
+
+pub async fn review_diff_content_raw_with_verification_reuse(
+    diff_content: &str,
+    config: config::Config,
+    repo_path: &Path,
+    verification_reuse_cache: crate::review::verification::VerificationReuseCache,
+) -> Result<ReviewResult> {
+    review_diff_content_raw_internal(
+        diff_content,
+        config,
+        repo_path,
+        None,
+        Some(verification_reuse_cache),
+    )
+    .await
 }
 
 #[tracing::instrument(name = "review_pipeline", skip(diff_content, config, repo_path, on_progress), fields(diff_bytes = diff_content.len(), model = %config.model))]
@@ -79,16 +95,53 @@ pub async fn review_diff_content_raw_with_progress(
     repo_path: &Path,
     on_progress: Option<ProgressCallback>,
 ) -> Result<ReviewResult> {
+    review_diff_content_raw_internal(diff_content, config, repo_path, on_progress, None).await
+}
+
+pub async fn review_diff_content_raw_with_progress_and_verification_reuse(
+    diff_content: &str,
+    config: config::Config,
+    repo_path: &Path,
+    on_progress: Option<ProgressCallback>,
+    verification_reuse_cache: crate::review::verification::VerificationReuseCache,
+) -> Result<ReviewResult> {
+    review_diff_content_raw_internal(
+        diff_content,
+        config,
+        repo_path,
+        on_progress,
+        Some(verification_reuse_cache),
+    )
+    .await
+}
+
+async fn review_diff_content_raw_internal(
+    diff_content: &str,
+    config: config::Config,
+    repo_path: &Path,
+    on_progress: Option<ProgressCallback>,
+    verification_reuse_cache: Option<crate::review::verification::VerificationReuseCache>,
+) -> Result<ReviewResult> {
+    let verification_reuse_cache = verification_reuse_cache.unwrap_or_default();
+
     if let Some(result) = maybe_review_chunked_diff_content(
         diff_content,
         config.clone(),
         repo_path,
         on_progress.clone(),
+        verification_reuse_cache.clone(),
     )
     .await?
     {
         return Ok(result);
     }
 
-    orchestrate::review_diff_content_raw_inner(diff_content, config, repo_path, on_progress).await
+    orchestrate::review_diff_content_raw_inner(
+        diff_content,
+        config,
+        repo_path,
+        on_progress,
+        verification_reuse_cache,
+    )
+    .await
 }

src/review/pipeline/chunking.rs

@@ -12,6 +12,7 @@ pub(super) async fn maybe_review_chunked_diff_content(
     config: config::Config,
     repo_path: &Path,
     on_progress: Option<ProgressCallback>,
+    verification_reuse_cache: crate::review::verification::VerificationReuseCache,
 ) -> Result<Option<ReviewResult>> {
     if !should_optimize_for_local(&config) {
         return Ok(None);
@@ -30,17 +31,22 @@ pub(super) async fn maybe_review_chunked_diff_content(
     );
 
     let mut merged = ReviewResult::default();
+    let mut verification_reuse_cache = verification_reuse_cache;
     for (index, chunk) in chunks.iter().enumerate() {
         eprintln!("Processing chunk {}/{}...", index + 1, chunks.len());
         match super::orchestrate::review_diff_content_raw_inner(
             chunk,
             config.clone(),
             repo_path,
             on_progress.clone(),
+            std::mem::take(&mut verification_reuse_cache),
         )
         .await
         {
-            Ok(chunk_result) => merge_chunk_result(&mut merged, chunk_result),
+            Ok(chunk_result) => {
+                verification_reuse_cache = chunk_result.verification_reuse_cache.clone();
+                merge_chunk_result(&mut merged, chunk_result)
+            }
             Err(error) => {
                 eprintln!("Warning: chunk {} failed: {}", index + 1, error);
             }
@@ -64,5 +70,8 @@ fn merge_chunk_result(merged: &mut ReviewResult, chunk_result: ReviewResult) {
     if merged.verification_report.is_none() {
         merged.verification_report = chunk_result.verification_report;
     }
+    merged
+        .verification_reuse_cache
+        .merge(chunk_result.verification_reuse_cache);
     merged.warnings.extend(chunk_result.warnings);
 }

src/review/pipeline/orchestrate.rs

@@ -18,6 +18,14 @@ pub(super) async fn review_diff_content_raw_inner(
     config: config::Config,
     repo_path: &Path,
     on_progress: Option<ProgressCallback>,
+    verification_reuse_cache: crate::review::verification::VerificationReuseCache,
 ) -> Result<ReviewResult> {
-    execute_review_pipeline_dag(diff_content, config, repo_path, on_progress).await
+    execute_review_pipeline_dag(
+        diff_content,
+        config,
+        repo_path,
+        on_progress,
+        verification_reuse_cache,
+    )
+    .await
 }

src/review/pipeline/orchestrate/dag.rs

@@ -43,6 +43,7 @@ struct ReviewPipelineDagContext<'a> {
     config: Option<config::Config>,
     repo_path: &'a Path,
     on_progress: Option<ProgressCallback>,
+    verification_reuse_cache: crate::review::verification::VerificationReuseCache,
     services: Option<PipelineServices>,
     session: Option<ReviewSession>,
     prepared_jobs: Option<PreparedReviewJobs>,
@@ -56,12 +57,14 @@ impl<'a> ReviewPipelineDagContext<'a> {
         config: config::Config,
         repo_path: &'a Path,
         on_progress: Option<ProgressCallback>,
+        verification_reuse_cache: crate::review::verification::VerificationReuseCache,
     ) -> Self {
         Self {
             diff_content,
             config: Some(config),
             repo_path,
             on_progress,
+            verification_reuse_cache,
             services: None,
             session: None,
             prepared_jobs: None,
@@ -81,11 +84,18 @@ pub(super) async fn execute_review_pipeline_dag(
     config: config::Config,
     repo_path: &Path,
     on_progress: Option<ProgressCallback>,
+    verification_reuse_cache: crate::review::verification::VerificationReuseCache,
 ) -> Result<ReviewResult> {
     let specs = build_review_pipeline_specs();
     let dag_description = describe_dag(&specs);
     debug!(?dag_description, "Executing review pipeline DAG");
-    let mut context = ReviewPipelineDagContext::new(diff_content, config, repo_path, on_progress);
+    let mut context = ReviewPipelineDagContext::new(
+        diff_content,
+        config,
+        repo_path,
+        on_progress,
+        verification_reuse_cache,
+    );
     let records = execute_dag(&specs, &mut context, |stage, context| {
         async move { execute_stage(stage, context).await }.boxed()
     })
@@ -250,7 +260,13 @@ async fn execute_session_stage(context: &mut ReviewPipelineDagContext<'_>) -> Re
         .as_ref()
         .ok_or_else(|| anyhow::anyhow!("session stage missing services"))?;
     context.session = Some(
-        ReviewSession::new(context.diff_content, services, context.on_progress.clone()).await?,
+        ReviewSession::new(
+            context.diff_content,
+            services,
+            context.on_progress.clone(),
+            std::mem::take(&mut context.verification_reuse_cache),
+        )
+        .await?,
     );
     Ok(())
 }

src/review/pipeline/postprocess/dag.rs

@@ -108,6 +108,7 @@ impl<'a> ReviewPostprocessDagContext<'a> {
             hotspots: self.session.enhanced_ctx.hotspots.clone(),
             agent_activity: self.agent_activity,
             verification_report,
+            verification_reuse_cache: self.session.verification_reuse_cache.clone(),
             warnings,
             dag_traces: self.session.graph_query_traces.clone(),
         }

src/review/pipeline/postprocess/verification.rs

@@ -1,7 +1,7 @@
 use tracing::{info, warn};
 
 use crate::core;
-use crate::review::verification::VerificationJudgeConfig;
+use crate::review::verification::{verify_comments_with_judges_and_reuse, VerificationJudgeConfig};
 
 use super::super::comments::is_analyzer_comment;
 use super::super::services::PipelineServices;
@@ -16,7 +16,7 @@ pub(super) struct VerificationPassOutput {
 pub(super) async fn apply_verification_pass(
     comments: Vec<core::Comment>,
     services: &PipelineServices,
-    session: &ReviewSession,
+    session: &mut ReviewSession,
 ) -> VerificationPassOutput {
     let (analyzer_comments, llm_comments): (Vec<_>, Vec<_>) =
         comments.into_iter().partition(is_analyzer_comment);
@@ -26,7 +26,7 @@ pub(super) async fn apply_verification_pass(
         && llm_comments.len() <= services.config.verification.max_comments
     {
         let comment_count_before = llm_comments.len();
-        let summary = super::super::super::verification::verify_comments_with_judges(
+        let summary = verify_comments_with_judges_and_reuse(
             llm_comments,
             &session.diffs,
             &session.source_files,
@@ -37,6 +37,7 @@ pub(super) async fn apply_verification_pass(
                 fail_open: services.config.verification.fail_open,
                 consensus_mode: services.config.verification.consensus_mode,
             },
+            Some(&mut session.verification_reuse_cache),
         )
         .await;
 

src/review/pipeline/session.rs

@@ -25,6 +25,7 @@ pub(super) struct ReviewSession {
     pub semantic_index: Option<core::semantic::SemanticIndex>,
     pub semantic_feedback_store: Option<core::SemanticFeedbackStore>,
     pub verification_context: HashMap<PathBuf, Vec<core::LLMContextChunk>>,
+    pub verification_reuse_cache: crate::review::verification::VerificationReuseCache,
     pub graph_query_traces: Vec<core::dag::DagExecutionTrace>,
 }
 
@@ -33,7 +34,14 @@ impl ReviewSession {
         diff_content: &str,
         services: &PipelineServices,
         on_progress: Option<ProgressCallback>,
+        verification_reuse_cache: crate::review::verification::VerificationReuseCache,
     ) -> Result<Self> {
-        build_review_session(diff_content, services, on_progress).await
+        build_review_session(
+            diff_content,
+            services,
+            on_progress,
+            verification_reuse_cache,
+        )
+        .await
     }
 }

src/review/pipeline/session/build.rs

@@ -16,6 +16,7 @@ pub(super) async fn build_review_session(
     diff_content: &str,
     services: &PipelineServices,
     on_progress: Option<ProgressCallback>,
+    verification_reuse_cache: crate::review::verification::VerificationReuseCache,
 ) -> Result<ReviewSession> {
     let diffs = parse_review_diffs(diff_content, services)?;
     let source_files = load_source_files(&diffs, services);
@@ -41,6 +42,7 @@ pub(super) async fn build_review_session(
         enhanced_ctx,
         enhanced_guidance,
         verification_context: HashMap::new(),
+        verification_reuse_cache,
         graph_query_traces: Vec::new(),
     })
 }