Thanks for digging into this, and for the detailed production evidence.

Fix 1 (token fallback) looks good — confirmed the if response.usage: block on current main has no else, and a rough-estimate fallback is the right pragmatic response when a provider silently ignores stream_options.include_usage. Worth adding a regression test in tests/run_agent/test_413_compression.py (or nearby) that feeds a usage=None response and asserts session counters get non-zero deltas and the compressor sees non-zero last_prompt_tokens.

Fix 2 (drop completion_tokens from the compression trigger) I'd like to push back on before we take it. The premise in the PR body is that reasoning tokens are "ephemeral output — they don't consume context window space for the next API call." But hermes actually does the opposite by design: at run_agent.py ~9094-9100, we explicitly re-send reasoning back on every subsequent turn:

# For ALL assistant messages, pass reasoning back to the API
# This ensures multi-turn reasoning context is preserved
if msg.get("role") == "assistant":
    reasoning_text = msg.get("reasoning")
    if reasoning_text:
        api_msg["reasoning_content"] = reasoning_text

reasoning_details is also preserved intentionally (the comment at ~9117 spells out OpenRouter multi-turn reasoning continuity), and Codex keeps codex_reasoning_items for the same reason. So in our design, completion_tokens from turn N should show up inside prompt_tokens on turn N+1, and last_prompt + last_completion is a tight lower bound for the next prompt — not an overestimate. Compression firing at 85K + 20K = 105K isn't premature under that model, it's a one-turn-early preflight of what the next call will actually report.

The "42% actual context usage" reading only holds if, on your GLM-5.1 / OpenRouter setup, one of these is true:

1. OpenRouter / GLM-5.1 accepts reasoning_content + reasoning_details on input but doesn't bill them as input tokens (provider-side).
2. Our extraction misses GLM's reasoning format so msg["reasoning"] is empty and nothing goes back.
3. Something is stripping think-tag content between turns before the next request.

Any of those is a real bug worth fixing — but the fix lives in _extract_reasoning / _build_assistant_message / the outgoing api_msg construction, not in the compression formula. The compression formula only becomes wrong if we've already lost the reasoning upstream.

A quick empirical check from your existing session logs: in your 6 compressed GLM-5.1 sessions, does last_prompt_tokens (or the provider-reported prompt_tokens on each API call) grow turn-over-turn by roughly last_completion_tokens? If yes, reasoning is being preserved and compression at 105K is actually correct. If it stays flat across turns while completion keeps producing 15K+ reasoning, that's the bug and it's upstream of the compression trigger.

Happy to help dig into that side of it if you want to pull a few turns of usage numbers from one of those session DBs. For now I'd suggest splitting this PR into the token-fallback fix alone (plus a test) and parking the compression change pending the investigation above.

You were right to push back — dropping completion_tokens entirely was wrong. I dug into the actual session data and found the upstream issue you predicted.

Session analysis confirms your scenario #2: _extract_reasoning() mostly misses GLM-5.1's reasoning output. Across all 6 compression-death sessions:

Zero messages had reasoning_details. Zero had <think> tags in content. GLM-5.1 via OpenRouter either returns reasoning in a format we don't capture, or the reasoning is provider-internal and never surfaces.

The improved fix uses the API-provided completion_tokens_details.reasoning_tokens (which we already extract in normalize_usage() into canonical_usage.reasoning_tokens) to subtract only the phantom reasoning portion before feeding the compressor:

_reasoning_toks = canonical_usage.reasoning_tokens
_content_completion = max(0, completion_tokens - _reasoning_toks)

This way:

• Non-thinking models (reasoning_tokens=0) → zero behavior change
• Thinking models with captured reasoning → reasoning shows up in prompt_tokens on the next call (self-correcting)
• Thinking models with uncaptured reasoning → phantom tokens no longer inflate the trigger

I also confirmed OpenCode has the identical bug (same formula, no reasoning subtraction, same premature auto-compact).

The token fallback fix (Fix 1) is unchanged — added a regression test as you suggested. Force-pushed with both fixes + 6 new tests.

Closed in favor of PR #13006 #13006 which fixes the same issue. Your reasoning-subtraction approach was more precise but bundled an unrelated fix (#12023). Thanks @kshitijk4poor!