fix: 2 TDD bugs — hunk header off-by-one, walkthrough false truncation

- smart_review_prompt.rs: Use saturating_sub(1) for inclusive end line
  in hunk headers. "Lines 10-15" → "Lines 10-14" for 5-line hunk.
- format.rs: Move truncation check before push in build_change_walkthrough
  so exactly max_entries files don't falsely report truncation.

985 tests pass, zero clippy warnings.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: haasonsaas

src/core/smart_review_prompt.rs

@@ -138,9 +138,9 @@ TAGS: [comma-separated relevant tags]
             let hunk_header = format!(
                 "### Hunk: Lines {}-{} (was {}-{})\n\n",
                 hunk.new_start,
-                hunk.new_start + hunk.new_lines,
+                hunk.new_start + hunk.new_lines.saturating_sub(1),
                 hunk.old_start,
-                hunk.old_start + hunk.old_lines
+                hunk.old_start + hunk.old_lines.saturating_sub(1)
             );
             if max_diff_chars > 0 && diff_chars.saturating_add(hunk_header.len()) > max_diff_chars {
                 diff_truncated = true;
@@ -211,3 +211,55 @@ TAGS: [comma-separated relevant tags]
         Ok(prompt)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::core::diff_parser::{ChangeType, DiffHunk, DiffLine};
+    use std::path::PathBuf;
+
+    // ── Bug: hunk header shows one-past-end line number ──────────────
+    //
+    // A hunk with new_start=10, new_lines=5 covers lines 10-14 (inclusive).
+    // The old code displayed "Lines 10-15", which is off by one.
+
+    #[test]
+    fn test_hunk_header_line_range_is_inclusive() {
+        let diff = UnifiedDiff {
+            file_path: PathBuf::from("test.rs"),
+            old_content: None,
+            new_content: None,
+            is_new: false,
+            is_deleted: false,
+            is_binary: false,
+            hunks: vec![DiffHunk {
+                old_start: 5,
+                old_lines: 3,
+                new_start: 10,
+                new_lines: 5,
+                context: String::new(),
+                changes: vec![DiffLine {
+                    content: "line".to_string(),
+                    change_type: ChangeType::Added,
+                    old_line_no: None,
+                    new_line_no: Some(10),
+                }],
+            }],
+        };
+        let (_system, user) =
+            SmartReviewPromptBuilder::build_enhanced_review_prompt(&diff, &[], 1000, 10000, None)
+                .unwrap();
+        // Should say "Lines 10-14" (inclusive), not "Lines 10-15"
+        assert!(
+            user.contains("Lines 10-14"),
+            "Hunk header should use inclusive end line; prompt contains: {}",
+            user.lines()
+                .find(|l| l.contains("Hunk:"))
+                .unwrap_or("(no hunk header found)")
+        );
+        assert!(
+            user.contains("was 5-7"),
+            "Old range should also be inclusive: 5 + 3 - 1 = 7"
+        );
+    }
+}

src/output/format.rs

@@ -546,18 +546,18 @@ pub fn build_change_walkthrough(diffs: &[core::UnifiedDiff]) -> String {
             "modified"
         };
 
+        if entries.len() >= max_entries {
+            truncated = true;
+            break;
+        }
+
         entries.push(format!(
             "- `{}` ({}; +{}, -{})",
             diff.file_path.display(),
             status,
             added,
             removed
         ));
-
-        if entries.len() >= max_entries {
-            truncated = true;
-            break;
-        }
     }
 
     if entries.is_empty() {
@@ -910,4 +910,51 @@ mod tests {
             "Files should appear in sorted order: a_first({a_pos}) < m_middle({m_pos}) < z_last({z_pos})"
         );
     }
+
+    // ── Bug: walkthrough falsely reports truncation at exactly max_entries ──
+    //
+    // The truncation check ran after pushing the entry, so when exactly
+    // max_entries (50) files exist, it would say "truncated" even though
+    // all entries were included.
+
+    #[test]
+    fn test_walkthrough_not_truncated_at_exactly_max() {
+        let diffs: Vec<core::UnifiedDiff> = (0..50)
+            .map(|i| core::UnifiedDiff {
+                file_path: PathBuf::from(format!("file{}.rs", i)),
+                old_content: None,
+                new_content: None,
+                is_new: false,
+                is_deleted: false,
+                is_binary: false,
+                hunks: vec![core::diff_parser::DiffHunk {
+                    old_start: 1,
+                    old_lines: 1,
+                    new_start: 1,
+                    new_lines: 1,
+                    context: String::new(),
+                    changes: vec![core::diff_parser::DiffLine {
+                        content: "line".to_string(),
+                        change_type: core::diff_parser::ChangeType::Added,
+                        old_line_no: None,
+                        new_line_no: Some(1),
+                    }],
+                }],
+            })
+            .collect();
+
+        let output = build_change_walkthrough(&diffs);
+        assert!(
+            !output.contains("truncated"),
+            "50 files (exactly max_entries) should not be truncated"
+        );
+        // All 50 files should be present
+        for i in 0..50 {
+            assert!(
+                output.contains(&format!("file{}.rs", i)),
+                "Missing file{}.rs in walkthrough",
+                i
+            );
+        }
+    }
 }