Trait SessionStore 

pub trait SessionStore: Send + Sync {
    // Required methods
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;

    // Provided methods
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 = SessionStoreResult<PreparedContinuation>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
}

Durable session store contract.

Required Methods

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.

Implementations must leave either the complete previous state or the complete committed state visible. One successful logical commit advances each changed existing run exactly once (new runs begin at revision one), and atomically enqueues authoritative run/output host publications. Identical retries are idempotent and conflicting retries must fail.

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.

This is the executor write path. Implementations must not expose a session or run without the checkpoint when the operation fails. Exact checkpoint retries are idempotent and conflicting retries fail.

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.

A new record retains its supplied creation and update evidence; updating an existing record assigns the store’s current update time and advances its revision.

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.

A zero sequence_no requests atomic session-local allocation. Replacing an existing run must preserve its assigned sequence; an explicit attempt to change that sequence fails.

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.

Implementations synthesize a generic durable diagnostic for failed and cancelled writes. Admission-owned terminal transitions must use Self::finalize_run_admission.

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

Provided Methods

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.

Implementations must validate the admission identity and fencing generation in the same transaction as the evidence write. Exact evidence retries may succeed after release, but a new or conflicting write from an expired or stale owner must fail.

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.

Every event must use the run-local scope for the admitted run. Implementations must validate the active admission identity, host, target, generation, and expiry in the same transaction as the inserts. Exact retries are idempotent; a different event at an occupied sequence conflicts and leaves the entire batch unchanged.

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.

The store must validate the lease in the same transaction as a new checkpoint write.

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.

A run may have at most one active claim. Claims are consumed by the related-run update in Self::commit_run_evidence.

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.

Stores must verify the exact current lease, its expiry, the target run’s source binding, and the matching Admitted claim in one operation before advancing the claim to Started.

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.

An Admitted claim proves no approved effect can have run, so this terminalizes only the replacement and consumes the claim while leaving the source waiting. Started is reported without mutation: callers must instead persist fail-closed related-run evidence.

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

Exact retries are idempotent. Reusing a publication key or event identity with different evidence must fail without inserting any member of the batch.

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.

Position allocation, exact-conflict checks, durable inserts, and outbox deletion occur in one transaction. Returned records are durable before this method completes.

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

Exact retries validate and deduplicate the supplied publications. A fingerprint or event conflict leaves the session, receipt, and outbox unchanged.

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

The key and fingerprint must match the receipt written when the deletion fence was acquired. Exact retries are idempotent and validate the same event publications.

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

Terminal transitions must use Self::finalize_run_admission so status, output, and diagnostics cannot be persisted independently.

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.

If complete terminal evidence was already committed under the active lease, that evidence is authoritative: finalization releases only the matching lease and ignores a differing process-local fallback outcome. An exact retry after a successful commit is idempotent. A stale owner cannot overwrite a different terminal result or release a newer generation.

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.

When an expired lease belongs to a waiting-HITL replacement whose source still waits, the replacement and source must both become cancelled, the exact started source claim must be validated and consumed, the admission must be removed, and session active-run state must be cleared as one atomic operation. Any mismatch fails closed without exposing a partial transition. Ordinary expired admissions retain the same replacement-only terminalization.

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.

Implementations must validate the exact live admission lease in the same transaction as both records. Exact retries return the original intent; any identity or payload mismatch fails without changing the receipt or inbox. No runtime effect may occur before success.

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.

The store validates admission id, host, target, generation, and expiry in the same transaction as the state update. Exact state retries are idempotent.

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

Implementations that detach non-cancellable database or network work must retain and drain that work here. Cancellation-safe implementations must explicitly return success; the default fails closed so a store cannot accidentally claim a complete shutdown guarantee.

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 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 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 = SessionStoreResult<PreparedContinuation>> + Send + 'async_trait>>

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

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

Implementations should normally rely on this default so every product applies the same snapshot identity and waiting-HITL evidence validation before admission or claim changes.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl SessionStore for InMemorySessionStore