Struct SqliteProcessRegistry 

pub struct SqliteProcessRegistry { /* private fields */ }

SQLite-backed process registry for one configured runtime deployment.

It is intentionally separate from Store: session databases persist one conversation, while this registry persists background process state and handle visibility across all sessions sharing the registry.

Implementations

impl SqliteProcessRegistry

pub async fn open( path: &Path, session_store_root: impl Into<PathBuf>, ) -> Result<Self>

Open a process registry whose terminal-retention prune removes the two process-owned session stores from session_store_root before the process row. The root is required and explicit; no sibling-directory convention is inferred.

pub async fn open_with_clock( path: &Path, clock: Arc<dyn Clock>, session_store_root: impl Into<PathBuf>, ) -> Result<Self>

pub async fn memory() -> Result<Self>

pub async fn memory_with_clock(clock: Arc<dyn Clock>) -> Result<Self>

Trait Implementations

impl ProcessRegistry for SqliteProcessRegistry

fn durability_tier(&self) -> DurabilityTier

Durability tier this process registry provides; defaults to DurabilityTier::Inline.

fn register_process<'life0, 'async_trait>( &'life0 self, registration: ProcessRegistration, ) -> Pin<Box<dyn Future<Output = Result<ProcessRecord, PluginError>> + Send + 'async_trait>>

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

fn put_segment_handover<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, handover: PersistedSegmentHandover, ) -> Pin<Box<dyn Future<Output = Result<(), PluginError>> + Send + 'async_trait>>

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

Persist the bounded engine continuation for exactly one segment. Repeating an identical write is an idempotent no-op; conflicting data for the same (process_id, segment_ordinal) is rejected.

fn get_segment_handover<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, segment_ordinal: u64, ) -> Pin<Box<dyn Future<Output = Result<Option<PersistedSegmentHandover>, PluginError>> + Send + 'async_trait>>

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

Load the continuation for an exact process segment ordinal.

fn latest_segment_handover<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<PersistedSegmentHandover>, PluginError>> + Send + 'async_trait>>

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

Load the highest persisted segment ordinal for recovery.

fn delete_segment_handovers<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), PluginError>> + Send + 'async_trait>>

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

Remove all cross-segment execution state once the process is terminal.

fn set_external_ref<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, external_ref: ProcessExternalRef, ) -> Pin<Box<dyn Future<Output = Result<ProcessRecord, PluginError>> + Send + 'async_trait>>

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

Attach a durable backend reference to a registered process.

fn grant_handle<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_scope: &'life1 SessionScope, process_id: &'life2 str, descriptor: ProcessHandleDescriptor, ) -> Pin<Box<dyn Future<Output = Result<ProcessHandleGrant, PluginError>> + Send + 'async_trait>>

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

fn revoke_handle<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_scope: &'life1 SessionScope, process_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), PluginError>> + Send + 'async_trait>>

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

fn transfer_handle_grants<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, from_scope: &'life1 SessionScope, to_scope: &'life2 SessionScope, process_ids: &'life3 [String], ) -> Pin<Box<dyn Future<Output = Result<(), PluginError>> + Send + 'async_trait>>

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

fn list_handle_grants<'life0, 'life1, 'async_trait>( &'life0 self, session_scope: &'life1 SessionScope, ) -> Pin<Box<dyn Future<Output = Result<Vec<ProcessHandleGrantEntry>, PluginError>> + Send + 'async_trait>>

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

fn list_live_handle_grants<'life0, 'life1, 'async_trait>( &'life0 self, session_scope: &'life1 SessionScope, ) -> Pin<Box<dyn Future<Output = Result<Vec<ProcessHandleGrantEntry>, PluginError>> + Send + 'async_trait>>

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

fn has_handle_grant<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_scope: &'life1 SessionScope, process_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<bool, PluginError>> + Send + 'async_trait>>

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

fn handle_grants_for_process<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<ProcessHandleGrant>, PluginError>> + Send + 'async_trait>>

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

fn delete_session_process_state<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<ProcessSessionDeleteReport, PluginError>> + Send + 'async_trait>>

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

fn append_event<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, request: ProcessEventAppendRequest, ) -> Pin<Box<dyn Future<Output = Result<ProcessEventAppendResult, PluginError>> + Send + 'async_trait>>

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

fn events_after<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, after_sequence: u64, ) -> Pin<Box<dyn Future<Output = Result<Vec<ProcessEvent>, PluginError>> + Send + 'async_trait>>

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

fn count_events_through<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, process_id: &'life1 str, event_type: &'life2 str, up_to_sequence: u64, ) -> Pin<Box<dyn Future<Output = Result<u64, PluginError>> + Send + 'async_trait>>

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

Count events of event_type with sequence <= up_to_sequence.

fn recent_events<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<ProcessEvent>, PluginError>> + Send + 'async_trait>>

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

The most recent limit events, in ascending sequence order.

fn wake_events_after<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, after_sequence: u64, ) -> Pin<Box<dyn Future<Output = Result<Vec<ProcessEvent>, PluginError>> + Send + 'async_trait>>

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

fn complete_process<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, await_output: ProcessAwaitOutput, authority: ProcessCompletionAuthority, ) -> Pin<Box<dyn Future<Output = Result<ProcessRecord, PluginError>> + Send + 'async_trait>>

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

Complete a process without a Lash process lease, under an explicit, auditable completion authority.

fn complete_process_with_lease<'life0, 'life1, 'async_trait>( &'life0 self, lease: &'life1 ProcessLease, await_output: ProcessAwaitOutput, ) -> Pin<Box<dyn Future<Output = Result<ProcessRecord, PluginError>> + Send + 'async_trait>>

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

Atomically append the terminal output while the supplied process lease is still current, then release that lease in the same transaction.

fn record_first_started<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, started: ProcessStarted, ) -> Pin<Box<dyn Future<Output = Result<ProcessRecord, PluginError>> + Send + 'async_trait>>

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

Record the durable, lease-fenced “execution started” fact (ADR 0019).

fn request_process_abandon<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, request: AbandonRequest, ) -> Pin<Box<dyn Future<Output = Result<ProcessRecord, PluginError>> + Send + 'async_trait>>

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

Set the durable, non-terminal Abandon Request marker (ADR 0019).

fn set_process_wait<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, wait: WaitState, ) -> Pin<Box<dyn Future<Output = Result<ProcessRecord, PluginError>> + Send + 'async_trait>>

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

fn clear_process_wait<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<ProcessRecord, PluginError>> + Send + 'async_trait>>

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

fn get_process<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Option<ProcessRecord>> + Send + 'async_trait>>

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

fn try_get_process<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<ProcessRecord>, PluginError>> + Send + 'async_trait>>

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

Fallible process lookup for correctness-critical execution paths where a transient store failure must not be mistaken for an absent row.

fn list_processes<'life0, 'life1, 'async_trait>( &'life0 self, filter: &'life1 ProcessListFilter, ) -> Pin<Box<dyn Future<Output = Result<Vec<ProcessRecord>, PluginError>> + Send + 'async_trait>>

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

fn processes_changed_since<'life0, 'async_trait>( &'life0 self, cursor: ProcessChangeCursor, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(Vec<ProcessRecord>, ProcessChangeCursor), PluginError>> + Send + 'async_trait>>

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

Return process records whose persisted row changed strictly after cursor, ordered by the backend’s per-store change sequence.

fn ack_wake<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, sequence: u64, ) -> Pin<Box<dyn Future<Output = Result<(), PluginError>> + Send + 'async_trait>>

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

fn list_non_terminal<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<ProcessRecord>, PluginError>> + Send + 'async_trait>>

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

All non-terminal process records, in stable process_id order.

fn filter_unregistered_process_ids<'life0, 'life1, 'async_trait>( &'life0 self, process_ids: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, PluginError>> + Send + 'async_trait>>

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

Return the candidate ids that have no persisted process row, preserving input order. Durable backends override this with one NOT EXISTS anti-join so recovery does not issue one point read per candidate.

fn live_reference_summary<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<ProcessLiveReferenceSummary>, PluginError>> + Send + 'async_trait>>

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

Count non-terminal process rows by their captured definition and execution-environment references.

fn claim_process_lease<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, process_id: &'life1 str, owner: &'life2 LeaseOwnerIdentity, lease_ttl_ms: u64, ) -> Pin<Box<dyn Future<Output = Result<ProcessLeaseClaimOutcome, PluginError>> + Send + 'async_trait>>

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

Claim the durable single-owner lease over a non-terminal process.

fn reclaim_process_lease<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, process_id: &'life1 str, owner: &'life2 LeaseOwnerIdentity, observed_holder: &'life3 ProcessLease, lease_ttl_ms: u64, ) -> Pin<Box<dyn Future<Output = Result<ProcessLeaseClaimOutcome, PluginError>> + Send + 'async_trait>>

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

Reclaim an unexpired process lease whose observed holder is definitely dead according to persisted local-process liveness metadata.

fn renew_process_lease<'life0, 'life1, 'async_trait>( &'life0 self, lease: &'life1 ProcessLease, lease_ttl_ms: u64, ) -> Pin<Box<dyn Future<Output = Result<ProcessLease, PluginError>> + Send + 'async_trait>>

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

Extend the expiry of a live lease the caller still owns.

fn get_process_lease<'life0, 'life1, 'async_trait>( &'life0 self, process_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<ProcessLease>, PluginError>> + Send + 'async_trait>>

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

Read the current lease row for a process without claiming it.

fn complete_process_lease<'life0, 'life1, 'async_trait>( &'life0 self, completion: &'life1 ProcessLeaseCompletion, ) -> Pin<Box<dyn Future<Output = Result<(), PluginError>> + Send + 'async_trait>>

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

Release a lease the caller owns, fenced by the completion’s (process_id, lease_token).

fn prune_terminal_processes<'life0, 'async_trait>( &'life0 self, cutoff_epoch_ms: u64, filter: Option<ProcessListFilter>, up_to_change_seq: Option<ProcessChangeCursor>, ) -> Pin<Box<dyn Future<Output = Result<ProcessPruneReport, PluginError>> + Send + 'async_trait>>

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

Physically delete terminal process rows whose updated_at_ms is older than cutoff_epoch_ms, match filter when one is supplied, and have a process change sequence no later than up_to_change_seq when supplied, together with their events, wake acks, handle grants, lease rows, and trigger-delivery reservations whose deterministic process id points at a pruned row. The same cutoff also prunes trigger-mutation idempotency receipts, bounding receipt retention under the host’s existing cleanup schedule. Durable backends also release attachment intents and delete the process-owned process-env:<id> and process-session-turn:<id> session stores before deleting the process row. Backends must fail toward retaining the terminal process if that cleanup cannot complete. Host-scheduled retention: hosts that project results/events into their own store call this to keep the registry bounded. Non-terminal rows are never touched. Callers must choose a retention window comfortably longer than any waiter lifetime — a pruned process id becomes “unknown process” to late awaits. Re-emitting the same trigger occurrence id after its process has aged out of retention may reserve a fresh delivery process id; occurrence-level idempotency still holds, and ordinary emit replays do not straddle a retention window in practice.