… search/log/json

Extends the excluded-tool lossless compaction beyond grep, dispatched by
detected shape (excluded tools stay out of *lossy* compression for accuracy):

- SEARCH (grep) -> ripgrep --heading fold. Byte-lossless. Gated on
  _try_detect_search (the general/Magika classifier calls grep-over-code
  SOURCE_CODE and would miss it).
- LOG -> ANSI strip + run-collapse. Byte-lossless modulo non-semantic ANSI.
- JSON -> whitespace-minify. DATA-lossless (json.loads equals the original
  object) but NOT byte-exact — a read-then-Edit(old_string) on the same JSON
  file could miss; documented and gated.

Renames compact_excluded_search -> compact_excluded_lossless. Source code and
glob path-lists match nothing -> verbatim. 10 tests (byte-exact for search/log,
data-equal for json, no-op on source/glob, off-by-default). ruff + mypy clean.

…neral personas

Wire compact_excluded_lossless through the persona path: add it to
AgentSavingsProfile (default off), set it True for the coding + general
workload personas, emit it in proxy_env + proxy_pipeline_kwargs, and honor it
as a per-request override in ContentRouter.apply (_runtime_compact_excluded_lossless).

So HEADROOM_SAVINGS_PROFILE=coding now losslessly folds excluded grep/log
(byte-lossless) and minifies excluded json (data-lossless) — recovering the
Read/Grep-heavy savings the exclude list otherwise fully protects, with no
accuracy loss on the byte-lossless tiers. End-to-end: coding-persona kwargs
fold a real grep tool output 36% (router:excluded:lossless_search), recoverable.

…t grep)

bash is not an excluded tool, so a search run through it takes the lossy
strategy path — the gap that leaves bash-heavy harnesses (opencode, Codex)
uncompressed losslessly. Detect the *command* behind a shell tool result
(peeling wrappers: rtk/sudo/env/timeout, and sh -c "..."), and when it is a
read-only search (grep/egrep/rg/git grep/ag/ack), fold the output with the
same byte-lossless ripgrep --heading transform excluded Grep gets, instead of
lossy compression.

The command whitelist is only a gate to *attempt*: compact_lossless verifies
reversibility and returns the input unchanged when it can't safely shrink, so a
mis-gated command (grep -l path-lists, grep -c counts) falls through with no
accuracy risk. Non-search bash (cat/build/mutate/diff) and all MCP/native tools
are untouched. Wired into both the OpenAI chat (string) and Anthropic (block)
router paths; command set + shell tool names are config-driven.

Measured on real grep output: ~46% token savings, byte-exact.

CI TestExcludeTools failures surfaced the real contract: excluded tools include
Read/Edit — the read-then-edit path. JSON minify is data-lossless but byte-
*different*, so a Read that returns minified JSON breaks a later Edit whose
old_string was copied from the pretty file on disk. That violates the no-
accuracy-loss invariant this work is built on.

Restrict the excluded fold to BYTE-lossless shapes only (search + log, both
byte-recoverable and not edited byte-for-byte); leave JSON verbatim. The
exclude-mechanism tests (custom set, glob) now pass unchanged — their byte-
identity holds — which confirms the corrected contract. Search/log fold
coverage stays in the dedicated fold tests. bash-search fold is unaffected
(search-only). Removes the now-dead _minify_json_data_lossless.

…data-lossless contract

Reverses the previous over-correction. JSON whitespace-minify IS lossless
(json.loads equals the original object — same information, fewer tokens); it's
free savings and stays. The right fix for the CI failures was never to drop
compression, but to update the stale TestExcludeTools assertions that expected
byte-identity: excluded tools are protected from *lossy* compression, and now
get information-preserving compaction (search fold, log collapse, JSON minify).

Tests now assert recovery, not byte-identity: JSON -> json.loads equality +
router:excluded:lossless_json; search -> search_unheading byte-exact +
router:excluded:lossless_search. Restores _minify_json_data_lossless.

Caveat (documented, not gated): minified JSON is byte-different, so a
read-then-Edit(old_string) on the same JSON file could miss; the data is fully
preserved. Acceptable trade for the token savings.