Struct TokenBudget 

pub struct TokenBudget { /* private fields */ }

Keep turns up to threshold_pct of the model’s context window.

Budget math (fixed in Step 18.1): the fullness figure anchors on the backend’s last-reported prompt size — which already includes the system prompt and ALL prior turns — plus a chars/4 estimate of content added or removed since that report. The previous implementation summed input + output per turn across history, double-counting every prior turn in every later reading (the B3 baseline measured 5.4× inflation by turn 20), which forced spurious pruning. Without any backend report the figure falls back to summing per-turn content estimates (each turn counted once).

Configure via [memory] provider = "token_budget". The budget is a construction-time value injected by the caller (Step 18.2, #247) with this precedence:

1. explicit [memory] context_tokens (a deliberate user override),
2. capability-derived (max_ok_input else safe_context from the caller’s probe cache — newt-core deliberately has no dependency on the probe types, mirroring the with_summarizer injection),
3. DEFAULT_CONTEXT_TOKENS when neither exists (fresh model).

The value is fixed for the provider’s lifetime: budgets refresh per session; mid-session capability ratchets are tracked live by the agentic loop’s own pre-send guard, not by this provider.

Implementations

impl TokenBudget

pub fn new(max_tokens: u32, threshold_pct: f32) -> Self

pub fn with_estimation(self, est: TokenEstimation) -> Self

Builder: set the token-estimation heuristic from [context.estimation].

pub fn with_budget(self, tokens: u32) -> Self

Inject a resolved token budget (builder form of the max_tokens constructor argument, mirroring Summarizing::with_summarizer). Same ≥512 clamp as TokenBudget::new.

Step 18.2 (#247): this replaces the deleted from_config() path, whose silent 8,192 fallback ignored empirical capability data. The caller resolves the budget (explicit config override → capability cache → DEFAULT_CONTEXT_TOKENS) and injects the value here.

Trait Implementations

impl MemoryProvider for TokenBudget

fn name(&self) -> &str

Short stable identifier, e.g. "rolling_window".

fn build_messages(&self, system_prompt: &str, new_task: &str) -> Vec<MemMessage>

Build the full message list (including history) to send to the model.

fn sync_turn<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, user: &'life1 str, assistant: &'life2 str, metrics: &'life3 TurnMetrics, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Persist a completed turn.

fn reset(&mut self)

Clear conversation-local history while preserving provider configuration and system-prompt state. Used when the TUI starts a fresh conversation inside the same running process.

fn restore_turns(&mut self, turns: &[ConversationTurn])

Replace conversation-local history with durable restored turns.

fn usage(&self) -> Option<(String, usize, usize)>

Report current usage for display (e.g. /memory command). Returns (label, current, max) — e.g. ("turns", 12, 20).

fn initialize<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 SessionContext, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

One-time setup at session start (load files, warm caches, etc.). Default: no-op.

fn system_prompt_block(&self) -> Option<String>

Return a static block for the system prompt.

fn prefetch<'life0, 'life1, 'async_trait>( &'life0 self, _query: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Recall relevant context to prepend to the user turn before the API call. Should be fast — use cached results, don’t block. Return empty string to contribute nothing.

fn take_compaction_record(&mut self) -> Option<String>

Take (and clear) the compaction record minted since the last call — the full marked summary message a compressing provider inserted into its working set (Step 18.5, #247). The caller persists it as a turn record (user = the marked message, assistant = empty, token columns NULL — it is not a backend-measured turn) so a later restore can rehydrate the same working-set shape via Self::restore_turns. Default: None — providers that never compress mint nothing.

fn on_pre_compress<'life0, 'life1, 'async_trait>( &'life0 self, _messages: &'life1 [MemMessage], ) -> Pin<Box<dyn Future<Output = String> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Called before old messages are discarded (e.g. during compression). Extract anything worth keeping from messages; return it as a string to include in the compression summary. Return empty string for nothing.

fn on_session_end<'life0, 'life1, 'async_trait>( &'life0 mut self, _messages: &'life1 [MemMessage], ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Called once when the session ends. Use for final extraction / cleanup.

fn add_note(&mut self, _fact: &str) -> Result<()>

Add a persistent note.

fn replace_note(&mut self, _old_substring: &str, _new_text: &str) -> Result<()>

Replace the single persisted note containing old_substring with new_text (Step 19.3 — the save_note tool’s replace action). Default: NotesUnsupported, same routing contract as add_note.

fn remove_note(&mut self, _substring: &str) -> Result<()>

Remove the single persisted note containing substring (Step 19.3 — the save_note tool’s remove action). Default: NotesUnsupported, same routing contract as add_note.