Struct MemoryIndex 

pub struct MemoryIndex { /* private fields */ }

A budgeted, frozen INDEX of memory the model can navigate (#319).

Instead of freezing every NOTE body verbatim into the system prompt (what NoteStore::system_prompt_block does today), this provider surfaces a SMALL index — note ids + first-line titles — capped at MEMORY_INDEX_BUDGET items. The bodies are pulled on demand via the memory_fetch tool (note:<id>). This is use_skill’s index-then-fetch shape applied to memory.

Additive and opt-in. It is registered only under [memory] disclosure = "index" (default frozen), so with the default config it is never constructed and behavior is bit-for-bit unchanged. Like NoteStore and SoulProvider it is system-prompt-only — build_messages returns Vec::new() so it never competes for the “first non-empty build_messages” slot in MemoryManager::build_messages.

The index is frozen at session start (KV-cache-safe). Notes created mid-session don’t appear until next session — the same accepted limitation NoteStore’s frozen snapshot has today; memory_fetch by a known id still works mid-session even when the index hasn’t refreshed (the index is a convenience surface, the fetch is the capability — design §8.7).

Past-turn keywords are deliberately NOT duplicated here: that is exactly what recall provides (snippet search over the store). The index points at recall for that axis rather than competing with it (design §3.1/§8.5).

Implementations

impl MemoryIndex

pub fn new(notes_path: impl Into<PathBuf>) -> Self

Build an index over the NOTES file at notes_path (the same file NoteStore reads). The bodies are fetched via memory_fetch; this provider only ever surfaces ids + titles.

pub fn default_path() -> Self

Construct over the default NOTES location (~/.newt/NOTES.md), mirroring NoteStore::default_path.

pub fn rows(&self) -> &[(usize, String)]

Rows currently listed in the index (test introspection).

Trait Implementations

impl MemoryProvider for MemoryIndex

fn name(&self) -> &str

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

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