Enum CompactionState 

pub enum CompactionState {
    Ready,
    CompactedThisTurn {
        cooldown: u8,
    },
    Cooling {
        turns_remaining: u8,
    },
    Exhausted {
        warned: bool,
    },
}

Lifecycle state of the compaction subsystem within a single session.

Replaces four independent boolean/u8 fields with an explicit state machine that makes invalid states unrepresentable (e.g., warned-without-exhausted).

Transition map

Ready
  → CompactedThisTurn { cooldown } when hard compaction succeeds (pruning or LLM)
  → CompactedThisTurn { cooldown: 0 } when focus truncation, eviction, or proactive
    compression fires (these callers do not want post-compaction cooldown)
  → Exhausted { warned: false } when compaction is counterproductive (too few messages,
    zero net freed tokens, or still above hard threshold after LLM compaction)

CompactedThisTurn { cooldown }
  → Cooling { turns_remaining: cooldown } when cooldown > 0  (via advance_turn)
  → Ready                                 when cooldown == 0 (via advance_turn)

Cooling { turns_remaining }
  → Cooling { turns_remaining - 1 } decremented inside maybe_compact each turn
  → Ready                           when turns_remaining reaches 0
  NOTE: Exhausted is NOT reachable from Cooling — all exhaustion-setting sites in
  summarization.rs are guarded by an early-return when in_cooldown is true.

Exhausted { warned: false }
  → Exhausted { warned: true } after the user warning is sent (one-shot)

Exhausted { warned: true }  (terminal — no further transitions)

turns_since_last_hard_compaction is a metric counter, not part of this state machine, and remains a separate field on ContextManager.

Variants

Ready

Normal state — compaction may fire if context exceeds thresholds.

CompactedThisTurn

Hard compaction (or focus truncation / eviction / proactive compression) ran this turn. No further compaction until advance_turn() is called at the next turn boundary. cooldown carries the number of cooling turns to enforce after this turn ends.

Fields

cooldown: u8

Cooling turns to enforce after this turn ends.

Cooling

Cooling down after a recent hard compaction. Hard tier is skipped; soft is still allowed. Counter decrements inside maybe_compact each turn until it reaches 0.

Fields

turns_remaining: u8

Remaining cooling turns before returning to Ready.

Exhausted

Compaction cannot reduce context further. No more attempts will be made. warned tracks whether the one-shot user warning has been sent.

Fields

warned: bool

Whether the user has already been notified of context exhaustion.

Implementations

impl CompactionState

pub fn is_compacted_this_turn(self) -> bool

Whether hard compaction (or a compaction-equivalent operation) already ran this turn.

When true, maybe_compact, maybe_proactive_compress, and maybe_soft_compact_mid_iteration all skip execution (CRIT-03).

pub fn is_exhausted(self) -> bool

Whether compaction is permanently disabled for this session.

pub fn cooldown_remaining(self) -> u8

Remaining cooldown turns (0 when not in Cooling state).

pub fn advance_turn(self) -> Self

Transition to the next-turn state at the start of each user turn.

Must be called exactly once per turn, before any compaction, eviction, or focus truncation can run. This guarantees that is_compacted_this_turn() returns false when the sidequest check executes — preserving the invariant that the sidequest only sees same-turn compaction set by eviction which runs after this call.

Transitions:

• CompactedThisTurn { cooldown: 0 } → Ready
• CompactedThisTurn { cooldown: n } → Cooling { turns_remaining: n }
• All other states are returned unchanged.

Trait Implementations

impl Clone for CompactionState

fn clone(&self) -> CompactionState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CompactionState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for CompactionState

fn eq(&self, other: &CompactionState) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for CompactionState

impl Eq for CompactionState

impl StructuralPartialEq for CompactionState