@@ -83,7 +83,11 @@ fn status_args_request_machine_output(args: &[String]) -> bool {
 
 fn log_args_request_machine_output(args: &[String]) -> bool {
     args.iter().enumerate().any(|(idx, arg)| {
-        arg == "--format"
+        // `-z` NUL-delimits records for programmatic consumers, independently of
+        // any --format/--pretty flag: `git log -z --name-only` is machine output
+        // with no custom format at all.
+        arg == "-z"
+            || arg == "--format"
             || arg.starts_with("--format=")
             || arg.starts_with("--pretty=format:")
             || arg.starts_with("--pretty=tformat:")
@@ -99,12 +103,13 @@ fn diff_args_request_machine_output(args: &[String]) -> bool {
         matches!(
             arg.as_str(),
             "-z"
-                | "--no-color"
                 | "--name-only"
                 | "--name-status"
                 | "--numstat"
                 | "--raw"
-                | "--word-porcelain"
+                // `--word-diff=porcelain` is the machine-readable word-diff; the
+                // plain/color variants are for humans, so they stay compacted.
+                | "--word-diff=porcelain"
         )
     })
 }
@@ -498,11 +503,9 @@ fn run_log(
 
         print!("{}", result.stdout);
 
-        timer.track(
+        timer.track_passthrough(
             &format!("git log {}", args.join(" ")),
             &format!("rtk git log {} (passthrough)", args.join(" ")),
-            &result.stdout,
-            &result.stdout,
         );
 
         return Ok(0);
@@ -930,11 +933,9 @@ fn run_status(args: &[String], verbose: u8, global_args: &[String]) -> Result<i3
             if !result.stderr.trim().is_empty() {
                 eprint!("{}", result.stderr);
             }
-            timer.track(
+            timer.track_passthrough(
                 &format!("git status {}", args.join(" ")),
                 &format!("rtk git status {} (passthrough)", args.join(" ")),
-                &result.stdout,
-                &result.stdout,
             );
             return Ok(result.exit_code);
         }
@@ -944,11 +945,9 @@ fn run_status(args: &[String], verbose: u8, global_args: &[String]) -> Result<i3
         }
         print!("{}", result.stdout);
 
-        timer.track(
+        timer.track_passthrough(
             &format!("git status {}", args.join(" ")),
             &format!("rtk git status {} (passthrough)", args.join(" ")),
-            &result.stdout,
-            &result.stdout,
         );
 
         return Ok(0);
@@ -2297,21 +2296,62 @@ mod tests {
         assert!(!log_args_request_machine_output(&["--oneline".to_string()]));
     }
 
+    #[test]
+    fn test_git_log_z_is_machine_output_without_format_flag() {
+        // `git log -z --name-only` is machine output with no custom format at all.
+        // Before this, -z fell to the compact path, which injects its own
+        // --pretty=format:<MARKER>, -10 and --no-merges and then filters —
+        // exactly the corruption the machine-output guard exists to prevent.
+        assert!(log_args_request_machine_output(&["-z".to_string()]));
+        assert!(log_args_request_machine_output(&[
+            "-z".to_string(),
+            "--name-only".to_string()
+        ]));
+    }
+
     #[test]
     fn test_git_diff_machine_output_args_passthrough() {
         for args in [
             vec!["--name-only".to_string()],
             vec!["--name-status".to_string()],
             vec!["--numstat".to_string()],
             vec!["--raw".to_string()],
-            vec!["--word-porcelain".to_string()],
+            vec!["--word-diff=porcelain".to_string()],
             vec!["-z".to_string(), "--name-only".to_string()],
         ] {
             assert!(diff_args_request_machine_output(&args), "{args:?}");
         }
         assert!(!diff_args_request_machine_output(&[]));
     }
 
+    #[test]
+    fn test_git_diff_word_diff_only_porcelain_is_machine_output() {
+        // `--word-porcelain` is not a git flag at all (`git diff --word-porcelain`
+        // exits 129); the real machine-readable spelling is `--word-diff=porcelain`.
+        assert!(!diff_args_request_machine_output(&[
+            "--word-porcelain".to_string()
+        ]));
+        assert!(diff_args_request_machine_output(&[
+            "--word-diff=porcelain".to_string()
+        ]));
+        // The human-facing word-diff modes must stay compacted.
+        for human in ["--word-diff=plain", "--word-diff=color", "--word-diff"] {
+            assert!(
+                !diff_args_request_machine_output(&[human.to_string()]),
+                "{human} is for humans and must stay compacted"
+            );
+        }
+    }
+
+    #[test]
+    fn test_git_diff_no_color_is_not_machine_output() {
+        // --no-color only suppresses ANSI; it says nothing about the output format,
+        // so treating it as machine output would disable compaction for free.
+        assert!(!diff_args_request_machine_output(&[
+            "--no-color".to_string()
+        ]));
+    }
+
     #[test]
     fn test_build_status_command_default_compact() {
         let cmd = build_status_command(&[], &[]);
 
@@ -0,0 +1,103 @@
+//! `rtk git` must hand machine-readable formats back byte-for-byte.
+//!
+//! The unit tests in `src/cmds/git/git.rs` only cover the flag predicates —
+//! whether an arg list *counts* as machine output. They cannot catch the actual
+//! defect this guards, which lives in the print path: swapping `print!` back to
+//! `println!("{}", stdout.trim())` still satisfies every predicate test while
+//! silently dropping the trailing newline and breaking `while read` loops.
+//!
+//! So these run the real binary against real git and compare bytes.
+
+use std::path::Path;
+use std::process::Command;
+
+/// Run a program in the repo root, returning raw stdout bytes.
+fn run(program: &str, args: &[&str]) -> Option<Vec<u8>> {
+    let out = Command::new(program)
+        .args(args)
+        .current_dir(Path::new(env!("CARGO_MANIFEST_DIR")))
+        .output()
+        .ok()?;
+    Some(out.stdout)
+}
+
+/// These compare against real `git` in this working tree. Skip rather than fail
+/// where that isn't available, so the suite stays green off a git checkout.
+fn git_available() -> bool {
+    run("git", &["rev-parse", "--git-dir"]).is_some_and(|o| !o.is_empty())
+}
+
+#[test]
+fn machine_readable_git_output_is_byte_identical_to_native() {
+    if !git_available() {
+        eprintln!("skipping: not a git checkout or git not on PATH");
+        return;
+    }
+
+    // Each case must survive rtk untouched — same bytes, trailing newline included.
+    let cases: &[&[&str]] = &[
+        &["status", "--porcelain"],
+        &["status", "--porcelain=v2"],
+        &["status", "-z"],
+        &["log", "--format=%H", "-3"],
+        &["log", "--pretty=format:%H", "-3"],
+        &["log", "-z", "--name-only", "-3"],
+        &["diff", "--name-only", "HEAD~1..HEAD"],
+        &["diff", "--name-status", "HEAD~1..HEAD"],
+        &["diff", "--numstat", "HEAD~1..HEAD"],
+        &["diff", "--raw", "HEAD~1..HEAD"],
+    ];
+
+    for args in cases {
+        let Some(native) = run("git", args) else {
+            continue;
+        };
+        let rtk = run(env!("CARGO_BIN_EXE_rtk"), &[&["git"], *args].concat())
+            .expect("rtk binary must run");
+
+        assert_eq!(
+            String::from_utf8_lossy(&rtk),
+            String::from_utf8_lossy(&native),
+            "`rtk git {args:?}` diverged from native git ({} bytes vs {})",
+            rtk.len(),
+            native.len()
+        );
+    }
+}
+
+#[test]
+fn human_facing_git_output_is_still_compacted() {
+    if !git_available() {
+        eprintln!("skipping: not a git checkout or git not on PATH");
+        return;
+    }
+
+    // The counterweight: widening the machine-output guard until everything
+    // passes through would make the byte-exactness test above pass trivially
+    // while destroying the compaction rtk exists for.
+    let native = run("git", &["status"]).expect("git status");
+    let rtk = run(env!("CARGO_BIN_EXE_rtk"), &["git", "status"]).expect("rtk git status");
+
+    assert!(
+        rtk.len() < native.len(),
+        "bare `git status` must still be compacted (rtk {} bytes vs native {})",
+        rtk.len(),
+        native.len()
+    );
+
+    // --no-color only suppresses ANSI; it must not buy a passthrough.
+    let native_nc = run("git", &["diff", "--no-color", "HEAD~1..HEAD"]).expect("git diff");
+    if !native_nc.is_empty() {
+        let rtk_nc = run(
+            env!("CARGO_BIN_EXE_rtk"),
+            &["git", "diff", "--no-color", "HEAD~1..HEAD"],
+        )
+        .expect("rtk git diff");
+        assert!(
+            rtk_nc.len() < native_nc.len(),
+            "`git diff --no-color` must stay compacted (rtk {} bytes vs native {})",
+            rtk_nc.len(),
+            native_nc.len()
+        );
+    }
+}