[gobby-cli-#121] fix(gsqz): Suppress outer compression header for */no-op strategy

Follow-up to #111. The inner [gsqz:low-savings] marker is suppressed
when adding it would grow output, but the outer
"[Output compressed by gsqz -- STRATEGY, X% reduction]" header was
still being prepended for the resulting */no-op strategy. That's
noise -- no compression actually happened, so the header is just
spurious.

Adds CompressionResult::is_passthrough() classifying passthrough,
excluded, and */no-op together. main.rs now uses it for both the
outer-header decision and the daemon savings report so the two stay
in sync. Adds a unit test for the classification and asserts the
existing low-savings-suppressed test result also reports as
passthrough.

Rolls into the unreleased 0.4.1 -- no version bump. Tests: 149 in
gsqz (+1 new), 268 across the workspace, all passing. Verified
end-to-end: the compound-git command that previously emitted
"git-mutation/low-savings, -1% reduction" now emits clean original
output (strategy=git-mutation/no-op, savings=0.0%, no header).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: joshwilhelmi

CHANGELOG.md

@@ -34,6 +34,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 #### gsqz
 
 - **Low-savings marker** — Suppress `[gsqz:low-savings]` marker when prepending it would grow the output beyond the original. The marker now only annotates when the annotation itself doesn't make things worse. (#111)
+- **Outer compression header for `/no-op` strategy** — When the low-savings marker is suppressed (above), the resulting `{pipeline}/no-op` strategy now also skips the outer `[Output compressed by gsqz — …, 0% reduction]` header and the daemon savings report. The user sees the original output verbatim. `CompressionResult::is_passthrough()` classifies `passthrough`, `excluded`, and `*/no-op` together so both call sites stay in sync. (#121)
 
 ## [0.1.0] — gobby-hooks
 

crates/gsqz/src/compressor.rs

@@ -18,6 +18,19 @@ impl CompressionResult {
         }
         (1.0 - self.compressed_chars as f64 / self.original_chars as f64) * 100.0
     }
+
+    /// True when no useful compression occurred — original output should be
+    /// surfaced verbatim, with no `[Output compressed by gsqz — …]` header
+    /// and no daemon savings report. Covers:
+    ///   - `passthrough` — output too short or fallback couldn't help.
+    ///   - `excluded` — command matched an exclusion regex.
+    ///   - `*/no-op` — a pipeline matched but adding the low-savings marker
+    ///     would itself have grown the output, so we kept the original.
+    pub fn is_passthrough(&self) -> bool {
+        self.strategy_name == "passthrough"
+            || self.strategy_name == "excluded"
+            || self.strategy_name.ends_with("/no-op")
+    }
 }
 
 struct CompiledPipeline {
@@ -479,6 +492,28 @@ mod tests {
         assert!(!result.compressed.contains("[gsqz:low-savings]"));
         assert_eq!(result.compressed, output);
         assert_eq!(result.compressed_chars, result.original_chars);
+        // /no-op is a passthrough — main.rs uses this to skip the outer header.
+        assert!(result.is_passthrough());
+    }
+
+    #[test]
+    fn test_is_passthrough_classification() {
+        let mk = |name: &str| CompressionResult {
+            compressed: String::new(),
+            original_chars: 0,
+            compressed_chars: 0,
+            strategy_name: name.into(),
+        };
+        // Pure passthrough cases — main.rs surfaces output verbatim.
+        assert!(mk("passthrough").is_passthrough());
+        assert!(mk("excluded").is_passthrough());
+        assert!(mk("git-mutation/no-op").is_passthrough());
+        assert!(mk("cargo-test/no-op").is_passthrough());
+        // Real compression — main.rs prepends the header and reports to daemon.
+        assert!(!mk("git-status").is_passthrough());
+        assert!(!mk("cargo-test/low-savings").is_passthrough());
+        assert!(!mk("pytest/on_empty").is_passthrough());
+        assert!(!mk("fallback").is_passthrough());
     }
 
     #[test]

crates/gsqz/src/main.rs

@@ -238,8 +238,7 @@ fn run_output_mode(cmd: &str, config: &Config, stats: bool) {
     }
 
     // Report savings to daemon (best-effort)
-    if result.strategy_name != "passthrough"
-        && result.strategy_name != "excluded"
+    if !result.is_passthrough()
         && let Some(ref url) = daemon_url
     {
         daemon::report_savings(
@@ -250,16 +249,15 @@ fn run_output_mode(cmd: &str, config: &Config, stats: bool) {
         );
     }
 
-    let output_str = if result.strategy_name != "passthrough" && result.strategy_name != "excluded"
-    {
+    let output_str = if result.is_passthrough() {
+        result.compressed
+    } else {
         format!(
             "[Output compressed by gsqz — {}, {:.0}% reduction]\n{}",
             result.strategy_name,
             result.savings_pct(),
             result.compressed
         )
-    } else {
-        result.compressed
     };
 
     print!("{}", output_str);

docs/guides/gsqz-user-guide.md

@@ -288,6 +288,7 @@ The `--stats` flag prints to stderr:
 Strategy names to look for:
 - A pipeline name (e.g. `git-status`, `pytest`, `cargo-test`) — matched and compressed
 - `{name}/low-savings` — pipeline matched but compression was marginal (<5%)
+- `{name}/no-op` — pipeline matched but adding the low-savings marker would have grown the output, so the original is surfaced verbatim (no header, no daemon report)
 - `{name}/on_empty` — pipeline produced empty output, on_empty fallback used
 - `fallback` — no pipeline matched, generic truncation applied (with `[gsqz:passthrough]` marker)
 - `passthrough` — output was too short or compression didn't help