anolisa-tokenless 0.7.12 → 0.7.14

package/README.md

@@ -18,7 +18,7 @@ Agent adapters are available for:
 - **Hermes Agent plugin** — response compression, TOON encoding, command rewriting (block + suggest), and registered but hard-disabled Tool Ready via Hermes's native plugin system.
 - **Qoder CLI plugin** — registered but hard-disabled Tool Ready, command rewriting, and response compression via Qoder's native hook system.
 - **Claude Code plugin** — RTK command rewriting, response/TOON compression, and registered but hard-disabled Tool Ready via Claude Code's official plugin marketplace.
-- **Codex plugin** — response compression, TOON encoding, registered but hard-disabled Tool Ready, and command rewriting via Codex's native hook system.
+- **Codex plugin** — RTK command rewriting, environment-failure diagnostics, and registered but hard-disabled Tool Ready via Codex's native hook system.
 - **OpenCode plugin** — schema/response/TOON compression, registered but hard-disabled Tool Ready, and command rewriting via OpenCode's local plugin API.
 - **DeepSeek Harness plugin** — native response compression and environment-error attribution through DSH's `tools/post-execute` seam.
 
@@ -40,7 +40,7 @@ cover schema compression, RTK rewriting, response compression, TOON, retrieval,
 | Hermes Agent plugin | — | Tool Ready ⛔ hard-disabled, Command rewriting ✅, Response compression ✅, TOON ✅, Schema compression ⏳ |
 | Qoder CLI plugin | — | Tool Ready ⛔ hard-disabled, Command rewriting ✅, Response compression ✅ |
 | Claude Code plugin | — | Tool Ready ⛔ hard-disabled, Command rewriting ✅, Response compression ✅, TOON ✅ |
-| Codex plugin | — | Tool Ready ⛔ hard-disabled, Command rewriting ✅, Response compression ✅, TOON ✅ |
+| Codex plugin | — | Tool Ready ⛔ hard-disabled, Command rewriting ✅, Environment diagnostics ✅, Response compression — protocol-blocked |
 | OpenCode plugin | — | Tool Ready ⛔ hard-disabled, Command rewriting ✅, Schema compression ✅, Response compression ✅, TOON ✅ |
 | DeepSeek Harness plugin | — | Response compression ✅, Environment-error attribution ✅ |
 | AgentScope framework integration | — | Schema ✅, RTK ✅, Response ✅, TOON ✅, Retrieval ✅ |
@@ -316,16 +316,18 @@ tokenless retrieve c30ccf5ed1125e0ed871ba8e
 
 # Or paste the whole truncation line — the hash is extracted automatically.
 # (Use the FULL 24-hex hash from your output; the value below is shorthand.)
-tokenless retrieve "<... 160 items truncated, retrieve with <<tokenless:c30ccf5ed1125e0ed871ba8e>>"
+tokenless retrieve "<... 160 items truncated, run: tokenless retrieve '<<tokenless:c30ccf5ed1125e0ed871ba8e>>'>"
 ```
 
 ### compress-toon / decompress-toon
 
-Encode JSON to TOON format (or decode back to JSON):
+Encode JSON to TOON format (or decode back to JSON). Payloads shorter than
+500 characters pass through unchanged by default (the same minimum the
+adapter hooks apply); use `--min-toon-chars 0` to encode them anyway:
 
 ```bash
-# Encode JSON to TOON
-echo '{"name":"Alice","age":30}' | tokenless compress-toon
+# Encode JSON to TOON (short payload, gate disabled for this call)
+echo '{"name":"Alice","age":30}' | tokenless compress-toon --min-toon-chars 0
 # name: Alice
 # age: 30
 
@@ -571,9 +573,12 @@ The plugin registers hooks at four Codex events, covering four strategies:
 | Session check | `SessionStart` | Verifies tokenless CLI is installed and functional (non-blocking) | ✅ Active |
 | Tool Ready | `PreToolUse` | Registered silent pass-through; no check, repair, context, or block | ⛔ Hard-disabled |
 | Command rewriting | `PreToolUse` | Rewrites shell commands via RTK for token savings | ✅ Active |
-| Response compression | `PostToolUse` | Compresses tool responses and encodes to TOON format, injects compressed summary as `additionalContext` | ✅ Active |
+| Environment diagnostics | `PostToolUse` | Adds actionable context only for classified environment failures | ✅ Active |
 
-> **Codex Protocol Constraint**: PostToolUse hooks cannot suppress the original tool output. The plugin injects a compressed *summary* as `additionalContext` — the model sees both the original output and the compressed summary.
+> **Codex protocol constraint**: `PostToolUse` cannot replace or suppress the
+> original tool output. Tokenless therefore does not append compressed content,
+> which would make the model-visible payload larger. First-pass savings for
+> supported shell commands come from RTK rewriting the command before execution.
 
 ### Install
 

package/adapters/tokenless/claude-code/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenless",
-  "version": "0.7.12",
+  "version": "0.7.14",
   "description": "Token-Less context compression for Claude Code — RTK command rewriting, response/TOON compression, and Tool Ready environment pre-check",
   "author": { "name": "ANOLISA" },
   "license": "Apache-2.0",

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

@@ -1,9 +1,10 @@
 {
   "name": "tokenless",
-  "version": "0.7.12",
-  "description": "Intelligent tool response compression, environment error detection, and token optimization. Strips noise (debug fields, nulls, empty values), truncates long strings/arrays, applies TOON encoding for JSON responses, and classifies environment errors with actionable fix hints.",
+  "version": "0.7.14",
+  "description": "Shell command output reduction and environment error diagnostics for Codex. Rewrites supported commands through RTK before execution and classifies environment failures with actionable fix hints.",
   "keywords": [
-    "compression",
+    "rtk",
+    "shell",
     "token",
     "context",
     "optimization",
@@ -13,7 +14,7 @@
   "hooks": "./hooks/hooks.json",
   "interface": {
     "displayName": "Tokenless",
-    "shortDescription": "Compress tool responses and detect environment errors to save tokens",
+    "shortDescription": "Reduce shell output with RTK and diagnose environment errors",
     "category": "developer-tools",
     "capabilities": ["hook"]
   }

package/adapters/tokenless/codex/README.md

@@ -1,18 +1,17 @@
 # Tokenless Plugin for Codex
 
-Intelligent tool response compression and environment error detection plugin for
-[Codex](https://github.com/openai/codex). Reduces token consumption by stripping
-noise, truncating verbose output, and classifying environment errors with
-actionable fix hints.
+Command-output reduction and environment error detection plugin for
+[Codex](https://github.com/openai/codex). It rewrites supported shell commands
+through RTK before execution and classifies environment errors with actionable
+fix hints.
 
 ## Features
 
 | Feature | Description |
 |---------|-------------|
-| **Response Compression** | Strips debug fields, nulls, empty values; truncates long strings (512 chars) and arrays (16 items); limits depth to 8 levels |
-| **TOON Encoding** | Further compresses valid JSON responses (15-40% additional savings vs. compressed JSON) |
+| **Command Rewriting** | Rewrites supported shell commands through RTK so verbose output is reduced at its source |
 | **Environment Error Detection** | Classifies tool failures as dependency/permission/file/network/package issues; injects fix hints to prevent retry loops |
-| **Statistics Tracking** | Records every compression operation to SQLite for auditing and optimization |
+| **Statistics Tracking** | Attributes RTK rewrites to the Codex session for auditing and optimization |
 
 ## How It Works
 
@@ -28,17 +27,14 @@ The plugin registers four hooks with Codex:
    - Rewrites commands via `rtk rewrite` for token optimization
    - Only applies to Bash/Shell/terminal/programmatic tools
 4. **`PostToolUse`** — runs after every tool execution:
-   - Skips content-reading tools (Read, Glob) and small responses (< 500 chars)
+   - Skips content-reading and task-management tools
    - Classifies environment errors and injects fix hints
-   - Compresses large JSON responses via `tokenless compress-response`
-   - Applies TOON encoding for additional savings
-   - Injects a compressed summary as `additionalContext`
 
-> **Codex Protocol Constraint**: PostToolUse hooks cannot suppress the original
-> tool output (`suppressOutput` is rejected). The plugin therefore injects a
-> compressed *summary* as `additionalContext` — the model sees both the original
-> output and the compressed summary, and can use the summary for efficient
-> processing of large outputs.
+> **Codex protocol constraint**: `PostToolUse` rejects output suppression and
+> replacement. Injecting compressed content through `additionalContext` would
+> leave the original in place and increase the prompt. The plugin therefore
+> reserves `additionalContext` for actionable environment diagnostics. Actual
+> first-pass savings come from RTK rewriting supported commands before they run.
 
 ## Installation
 
@@ -77,15 +73,12 @@ Or install from the marketplace (once published).
 
 ## Hook Output Format
 
-The plugin injects `additionalContext` in the following format:
+For a classified environment failure, the plugin injects `additionalContext`
+in the following format:
 
 ```
-[tokenless:compressed] Bash: 45,230 → 2,100 chars (95% reduction)
 [tokenless:env:ENV_DEPENDENCY_MISSING] Missing dependency detected. ...
 Do NOT retry the same command — fix the environment first.
---- compressed content ---
-{... compressed JSON or TOON content ...}
---- end compressed content ---
 ```
 
 ## Configuration
@@ -114,21 +107,18 @@ tokenless stats list --limit 20
 tokenless stats show <id>
 ```
 
-## Compression Pipeline
+## Savings Path
 
 ```
-Raw tool_response (JSON)
+Shell command
     │
-    ├─ Step 1: ResponseCompressor
-    │   ├─ Drop: debug, trace, stack, stacktrace, logs, logging fields
-    │   ├─ Truncate: strings > 512 chars, arrays > 16 items
-    │   ├─ Drop: null values, empty strings, empty arrays, empty objects
-    │   └─ Limit: max depth 8 levels
+    ├─ PreToolUse: rtk rewrite
+    │   └─ Replaces the command with an output-reducing equivalent
     │
-    ├─ Step 2: TOON Encoding (if result is still valid JSON)
-    │   └─ Binary-to-TOON format encoding (~15-40% additional savings)
+    ├─ Tool execution
+    │   └─ Codex receives the already-reduced output
     │
-    └─ Guard: output only if smaller than input (safety check)
+    └─ PostToolUse: environment diagnostics only
 ```
 
 ## Architecture
@@ -139,7 +129,7 @@ codex-plugin-tokenless/
 ├── hooks/
 │   └── hooks.json           # Hook definitions (SessionStart, PreToolUse, PostToolUse)
 ├── scripts/
-│   ├── compress-response    # PostToolUse: response compression + env error detection
+│   ├── response-diagnostics # PostToolUse: environment error detection
 │   ├── rewrite-hook         # PreToolUse: RTK command rewriting
 │   ├── tool-ready           # PreToolUse: registered hard-disabled pass-through
 │   ├── check-tokenless      # SessionStart: version/availability check

package/adapters/tokenless/codex/hooks/hooks.json

@@ -29,9 +29,9 @@
         "hooks": [
           {
             "type": "command",
-            "command": "${PLUGIN_ROOT}/scripts/compress-response",
-            "timeout": 15,
-            "statusMessage": "Compressing tool response..."
+            "command": "${PLUGIN_ROOT}/scripts/response-diagnostics",
+            "timeout": 10,
+            "statusMessage": "Checking tool response..."
           }
         ]
       }

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

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""Codex PostToolUse environment diagnostics for the Tokenless plugin.
+
+Codex does not let PostToolUse hooks replace or suppress the original tool
+response. Adding compressed content through ``additionalContext`` therefore
+increases the model-visible payload instead of reducing it. This hook only
+adds actionable context for classified environment failures; successful and
+unclassified responses pass through unchanged.
+
+Protocol:
+    stdin  <- Codex PostToolUse JSON (tool_name, tool_response, ...)
+    stdout -> {"hookSpecificOutput": {"hookEventName": "PostToolUse",
+                                       "additionalContext": "..."}}
+
+Fail-open: every error path exits successfully with empty stdout so a
+diagnostic failure never blocks the agent session.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+# 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.
+#   - Other paths must be owned by the current user or root, and their parent
+#     directory must not be world-writable.
+_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."""
+    for prefix in (
+        "/usr/share/",
+        "/usr/local/share/",
+        "/usr/libexec/",
+        "/usr/lib/anolisa/",
+    ):
+        if path.startswith(prefix):
+            return True
+
+    try:
+        stat = os.stat(path)
+        parent_stat = os.stat(os.path.dirname(path))
+    except OSError:
+        return False
+    if stat.st_uid not in (os.getuid(), 0):
+        return False
+    if parent_stat.st_uid not in (os.getuid(), 0):
+        return False
+    return not parent_stat.st_mode & 0o002
+
+
+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 = ""
+
+_HOOK_UTILS_CANDIDATES = [
+    os.path.join(_HERE, "..", "..", "common", "hooks"),
+    "/usr/share/anolisa/adapters/tokenless/common/hooks",
+    "/usr/local/share/anolisa/adapters/tokenless/common/hooks",
+    (
+        os.path.join(
+            _REAL_HOME,
+            ".local",
+            "share",
+            "anolisa",
+            "adapters",
+            "tokenless",
+            "common",
+            "hooks",
+        )
+        if _REAL_HOME
+        else ""
+    ),
+]
+_HOOK_UTILS_RESOLVED = ""
+for _candidate in _HOOK_UTILS_CANDIDATES:
+    resolved = os.path.realpath(_candidate) if _candidate else ""
+    if resolved and _is_trusted_dir(resolved) and os.path.isdir(resolved):
+        _HOOK_UTILS_RESOLVED = resolved
+        sys.path.insert(0, resolved)
+        break
+
+if _HOOK_UTILS_RESOLVED:
+    from hook_utils import (  # noqa: E402
+        SKIP_TOOLS as _SKIP_TOOLS_SHARED,
+        classify_env_error as _classify_env_error,
+        skip_silent as _skip,
+    )
+else:
+
+    def _skip() -> None:  # type: ignore[assignment,misc]
+        sys.exit(0)
+
+    def _classify_env_error(  # type: ignore[assignment,misc]
+        tool_response: object,
+    ) -> tuple[str | None, str | None]:
+        return None, None
+
+    _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",
+    }
+
+
+SKIP_TOOLS: set[str] = _SKIP_TOOLS_SHARED | {
+    "TodoWrite",
+    "Task",
+    "TaskStatus",
+}
+
+
+def main() -> None:
+    try:
+        raw = sys.stdin.read()
+        if not raw.strip():
+            _skip()
+        input_data = json.loads(raw)
+    except (json.JSONDecodeError, EOFError, ValueError):
+        _skip()
+
+    tool_name = input_data.get("tool_name", "")
+    tool_response = input_data.get("tool_response")
+    if tool_name in SKIP_TOOLS or tool_response is None:
+        _skip()
+
+    env_category, env_hint = _classify_env_error(tool_response)
+    if not env_category or not env_hint:
+        _skip()
+
+    response = {
+        "hookSpecificOutput": {
+            "hookEventName": "PostToolUse",
+            "additionalContext": (
+                f"[tokenless:env:{env_category}] {env_hint} "
+                "Do NOT retry the same command — fix the environment first."
+            ),
+        }
+    }
+    print(json.dumps(response, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

package/adapters/tokenless/common/cosh-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenless",
-  "version": "0.7.12",
+  "version": "0.7.14",
   "contextFileName": "COPILOT.md",
   "hooks": {
     "PreToolUse": [