anolisa-tokenless 0.7.13 → 0.7.14

package/adapters/tokenless/common/hooks/hook_utils.py

@@ -231,9 +231,9 @@ def get_thresholds(tool_name: str) -> tuple[int, int, int]:
 
 # -- Shared environment error patterns ----------------------------------------
 #
-# Superset of patterns from both the codex and hook adapters. Uses regex
+# Superset of patterns from both the Codex diagnostics and shared hook adapters. Uses regex
 # matching (case-insensitive) so patterns like "/bin/sh:.*: not found" work
-# correctly. Both codex/scripts/compress-response and compress_response_hook
+# correctly. Both codex/scripts/response-diagnostics and compress_response_hook
 # import this list and the classify_env_error() function below.
 
 ENV_PATTERNS: list[tuple[list[str], str, str]] = [
@@ -315,7 +315,7 @@ def classify_env_error(tool_response) -> tuple[str | None, str | None]:
     Accepts either a parsed dict (with stderr/error/exit_code fields) or a
     plain string. Returns (category_tag, fix_hint) or (None, None).
 
-    Shared by codex/scripts/compress-response and compress_response_hook.
+    Shared by codex/scripts/response-diagnostics and compress_response_hook.
     """
     if isinstance(tool_response, dict):
         text = str(tool_response.get("stderr", "")) + str(tool_response.get("error", ""))
@@ -496,6 +496,73 @@ def run(args: list[str], input_data: str, timeout: int = 3) -> subprocess.Comple
         return None
 
 
+def build_compression_request(
+    content: str,
+    agent_id: str,
+    seam: str,
+    session_id: str = "",
+    tool_use_id: str = "",
+    tool_name: str = "",
+    replace_output: bool = False,
+    publish_retrieve_tool: bool = False,
+    replace_with_text: bool = False,
+) -> dict:
+    """Build a protocol-v1 CompressionRequest for ``tokenless compress``.
+
+    The adapter only copies the model-visible value and declares what its
+    host can do with the result (roadmap §4.5); all compression decisions
+    live behind the entry point.
+    """
+    request = {
+        "protocol_version": 1,
+        "content": content,
+        "agent_id": agent_id,
+        "seam": seam,
+        "capabilities": {
+            "replace_output": replace_output,
+            "publish_retrieve_tool": publish_retrieve_tool,
+            "replace_with_text": replace_with_text,
+        },
+    }
+    if session_id:
+        request["session_id"] = session_id
+    if tool_use_id:
+        request["tool_use_id"] = tool_use_id
+    if tool_name:
+        request["tool_name"] = tool_name
+    return request
+
+
+def run_compress(
+    tokenless_bin: str, request: dict, timeout: int
+) -> dict | None:
+    """Run ``tokenless compress`` on one request; None on any failure.
+
+    The single Tokenless subprocess of a hook invocation (roadmap §5.6).
+    Fail-open: a dead binary, non-zero exit, or malformed stdout all
+    return None so the caller passes the original through.
+    """
+    proc = run(
+        [tokenless_bin, "compress"],
+        json.dumps(request, ensure_ascii=False),
+        timeout=timeout,
+    )
+    if proc is None or proc.returncode != 0 or not proc.stdout.strip():
+        if proc is not None and proc.returncode != 0:
+            warn(f"tokenless compress exited {proc.returncode}")
+        return None
+    response = try_parse_json(proc.stdout.strip())
+    if not isinstance(response, dict):
+        warn("tokenless compress returned malformed output")
+        return None
+    if response.get("protocol_version") != 1:
+        # Version-skewed binary: never trust a response whose contract
+        # this adapter does not speak.
+        warn("tokenless compress returned an unsupported protocol version")
+        return None
+    return response
+
+
 def detect_cosh_ng_runtime() -> tuple | None:
     """Detect if we are running under Cosh-NG and return its version.
 

package/adapters/tokenless/dsh/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anolisa/dsh-tokenless",
-  "version": "0.7.13",
+  "version": "0.7.14",
   "description": "Native DeepSeek Harness response compression for Tokenless",
   "type": "module",
   "main": "./dist/index.js",

package/adapters/tokenless/hermes/__init__.py

@@ -184,6 +184,8 @@ _MIN_RESPONSE_LEN = 200
 # saves only a few characters (observed ~0.3% below ~500 chars) while
 # the per-event encode cost stays the same, so payloads under this
 # threshold keep the response-compressed form and skip TOON entirely.
+# Mirrors tokenless-runtime's MIN_TOON_CHARS, the default the
+# compress-toon CLI applies; keep the two values in sync.
 _MIN_TOON_CHARS = 500
 
 _SKIP_TOOLS: set[str] = _SKIP_TOOLS_SHARED | {

package/adapters/tokenless/hermes/plugin.yaml

@@ -1,5 +1,5 @@
 name: tokenless
-version: "0.7.13"
+version: "0.7.14"
 description: "Token-Less context compression for Hermes Agent — response compression, TOON encoding, command rewriting, and registered but hard-disabled Tool Ready"
 author: ANOLISA
 requires_env: []

package/adapters/tokenless/manifest.json

@@ -1,6 +1,6 @@
 {
   "component": "tokenless",
-  "version": "0.7.13",
+  "version": "0.7.14",
   "targets": {
     "cosh": {
       "compatibleVersions": "*",
@@ -99,8 +99,7 @@
         "hooks": [
           "tool-ready",
           "rewrite",
-          "compress-response",
-          "compress-toon"
+          "response-diagnostics"
         ]
       },
       "actions": {

package/adapters/tokenless/openclaw/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "tokenless",
   "name": "Tokenless",
-  "version": "0.7.13",
+  "version": "0.7.14",
   "description": "Unified RTK command rewriting + response/TOON compression + registered but hard-disabled Tool Ready. Wraps tokenless and rtk system binaries via child_process — this is expected and not malicious.",
   "activation": {
     "onCapabilities": ["hook"]

package/adapters/tokenless/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokenless/openclaw-plugin",
-  "version": "0.7.13",
+  "version": "0.7.14",
   "description": "Unified OpenClaw plugin — RTK command rewriting + tokenless schema/response compression for 60-90% LLM token savings",
   "type": "module",
   "main": "dist/index.js",

package/adapters/tokenless/qoder/.qoder-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenless",
-  "version": "0.7.13",
+  "version": "0.7.14",
   "description": "Token-Less LLM Token Optimization Toolkit for Qoder CLI",
   "author": {
     "name": "Shile Zhang",

package/adapters/tokenless/qwencode/qwen-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenless",
-  "version": "0.7.13",
+  "version": "0.7.14",
   "description": "Token-Less context compression for Qwen Code — RTK command rewriting, response/TOON/schema compression, and registered but hard-disabled Tool Ready",
   "author": { "name": "ANOLISA" },
   "license": "Apache-2.0",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "anolisa-tokenless",
   "type": "module",
-  "version": "0.7.13",
+  "version": "0.7.14",
   "description": "Token-Less — LLM token optimization toolkit (schema/response compression, command rewriting, tool readiness)",
   "license": "Apache-2.0",
   "repository": {
@@ -44,10 +44,10 @@
     "arm64"
   ],
   "optionalDependencies": {
-    "@anolisa/tokenless-linux-x64": "0.7.13",
-    "@anolisa/tokenless-linux-arm64": "0.7.13",
-    "@anolisa/tokenless-darwin-x64": "0.7.13",
-    "@anolisa/tokenless-darwin-arm64": "0.7.13"
+    "@anolisa/tokenless-linux-x64": "0.7.14",
+    "@anolisa/tokenless-linux-arm64": "0.7.14",
+    "@anolisa/tokenless-darwin-x64": "0.7.14",
+    "@anolisa/tokenless-darwin-arm64": "0.7.14"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",

package/adapters/tokenless/codex/scripts/compress-response

@@ -1,445 +0,0 @@
-#!/usr/bin/env python3
-"""Codex PostToolUse compression hook for the Tokenless plugin.
-
-Reads a PostToolUse hook request from stdin, compresses the tool response
-via ``tokenless compress-response`` and optional TOON encoding, then
-injects a compressed summary and environment error classification as
-``additionalContext``.
-
-Protocol:
-    stdin  ← codex PostToolUse JSON (tool_name, tool_response, ...)
-    stdout → {"hookSpecificOutput": {"hookEventName": "PostToolUse",
-                                      "additionalContext": "..."}}
-
-Design notes for Codex:
-    - PostToolUse CANNOT suppress the original tool output (``suppressOutput``
-      is rejected by the codex hook engine for this event).
-    - ``additionalContext`` is additive — the model sees both the original
-      output AND the injected context.
-    - Therefore we inject a compressed *summary* rather than duplicating the
-      full content, plus environment error classification with fix hints.
-    - For very large JSON responses (> 4 KB), we include the full compressed
-      content so the model has a compact alternative to the raw output.
-
-Fail-open: every error path silently passes through (exit 0 with empty
-stdout) so the agent session is never blocked by a compression failure.
-"""
-
-import json
-import os
-import shutil
-import subprocess
-import sys
-from typing import Optional
-
-# Resolve shared hook utilities (common/hooks/) with FHS fallback paths.
-# Primary: relative path (works for source-tree and FHS/RPM install).
-# Fallbacks: system and user FHS paths (works when Codex caches only the
-# plugin subdirectory and the relative path resolves outside the cache).
-#
-# Trust model (aligned with bash is_trusted_file / Rust is_trusted_path):
-#   - System FHS paths (/usr/share, /usr/local/share) are unconditional.
-#   - User-relative paths use passwd DB home (NOT $HOME — env-controllable),
-#     with ownership and parent-dir permission checks.
-#   - Relative ../../common/hooks is trusted only if the resolved target
-#     exists and is under a system prefix or a passwd-validated home path.
-_HERE = os.path.dirname(os.path.abspath(__file__))
-
-
-def _is_trusted_dir(path: str) -> bool:
-    """Check whether a directory is trusted for Python module imports.
-
-    Mirrors the trust criteria in bash tool_ready_hook.sh (is_trusted_file)
-    and Rust env_check.rs (is_trusted_path): system paths unconditional,
-    user paths validated via passwd + ownership + parent permission checks.
-
-    NOTE: Callers should pass realpath-resolved paths (not just abspath)
-    so that symlink targets are validated before the trust check — a
-    symlinked /usr/share/anolisa → /tmp/ would bypass the prefix check
-    if only abspath is used.
-    """
-    # System FHS prefixes are always trusted
-    for prefix in ("/usr/share/", "/usr/local/share/", "/usr/libexec/", "/usr/lib/anolisa/"):
-        if path.startswith(prefix):
-            return True
-    # For paths outside system prefixes (e.g. source-tree cloned to
-    # /opt/anolisa/), trust them if owned by current uid or root AND
-    # parent directory is not world-writable. This covers developer
-    # worktrees without requiring the path to be under passwd home.
-    try:
-        st = os.stat(path)
-    except OSError:
-        return False
-    if st.st_uid != os.getuid() and st.st_uid != 0:
-        # Not owned by us or root — refuse. Home paths must be owned by
-        # us or root; source-tree paths outside system prefixes are
-        # already covered by the ownership check above (current uid/root).
-        return False
-    # Ownership OK — check parent directory is not world-writable
-    parent = os.path.dirname(path)
-    try:
-        pst = os.stat(parent)
-    except OSError:
-        return False
-    if pst.st_uid != os.getuid() and pst.st_uid != 0:
-        return False
-    if pst.st_mode & 0o002:  # world-writable
-        return False
-    return True
-
-
-# Resolve real home from passwd DB for user-install fallback path.
-# Falls back to "" (empty) when unavailable — candidate is then skipped.
-try:
-    import pwd as _pwd
-    _REAL_HOME = _pwd.getpwuid(os.getuid()).pw_dir
-except (ImportError, KeyError):
-    _REAL_HOME = ""
-if not os.path.isabs(_REAL_HOME):
-    _REAL_HOME = ""
-
-
-def _user_path(*parts: str) -> str:
-    return os.path.join(_REAL_HOME, *parts) if _REAL_HOME else ""
-
-
-_HOOK_UTILS_CANDIDATES = [
-    os.path.join(_HERE, "..", "..", "common", "hooks"),                   # source-tree / FHS
-    "/usr/share/anolisa/adapters/tokenless/common/hooks",                  # RPM system
-    "/usr/local/share/anolisa/adapters/tokenless/common/hooks",            # manual system
-    os.path.join(_REAL_HOME, ".local", "share",
-                 "anolisa", "adapters", "tokenless", "common", "hooks") if _REAL_HOME else "",
-]
-_HOOK_UTILS_RESOLVED = ""
-for _C in _HOOK_UTILS_CANDIDATES:
-    if _C and _is_trusted_dir(os.path.realpath(_C)) and os.path.isdir(_C):
-        _HOOK_UTILS_RESOLVED = os.path.realpath(_C)
-        sys.path.insert(0, _C)
-        break
-
-if _HOOK_UTILS_RESOLVED:
-    from hook_utils import (  # noqa: E402
-        skip_silent as _skip,
-        try_parse_json as _try_parse_json,
-        warn as _warn,
-        classify_env_error as _classify_env_error,
-        get_thresholds as _get_thresholds,
-        SKIP_TOOLS as _SKIP_TOOLS_SHARED,
-    )
-else:
-    # Fail-open: no trusted hook_utils found → provide inline fallbacks
-    # so the hook script exits 0 (passthrough) rather than ImportError → exit 1.
-    def _skip() -> None:  # type: ignore[assignment,misc]
-        sys.exit(0)
-
-    def _try_parse_json(data: str) -> object | None:  # type: ignore[assignment,misc]
-        try:
-            return json.loads(data)
-        except (json.JSONDecodeError, ValueError):
-            return None
-
-    def _warn(msg: str) -> None:  # type: ignore[assignment,misc]
-        print(f"[tokenless] WARNING: {msg}", file=sys.stderr)
-
-    def _classify_env_error(tool_response) -> tuple[str | None, str | None]:  # type: ignore[assignment,misc]
-        # Classification unavailable without hook_utils — return no-op.
-        # Caller handles (None, None) by skipping env error injection.
-        return None, None
-
-    def _get_thresholds(tool_name: str) -> tuple[int, int, int]:  # type: ignore[assignment,misc]
-        # Hardcoded defaults mirroring hook_utils.get_thresholds().
-        # Keep in sync with common/hooks/hook_utils.py thresholds.
-        return (65_536, 128, 8) if tool_name in {"Bash", "bash", "Shell", "shell", "exec", "terminal"} else (1_048_576, 65_536, 32)
-
-    _SKIP_TOOLS_SHARED: set[str] = {  # type: ignore[assignment,misc]
-        "Read", "read", "read_file", "read_many_files",
-        "Glob", "glob", "list_directory",
-        "Grep", "grep", "grep_search", "search_files",
-        "Lsp", "lsp",
-        "NotebookRead", "notebook_read", "notebookread",
-    }
-
-# ---------------------------------------------------------------------------
-# constants
-# ---------------------------------------------------------------------------
-
-AGENT_ID = os.environ.get("TOKENLESS_AGENT_ID", "codex")
-MIN_RESPONSE_CHARS: int = 500
-LARGE_RESPONSE_CHARS: int = 4000
-# TOON on small JSON saves only a few characters (observed ~0.3% below
-# ~500 chars) while the per-event encode cost stays the same, so payloads
-# under this threshold keep the compressed form and skip the TOON pass.
-MIN_TOON_CHARS: int = 500
-
-# 3-layer compression strategy:
-#   Layer 1: Content retrieval + task management → skip all compression
-#   Layer 2: Shell/exec → moderate truncation (64K/128/8)
-#   Layer 3: API/structured → zero-truncation (1M/64K/32)
-
-# Layer 1: content retrieval (shared) + codex-specific task management
-SKIP_TOOLS: set[str] = _SKIP_TOOLS_SHARED | {
-    "TodoWrite", "Task", "TaskStatus",
-}
-
-# Cap for compressed content included in additionalContext (large responses only).
-# Layer 2 thresholds (64K strings) preserve 95% of real shell output; Layer 3
-# zero-truncation (1M strings) can still produce large payloads for API tools.
-COMPRESSED_CONTENT_CAP: int = 32_768
-
-# -- tokenless binary search paths (ANOLISA FHS spec) ------------------------
-# Codex can cache this script without common/hooks. Keep this standalone list
-# aligned with hook_utils.py::_known_binary_paths.
-
-_TOKENLESS_FALLBACK = "/usr/bin/tokenless"
-_TOKENLESS_SYSTEM_FALLBACK = "/usr/local/bin/tokenless"
-_TOKENLESS_LOCAL_BIN = _user_path(".local", "bin", "tokenless")
-_TOKENLESS_LOCAL_SHARE = _user_path(
-    ".local", "share", "anolisa", "tokenless", "tokenless"
-)
-_TOKENLESS_LOCAL_LIB = _user_path(
-    ".local", "lib", "anolisa", "tokenless", "tokenless"
-)
-
-# ---------------------------------------------------------------------------
-# helpers
-# ---------------------------------------------------------------------------
-
-
-def _find_tokenless() -> Optional[str]:
-    """Locate the tokenless CLI binary."""
-    explicit = os.environ.get("TOKENLESS_BIN", "")
-    if explicit and os.path.isfile(explicit) and os.access(explicit, os.X_OK):
-        return explicit
-
-    path = shutil.which("tokenless")
-    if path:
-        return path
-
-    for fp in (
-        _TOKENLESS_LOCAL_BIN,
-        _TOKENLESS_SYSTEM_FALLBACK,
-        _TOKENLESS_FALLBACK,
-        _TOKENLESS_LOCAL_SHARE,
-        _TOKENLESS_LOCAL_LIB,
-    ):
-        if os.path.isfile(fp) and os.access(fp, os.X_OK):
-            return fp
-    return None
-
-
-def _is_json_serializable(obj) -> bool:
-    """Check if a value is a JSON object or array (compressible)."""
-    return isinstance(obj, (dict, list))
-
-
-def _extract_text_for_compression(tool_response) -> Optional[str]:
-    """Extract a JSON string from tool_response for compression."""
-    if isinstance(tool_response, str):
-        return tool_response
-    if isinstance(tool_response, (dict, list)):
-        return json.dumps(tool_response, separators=(",", ":"), ensure_ascii=False)
-    return None
-
-
-def _run_tokenless(tokenless_bin: str, subcommand: str, input_data: str,
-                   session_id: str = "", tool_use_id: str = "",
-                   timeout: int = 10,
-                   extra_args: Optional[list[str]] = None) -> Optional[str]:
-    """Run a tokenless subcommand with input, return stdout or None on failure."""
-    cmd = [tokenless_bin, subcommand, "--agent-id", AGENT_ID]
-    if extra_args:
-        cmd.extend(extra_args)
-    if session_id:
-        cmd.extend(["--session-id", session_id])
-    if tool_use_id:
-        cmd.extend(["--tool-use-id", tool_use_id])
-
-    try:
-        proc = subprocess.run(
-            cmd,
-            input=input_data,
-            capture_output=True,
-            text=True,
-            timeout=timeout,
-        )
-        if proc.returncode == 0 and proc.stdout.strip():
-            return proc.stdout.strip()
-        if proc.returncode != 0 and proc.stderr:
-            _warn(f"{subcommand}: {proc.stderr.strip()[:200]}")
-    except subprocess.TimeoutExpired:
-        _warn(f"{subcommand} timed out after {timeout}s")
-    except OSError as e:
-        _warn(f"{subcommand} OS error: {e}")
-    return None
-
-
-# ---------------------------------------------------------------------------
-# main
-# ---------------------------------------------------------------------------
-
-
-def main() -> None:
-    # 1. Locate tokenless binary (fail-open: skip if not installed)
-    tokenless_bin = _find_tokenless()
-    if not tokenless_bin:
-        _skip()
-
-    # 2. Read and parse stdin JSON from codex
-    try:
-        raw = sys.stdin.read()
-        if not raw.strip():
-            _skip()
-        input_data = json.loads(raw)
-    except (json.JSONDecodeError, EOFError, ValueError):
-        _skip()
-
-    # 3. Extract fields
-    tool_name = input_data.get("tool_name", "")
-    tool_response = input_data.get("tool_response")
-    session_id = input_data.get("session_id", "")
-    tool_use_id = input_data.get("tool_use_id", "")
-
-    # 4. Layer 1: Content retrieval + task management → skip entirely
-    if tool_name in SKIP_TOOLS:
-        _skip()
-
-    # 5. Skip empty or trivial responses
-    if tool_response is None:
-        _skip()
-
-    raw_text = _extract_text_for_compression(tool_response)
-    if not raw_text or raw_text in ("{}", "[]", '""'):
-        _skip()
-
-    # 6. Detect environment errors (always, regardless of size)
-    env_category, env_hint = _classify_env_error(tool_response)
-
-    # 7. Skip compression for small responses, but still report env errors
-    if len(raw_text) < MIN_RESPONSE_CHARS:
-        if env_category:
-            response = {
-                "hookSpecificOutput": {
-                    "hookEventName": "PostToolUse",
-                    "additionalContext": (
-                        f"[tokenless:env:{env_category}] {env_hint} "
-                        f"Do NOT retry the same command — fix the environment first."
-                    ),
-                }
-            }
-            print(json.dumps(response, ensure_ascii=False))
-        _skip()
-
-    # 8. Determine JSON status (needed for compression pipeline)
-    parsed = _try_parse_json(raw_text)
-    is_json = parsed is not None and _is_json_serializable(parsed)
-
-    # 9. Compression pipeline: 3-layer dispatch thresholds
-    #   Layer 1 (content retrieval): already skipped above
-    #   Layer 2 (shell/exec): moderate truncation (64K/128/8)
-    #   Layer 3 (API/structured): zero-truncation (1M/64K/32)
-    compressed_text: Optional[str] = None
-    toon_text: Optional[str] = None
-
-    # -- Build compression input --
-    # If the response is plain text (not JSON), wrap it as a structured
-    # dict so the compression pipeline can still run and record stats.
-    # Otherwise bare strings like git log output would be silently skipped
-    # and never appear in tokenless stats, unlike openclaw/hermes where the
-    # agent framework natively wraps Bash output in {"stdout":...,...}.
-    if is_json:
-        compression_input = raw_text
-    else:
-        compression_input = json.dumps(
-            {"stdout": raw_text}, separators=(",", ":"), ensure_ascii=False
-        )
-
-    # -- Determine thresholds based on tool category --
-    thresholds = _get_thresholds(tool_name)
-
-    # -- Response compression --
-    compressed_text = _run_tokenless(
-        tokenless_bin, "compress-response",
-        compression_input, session_id, tool_use_id, timeout=10,
-        extra_args=[
-            "--truncate-strings-at", str(thresholds[0]),
-            "--truncate-arrays-at", str(thresholds[1]),
-            "--max-depth", str(thresholds[2]),
-        ],
-    )
-    if compressed_text and len(compressed_text) >= len(compression_input):
-        compressed_text = None  # no savings → skip
-
-    # -- TOON encoding (if still valid JSON after compression) --
-    if compressed_text:
-        toon_input = compressed_text
-    else:
-        toon_input = compression_input
-
-    toon_parsed = _try_parse_json(toon_input)
-    if toon_parsed is not None and len(toon_input) >= MIN_TOON_CHARS:
-        toon_text = _run_tokenless(
-            tokenless_bin, "compress-toon",
-            toon_input, session_id, tool_use_id, timeout=10,
-        )
-        if toon_text and len(toon_text) >= len(toon_input):
-            toon_text = None  # no savings → skip
-
-    # 10. Build additionalContext
-    parts: list[str] = []
-
-    original_chars = len(raw_text)
-    final_text = toon_text or compressed_text
-    is_large = len(raw_text) >= LARGE_RESPONSE_CHARS
-
-    if final_text:
-        final_chars = len(final_text)
-        savings_pct = round((1 - final_chars / max(original_chars, 1)) * 100)
-        parts.append(
-            f"[tokenless:compressed] {tool_name}: "
-            f"{original_chars:,} → {final_chars:,} chars ({savings_pct}% reduction)"
-        )
-    else:
-        # No compression savings
-        if is_large:
-            parts.append(
-                f"[tokenless] {tool_name}: {original_chars:,} chars, "
-                f"no compression savings achieved"
-            )
-
-    # Environment error hints
-    if env_category:
-        parts.append(
-            f"[tokenless:env:{env_category}] {env_hint} "
-            f"Do NOT retry the same command — fix the environment first."
-        )
-
-    # For large responses, include the compressed content so the model has a
-    # compact alternative to the raw output.
-    if final_text and is_large:
-        parts.append("--- compressed content ---")
-        if len(final_text) > COMPRESSED_CONTENT_CAP:
-            parts.append(final_text[:COMPRESSED_CONTENT_CAP])
-            parts.append(
-                f"... (compressed content truncated at {COMPRESSED_CONTENT_CAP:,} chars)"
-            )
-        else:
-            parts.append(final_text)
-        parts.append("--- end compressed content ---")
-
-    if not parts:
-        _skip()
-
-    additional_context = "\n".join(parts)
-
-    # 11. Output codex hook response
-    response = {
-        "hookSpecificOutput": {
-            "hookEventName": "PostToolUse",
-            "additionalContext": additional_context,
-        }
-    }
-    print(json.dumps(response, ensure_ascii=False))
-
-
-if __name__ == "__main__":
-    main()