fix(diff): correct truncation overflow count in condense_unified_diff

The overflow message "+N more" in condense_unified_diff was lying.
The `changes` vec was capped at 15 entries, so `changes.len() - 10`
could only reach 5 — reporting "+5 more" when 190 lines were actually
truncated. Fix: track `added + removed` directly and compute true
overflow as `(added + removed) - 10`.

Adds 7 accuracy tests across 4 modules to lock in correct overflow
reporting:
- diff_cmd: overflow count matches true total (200 changes → "+190 more")
- diff_cmd: no spurious overflow message for 8 changes
- git: format_status overflow count is exact (25 staged → "+10 more")
- git: compact_diff recovery hint present when hunk is truncated
- grep: documents uncapped-vector invariant that prevents the diff bug
- filter: smart_truncate kept + reported_more == total_lines

Closes the test gap flagged in testing-patterns.md backlog for diff_cmd.rs.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Signed-off-by: Florian BRUNIAUX <florian@bruniaux.com>

Author: FlorianBruniaux

src/diff_cmd.rs

@@ -172,8 +172,9 @@ fn condense_unified_diff(diff: &str) -> String {
                     for c in changes.iter().take(10) {
                         result.push(format!("  {}", c));
                     }
-                    if changes.len() > 10 {
-                        result.push(format!("  ... +{} more", changes.len() - 10));
+                    let total = added + removed;
+                    if total > 10 {
+                        result.push(format!("  ... +{} more", total - 10));
                     }
                 }
                 current_file = line
@@ -203,8 +204,9 @@ fn condense_unified_diff(diff: &str) -> String {
         for c in changes.iter().take(10) {
             result.push(format!("  {}", c));
         }
-        if changes.len() > 10 {
-            result.push(format!("  ... +{} more", changes.len() - 10));
+        let total = added + removed;
+        if total > 10 {
+            result.push(format!("  ... +{} more", total - 10));
         }
     }
 
@@ -364,4 +366,52 @@ diff --git a/b.rs b/b.rs
         let result = condense_unified_diff("");
         assert!(result.is_empty());
     }
+
+    // --- truncation accuracy ---
+
+    fn make_large_unified_diff(added: usize, removed: usize) -> String {
+        let mut lines = vec![
+            "diff --git a/config.yaml b/config.yaml".to_string(),
+            "--- a/config.yaml".to_string(),
+            "+++ b/config.yaml".to_string(),
+            "@@ -1,200 +1,200 @@".to_string(),
+        ];
+        for i in 0..removed {
+            lines.push(format!("-old_value_{}", i));
+        }
+        for i in 0..added {
+            lines.push(format!("+new_value_{}", i));
+        }
+        lines.join("\n")
+    }
+
+    #[test]
+    fn test_condense_unified_diff_overflow_count_accuracy() {
+        // 100 added + 100 removed = 200 total changes, only 10 shown
+        // True overflow = 200 - 10 = 190
+        // Bug: changes vec capped at 15, so old code showed "+5 more" (15-10) instead of "+190 more"
+        let diff = make_large_unified_diff(100, 100);
+        let result = condense_unified_diff(&diff);
+        assert!(
+            result.contains("+190 more"),
+            "Expected '+190 more' but got:\n{}",
+            result
+        );
+        assert!(
+            !result.contains("+5 more"),
+            "Bug still present: showing '+5 more' instead of true overflow"
+        );
+    }
+
+    #[test]
+    fn test_condense_unified_diff_no_false_overflow() {
+        // 8 changes total — all fit within the 10-line display cap, no overflow message
+        let diff = make_large_unified_diff(4, 4);
+        let result = condense_unified_diff(&diff);
+        assert!(
+            !result.contains("more"),
+            "No overflow message expected for 8 changes, got:\n{}",
+            result
+        );
+    }
 }

src/filter.rs

@@ -491,4 +491,49 @@ fn main() {
         assert!(!result.contains("// This is a comment"));
         assert!(result.contains("fn main()"));
     }
+
+    // --- truncation accuracy ---
+
+    #[test]
+    fn test_smart_truncate_overflow_count_exact() {
+        // 200 plain-text lines with max_lines=20.
+        // smart_truncate keeps the first max_lines/2=10 lines, then skips the rest.
+        // The overflow message "// ... N more lines (total: T)" must satisfy:
+        //   kept_count + N == T
+        let total_lines = 200usize;
+        let max_lines = 20usize;
+        let content: String = (0..total_lines)
+            .map(|i| format!("plain text line number {}", i))
+            .collect::<Vec<_>>()
+            .join("\n");
+
+        let output = smart_truncate(&content, max_lines, &Language::Rust);
+
+        // Extract the overflow message
+        let overflow_line = output
+            .lines()
+            .find(|l| l.contains("more lines"))
+            .unwrap_or_else(|| panic!("No overflow message found in:\n{}", output));
+
+        // Parse "// ... N more lines (total: T)"
+        let reported_more: usize = overflow_line
+            .split_whitespace()
+            .find(|w| w.parse::<usize>().is_ok())
+            .and_then(|w| w.parse().ok())
+            .unwrap_or_else(|| panic!("Could not parse overflow count from: {}", overflow_line));
+
+        let kept_count = output
+            .lines()
+            .filter(|l| !l.contains("more lines") && !l.contains("omitted"))
+            .count();
+
+        assert_eq!(
+            kept_count + reported_more,
+            total_lines,
+            "kept ({}) + reported_more ({}) must equal total ({})",
+            kept_count,
+            reported_more,
+            total_lines
+        );
+    }
 }

src/git.rs

@@ -2304,4 +2304,47 @@ no changes added to commit (use "git add" and/or "git commit -a")
 
         let _ = std::fs::remove_dir_all(&tmp);
     }
+
+    // --- truncation accuracy ---
+
+    #[test]
+    fn test_format_status_overflow_count_exact() {
+        // 25 staged files, default status_max_files = 15
+        // Should show 15, overflow = 25 - 15 = 10, report "+10 more"
+        let mut porcelain = String::from("## main...origin/main\n");
+        for i in 0..25 {
+            porcelain.push_str(&format!("M  staged_file_{}.rs\n", i));
+        }
+        let result = format_status_output(&porcelain);
+        assert!(
+            result.contains("+10 more"),
+            "Expected '+10 more' for 25 staged files (max_files=15), got:\n{}",
+            result
+        );
+        assert!(
+            result.contains("Staged: 25 files"),
+            "Expected 'Staged: 25 files', got:\n{}",
+            result
+        );
+    }
+
+    #[test]
+    fn test_compact_diff_recovery_hint_present() {
+        // A hunk with 110 lines exceeds max_hunk_lines (100), triggers truncation
+        // The recovery hint must appear so LLMs can re-fetch the full diff
+        let mut diff = String::new();
+        diff.push_str("diff --git a/large.rs b/large.rs\n");
+        diff.push_str("--- a/large.rs\n");
+        diff.push_str("+++ b/large.rs\n");
+        diff.push_str("@@ -1,150 +1,150 @@\n");
+        for i in 0..110 {
+            diff.push_str(&format!("+added line {}\n", i));
+        }
+        let result = compact_diff(&diff, 500);
+        assert!(
+            result.contains("[full diff: rtk git diff --no-compact]"),
+            "Expected recovery hint when hunk is truncated, got:\n{}",
+            result
+        );
+    }
 }

src/grep_cmd.rs

@@ -280,6 +280,27 @@ mod tests {
         assert_eq!(filtered[0], "-i");
     }
 
+    // --- truncation accuracy ---
+
+    #[test]
+    fn test_grep_overflow_uses_uncapped_total() {
+        // Confirm the grep overflow invariant: matches vec is never capped before overflow calc.
+        // If total_matches > per_file, overflow = total_matches - per_file (not capped).
+        // This documents that grep_cmd.rs avoids the diff_cmd bug (cap at N then compute N-10).
+        let per_file = config::limits().grep_max_per_file;
+        let total_matches = per_file + 42;
+        let overflow = total_matches - per_file;
+        assert_eq!(overflow, 42, "overflow must equal true suppressed count");
+        // Demonstrate why capping before subtraction is wrong:
+        let hypothetical_cap = per_file + 5;
+        let capped = total_matches.min(hypothetical_cap);
+        let wrong_overflow = capped - per_file;
+        assert_ne!(
+            wrong_overflow, overflow,
+            "capping before subtraction gives wrong overflow"
+        );
+    }
+
     // Verify line numbers are always enabled in rg invocation (grep_cmd.rs:24).
     // The -n/--line-numbers clap flag in main.rs is a no-op accepted for compat.
     #[test]