Struct PersistentBuffer 

pub struct PersistentBuffer { /* private fields */ }

Persistent buffer for crash recovery

This buffer continuously stores session context entries. If all other detection methods fail, we can recover from this buffer.

Buffer Lifecycle

1. Start buffering when session starts
2. Continuously append context entries
3. Periodically flush to disk
4. Recover after crash
5. Clear buffer after successful storage

Example

use nexus_memory_hooks::buffer::PersistentBuffer;
use nexus_memory_hooks::session::SessionContext;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut buffer = PersistentBuffer::new(None)?;

    // Start buffering for an agent
    buffer.start_buffering("claude-code").await?;

    // Buffer context periodically
    let ctx = SessionContext::new("claude-code");
    buffer.buffer_context("claude-code", ctx, "checkpoint").await?;

    // Recover after crash
    if let Some(data) = buffer.recover_buffer("claude-code").await? {
        println!("Recovered {} entries", data.entries.len());
    }

    // Clear after successful storage
    buffer.clear_buffer("claude-code").await?;

    Ok(())
}

Implementations

impl PersistentBuffer

pub fn new(buffer_dir: Option<PathBuf>) -> Result<Self>

Create a new persistent buffer

Arguments

• buffer_dir - Directory for buffer files (default: ~/.local/share/nexus/buffer)

pub fn with_flush_interval(self, secs: u64) -> Self

Set flush interval

pub fn with_max_entries(self, max: usize) -> Self

Set max entries before auto-flush

pub async fn start_buffering(&self, agent_type: &str) -> Result<()>

Start buffering for an agent

pub async fn buffer_context( &self, agent_type: &str, context: SessionContext, context_type: &str, ) -> Result<()>

Buffer a context entry

pub async fn flush_to_disk(&self, agent_type: &str) -> Result<()>

Flush buffer to disk

pub async fn flush_all(&self) -> Result<()>

Flush all buffers to disk

pub async fn recover_buffer( &self, agent_type: &str, ) -> Result<Option<BufferData>>

Recover buffered context after crash

pub async fn clear_buffer(&self, agent_type: &str) -> Result<()>

Clear buffer after successful storage

pub async fn get_buffer_status(&self, agent_type: &str) -> Option<BufferStatus>

Get buffer status

pub async fn list_buffers(&self) -> Vec<BufferStatus>

List all active buffers

pub async fn has_buffer(&self, agent_type: &str) -> bool

Check if buffer exists for agent