…im 2 d/e)

ABSORB_MATRIX Dim 2 residual (d)+(e): give the reasoning-loop's
compaction summarizer an anti-thrash cooldown and a consecutive-failure
circuit breaker, mirroring the console compactor's breaker
(corlinman_server...console.compaction.Compactor) at per-turn loop scope.

The cheap tool-result elide fast path is NEVER gated — only the
heavyweight summarization LLM sub-call — so a turn under context pressure
still shrinks while the summarizer is parked.

Behaviour (in-loop = across the rounds of one per-turn ReasoningLoop):
- A failed summary sub-call (raised OR empty-text return, matching the
  console compactor's "returned no text") increments a consecutive-failure
  count and parks the slow path for CORLINMAN_COMPACT_SUMMARY_COOLDOWN_ROUNDS
  rounds (default 5).
- After CORLINMAN_COMPACT_SUMMARY_BREAKER_LIMIT consecutive failures
  (default 3) the summarizer is disabled for the rest of the turn — no
  further attempts even once the cooldown elapses — with one warning log
  (reasoning_loop.summary_breaker_tripped).
- A successful summary re-arms the failure count. A run of two low-savings
  successes (each shrinking the estimate <10%) trips the same cooldown so
  we stop paying the sub-call cost for marginal gains (hermes anti-thrash).

Implementation:
- New import-time int knobs via a new _env_positive_int helper (integer
  sibling of _env_positive_float), floored at 1.
- _compact_history gains keyword-only summary_allowed (gates only the slow
  path) and outcome dict (records summary_attempted / summary_failed /
  summary_saved_fraction). The overflow-retry site (fast_path_only=True)
  is untouched.
- ReasoningLoop gains per-turn state (_summary_failures / _summary_disabled
  / _summary_cooldown_until_round / _summary_low_savings_streak), reset in
  run() alongside _auto_continue_count, advanced by a fully-defensive
  _update_summary_breaker_state (try/except like the hook call sites).

Tests (TDD, corlinman-agent/tests/test_reasoning_loop.py): failure sets
cooldown then re-attempts after it elapses; breaker disables for the
remainder past the cooldown; success resets the failure count; a
low-savings streak trips the cooldown; summary_allowed=False gates only
the LLM call (elide still happens); outcome dict recording on
success/failure; _env_positive_int parse (default/override/garbage/floor).
Existing compaction tests unchanged (two monkeypatch _compact_history
stand-ins gained the new kwargs to match the signature).

A failure between two low-savings successes broke the 'consecutive'
premise of the anti-thrash policy, but the streak counter survived the
failure — after the failure cooldown expired, a single later low-savings
success read as the second consecutive one and triggered a spurious
cooldown. The failure branch now zeroes the streak, so anti-thrash fires
only on truly consecutive low-savings successes.

Regression test scripts success(low)→failure→success(low) and asserts
the third attempt does NOT trip (without the reset, round 4 would be
suppressed). 73 passed; ruff+mypy clean.

…odex #111 r2)

cooldown_until was rounds + N against a 'rounds >= until' gate, so N=1
retried on the very next round and the default 5 skipped only four —
contrary to the knob's documented 'how many rounds the slow path is
skipped'. Assignment is now rounds + N + 1 at both trip sites (failure
and low-savings streak), making the knob exact: N=1 skips one round.

Test expectations shifted accordingly (streak-trip and streak-reset
sequences gained one suppressed round); the two provider-counting tests'
assertions were already invariant under the shift (2 and 3 sub-calls) —
comments updated to the new round arithmetic. 73 passed; ruff+mypy clean.