Struct LocalSessionStore 

pub struct LocalSessionStore { /* private fields */ }

Session store bound to a resolved CLI database path.

Implementations

impl LocalSessionStore

pub fn new(config: CliConfig) -> SessionStoreResult<Self>

Open a CLI session-store adapter before it is used by async runtime code.

Trait Implementations

impl Clone for LocalSessionStore

fn clone(&self) -> LocalSessionStore

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LocalSessionStore

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

Formats the value using the given formatter.

impl SessionStore for LocalSessionStore

fn commit_run_evidence<'life0, 'async_trait>( &'life0 self, commit: RunEvidenceCommit, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<RunRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Atomically persist a complete run evidence bundle.

fn commit_checkpoint<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, checkpoint: AgentCheckpoint, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Atomically bootstrap missing session/run records and persist one runtime checkpoint.

fn claim_hitl_resume<'life0, 'async_trait>( &'life0 self, claim: HitlResumeClaim, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Acquire exclusive ownership of a waiting run before any continuation side effect.

fn start_hitl_resume_effect<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, lease: &'life1 RunAdmissionLease, source_run_id: &'life2 RunId, claim_id: &'life3 str, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Atomically authorize the first HITL continuation effect under a live admission lease.

fn abort_admitted_hitl_resume<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, lease: &'life1 RunAdmissionLease, source_run_id: &'life2 RunId, claim_id: &'life3 str, output_preview: &'life4 str, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<HitlResumeAbortOutcome>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Atomically abort a pre-worker waiting-run replacement under its live admission lease.

fn mark_hitl_resume_started<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, run_id: &'life2 RunId, claim_id: &'life3 str, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Mark a non-admitted claim started immediately before the first continuation hook or tool executes.

fn release_hitl_resume_claim<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, run_id: &'life2 RunId, claim_id: &'life3 str, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Release a preflight claim. Stores must reject release after execution has started.

fn pending_stream_publications<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Vec<PendingStreamPublication>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List transactionally enqueued stream publications still awaiting at least one sink.

fn acknowledge_stream_publication<'life0, 'life1, 'async_trait>( &'life0 self, publication_id: &'life1 str, target: StreamPublicationTarget, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Acknowledge one sink only after its complete idempotent delivery succeeds.

fn create_session_idempotent<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session: SessionRecord, idempotency_key: &'life1 str, command_fingerprint: &'life2 str, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<SessionRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Atomically create a session and bind an idempotency key to a normalized fingerprint.

fn update_managed_session<'life0, 'life1, 'async_trait>( &'life0 self, command: UpdateManagedSession, command_fingerprint: &'life1 str, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<SessionRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Apply an allowlisted session patch with expected-revision and idempotency checks.

fn acquire_session_deletion_fence<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, expected_revision: u64, fence_id: &'life2 str, requested_by: &'life3 str, idempotency_key: &'life4 str, command_fingerprint: &'life5 str, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<SessionRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

Acquire a deletion fence that blocks run, continuation, and delegation admission.

fn tombstone_session<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, fence_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<SessionRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Complete a fenced session tombstone. This never purges retained evidence.

fn session_continuation_fence<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, namespace_id: &'life1 str, session_id: &'life2 SessionId, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<SessionContinuationFence>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load the deletion/continuation fence used by async supervisors before side effects.

fn acquire_run_admission<'life0, 'async_trait>( &'life0 self, request: AcquireRunAdmission, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<RunAdmissionReceipt>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Atomically persist a queued run and acquire the session’s single active lease.

fn heartbeat_run_admission<'life0, 'life1, 'async_trait>( &'life0 self, lease: &'life1 RunAdmissionLease, lease_expires_at: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<RunAdmissionLease>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Extend a lease only for its current host and fencing generation.

fn release_run_admission<'life0, 'life1, 'async_trait>( &'life0 self, lease: &'life1 RunAdmissionLease, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Release a lease after terminal run durability; stale generations cannot release a new owner.

fn load_run_admission<'life0, 'life1, 'async_trait>( &'life0 self, target: &'life1 ManagedRunTarget, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Option<RunAdmissionLease>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load durable admission truth for a composite target.

fn reconcile_expired_run_admissions<'life0, 'life1, 'async_trait>( &'life0 self, namespace_id: &'life1 str, now: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Vec<ManagedRunTarget>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Deterministically terminalize expired active leases owned by prior host instances.

fn load_control_receipt<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, target: &'life1 ManagedRunTarget, idempotency_key: &'life2 str, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Option<DurableControlReceipt>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load a durable control receipt by composite target and idempotency key.

fn reserve_control_receipt<'life0, 'async_trait>( &'life0 self, receipt: DurableControlReceipt, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<DurableControlReceipt>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Reserve or replay a durable fenced control receipt.

fn update_control_receipt_state<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, receipt_id: &'life1 str, state: &'life2 str, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<DurableControlReceipt>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Record the final accepted/failed effect state for a reserved receipt.

fn drain_background_subagent_operations<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Wait for store-owned background-subagent operations whose caller futures may have ended.

fn save_session<'life0, 'async_trait>( &'life0 self, session: SessionRecord, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Save a session record.

fn load_session<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<SessionRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load a session record.

fn list_sessions<'life0, 'async_trait>( &'life0 self, filter: SessionFilter, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Vec<SessionRecord>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List sessions by optional filter.

fn list_session_page<'life0, 'async_trait>( &'life0 self, query: SessionPageQuery, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<SessionPage>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Return one storage-bounded stable keyset page of sessions.

fn update_session_status<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, status: SessionStatus, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Update session status.

fn save_context_state<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, state: ResumableState, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Save a context state snapshot for a session.

fn save_environment_state<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, environment_state: EnvironmentStateRef, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Save an environment state reference for a session.

fn append_run<'life0, 'async_trait>( &'life0 self, run: RunRecord, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Append or replace a run record.

fn load_run<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, run_id: &'life2 RunId, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<RunRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load a run record.

fn list_runs<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Vec<RunRecord>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List runs for a session.

fn update_run_status<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, run_id: &'life2 RunId, status: RunStatus, output_preview: Option<String>, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Update run status and optional output preview through the legacy low-level path.

fn append_checkpoint<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, checkpoint: AgentCheckpoint, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Append a full runtime checkpoint.

fn load_checkpoints<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, run_id: &'life2 RunId, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Vec<AgentCheckpoint>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load checkpoints for a run in insertion order.

fn append_stream_records<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, run_id: &'life2 RunId, records: Vec<AgentStreamRecord>, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Append runtime stream records used as resume evidence.

fn replay_stream_records<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, run_id: &'life2 RunId, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Vec<AgentStreamRecord>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Replay runtime stream records for a run.

fn replay_stream_records_after<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, run_id: &'life2 RunId, after_sequence: Option<usize>, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Vec<AgentStreamRecord>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Replay runtime stream records after a sequence cursor.

fn save_stream_cursor<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, run_id: &'life2 RunId, cursor: StreamCursorRef, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Store a stream cursor reference for a run and session.

fn append_approval<'life0, 'async_trait>( &'life0 self, approval: ApprovalRecord, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Append an approval record.

fn load_approvals<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, run_id: &'life2 RunId, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Vec<ApprovalRecord>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load approval records for a run.

fn append_deferred_tool<'life0, 'async_trait>( &'life0 self, record: DeferredToolRecord, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Append a deferred tool record.

fn load_deferred_tools<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, run_id: &'life2 RunId, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Vec<DeferredToolRecord>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load deferred tool records for a run.

fn compact_run_trace<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, run_id: &'life2 RunId, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<CompactRunTrace>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Return compact run trace projection.

fn compact_session_trace<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<CompactSessionTrace>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Return compact session trace projection.

fn commit_run_evidence_fenced<'life0, 'life1, 'async_trait>( &'life0 self, lease: &'life1 RunAdmissionLease, commit: RunEvidenceCommit, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<RunRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Atomically persist a complete run evidence bundle under an active admission lease.

fn append_replay_events_fenced<'life0, 'life1, 'async_trait>( &'life0 self, lease: &'life1 RunAdmissionLease, events: Vec<ReplayEvent>, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Atomically append a replay-event batch under an active admission lease.

fn commit_checkpoint_fenced<'life0, 'life1, 'async_trait>( &'life0 self, lease: &'life1 RunAdmissionLease, checkpoint: AgentCheckpoint, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Persist one runtime checkpoint under an active admission lease.

fn enqueue_host_event_publications<'life0, 'async_trait>( &'life0 self, publications: Vec<PendingHostEventPublication>, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Atomically enqueue view-independent host-event publications.

fn pending_host_event_publications<'life0, 'async_trait>( &'life0 self, limit: usize, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Vec<PendingHostEventPublication>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List a bounded oldest-first batch of host-event outbox entries.

fn materialize_host_event_publications<'life0, 'async_trait>( &'life0 self, limit: usize, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Vec<DurableHostEventRecord>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Idempotently materialize a bounded outbox batch into the canonical durable event log.

fn replay_host_events<'life0, 'async_trait>( &'life0 self, query: DurableHostEventQuery, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<DurableHostEventPage>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Replay a bounded, class-filtered durable host-event page.

fn host_event_fence<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, scope: &'life1 DurableHostEventScope, event_classes: &'life2 [DurableHostEventClass], ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Option<u64>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Capture the latest eligible durable backend position for one scope and class set.

fn create_session_idempotent_with_host_events<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session: SessionRecord, idempotency_key: &'life1 str, command_fingerprint: &'life2 str, publications: Vec<PendingHostEventPublication>, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<SessionRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Atomically create a session, bind its idempotency receipt, and enqueue host events.

fn load_session_mutation_receipt<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, namespace_id: &'life1 str, idempotency_key: &'life2 str, command_fingerprint: &'life3 str, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Option<SessionRecord>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Read a session mutation receipt without creating or changing durable state.

fn update_managed_session_with_host_events<'life0, 'life1, 'async_trait>( &'life0 self, command: UpdateManagedSession, command_fingerprint: &'life1 str, publications: Vec<PendingHostEventPublication>, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<SessionRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Apply an allowlisted session patch and enqueue host events in the same atomic mutation.

fn tombstone_session_idempotent_with_host_events<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, fence_id: &'life2 str, idempotency_key: &'life3 str, command_fingerprint: &'life4 str, publications: Vec<PendingHostEventPublication>, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<SessionRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Complete a fenced tombstone while replacing its idempotency receipt and enqueuing events.

fn load_run_admission_receipt<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, namespace_id: &'life1 str, idempotency_key: &'life2 str, command_fingerprint: &'life3 str, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Option<RunAdmissionReceipt>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Read an admission idempotency receipt without creating or changing durable state.

fn update_run_status_fenced<'life0, 'life1, 'async_trait>( &'life0 self, lease: &'life1 RunAdmissionLease, status: RunStatus, output_preview: Option<String>, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<RunRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Update one admitted run to an active status while validating its lease atomically.

fn finalize_run_admission<'life0, 'life1, 'async_trait>( &'life0 self, lease: &'life1 RunAdmissionLease, terminal: RunTerminalProjection, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<RunRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Atomically persist a non-active status and release its matching admission lease.

fn admit_run_control<'life0, 'async_trait>( &'life0 self, request: AdmitRunControl, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<DurableRunControlIntent>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Atomically reserve an authority/key/fingerprint-bound receipt and durable effect intent.

fn load_run_control_intent<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, target: &'life1 ManagedRunTarget, operation_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Option<DurableRunControlIntent>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load one durable control effect by target and deterministic operation id.

fn list_run_control_intents<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, target: &'life1 ManagedRunTarget, statuses: &'life2 [DurableRunControlStatus], limit: usize, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Vec<DurableRunControlIntent>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

List a bounded oldest-first control inbox for recovery and delivery.

fn advance_run_control_intent<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, lease: &'life1 RunAdmissionLease, operation_id: &'life2 str, expected: DurableRunControlStatus, next: DurableRunControlStatus, occurred_at: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<DurableRunControlIntent>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Monotonically acknowledge runtime delivery or consumption under the exact live lease.

fn reconcile_run_control_intent<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, target: &'life1 ManagedRunTarget, operation_id: &'life2 str, occurred_at: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<DurableRunControlIntent>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Mark a pending, delivered, or consumed intent reconciled during terminal/stale recovery.

fn record_background_subagent_acceptance<'life0, 'async_trait>( &'life0 self, record: BackgroundSubagentRecord, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<BackgroundSubagentRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Idempotently persist one accepted durable background-subagent attempt.

fn update_background_subagent_execution<'life0, 'async_trait>( &'life0 self, record: BackgroundSubagentRecord, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<BackgroundSubagentRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Persist a monotonic non-terminal lifecycle transition or child-run correlation.

fn heartbeat_background_subagent<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, attempt_id: &'life1 SubagentAttemptId, host_instance_id: &'life2 str, fencing_generation: u64, lease_expires_at: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<BackgroundSubagentRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Extend an active background execution lease for its current fenced owner.

fn commit_background_subagent_terminal<'life0, 'async_trait>( &'life0 self, commit: BackgroundSubagentTerminalCommit, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<BackgroundSubagentRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Atomically persist terminal evidence and its optional oversized-result artifact.

fn load_background_subagent_artifact<'life0, 'life1, 'async_trait>( &'life0 self, artifact_ref: &'life1 str, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<BackgroundSubagentArtifact>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load one retained background-result artifact by stable reference.

fn expire_background_subagent_retention<'life0, 'life1, 'async_trait>( &'life0 self, namespace_id: &'life1 str, now: DateTime<Utc>, limit: usize, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Vec<BackgroundSubagentRecord>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Expire retained background-result content while preserving minimal audit evidence.

fn record_background_subagent_terminal<'life0, 'async_trait>( &'life0 self, record: BackgroundSubagentRecord, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<BackgroundSubagentRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Idempotently persist immutable terminal outcome before delivery becomes claimable.

fn load_background_subagent<'life0, 'life1, 'async_trait>( &'life0 self, attempt_id: &'life1 SubagentAttemptId, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<BackgroundSubagentRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load one durable background attempt by globally unique attempt identity.

fn list_background_subagents<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, namespace_id: &'life1 str, session_id: Option<&'life2 SessionId>, limit: usize, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Vec<BackgroundSubagentRecord>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

List bounded durable background attempts in one host namespace and optional session.

fn list_pending_background_subagents<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, namespace_id: &'life1 str, session_id: Option<&'life2 SessionId>, limit: usize, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Vec<BackgroundSubagentRecord>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

List terminal results still awaiting or holding logical delivery ownership.

fn claim_background_subagent_delivery<'life0, 'life1, 'async_trait>( &'life0 self, attempt_id: &'life1 SubagentAttemptId, claim: DurableBackgroundSubagentDeliveryClaim, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<BackgroundSubagentRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Atomically claim one terminal result, allowing exact-claim idempotent replay.

fn acknowledge_background_subagent_delivery<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, attempt_id: &'life1 SubagentAttemptId, claim_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<BackgroundSubagentRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Acknowledge one matching claim as logically delivered.

fn release_background_subagent_delivery<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, attempt_id: &'life1 SubagentAttemptId, claim_id: &'life2 str, release: DurableBackgroundSubagentDeliveryRelease, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<BackgroundSubagentRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Release one matching claim with a durable retry or consumer-termination disposition.

fn acquire_background_subagent_continuation<'life0, 'async_trait>( &'life0 self, request: AcquireBackgroundSubagentContinuation, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<BackgroundSubagentContinuationReceipt>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Atomically admit a continuation run and consume its background result exactly once.

fn reconcile_background_subagents<'life0, 'life1, 'async_trait>( &'life0 self, namespace_id: &'life1 str, now: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Vec<BackgroundSubagentRecord>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Classify lost in-process executions and reclaim expired delivery claims after restart.

fn latest_checkpoint<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, run_id: &'life2 RunId, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<Option<AgentCheckpoint>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load the latest checkpoint for a run.

fn resume_snapshot<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, run_id: &'life2 RunId, ) -> Pin<Box<dyn Future<Output = SessionStoreResult<SessionResumeSnapshot>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load a resume snapshot from session, checkpoint, and stream evidence.

fn prepare_continuation<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, run_id: &'life2 RunId, mode: ContinuationPreparationMode, ) -> Pin<Box<dyn Future<Output = Result<PreparedContinuation, SessionStoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: 'async_trait,

Load and side-effect-free prepare one host-neutral continuation package.