chore(release): prep ghook 0.2.1 and gsqz 0.4.2

ghook 0.2.1:
- Short-circuit when GOBBY_HOOKS_DISABLED=1 is set so daemon-spawned ACP
  subprocesses (gemini --acp, qwen --acp) don't register phantom sessions
  via inherited SessionStart hooks. Returns {} with exit 0 before enqueue,
  POST, or terminal-context capture.
- Carry GOBBY_ACP_CHILD through terminal_context.capture() so the daemon's
  SESSION_START handler can still recognize ACP subprocesses even if the
  env short-circuit didn't fire.
- Extend extract_reason() to check hookSpecificOutput.permissionDecisionReason
  (and .reason inside that object) after the top-level fallback keys. Modern
  Claude Code PreToolUse deny responses put the reason inside hookSpecificOutput;
  is_blocked() already recognized the nested shape, so extract_reason() was
  asymmetric and surfaced bare "Blocked by hook" instead of the daemon's
  actual message.

gsqz 0.4.2:
- Floor CompressionResult::savings_pct() at 0.0 so a badly-matched pipeline
  that grows output doesn't report negative savings to the daemon.

Gobby-Task: #139

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

Author: joshwilhelmi

CHANGELOG.md

@@ -7,6 +7,24 @@ All notable changes to gobby-cli are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.1] — gobby-hooks
+
+### Fixed
+
+#### gobby-hooks
+
+- **Drop phantom ACP session registrations** — `ghook` now short-circuits when `GOBBY_HOOKS_DISABLED=1` is set in the process environment, returning `{}` with exit 0 before any side effect (no enqueue, no POST, no terminal-context capture). Daemon-spawned `gemini --acp` / `qwen --acp` subprocesses inherit the host CLI's SessionStart hook; this env flag lets the daemon mark them so they don't register phantom sessions.
+- **`gobby_acp_child` in terminal_context** — `terminal_context.capture()` now includes `gobby_acp_child` (read from `GOBBY_ACP_CHILD`). The daemon's SESSION_START handler uses it as a second line of defense to recognize and drop registrations from ACP subprocesses even if the env short-circuit didn't fire.
+- **Surface nested `permissionDecisionReason` in block messages** — `extract_reason` now also checks `hookSpecificOutput.permissionDecisionReason` (and `.reason` inside that object) after the top-level fallback keys. Modern Claude Code PreToolUse deny responses carry the reason inside `hookSpecificOutput`; `is_blocked` already recognized the nested shape, but `extract_reason` didn't — so denies surfaced as the bare "Blocked by hook" fallback instead of the daemon's actual message.
+
+## [0.4.2] — gsqz
+
+### Fixed
+
+#### gsqz
+
+- **Floor `savings_pct` at 0%** — when compressed output ends up larger than the original, `CompressionResult::savings_pct()` now returns `0.0` instead of a negative percentage. Prevents negative savings values from being reported to the daemon.
+
 ## [0.6.2] — gcode
 
 ### Added

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "gobby-hooks"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2024"
 rust-version = "1.85"
 authors = ["Josh Wilhelmi <hello@gobby.ai>"]

crates/ghook/Cargo.toml

@@ -125,6 +125,15 @@ fn run_gobby_owned(args: &Args) -> ExitCode {
         return ExitCode::from(2);
     };
 
+    // Daemon-spawned ACP subprocesses (gemini --acp, qwen --acp) set
+    // GOBBY_HOOKS_DISABLED=1 to stop their inherited SessionStart hook from
+    // registering phantom sessions. Short-circuit before any side effects: no
+    // enqueue, no POST, no terminal-context enrichment.
+    if hooks_disabled_by_env() {
+        println!("{}", serde_json::json!({}));
+        return ExitCode::SUCCESS;
+    }
+
     let cfg = CliConfig::for_dispatch(cli);
     let is_critical = cfg.is_critical_hook(hook_type);
 
@@ -250,6 +259,10 @@ fn run_gobby_owned(args: &Args) -> ExitCode {
     emit_action(action)
 }
 
+fn hooks_disabled_by_env() -> bool {
+    std::env::var_os("GOBBY_HOOKS_DISABLED").is_some_and(|v| v == "1")
+}
+
 fn detect_source(cfg: &CliConfig) -> String {
     if cfg.source != "claude" {
         return cfg.source.to_string();
@@ -391,13 +404,29 @@ fn extract_reason(result: &Value) -> String {
     let Some(map) = result.as_object() else {
         return "Blocked by hook".to_string();
     };
+
     for key in ["stopReason", "user_message", "reason"] {
         if let Some(reason) = map.get(key).and_then(Value::as_str)
             && !reason.is_empty()
         {
             return reason.to_string();
         }
     }
+
+    // Modern Claude Code PreToolUse denies put the reason inside
+    // hookSpecificOutput.permissionDecisionReason — mirror the nested lookup
+    // already done by is_blocked so users see the daemon's actual message
+    // instead of the bare "Blocked by hook" fallback.
+    if let Some(hook_specific) = map.get("hookSpecificOutput").and_then(Value::as_object) {
+        for key in ["permissionDecisionReason", "reason"] {
+            if let Some(reason) = hook_specific.get(key).and_then(Value::as_str)
+                && !reason.is_empty()
+            {
+                return reason.to_string();
+            }
+        }
+    }
+
     "Blocked by hook".to_string()
 }
 
@@ -484,6 +513,23 @@ mod tests {
         assert_eq!(action.stderr_message, None);
     }
 
+    #[test]
+    fn action_from_success_surfaces_nested_permission_decision_reason() {
+        let action = action_from_success_response(
+            "claude",
+            "PreToolUse",
+            r#"{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"Task #50 requires TDD expansion before edits"}}"#,
+        )
+        .unwrap();
+
+        assert_eq!(action.exit_code, 2);
+        assert!(action.stdout_json.is_none());
+        assert_eq!(
+            action.stderr_message.as_deref(),
+            Some("Task #50 requires TDD expansion before edits")
+        );
+    }
+
     #[test]
     fn action_from_success_treats_stop_block_as_exit_two() {
         let action = action_from_success_response(
@@ -566,6 +612,41 @@ mod tests {
         );
     }
 
+    #[test]
+    fn hooks_disabled_by_env_reads_env_var() {
+        // Avoid racing other tests that read GOBBY_* env vars — touching the
+        // process env from tests is inherently global, but the key we use is
+        // unique to this check.
+        // SAFETY: single-threaded Rust tests within this module; no other test
+        // reads or writes GOBBY_HOOKS_DISABLED.
+        unsafe {
+            std::env::remove_var("GOBBY_HOOKS_DISABLED");
+        }
+        assert!(!hooks_disabled_by_env());
+
+        unsafe {
+            std::env::set_var("GOBBY_HOOKS_DISABLED", "1");
+        }
+        assert!(hooks_disabled_by_env());
+
+        unsafe {
+            std::env::set_var("GOBBY_HOOKS_DISABLED", "0");
+        }
+        assert!(!hooks_disabled_by_env(), "only '1' should short-circuit");
+
+        unsafe {
+            std::env::set_var("GOBBY_HOOKS_DISABLED", "");
+        }
+        assert!(
+            !hooks_disabled_by_env(),
+            "empty string should not short-circuit"
+        );
+
+        unsafe {
+            std::env::remove_var("GOBBY_HOOKS_DISABLED");
+        }
+    }
+
     #[test]
     fn is_blocked_matches_dispatcher_patterns() {
         assert!(is_blocked(&json!({"continue": false})));

crates/ghook/src/main.rs

@@ -32,6 +32,9 @@ pub fn capture() -> Value {
         "gobby_agent_run_id": env_or_null("GOBBY_AGENT_RUN_ID"),
         "gobby_project_id": env_or_null("GOBBY_PROJECT_ID"),
         "gobby_workflow_name": env_or_null("GOBBY_WORKFLOW_NAME"),
+        // Carried so the daemon's SESSION_START handler can recognize and
+        // drop registrations from daemon-spawned ACP subprocesses.
+        "gobby_acp_child": env_or_null("GOBBY_ACP_CHILD"),
     })
 }
 
@@ -181,6 +184,7 @@ mod tests {
             "gobby_agent_run_id",
             "gobby_project_id",
             "gobby_workflow_name",
+            "gobby_acp_child",
         ] {
             assert!(obj.contains_key(key), "missing key: {key}");
         }

crates/ghook/src/terminal_context.rs

@@ -1,6 +1,6 @@
 [package]
 name = "gobby-squeeze"
-version = "0.4.1"
+version = "0.4.2"
 edition = "2024"
 rust-version = "1.85"
 authors = ["Josh Wilhelmi <hello@gobby.ai>"]

crates/gsqz/Cargo.toml

@@ -16,7 +16,7 @@ impl CompressionResult {
         if self.original_chars == 0 {
             return 0.0;
         }
-        (1.0 - self.compressed_chars as f64 / self.original_chars as f64) * 100.0
+        ((1.0 - self.compressed_chars as f64 / self.original_chars as f64) * 100.0).max(0.0)
     }
 
     /// True when no useful compression occurred — original output should be

crates/gsqz/src/compressor.rs

@@ -282,7 +282,7 @@ Almost always config-only. ghook treats `--type` as opaque. To make a hook criti
 
 ## Versioning
 
-ghook is at `0.2.0`. `SCHEMA_VERSION` is also `1`. The two version numbers are independent:
+ghook is at `0.2.1`. `SCHEMA_VERSION` is also `1`. The two version numbers are independent:
 
 - **Crate version** bumps for any code change (binary behavior, dependencies, perf, etc.).
 - **`SCHEMA_VERSION`** bumps only when the envelope shape changes in a way the daemon must explicitly handle.