feat(feedback): track dismissed findings separately

Record lifecycle dismissals in the feedback store without mixing them into rejection stats, and update TODO.md for verified shipped work and the new dismissal split.

Author: haasonsaas

TODO.md

@@ -25,7 +25,7 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 1. [ ] Add first-class comment outcome states beyond thumbs: `new`, `accepted`, `rejected`, `addressed`, `stale`, `auto_fixed`.
 2. [ ] Infer "addressed by later commit" by diffing follow-up pushes against the original commented lines.
 3. [ ] Feed addressed/not-addressed outcomes into the reinforcement store alongside thumbs.
-4. [ ] Separate false-positive rejections from "valid but won't fix" dismissals in stored feedback.
+4. [x] Separate false-positive rejections from "valid but won't fix" dismissals in stored feedback.
 5. [ ] Weight reinforcement by reviewer role or trust level when GitHub identity is available.
 6. [ ] Add rule-level reinforcement decay so old team preferences do not dominate forever.
 7. [x] Add path-scoped reinforcement buckets so teams can prefer different standards in `tests/`, `scripts/`, and production code.
@@ -50,26 +50,26 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 
 21. [ ] Build a first-class `fix until clean` loop that can run review, apply fixes, rerun review, and stop on convergence.
 22. [ ] Reuse the existing DAG runtime to model iterative review/fix loops as resumable workflow nodes.
-23. [ ] Add a max-iteration policy and loop budget controls for autonomous review convergence.
+23. [x] Add a max-iteration policy and loop budget controls for autonomous review convergence.
 24. [ ] Add "issue replay" prompts that hand unresolved findings back to a coding agent with file-local context.
 25. [ ] Add a handoff contract from reviewer findings to fix agents with rule IDs, evidence, and suggested diffs.
 26. [ ] Persist loop-level telemetry: iterations, fixes attempted, findings cleared, findings reopened.
-27. [ ] Add "challenge the finding" verification loops where a validator tries to falsify a suspected issue before keeping it.
+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.
 29. [ ] Allow loop policies to differ by profile: conservative auditor, high-autonomy fixer, or report-only.
 30. [ ] Add eval fixtures specifically for loop convergence and reopened-issue regressions.
 
 ## 4. Code Graph and Repository Intelligence
 
 31. [ ] Turn the current symbol graph into a persisted repository graph with durable storage and reload support.
-32. [ ] Add caller/callee expansion APIs for multi-hop impact analysis from changed symbols.
+32. [x] Add caller/callee expansion APIs for multi-hop impact analysis from changed symbols.
 33. [ ] Add contract edges between interfaces, implementations, and API endpoints.
 34. [ ] Add "similar implementation" lookup so repeated patterns and divergences are explicit.
 35. [ ] Add cross-file blast-radius summaries to findings when a change affects many callers.
 36. [ ] Add graph freshness/version metadata so reviews know whether they are using stale repository intelligence.
 37. [ ] Add graph-backed ranking of related files before semantic RAG retrieval.
 38. [ ] Add graph query traces to `dag_traces` or review artifacts for explainability and debugging.
-39. [ ] Add graph-aware eval fixtures that require multi-hop code understanding to pass.
+39. [x] Add graph-aware eval fixtures that require multi-hop code understanding to pass.
 40. [ ] Split `src/core/symbol_graph.rs` into construction, persistence, traversal, and ranking modules as it grows.
 
 ## 5. External Context and Pattern Repositories
@@ -107,8 +107,8 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 65. [x] Add review completeness and mean-time-to-resolution charts.
 66. [ ] Add feedback-learning effectiveness metrics: did reranked findings get higher acceptance after rollout?
 67. [ ] Add pattern-repository utilization analytics showing when extra context actually affected findings.
-68. [ ] Add eval-vs-production dashboards comparing benchmark strength against real-world acceptance.
-69. [ ] Add drill-downs from trend charts directly into the affected reviews, findings, and rules.
+68. [x] Add eval-vs-production dashboards comparing benchmark strength against real-world acceptance.
+69. [x] Add drill-downs from trend charts directly into the affected reviews, findings, and rules.
 70. [x] Add exportable JSON/CSV reports for review quality, lifecycle, and reinforcement metrics.
 
 ## 8. APIs, Automation, and MCP-Like Surfaces
@@ -130,7 +130,7 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 82. [ ] Split `src/server/state.rs` into session lifecycle, persistence, progress, and GitHub coordination modules.
 83. [ ] Add queue depth and worker saturation metrics for long-running review and eval jobs.
 84. [ ] Add retention policies for review artifacts, eval artifacts, and trend histories.
-85. [ ] Add storage migrations for richer comment lifecycle and reinforcement schemas.
+85. [x] Add storage migrations for richer comment lifecycle and reinforcement schemas.
 86. [ ] Add deployment docs for self-hosted review + analytics + trend retention setups.
 87. [ ] Add secret-management guidance and validation for multi-provider enterprise installs.
 88. [ ] Add background jobs for recomputing analytics after schema or scoring changes.
@@ -180,4 +180,4 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 - [x] Add path-scoped reinforcement buckets so feedback can distinguish `tests/**`, `scripts/**`, and broader code areas.
 - [x] Add review completeness metrics across summaries, PR readiness, and ReviewView surfaces.
 - [x] Add per-PR readiness timelines that preserve historical mergeability checkpoints.
-- [ ] Commit and push each validated checkpoint before moving to the next epic.
+- [x] Commit and push each validated checkpoint before moving to the next epic.

src/review/feedback.rs

@@ -18,7 +18,10 @@ pub use patterns::derive_file_patterns;
 #[allow(unused_imports)]
 pub use persistence::{load_feedback_store, load_feedback_store_from_path, save_feedback_store};
 #[allow(unused_imports)]
-pub use record::{apply_comment_feedback_signal, record_comment_feedback_stats};
+pub use record::{
+    apply_comment_dismissal_signal, apply_comment_feedback_signal, record_comment_dismissal_stats,
+    record_comment_feedback_stats,
+};
 #[allow(unused_imports)]
 pub use semantic::{record_semantic_feedback_example, record_semantic_feedback_examples};
 #[allow(unused_imports)]
@@ -34,6 +37,7 @@ mod tests {
         let store = FeedbackStore::default();
         assert!(store.suppress.is_empty());
         assert!(store.accept.is_empty());
+        assert!(store.dismissed.is_empty());
         assert!(store.by_comment_type.is_empty());
         assert!(store.by_category.is_empty());
         assert!(store.by_file_pattern.is_empty());
@@ -62,20 +66,24 @@ mod tests {
         let mut store = FeedbackStore::default();
         store.suppress.insert("c1".to_string());
         store.accept.insert("c2".to_string());
+        store.dismissed.insert("c3".to_string());
         store.by_comment_type.insert(
             "style".to_string(),
             FeedbackTypeStats {
                 accepted: 1,
                 rejected: 2,
+                dismissed: 3,
             },
         );
 
         let json = serde_json::to_string(&store).unwrap();
         let deserialized: FeedbackStore = serde_json::from_str(&json).unwrap();
         assert!(deserialized.suppress.contains("c1"));
         assert!(deserialized.accept.contains("c2"));
+        assert!(deserialized.dismissed.contains("c3"));
         assert_eq!(deserialized.by_comment_type["style"].accepted, 1);
         assert_eq!(deserialized.by_comment_type["style"].rejected, 2);
+        assert_eq!(deserialized.by_comment_type["style"].dismissed, 3);
     }
 
     #[test]
@@ -98,6 +106,7 @@ mod tests {
         let stats = FeedbackPatternStats {
             accepted: 10,
             rejected: 0,
+            dismissed: 0,
         };
         assert_eq!(stats.acceptance_rate(), 1.0);
         assert_eq!(stats.total(), 10);
@@ -108,6 +117,7 @@ mod tests {
         let stats = FeedbackPatternStats {
             accepted: 0,
             rejected: 10,
+            dismissed: 0,
         };
         assert_eq!(stats.acceptance_rate(), 0.0);
     }
@@ -117,6 +127,7 @@ mod tests {
         let stats = FeedbackPatternStats {
             accepted: 3,
             rejected: 7,
+            dismissed: 0,
         };
         assert!((stats.acceptance_rate() - 0.3).abs() < f32::EPSILON);
     }

src/review/feedback/record.rs

@@ -25,6 +25,18 @@ pub fn record_comment_feedback_stats(
     }
 }
 
+pub fn record_comment_dismissal_stats(store: &mut FeedbackStore, comment: &core::Comment) {
+    let key = classify_comment_type(comment).as_str().to_string();
+    let stats = store.by_comment_type.entry(key).or_default();
+    stats.dismissed = stats.dismissed.saturating_add(1);
+
+    let file_patterns = derive_file_patterns(&comment.file_path);
+    store.record_dismissal_patterns(&comment.category.to_string(), &file_patterns);
+    if let Some(rule_id) = normalize_rule_id(comment.rule_id.as_deref()) {
+        store.record_rule_dismissal_patterns(&rule_id, &file_patterns);
+    }
+}
+
 pub fn apply_comment_feedback_signal(
     store: &mut FeedbackStore,
     comment: &core::Comment,
@@ -45,6 +57,16 @@ pub fn apply_comment_feedback_signal(
     changed
 }
 
+pub fn apply_comment_dismissal_signal(store: &mut FeedbackStore, comment: &core::Comment) -> bool {
+    let changed = store.dismissed.insert(comment.id.clone());
+
+    if changed {
+        record_comment_dismissal_stats(store, comment);
+    }
+
+    changed
+}
+
 #[cfg(test)]
 mod tests {
     use std::path::PathBuf;
@@ -113,4 +135,23 @@ mod tests {
         assert_eq!(store.by_rule["sec.sql.injection"].accepted, 1);
         assert_eq!(store.by_rule["sec.sql.injection"].rejected, 1);
     }
+
+    #[test]
+    fn apply_comment_dismissal_signal_is_idempotent() {
+        let comment = sample_comment();
+        let mut store = FeedbackStore::default();
+
+        assert!(apply_comment_dismissal_signal(&mut store, &comment));
+        assert!(!apply_comment_dismissal_signal(&mut store, &comment));
+
+        assert!(store.dismissed.contains(&comment.id));
+        assert_eq!(store.by_comment_type["logic"].dismissed, 1);
+        assert_eq!(store.by_category["Security"].dismissed, 1);
+        assert_eq!(store.by_file_pattern["src/**"].dismissed, 1);
+        assert_eq!(store.by_rule["sec.sql.injection"].dismissed, 1);
+        assert_eq!(
+            store.by_rule_file_pattern["sec.sql.injection|*.rs"].dismissed,
+            1
+        );
+    }
 }

src/review/feedback/store.rs

@@ -8,6 +8,8 @@ pub struct FeedbackTypeStats {
     pub accepted: usize,
     #[serde(default)]
     pub rejected: usize,
+    #[serde(default)]
+    pub dismissed: usize,
 }
 
 /// Tracks acceptance/rejection counts for a specific pattern (category, file extension, etc.)
@@ -17,6 +19,8 @@ pub struct FeedbackPatternStats {
     pub accepted: usize,
     #[serde(default)]
     pub rejected: usize,
+    #[serde(default)]
+    pub dismissed: usize,
 }
 
 impl FeedbackPatternStats {
@@ -40,6 +44,8 @@ pub struct FeedbackStore {
     #[serde(default)]
     pub accept: HashSet<String>,
     #[serde(default)]
+    pub dismissed: HashSet<String>,
+    #[serde(default)]
     pub by_comment_type: HashMap<String, FeedbackTypeStats>,
     /// Feedback stats keyed by category (e.g., "Bug", "Security", "Performance").
     #[serde(default)]
@@ -122,6 +128,43 @@ impl FeedbackStore {
             update_pattern_stats(comp_stats, accepted);
         }
     }
+
+    /// Record a dismissal event across one or more file-pattern buckets.
+    pub fn record_dismissal_patterns<S>(&mut self, category: &str, file_patterns: &[S])
+    where
+        S: AsRef<str>,
+    {
+        let cat_stats = self.by_category.entry(category.to_string()).or_default();
+        update_pattern_dismissed(cat_stats);
+
+        for pattern in collect_unique_patterns(file_patterns) {
+            let fp_stats = self.by_file_pattern.entry(pattern.clone()).or_default();
+            update_pattern_dismissed(fp_stats);
+
+            let composite = format!("{category}|{pattern}");
+            let comp_stats = self.by_category_file_pattern.entry(composite).or_default();
+            update_pattern_dismissed(comp_stats);
+        }
+    }
+
+    /// Record a dismissal event across normalized rule-id buckets.
+    pub fn record_rule_dismissal_patterns<S>(&mut self, rule_id: &str, file_patterns: &[S])
+    where
+        S: AsRef<str>,
+    {
+        let Some(rule_id) = normalize_feedback_key(rule_id) else {
+            return;
+        };
+
+        let rule_stats = self.by_rule.entry(rule_id.clone()).or_default();
+        update_pattern_dismissed(rule_stats);
+
+        for pattern in collect_unique_patterns(file_patterns) {
+            let composite = format!("{}|{}", rule_id, pattern);
+            let comp_stats = self.by_rule_file_pattern.entry(composite).or_default();
+            update_pattern_dismissed(comp_stats);
+        }
+    }
 }
 
 fn update_pattern_stats(stats: &mut FeedbackPatternStats, accepted: bool) {
@@ -132,6 +175,10 @@ fn update_pattern_stats(stats: &mut FeedbackPatternStats, accepted: bool) {
     }
 }
 
+fn update_pattern_dismissed(stats: &mut FeedbackPatternStats) {
+    stats.dismissed += 1;
+}
+
 fn collect_unique_patterns<S>(file_patterns: &[S]) -> HashSet<String>
 where
     S: AsRef<str>,

src/review/filters.rs

@@ -108,6 +108,7 @@ mod tests {
                 super::super::feedback::FeedbackTypeStats {
                     accepted: 0,
                     rejected: 3,
+                    dismissed: 0,
                 },
             )]),
             ..Default::default()
@@ -144,6 +145,7 @@ mod tests {
                 super::super::feedback::FeedbackTypeStats {
                     accepted: 0,
                     rejected: 10,
+                    dismissed: 0,
                 },
             )]),
             ..Default::default()
@@ -170,6 +172,7 @@ mod tests {
                 super::super::feedback::FeedbackTypeStats {
                     accepted: 0,
                     rejected: 10,
+                    dismissed: 0,
                 },
             )]),
             ..Default::default()

src/review/mod.rs

@@ -13,8 +13,9 @@ pub use context_helpers::{
     resolve_pattern_repositories,
 };
 pub use feedback::{
-    apply_comment_feedback_signal, derive_file_patterns, load_feedback_store,
-    load_feedback_store_from_path, record_semantic_feedback_examples, save_feedback_store,
+    apply_comment_dismissal_signal, apply_comment_feedback_signal, derive_file_patterns,
+    load_feedback_store, load_feedback_store_from_path, record_semantic_feedback_examples,
+    save_feedback_store,
 };
 #[allow(unused_imports)]
 pub use filters::apply_review_filters;

src/server/api.rs

@@ -1278,14 +1278,21 @@ pub async fn update_comment_lifecycle(
 
     let mut session = load_review_session_for_update(&state, &id).await?;
 
-    let status_changed = {
+    let (status_changed, dismissed_comment) = {
         let comment = session
             .comments
             .iter_mut()
             .find(|c| c.id == request.comment_id)
             .ok_or(StatusCode::NOT_FOUND)?;
 
-        apply_comment_lifecycle_transition(comment, next_status, current_timestamp())
+        let changed = apply_comment_lifecycle_transition(comment, next_status, current_timestamp());
+        let dismissed_comment = if changed && next_status == CommentStatus::Dismissed {
+            Some(comment.clone())
+        } else {
+            None
+        };
+
+        (changed, dismissed_comment)
     };
 
     if status_changed {
@@ -1295,6 +1302,14 @@ pub async fn update_comment_lifecycle(
             previous_summary.as_ref(),
         ));
         persist_updated_review_session(&state, session).await;
+
+        if let Some(comment) = dismissed_comment {
+            let config = state.config.read().await.clone();
+            let mut feedback_store = crate::review::load_feedback_store(&config);
+            if crate::review::apply_comment_dismissal_signal(&mut feedback_store, &comment) {
+                let _ = crate::review::save_feedback_store(&config.feedback_path, &feedback_store);
+            }
+        }
     }
 
     Ok(Json(CommentLifecycleResponse { ok: true }))