Struct SessionStore 

pub struct SessionStore { /* private fields */ }

Persists SessionSnapshot JSON files to disk under <data_dir>/sessions/.

By default, secret redaction is enabled so API keys and tokens are scrubbed from saved event text.

Implementations

impl SessionStore

pub fn new(data_dir: PathBuf) -> Self

Creates a new store with secret redaction enabled.

pub fn with_redaction(data_dir: PathBuf, redact_secrets: bool) -> Self

Creates a new store with the given redaction setting.

pub fn root(&self) -> &PathBuf

Returns the directory where session JSON files are stored.

pub fn create_id() -> SessionId

Generates a session id that is unique across concurrent NAVI instances.

The timestamp keeps ids naturally ordered, while the process id, in-process sequence, and random nonce prevent two agents started in the same millisecond from sharing a provider cache-affinity identity.

pub fn save(&self, snapshot: &SessionSnapshot) -> Result<PathBuf>

Serializes and saves a snapshot to disk, creating the sessions directory if needed. Applies secret redaction unless disabled.

This is the blocking implementation used internally and in tests. Use Self::save_async from async contexts to avoid blocking the Tokio runtime.

pub async fn save_async(&self, snapshot: SessionSnapshot) -> Result<PathBuf>

Async wrapper around Self::save that runs the blocking filesystem operations on the Tokio blocking thread pool.

pub fn list(&self) -> Vec<SessionSnapshot>

Loads all saved sessions from disk, sorted by most recently updated first.

pub fn list_info(&self) -> Vec<SessionSnapshotInfo>

Loads only session metadata from disk, sorted by most recently updated first.

pub async fn list_async(&self) -> Vec<SessionSnapshot>

Async wrapper around Self::list that runs the blocking filesystem operations on the Tokio blocking thread pool.

pub async fn list_info_async(&self) -> Vec<SessionSnapshotInfo>

Async wrapper around Self::list_info that avoids blocking the async runtime.

pub fn load(&self, session_id: &str) -> Result<SessionSnapshot>

Loads a single session by id. Returns an error if the file is missing or the snapshot version is newer than supported.

pub async fn load_async(&self, session_id: String) -> Result<SessionSnapshot>

Async wrapper around Self::load that runs the blocking filesystem operations on the Tokio blocking thread pool.

pub fn delete(&self, session_id: &str) -> Result<bool>

Deletes the session file. Returns true if the file existed and was removed.

pub fn rename(&self, session_id: &str, title: &str) -> Result<bool>

Renames a saved session by updating its title field in the snapshot. Returns true if the session existed and was updated.

pub async fn rename_async( &self, session_id: String, title: String, ) -> Result<bool>

Async wrapper around Self::rename.

pub async fn delete_async(&self, session_id: String) -> Result<bool>

Async wrapper around Self::delete that runs the blocking filesystem operations on the Tokio blocking thread pool.

pub fn save_memory( &self, project_dir: &Path, memory: &ProjectMemory, ) -> Result<PathBuf>

Persists project memory to <data_dir>/memory/<hash>.json.

pub async fn save_memory_async( &self, project_dir: PathBuf, memory: ProjectMemory, ) -> Result<PathBuf>

Async wrapper around Self::save_memory that runs the blocking filesystem operations on the Tokio blocking thread pool.

pub fn load_memory(&self, project_dir: &Path) -> Option<ProjectMemory>

Loads project memory from disk, returning None if no memory file exists.

pub async fn load_memory_async( &self, project_dir: PathBuf, ) -> Option<ProjectMemory>

Async wrapper around Self::load_memory that runs the blocking filesystem operations on the Tokio blocking thread pool.

pub fn add_memory_entry( &self, project_dir: &Path, session_id: &SessionId, summary: String, ) -> Result<PathBuf>

Appends a new memory entry for the project and persists it to disk.

pub async fn add_memory_entry_async( &self, project_dir: PathBuf, session_id: String, summary: String, ) -> Result<PathBuf>

Async wrapper around Self::add_memory_entry that runs the blocking filesystem operations on the Tokio blocking thread pool.

Trait Implementations

impl Clone for SessionStore

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SessionStore

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

Formats the value using the given formatter.