feat(feedback): decay stale rule reinforcement

Author: haasonsaas

TODO.md

@@ -27,7 +27,7 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 3. [x] Feed addressed/not-addressed outcomes into the reinforcement store alongside thumbs.
 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.
+6. [x] 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.
 8. [ ] Persist explanation text from follow-up feedback replies and mine it into reusable review guidance.
 9. [ ] Learn "preferred phrasing" for accepted comments so comment tone and specificity improve over time.

src/commands/misc/feedback/backfill.rs

@@ -41,9 +41,12 @@ fn build_feedback_store_from_reviews(
     };
 
     for session in &sessions {
+        let timestamp = feedback_event_timestamp(session);
         for comment in &session.comments {
             if let Some(accepted) = normalize_feedback_label(comment.feedback.as_deref()) {
-                if review::apply_comment_feedback_signal(&mut store, comment, accepted) {
+                if review::apply_comment_feedback_signal_at(
+                    &mut store, comment, accepted, timestamp,
+                ) {
                     if accepted {
                         summary.accepted += 1;
                     } else {
@@ -110,10 +113,11 @@ fn backfill_not_addressed_outcomes(
                 .filter(|comment| comment.status == CommentStatus::Open)
             {
                 if current_comment_ids.contains(comment.id.as_str())
-                    && review::apply_comment_resolution_outcome_signal(
+                    && review::apply_comment_resolution_outcome_signal_at(
                         store,
                         comment,
                         review::CommentResolutionOutcome::NotAddressed,
+                        feedback_event_timestamp(current),
                     )
                 {
                     not_addressed += 1;
@@ -163,6 +167,10 @@ fn normalize_feedback_label(label: Option<&str>) -> Option<bool> {
     }
 }
 
+fn feedback_event_timestamp(session: &ReviewSession) -> i64 {
+    session.completed_at.unwrap_or(session.started_at)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -362,4 +370,55 @@ mod tests {
             serde_json::to_value(&list_store).unwrap()
         );
     }
+
+    #[test]
+    fn build_feedback_store_replays_rule_decay_in_chronological_order() {
+        let half_life = 30 * 24 * 60 * 60;
+
+        let stale_rejects = (0..32)
+            .map(|index| {
+                let mut comment = sample_comment(
+                    &format!("Stale reject {index}"),
+                    Category::Security,
+                    "src/lib.rs",
+                );
+                comment.feedback = Some("reject".to_string());
+                comment.rule_id = Some("SEC.SQL.INJECTION".to_string());
+                comment.id = format!("stale-reject-{index}");
+                comment
+            })
+            .collect::<Vec<_>>();
+        let recent_accepts = (0..4)
+            .map(|index| {
+                let mut comment = sample_comment(
+                    &format!("Recent accept {index}"),
+                    Category::Security,
+                    "src/lib.rs",
+                );
+                comment.feedback = Some("accept".to_string());
+                comment.rule_id = Some("SEC.SQL.INJECTION".to_string());
+                comment.id = format!("recent-accept-{index}");
+                comment
+            })
+            .collect::<Vec<_>>();
+
+        let (store, _) = build_feedback_store_from_reviews(vec![
+            sample_review_session("stale", 1_000, "raw", None, stale_rejects),
+            sample_review_session(
+                "recent",
+                1_000 + (4 * half_life),
+                "raw",
+                None,
+                recent_accepts,
+            ),
+        ]);
+
+        let stats = &store.by_rule["sec.sql.injection"];
+        let recent_timestamp = 1_000 + (4 * half_life) + 1;
+        assert!(stats.acceptance_rate() < 0.2);
+        assert!(
+            stats.decayed_acceptance_rate_at(recent_timestamp).unwrap() > 0.6,
+            "expected recent accepts to outweigh stale rejects after replay"
+        );
+    }
 }

src/review/feedback.rs

@@ -20,13 +20,15 @@ pub use persistence::{load_feedback_store, load_feedback_store_from_path, save_f
 #[allow(unused_imports)]
 pub use record::{
     apply_comment_dismissal_signal, apply_comment_feedback_signal,
-    apply_comment_resolution_outcome_signal, record_comment_dismissal_stats,
-    record_comment_feedback_stats, record_comment_resolution_stats, CommentResolutionOutcome,
+    apply_comment_feedback_signal_at, apply_comment_resolution_outcome_signal,
+    apply_comment_resolution_outcome_signal_at, record_comment_dismissal_stats,
+    record_comment_feedback_stats, record_comment_feedback_stats_at,
+    record_comment_resolution_stats, record_comment_resolution_stats_at, CommentResolutionOutcome,
 };
 #[allow(unused_imports)]
 pub use semantic::{record_semantic_feedback_example, record_semantic_feedback_examples};
 #[allow(unused_imports)]
-pub use store::{FeedbackPatternStats, FeedbackStore, FeedbackTypeStats};
+pub use store::{DecayedFeedbackStats, FeedbackPatternStats, FeedbackStore, FeedbackTypeStats};
 
 #[cfg(test)]
 mod tests {
@@ -72,6 +74,21 @@ mod tests {
         store.dismissed.insert("c3".to_string());
         store.addressed.insert("c4".to_string());
         store.not_addressed.insert("c5".to_string());
+        store.by_rule.insert(
+            "style.rule".to_string(),
+            FeedbackPatternStats {
+                accepted: 1,
+                rejected: 2,
+                dismissed: 0,
+                addressed: 0,
+                not_addressed: 0,
+                decayed: Some(DecayedFeedbackStats {
+                    positive: 0.75,
+                    negative: 1.25,
+                    last_event_at: Some(123),
+                }),
+            },
+        );
         store.by_comment_type.insert(
             "style".to_string(),
             FeedbackTypeStats {
@@ -95,6 +112,10 @@ mod tests {
         assert_eq!(deserialized.by_comment_type["style"].dismissed, 3);
         assert_eq!(deserialized.by_comment_type["style"].addressed, 4);
         assert_eq!(deserialized.by_comment_type["style"].not_addressed, 5);
+        assert_eq!(
+            deserialized.by_rule["style.rule"].decayed_total_at(123),
+            Some(2.0)
+        );
     }
 
     #[test]
@@ -120,6 +141,7 @@ mod tests {
             dismissed: 0,
             addressed: 0,
             not_addressed: 0,
+            decayed: None,
         };
         assert_eq!(stats.acceptance_rate(), 1.0);
         assert_eq!(stats.total(), 10);
@@ -133,6 +155,7 @@ mod tests {
             dismissed: 0,
             addressed: 0,
             not_addressed: 0,
+            decayed: None,
         };
         assert_eq!(stats.acceptance_rate(), 0.0);
     }
@@ -145,6 +168,7 @@ mod tests {
             dismissed: 0,
             addressed: 0,
             not_addressed: 0,
+            decayed: None,
         };
         assert!((stats.acceptance_rate() - 0.3).abs() < f32::EPSILON);
     }
@@ -157,12 +181,47 @@ mod tests {
             dismissed: 0,
             addressed: 3,
             not_addressed: 1,
+            decayed: None,
         };
 
         assert!((stats.acceptance_rate() - (4.0 / 6.0)).abs() < f32::EPSILON);
         assert_eq!(stats.total(), 6);
     }
 
+    #[test]
+    fn rule_feedback_decay_prioritizes_recent_signals() {
+        let half_life = 30 * 24 * 60 * 60;
+        let mut store = FeedbackStore::default();
+
+        for _ in 0..32 {
+            store.record_rule_feedback_patterns_at("sec.sql.injection", &["*.rs"], false, 1_000);
+        }
+        for _ in 0..4 {
+            store.record_rule_feedback_patterns_at(
+                "sec.sql.injection",
+                &["*.rs"],
+                true,
+                1_000 + (4 * half_life),
+            );
+        }
+
+        let stats = &store.by_rule["sec.sql.injection"];
+        let decayed_total = stats.decayed_total_at(1_000 + (4 * half_life)).unwrap();
+        let decayed_rate = stats
+            .decayed_acceptance_rate_at(1_000 + (4 * half_life))
+            .unwrap();
+
+        assert!(
+            decayed_total >= 5.0,
+            "expected enough fresh signal, got {decayed_total}"
+        );
+        assert!(
+            decayed_rate > 0.6,
+            "expected recent accepts to outweigh stale rejects, got {decayed_rate}"
+        );
+        assert!(stats.acceptance_rate() < 0.2);
+    }
+
     // ── record_feedback tests ─────────────────────────────────────────────
 
     #[test]

src/review/feedback/record.rs

@@ -31,6 +31,27 @@ pub fn record_comment_feedback_stats(
     }
 }
 
+pub fn record_comment_feedback_stats_at(
+    store: &mut FeedbackStore,
+    comment: &core::Comment,
+    accepted: bool,
+    timestamp: i64,
+) {
+    let key = classify_comment_type(comment).as_str().to_string();
+    let stats = store.by_comment_type.entry(key).or_default();
+    if accepted {
+        stats.accepted = stats.accepted.saturating_add(1);
+    } else {
+        stats.rejected = stats.rejected.saturating_add(1);
+    }
+
+    let file_patterns = derive_file_patterns(&comment.file_path);
+    store.record_feedback_patterns(&comment.category.to_string(), &file_patterns, accepted);
+    if let Some(rule_id) = normalize_rule_id(comment.rule_id.as_deref()) {
+        store.record_rule_feedback_patterns_at(&rule_id, &file_patterns, accepted, timestamp);
+    }
+}
+
 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();
@@ -65,6 +86,29 @@ pub fn record_comment_resolution_stats(
     }
 }
 
+pub fn record_comment_resolution_stats_at(
+    store: &mut FeedbackStore,
+    comment: &core::Comment,
+    outcome: CommentResolutionOutcome,
+    timestamp: i64,
+) {
+    let key = classify_comment_type(comment).as_str().to_string();
+    let stats = store.by_comment_type.entry(key).or_default();
+    let addressed = matches!(outcome, CommentResolutionOutcome::Addressed);
+
+    if addressed {
+        stats.addressed = stats.addressed.saturating_add(1);
+    } else {
+        stats.not_addressed = stats.not_addressed.saturating_add(1);
+    }
+
+    let file_patterns = derive_file_patterns(&comment.file_path);
+    store.record_outcome_patterns(&comment.category.to_string(), &file_patterns, addressed);
+    if let Some(rule_id) = normalize_rule_id(comment.rule_id.as_deref()) {
+        store.record_rule_outcome_patterns_at(&rule_id, &file_patterns, addressed, timestamp);
+    }
+}
+
 pub fn apply_comment_feedback_signal(
     store: &mut FeedbackStore,
     comment: &core::Comment,
@@ -85,6 +129,27 @@ pub fn apply_comment_feedback_signal(
     changed
 }
 
+pub fn apply_comment_feedback_signal_at(
+    store: &mut FeedbackStore,
+    comment: &core::Comment,
+    accepted: bool,
+    timestamp: i64,
+) -> bool {
+    let changed = if accepted {
+        store.suppress.remove(&comment.id);
+        store.accept.insert(comment.id.clone())
+    } else {
+        store.accept.remove(&comment.id);
+        store.suppress.insert(comment.id.clone())
+    };
+
+    if changed {
+        record_comment_feedback_stats_at(store, comment, accepted, timestamp);
+    }
+
+    changed
+}
+
 pub fn apply_comment_dismissal_signal(store: &mut FeedbackStore, comment: &core::Comment) -> bool {
     let changed = store.dismissed.insert(comment.id.clone());
 
@@ -112,6 +177,24 @@ pub fn apply_comment_resolution_outcome_signal(
     changed
 }
 
+pub fn apply_comment_resolution_outcome_signal_at(
+    store: &mut FeedbackStore,
+    comment: &core::Comment,
+    outcome: CommentResolutionOutcome,
+    timestamp: i64,
+) -> bool {
+    let changed = match outcome {
+        CommentResolutionOutcome::Addressed => store.addressed.insert(comment.id.clone()),
+        CommentResolutionOutcome::NotAddressed => store.not_addressed.insert(comment.id.clone()),
+    };
+
+    if changed {
+        record_comment_resolution_stats_at(store, comment, outcome, timestamp);
+    }
+
+    changed
+}
+
 #[cfg(test)]
 mod tests {
     use std::path::PathBuf;
@@ -143,8 +226,12 @@ mod tests {
         let comment = sample_comment();
         let mut store = FeedbackStore::default();
 
-        assert!(apply_comment_feedback_signal(&mut store, &comment, true));
-        assert!(!apply_comment_feedback_signal(&mut store, &comment, true));
+        assert!(apply_comment_feedback_signal_at(
+            &mut store, &comment, true, 1_000
+        ));
+        assert!(!apply_comment_feedback_signal_at(
+            &mut store, &comment, true, 1_000,
+        ));
 
         assert!(store.accept.contains(&comment.id));
         assert_eq!(store.by_category["Security"].accepted, 1);
@@ -162,6 +249,10 @@ mod tests {
             store.by_rule_file_pattern["sec.sql.injection|*.rs"].accepted,
             1
         );
+        assert_eq!(
+            store.by_rule["sec.sql.injection"].decayed_total_at(1_000),
+            Some(1.0)
+        );
     }
 
     #[test]