[project-#175] fix: exclude gobby and git from gsqz

Author: joshwilhelmi

crates/gsqz/README.md

@@ -25,7 +25,7 @@ AI coding assistants run shell commands and dump the full output into the contex
 
 ## The Fix
 
-gsqz wraps your shell commands and compresses their output using pattern-matched pipelines. It knows how to summarize `git status`, collapse test output, group lint errors by rule, and truncate walls of text — all configured in plain YAML.
+gsqz wraps your shell commands and compresses their output using pattern-matched pipelines. It knows how to collapse test output, group lint errors by rule, summarize builds, and truncate walls of text — all configured in plain YAML.
 
 ```text
 $ gsqz -- cargo test
@@ -91,7 +91,6 @@ gsqz is installed automatically as part of the [Gobby](https://github.com/GobbyA
 
 ```bash
 # Compress command output (backward-compatible form)
-gsqz -- git status
 gsqz -- cargo test
 gsqz -- npm run lint
 
@@ -167,9 +166,6 @@ pipelines:
 
 | Pipeline | Matches | What it does |
 |----------|---------|-------------|
-| `git-status` | `git status` | Groups by status code (Modified, Added, Untracked...) |
-| `git-diff` | `git diff` | Per-file section truncation |
-| `git-log` | `git log` | Head + tail with omission marker |
 | `pytest` | `pytest`, `uv run pytest` | Extracts failures + summary |
 | `cargo-test` | `cargo test` | Extracts failures + summary |
 | `generic-test` | `npm test`, `go test`, etc. | Failure grouping |
@@ -179,6 +175,8 @@ pipelines:
 
 ...and 10+ more. Run `gsqz --dump-config` to see the full list.
 
+Gobby-owned CLIs (`gobby`, `gobby-cli`, `gcode`, `ghook`, `gloc`, `gsqz`) and `git` are always surfaced raw with no compression header and no savings report.
+
 ### Step reference
 
 | Step | Parameters | Description |

crates/gsqz/SKILL.md

@@ -3,7 +3,7 @@ name: gsqz
 description: >
   Output compressor for LLM token optimization. Wraps shell commands and compresses
   verbose output by 70-95% using pattern-matched pipelines. Use when running tests,
-  builds, git operations, linting, or any command that produces more output than an
+  builds, linting, or any command that produces more output than an
   LLM needs. Triggers on: compress output, reduce tokens, verbose output, test output,
   build output, token savings, save context, shrink output.
 ---
@@ -18,7 +18,6 @@ Prefix any command with `gsqz --`:
 
 ```bash
 gsqz -- cargo test
-gsqz -- git status
 gsqz -- npm run lint
 ```
 
@@ -30,7 +29,6 @@ gsqz auto-detects the command and applies the right compression:
 
 | Category | Commands |
 |---|---|
-| Git | status, diff, log, push/pull/fetch/clone, add/commit/stash |
 | Tests | pytest, cargo test, npm test, vitest, jest, mocha, go test |
 | Linters | ruff, mypy, pylint, eslint, tsc, biome, golangci-lint, staticcheck |
 | Build | cargo build, go build, next build, webpack, make |
@@ -40,6 +38,8 @@ gsqz auto-detects the command and applies the right compression:
 | GitHub | gh pr/issue list/view |
 | Fallback | Any unmatched command: keeps first 20 + last 20 lines |
 
+Gobby-owned CLIs (`gobby`, `gobby-cli`, `gcode`, `ghook`, `gloc`, `gsqz`) and `git` are built-in exclusions. gsqz surfaces them raw.
+
 ## When NOT to Use
 
 - **Interactive commands** — gsqz captures all output, breaking interactivity

crates/gsqz/config.yaml

@@ -15,60 +15,6 @@ settings:
   on_empty: 'No output after compression.'
 
 pipelines:
-  # === Git ===
-  git-status:
-    match: '\bgit\s+status\b'
-    steps:
-      - filter_lines:
-          patterns:
-            - '^\s*$'
-            - '^On branch '
-            - '^Your branch is '
-            - '^  \(use "git '
-            - '^Changes not staged'
-            - '^Changes to be committed'
-            - '^Untracked files:'
-            - '^no changes added'
-      - group_lines:
-          mode: git_status
-
-  git-diff:
-    match: '\bgit\s+diff\b'
-    steps:
-      - filter_lines:
-          patterns:
-            - '^index [0-9a-f]'
-      - group_lines:
-          mode: git_diff
-
-  git-log:
-    match: '\bgit\s+log\b'
-    steps:
-      - filter_lines:
-          patterns:
-            - '^Merge:'
-            - '^\s*$'
-
-  git-transfer:
-    match: '\bgit\s+(?:push|pull|fetch|clone)\b'
-    steps:
-      - filter_lines:
-          patterns:
-            - '^remote: Counting'
-            - '^remote: Compressing'
-            - '^remote: Total'
-            - '^Receiving objects:'
-            - '^Resolving deltas:'
-            - '^Unpacking objects:'
-            - '^remote: Enumerating'
-
-  git-mutation:
-    match: '\bgit\s+(?:add|commit|stash|tag|branch)\b'
-    steps:
-      - filter_lines:
-          patterns:
-            - '^\s*$'
-
   # === Test runners ===
   pytest:
     match: '\b(?:pytest|py\.test)\b'
@@ -274,4 +220,6 @@ fallback:
         head: 20
         tail: 20
 
+# These are additive. Gobby-owned CLIs and git are always excluded in code:
+# gobby, gobby-cli, gcode, ghook, gloc, gsqz, git.
 excluded_commands: []

crates/gsqz/src/compressor.rs

@@ -1,7 +1,7 @@
 use regex::Regex;
 
 use crate::command_split;
-use crate::config::{Config, Step};
+use crate::config::{BUILTIN_EXCLUDED_COMMANDS, Config, Step};
 use crate::primitives::{dedup, filter, group, match_output, prose, replace, truncate};
 
 pub struct CompressionResult {
@@ -33,6 +33,20 @@ impl CompressionResult {
     }
 }
 
+fn first_command_token(segment: &str) -> Option<&str> {
+    segment
+        .split_whitespace()
+        .find(|token| !token.contains('='))
+}
+
+fn command_basename(token: &str) -> &str {
+    token
+        .trim_matches(|c| c == '\'' || c == '"')
+        .rsplit(['/', '\\'])
+        .next()
+        .unwrap_or(token)
+}
+
 struct CompiledPipeline {
     name: String,
     regex: Regex,
@@ -82,26 +96,36 @@ impl Compressor {
         }
     }
 
+    pub fn command_is_excluded(&self, command: &str) -> bool {
+        command_split::split_compound(command)
+            .iter()
+            .filter_map(|segment| first_command_token(segment))
+            .map(command_basename)
+            .any(|name| BUILTIN_EXCLUDED_COMMANDS.contains(&name))
+            || self.excluded.iter().any(|r| r.is_match(command))
+    }
+
     pub fn compress(&self, command: &str, output: &str) -> CompressionResult {
         let original_chars = output.len();
 
-        // Skip if too short
-        if original_chars < self.min_length {
+        // Built-in and configured exclusions are raw passthrough. Check before
+        // length so excluded commands are always identified as `excluded`.
+        if self.command_is_excluded(command) {
             return CompressionResult {
                 compressed: output.to_string(),
                 original_chars,
                 compressed_chars: original_chars,
-                strategy_name: "passthrough".into(),
+                strategy_name: "excluded".into(),
             };
         }
 
-        // Skip excluded commands
-        if self.excluded.iter().any(|r| r.is_match(command)) {
+        // Skip if too short
+        if original_chars < self.min_length {
             return CompressionResult {
                 compressed: output.to_string(),
                 original_chars,
                 compressed_chars: original_chars,
-                strategy_name: "excluded".into(),
+                strategy_name: "passthrough".into(),
             };
         }
 
@@ -315,7 +339,7 @@ mod tests {
     }
 
     #[test]
-    fn test_git_status_pipeline() {
+    fn test_git_status_is_excluded() {
         let compressor = Compressor::new(&test_config());
         let mut lines = Vec::new();
         for i in 0..100 {
@@ -326,9 +350,64 @@ mod tests {
         }
         let output = lines.join("");
         let result = compressor.compress("git status", &output);
-        assert_eq!(result.strategy_name, "git-status");
-        assert!(result.compressed.contains("Modified"));
-        assert!(result.compressed.contains("Untracked"));
+        assert_eq!(result.strategy_name, "excluded");
+        assert_eq!(result.compressed, output);
+        assert_eq!(result.compressed_chars, result.original_chars);
+        assert!(result.is_passthrough());
+        assert!(!result.compressed.contains("[gsqz:"));
+    }
+
+    #[test]
+    fn test_builtin_excluded_commands_are_raw_passthrough() {
+        let compressor = Compressor::new(&test_config());
+        let output = (0..120)
+            .map(|i| format!("structured output line {}\n", i))
+            .collect::<String>();
+
+        for command in [
+            "gobby status",
+            "gobby-cli status",
+            "gcode search symbol",
+            "ghook --diagnose",
+            "gloc prompt",
+            "gsqz --stats -- cargo test",
+            "git diff",
+        ] {
+            let result = compressor.compress(command, &output);
+            assert_eq!(result.strategy_name, "excluded", "{command}");
+            assert_eq!(result.compressed, output, "{command}");
+            assert_eq!(result.compressed_chars, result.original_chars, "{command}");
+            assert!(result.is_passthrough(), "{command}");
+        }
+    }
+
+    #[test]
+    fn test_builtin_exclusion_runs_before_min_length() {
+        let compressor = Compressor::new(&test_config());
+        let result = compressor.compress("gcode search symbol", "ok");
+        assert_eq!(result.strategy_name, "excluded");
+        assert_eq!(result.compressed, "ok");
+    }
+
+    #[test]
+    fn test_builtin_exclusion_matches_compound_segments() {
+        let compressor = Compressor::new(&test_config());
+        let output = (0..120)
+            .map(|i| format!("line {}\n", i))
+            .collect::<String>();
+
+        let result = compressor.compress("cargo test && git status", &output);
+        assert_eq!(result.strategy_name, "excluded");
+
+        let result = compressor.compress("rg git README.md", &output);
+        assert_ne!(result.strategy_name, "excluded");
+    }
+
+    #[test]
+    fn test_builtin_exclusion_matches_binary_paths() {
+        let compressor = Compressor::new(&test_config());
+        let result = compressor.compress("/Users/josh/.gobby/bin/gcode search", "ok");
+        assert_eq!(result.strategy_name, "excluded");
     }
 
     #[test]
@@ -507,10 +586,10 @@ mod tests {
         // 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("pytest/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("pytest").is_passthrough());
         assert!(!mk("cargo-test/low-savings").is_passthrough());
         assert!(!mk("pytest/on_empty").is_passthrough());
         assert!(!mk("fallback").is_passthrough());
@@ -556,10 +635,12 @@ mod tests {
     fn test_compound_falls_back_to_earlier_segment() {
         let compressor = Compressor::new(&test_config());
         // Last segment doesn't match any pipeline, first does
-        let output = (0..200)
-            .map(|i| format!(" M src/file_{}.rs\n", i))
-            .collect::<String>();
-        let result = compressor.compress("git status && unknown-cmd", &output);
-        assert_eq!(result.strategy_name, "git-status");
+        let mut lines: Vec<String> = (0..100)
+            .map(|i| format!("test test_{} ... ok\n", i))
+            .collect();
+        lines.push("test result: ok. 100 passed; 0 failed\n".into());
+        let output = lines.join("");
+        let result = compressor.compress("cargo test && unknown-cmd", &output);
+        assert_eq!(result.strategy_name, "cargo-test");
     }
 }

crates/gsqz/src/config.rs

@@ -9,6 +9,16 @@ const DEFAULT_CONFIG: &str = include_str!("../config.yaml");
 /// The raw compiled-in config YAML, for `--init` to write to disk.
 pub const DEFAULT_CONFIG_YAML: &str = DEFAULT_CONFIG;
 
+pub const BUILTIN_EXCLUDED_COMMANDS: &[&str] = &[
+    "gobby",
+    "gobby-cli",
+    "gcode",
+    "ghook",
+    "gloc",
+    "gsqz",
+    "git",
+];
+
 #[derive(Debug, Clone, Deserialize)]
 pub struct Config {
     #[serde(default)]
@@ -333,6 +343,10 @@ impl Config {
                 pipeline.steps.len()
             ));
         }
+        out.push_str(&format!(
+            "\nbuiltin_excluded_commands: {:?}\n",
+            BUILTIN_EXCLUDED_COMMANDS
+        ));
         if !self.excluded_commands.is_empty() {
             out.push_str(&format!(
                 "\nexcluded_commands: {:?}\n",
@@ -358,17 +372,16 @@ mod tests {
     #[test]
     fn test_default_config_has_expected_pipelines() {
         let config = Config::builtin();
-        assert!(config.pipelines.contains_key("git-status"));
         assert!(config.pipelines.contains_key("pytest"));
         assert!(config.pipelines.contains_key("cargo-test"));
     }
 
     #[test]
     fn test_pipeline_has_match_and_steps() {
         let config = Config::builtin();
-        let git_status = config.pipelines.get("git-status").unwrap();
-        assert!(!git_status.match_pattern.is_empty());
-        assert!(!git_status.steps.is_empty());
+        let pytest = config.pipelines.get("pytest").unwrap();
+        assert!(!pytest.match_pattern.is_empty());
+        assert!(!pytest.steps.is_empty());
     }
 
     #[test]
@@ -505,6 +518,7 @@ mod tests {
         assert!(dump.contains("min_output_length: 1000"));
         assert!(dump.contains("max_compressed_lines: 100"));
         assert!(dump.contains("pipelines:"));
+        assert!(dump.contains("builtin_excluded_commands:"));
     }
 
     #[test]