Struct ContextManager 

pub struct ContextManager {
    pub budget: Option<ContextBudget>,
    pub soft_compaction_threshold: f32,
    pub hard_compaction_threshold: f32,
    pub compaction_preserve_tail: usize,
    pub prune_protect_tokens: usize,
    pub compression: CompressionConfig,
    pub routing: StoreRoutingConfig,
    pub store_routing_provider: Option<Arc<AnyProvider>>,
    /* private fields */
}

Per-session context lifecycle manager.

Holds the token budget, compaction lifecycle state, and routing configuration. Callers in zeph-core drive the state machine via advance_turn, compaction_tier, and related accessors; the assembler reads the budget via build_router and field access.

Fields

budget: Option<ContextBudget>

Token budget for this session. None until configured via apply_budget_config.

soft_compaction_threshold: f32

Soft compaction threshold (default 0.70): prune tool outputs + apply deferred summaries.

hard_compaction_threshold: f32

Hard compaction threshold (default 0.90): full LLM-based summarization.

compaction_preserve_tail: usize

Number of recent messages preserved during hard compaction.

prune_protect_tokens: usize

Token count protected from pruning during soft compaction.

compression: CompressionConfig

Compression configuration for proactive compression.

routing: StoreRoutingConfig

Routing configuration for query-aware memory routing.

store_routing_provider: Option<Arc<AnyProvider>>

Resolved provider for LLM/hybrid routing. None when strategy is Heuristic or when the named provider could not be resolved from the pool.

Implementations

impl ContextManager

pub fn new() -> Self

Create a new ContextManager with default thresholds and no budget.

pub fn apply_budget_config( &mut self, budget_tokens: usize, reserve_ratio: f32, hard_compaction_threshold: f32, compaction_preserve_tail: usize, prune_protect_tokens: usize, soft_compaction_threshold: f32, compaction_cooldown_turns: u8, )

Apply budget and compaction thresholds from config.

Must be called once after config is resolved. Safe to call again when config reloads.

pub fn reset_compaction(&mut self)

Reset compaction state for a new conversation.

Clears cooldown, exhaustion, and turn counters so the new conversation starts with a clean compaction slate.

pub fn compaction_tier(&self, cached_tokens: u64) -> CompactionTier

Determine which compaction tier applies for the given token count.

• Hard when cached_tokens > budget * hard_compaction_threshold
• Soft when cached_tokens > budget * soft_compaction_threshold
• None otherwise (or when no budget is set)

pub fn compaction_state(&self) -> CompactionState

Check if proactive compression should fire for the current turn.

Returns Some((threshold_tokens, max_summary_tokens)) when proactive compression should be triggered, None otherwise.

For CompressionStrategy::Focus, the threshold is the soft-compaction fraction of the budget (same gate used by mid-iteration soft compaction). The max_summary_tokens element is unused on the Focus path — the auto-consolidation function uses FocusConfig.max_knowledge_tokens / 2 instead.

Returns the current compaction lifecycle state.

pub fn compaction_state_mut(&mut self) -> &mut CompactionState

Returns a mutable reference to the compaction lifecycle state.

pub fn set_compaction_state(&mut self, state: CompactionState)

Replaces the compaction lifecycle state.

pub fn compaction_cooldown_turns(&self) -> u8

Returns the number of cooling turns enforced after a hard compaction.

pub fn set_compaction_cooldown_turns(&mut self, turns: u8)

Sets the number of cooling turns enforced after a hard compaction.

pub fn turns_since_last_hard_compaction(&self) -> Option<u64>

Returns the number of user-message turns since the last hard compaction, if any.

pub fn turns_since_last_hard_compaction_mut(&mut self) -> &mut Option<u64>

Returns a mutable reference to the turns-since-last-hard-compaction counter.

pub fn set_turns_since_last_hard_compaction(&mut self, value: Option<u64>)

Sets the turns-since-last-hard-compaction counter.

pub fn should_proactively_compress( &self, current_tokens: u64, ) -> Option<(usize, usize)>

Will return None if compaction already happened this turn (CRIT-03 fix).

Trait Implementations

impl Default for ContextManager

fn default() -> Self

Returns the “default value” for a type.