Struct NoteStore 

pub struct NoteStore { /* private fields */ }

Persistent agent notes at ~/.newt/NOTES.md.

Notes are read once at session start and frozen into the system prompt so the model’s prefix cache stays valid. Mid-session writes (via /remember <fact>) update the file but NOT the system prompt block — changes take effect next session.

Modelled on hermes-agent’s MemoryStore (MEMORY.md pattern).

Implementations

impl NoteStore

pub const DEFAULT_CHAR_LIMIT: usize = 2_200

pub fn new(path: impl Into<PathBuf>, char_limit: usize) -> Self

pub fn default_path() -> Self

Create at the default location ~/.newt/NOTES.md.

pub fn entries(&self) -> &[String]

Current live entries, in order.

pub fn is_empty(&self) -> bool

pub fn body_by_id(&self, id: &str) -> Option<&str>

The verbatim body of the note addressed by id — the by-id read the memory_fetch tool’s note:<id> resolver needs (progressive-disclosure memory, Workstream A MVP, #319). id is the 1-based entry number the memory index renders (the same numbering Self::numbered_listing and the curator error already show, so the model fetches an id it was shown). Returns None for a non-positive, non-numeric, or out-of-range id — labelled absence, never an error.

pub fn index_entries(&self) -> Vec<(usize, &str)>

(id, first-line title) for every note entry, in order — what the budgeted memory index lists (titles/ids, never bodies). id is the 1-based entry number Self::body_by_id resolves; the title is the entry’s first non-empty line, the human-readable hint the model uses to decide whether to memory_fetch the body.

pub fn char_usage(&self) -> (usize, usize)

pub fn add(&mut self, fact: &str) -> Result<()>

Add an entry. Over-budget adds fail with the full current entry list (see Self::over_budget_error). Exact duplicates are a no-op.

Runs the write-time security scan (crate::notes_scan::scan_note) before anything else can succeed — the scan precedes even the duplicate no-op so malicious text never gets a silent Ok.

pub fn replace(&mut self, old_substr: &str, new_text: &str) -> Result<()>

Replace the single entry containing old_substr with new_text. Exactly one entry must match; the result must fit the char budget.

The replacement text goes through the same write-time security scan as Self::add — replace is a write path, not a loophole.

pub fn remove(&mut self, substr: &str) -> Result<()>

Remove the single entry containing substr. Exactly one entry must match.

Trait Implementations

impl Debug for NoteStore

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

Formats the value using the given formatter.

impl MemoryProvider for NoteStore

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

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.