Struct SessionArchive 

pub struct SessionArchive { /* private fields */ }

Implementations

impl SessionArchive

pub fn set_primary_agent(&mut self, primary_agent: impl Into<String>)

Records the active primary agent (session “mode”) so a later resume can restore it. Called once the active agent is selected, after the archive and thread have been started.

pub fn metadata(&self) -> &SessionArchiveMetadata

pub async fn new( metadata: SessionArchiveMetadata, custom_suffix: Option<String>, ) -> Result<Self>

pub async fn new_with_identifier( metadata: SessionArchiveMetadata, session_identifier: String, ) -> Result<Self>

Create a session archive using an explicitly reserved session identifier.

pub fn resume_from_listing( listing: &SessionListing, metadata: SessionArchiveMetadata, ) -> Self

Reopen an existing archive file so follow-up runs can overwrite the snapshot in place.

pub fn finalize( &self, transcript: Vec<String>, total_messages: usize, distinct_tools: Vec<String>, messages: Vec<SessionMessage>, ) -> Result<PathBuf>

pub fn finalize_with_diagnostics( &self, transcript: Vec<String>, total_messages: usize, distinct_tools: Vec<String>, messages: Vec<SessionMessage>, turn_diagnostics: Option<SnapshotTurnDiagnostics>, ) -> Result<PathBuf>

Finalize the archive while retaining lightweight diagnostics for the last turn. The final snapshot still omits the heavy progress history.

pub fn persist_progress(&self, args: SessionProgressArgs) -> Result<PathBuf>

pub async fn persist_progress_async_with_status( &self, args: SessionProgressArgs, ) -> Result<SessionProgressPersistenceStatus>

Persist progress asynchronously and report whether this call wrote a new durable snapshot.

A throttled checkpoint still returns the archive path for diagnostics, but it must not be treated as durable by callers that acknowledge state only after history has been written.

pub async fn persist_progress_async_with_status_forced( &self, args: SessionProgressArgs, ) -> Result<SessionProgressPersistenceStatus>

Persist progress immediately, bypassing the normal progress throttle.

This is intended for terminal handoff checkpoints where the latest conversation must be durable before an external artifact is written.

pub async fn persist_progress_async( &self, args: SessionProgressArgs, ) -> Result<PathBuf>

pub fn set_loaded_skills(&mut self, skills: Vec<String>)

Update loaded skills in the archive metadata

pub fn set_continuation_metadata( &mut self, continuation_metadata: Option<SessionContinuationMetadata>, )

Update continuation metadata in the archive metadata.

pub fn path(&self) -> &Path

pub async fn verify_persisted_resume_identifier( &self, persisted_path: &Path, ) -> Result<Option<VerifiedSessionArchiveIdentifier>>

Verify that a persisted snapshot resolves back to this archive and return its typed resume identifier.

pub async fn fork( source_snapshot: &SessionSnapshot, custom_suffix: Option<String>, ) -> Result<Self>

Create a forked session from an existing session snapshot

This creates a new session archive that inherits metadata from the source session but operates independently. The forked session will have a new archive file with a custom suffix if provided.

Arguments

• source_snapshot - The snapshot of the session to fork from
• custom_suffix - Optional custom suffix for the new session ID

Returns

A new SessionArchive instance for the forked session

Trait Implementations

impl Clone for SessionArchive

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 SessionArchive

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

Formats the value using the given formatter.