Struct Summarizing 

pub struct Summarizing { /* private fields */ }

LLM-powered summarisation of old turns when context fills.

Since Step 18.5 (#247) this provider owns no summarisation logic of its own: when its anchored fullness figure crosses the budget it delegates to the SAME prune → boundary → redacted summary → marker assembly pipeline the agentic loop uses ([crate::agentic::compress], Step 18.4). The pre-18.4 implementation — its own prompt template, placeholder text, and anti-thrash counters — is deleted; the summary message in history is now the pipeline’s marked compaction message ([SUMMARY_PREFIX]).

Fullness tracking is unchanged (Step 18.1): last backend-reported prompt size plus the estimated content delta since — the old per-turn input + output running sum double-counted history and triggered spurious compressions.

Continuity (Step 18.5): the latest compaction message is offered to the caller once via MemoryProvider::take_compaction_record for durable persistence, and MemoryProvider::restore_turns rehydrates it — the restored working set is [compaction message] + [turns recorded after it], so the next compression chains off the previous summary instead of re-summarizing from scratch.

Configure: [memory] provider = "summarizing", plus an optional explicit context_tokens override. The compression budget (max_tokens) is a construction-time value injected by the caller with the same precedence as TokenBudget (Step 18.2, #247): explicit config override → capability-derived (max_ok_input else safe_context) → DEFAULT_CONTEXT_TOKENS. Fixed per session; the loop’s pre-send guard tracks mid-session capability ratchets live.

Implementations

impl Summarizing

pub fn new(max_tokens: u32) -> Self

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

Builder: set the token-estimation heuristic + summarizer cap floor from config ([context.estimation] / [context] summary_input_cap_floor_chars).

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

Inject a resolved token budget (builder form of the max_tokens constructor argument). Same ≥1 clamp as Summarizing::new. See TokenBudget::with_budget for the resolution precedence the caller is expected to apply (Step 18.2, #247).

pub fn with_summarizer( self, f: impl Fn(String) -> SummarizeFuture + Send + Sync + 'static, ) -> Self

Inject a summariser (required for real summaries; tests can use a stub). Takes the loop’s async crate::agentic::SummarizeFn shape since Step 18.5 — the TUI passes the very same summarizer it builds for the loop, so there is exactly one HTTP wiring. The old sync Fn(&str) -> Result<String> form (whose TUI impl blocked inside sync_turn) is gone with the logic that called it.

Trait Implementations

impl MemoryProvider for Summarizing

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 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 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 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.