fix(git): keep the trailing newline on filtered 'git status' output

`filter_status_with_args` joins kept lines with \n and has no terminal
newline; `never_worse` may instead return git's raw stdout, which does.
`print!` on either is wrong in one of the two cases, so the arg-carrying
status path (--short / -s / --porcelain) dropped the final newline.

The last entry then glues to whatever prints next, and — worse than
cosmetic — any pipeline that counts lines undercounts by one:

    git status --porcelain | cat -A   ->  ?? handoff/$      (1 line)
    rtk git status --porcelain | cat -A -> ?? handoff/       (0 lines)

On a tree with a single change, `rtk git status --porcelain | wc -l`
therefore reports 0 — a false 'clean' on the exact question the command
is usually asked. Anything gating a commit/no-commit decision on piped
porcelain output takes the wrong branch.

Normalize to exactly one trailing newline via a pure, unit-tested
`with_trailing_newline`. Empty output stays empty: --porcelain on a
clean tree correctly prints nothing.

Author: strickdd

src/cmds/git/git.rs

@@ -1469,6 +1469,25 @@ fn filter_status_with_args(output: &str) -> String {
     }
 }
 
+/// Ensure filtered output ends with exactly one trailing newline, matching git.
+///
+/// `filter_status_with_args` joins its kept lines with `\n` and therefore has no
+/// terminal newline, while `never_worse` may hand back git's raw stdout, which
+/// does. Printing either verbatim is wrong in one of the two cases: the joined
+/// form glues its last entry to whatever prints next, so
+/// `rtk git status --porcelain | wc -l` undercounts by one — reporting `0`, i.e.
+/// "clean", on a tree with a single change.
+///
+/// Empty output is left empty: `--porcelain` on a clean tree prints nothing at
+/// all, and a lone newline there would be a different fidelity bug.
+fn with_trailing_newline(output: &str) -> String {
+    if output.is_empty() || output.ends_with('\n') {
+        output.to_string()
+    } else {
+        format!("{}\n", output)
+    }
+}
+
 fn run_status(args: &[String], verbose: u8, global_args: &[String]) -> Result<i32> {
     let timer = tracking::TimedExecution::start();
 
@@ -1527,7 +1546,7 @@ fn run_status(args: &[String], verbose: u8, global_args: &[String]) -> Result<i3
 
         // Apply minimal filtering: strip ANSI, remove hints, empty lines
         let filtered = filter_status_with_args(&result.stdout);
-        let filtered = never_worse(&result.stdout, &filtered).to_string();
+        let filtered = with_trailing_newline(never_worse(&result.stdout, &filtered));
         print!("{}", filtered);
 
         timer.track(
@@ -2951,6 +2970,36 @@ mod tests {
         assert_eq!(args, vec!["status", "--porcelain", "-b"]);
     }
 
+    #[test]
+    fn with_trailing_newline_appends_when_missing() {
+        assert_eq!(
+            with_trailing_newline(" M tracked.txt\n?? zzz-last.txt"),
+            " M tracked.txt\n?? zzz-last.txt\n"
+        );
+    }
+
+    #[test]
+    fn with_trailing_newline_leaves_existing_newline_alone() {
+        assert_eq!(with_trailing_newline(" M tracked.txt\n"), " M tracked.txt\n");
+    }
+
+    #[test]
+    fn with_trailing_newline_keeps_empty_output_empty() {
+        // `--porcelain` on a clean tree prints nothing; a lone newline would be
+        // its own fidelity bug.
+        assert_eq!(with_trailing_newline(""), "");
+    }
+
+    #[test]
+    fn filtered_status_line_count_matches_git() {
+        // The regression this guards: `rtk git status --porcelain | wc -l`
+        // reported 0 on a one-file dirty tree, i.e. a false "clean".
+        let raw = "?? handoff/\n";
+        let filtered = with_trailing_newline(&filter_status_with_args(raw));
+        assert_eq!(filtered.lines().count(), raw.lines().count());
+        assert_eq!(filtered, raw);
+    }
+
     #[test]
     fn test_uses_compact_status_path_for_branch_and_short_flags() {
         assert!(uses_compact_status_path(&["-b".to_string()]));