Struct SqliteAgentMemoryStore 

pub struct SqliteAgentMemoryStore { /* private fields */ }

Bundled SQLite store. Cheap to clone; connections are cached per realm and shared across clones.

Implementations

impl SqliteAgentMemoryStore

pub fn open(root: impl Into<PathBuf>) -> Result<Self, AgentMemoryError>

pub fn path_for_realm(&self, realm: &str) -> PathBuf

Same directory + percent-encoding scheme as MarkdownAgentMemoryStore::path_for, one database per realm.

impl SqliteAgentMemoryStore

pub async fn resolve_dream_audit_verdicts( &self, realm: &str, record_id: &str, resolution: &str, ) -> Result<usize, AgentMemoryError>

Resolve every open audit verdict for record_id (the operator acted: superseded/retired/dismissed via the review queue).

Deliberately NOT on StewardStore/MemoryPanelStore: no production caller exists yet (the operator review-queue mutation is a reserved seam); it joins the capability trait with its first consumer.

Trait Implementations

impl AgentMemoryProvider for SqliteAgentMemoryStore

fn recall<'life0, 'async_trait>( &'life0 self, request: AgentMemoryRecallRequest, ) -> Pin<Box<dyn Future<Output = Result<Vec<AgentMemoryRecord>, AgentMemoryError>> + Send + 'async_trait>>

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

fn supports_remember(&self) -> bool

fn remember<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, realm: &'life1 str, identity: &'life2 AgentIdentity, memory: NewAgentMemory, ) -> Pin<Box<dyn Future<Output = Result<AgentMemoryRecord, AgentMemoryError>> + Send + 'async_trait>>

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

fn supports_forget(&self) -> bool

fn forget<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, realm: &'life1 str, identity: &'life2 AgentIdentity, memory_id: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<AgentMemoryForgetResult, AgentMemoryError>> + Send + 'async_trait>>

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

fn manifest<'life0, 'life1, 'async_trait>( &'life0 self, scopes: &'life1 [MemoryScope], tier: ManifestTier, ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordMeta>, AgentMemoryError>> + Send + 'async_trait>>

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

Metadata manifest over the composed scopes (§8.3). WorkingSet(k) is the union of the top-K ranked records and the recent/unranked slice; Full is every active record’s metadata.

fn supports_manifest(&self) -> bool

fn supersede<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, scope: &'life1 MemoryScope, prior: &'life2 str, record: NewMemoryRecord, ) -> Pin<Box<dyn Future<Output = Result<MemoryId, AgentMemoryError>> + Send + 'async_trait>>

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

Update-in-place with history (fixes D4): the new record supersedes prior within its lineage and inherits its working-set rank.

fn supports_supersede(&self) -> bool

fn mark_usage<'life0, 'life1, 'async_trait>( &'life0 self, ids: &'life1 [MemoryId], event: UsageEvent, ) -> Pin<Box<dyn Future<Output = Result<(), AgentMemoryError>> + Send + 'async_trait>>

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

Mechanical usage-ledger updates (§9.2). Deliberately flag-less: it is an internal coordinator surface, not an advertised RPC capability.

fn log_injections<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, realm: &'life1 str, entries: &'life2 [InjectionLogEntry], ) -> Pin<Box<dyn Future<Output = Result<(), AgentMemoryError>> + Send + 'async_trait>>

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

Injection-ledger append (§9.2): which records entered whose context, through which surface, when. Internal coordinator telemetry — default no-op (not an error) so simple providers like the markdown store need no capability flag and the coordinator never has to care.

fn propose<'life0, 'life1, 'async_trait>( &'life0 self, scope: &'life1 MemoryScope, record: NewMemoryRecord, author: MemoryAuthor, ) -> Pin<Box<dyn Future<Output = Result<ProposalId, AgentMemoryError>> + Send + 'async_trait>>

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

Queue a record for steward-committed scopes (mob/operator — §7.2 write authority). author is the proposing principal — the Recorder proposes with real MemoryAuthor::Agent authorship (§8.2), the RPC path with Application.

fn supports_propose(&self) -> bool

fn remember_authored<'life0, 'life1, 'async_trait>( &'life0 self, scope: &'life1 MemoryScope, record: NewMemoryRecord, author: MemoryAuthor, ) -> Pin<Box<dyn Future<Output = Result<AuthoredWriteReceipt, AgentMemoryError>> + Send + 'async_trait>>

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

Agent-authored create in scope. Default-unsupported: the Recorder only registers against providers that implement this.

fn supersede_authored<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, scope: &'life1 MemoryScope, prior: &'life2 str, record: NewMemoryRecord, author: MemoryAuthor, ) -> Pin<Box<dyn Future<Output = Result<AuthoredWriteReceipt, AgentMemoryError>> + Send + 'async_trait>>

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

Agent-authored supersede within a single record’s lineage in the author’s own writable scope (§8.2). Cross-scope updates are a validator reject, not a policy the caller can waive.

fn forget_authored<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, scope: &'life1 MemoryScope, memory_id: &'life2 str, author: MemoryAuthor, ) -> Pin<Box<dyn Future<Output = Result<AgentMemoryForgetResult, AgentMemoryError>> + Send + 'async_trait>>

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

Agent-authored tombstone in the author’s own scope.

fn supports_authored_writes(&self) -> bool

fn as_taintable(&self) -> Option<Arc<dyn TaintableStore>>

§10.1 firewall control surface, when this provider supports gate/sink/resolver installation.

fn as_steward_store(&self) -> Option<Arc<dyn StewardStore>>

§8.5 steward dream read/write surface.

fn as_memory_panel_store(&self) -> Option<Arc<dyn MemoryPanelStore>>

§9.3 console Memory panel read API.

fn as_selected_record_fetch(&self) -> Option<Arc<dyn SelectedRecordFetch>>

§8.3 Selector body fetch for selector-chosen record ids.

fn as_tombstone_source(&self) -> Option<Arc<dyn TombstoneSource>>

§8.4 Distiller tombstone reads (recently tombstoned records per scope, for dedup against re-distillation).

impl Clone for SqliteAgentMemoryStore

fn clone(&self) -> SqliteAgentMemoryStore

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl MemoryPanelStore for SqliteAgentMemoryStore

fn panel_realms<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, AgentMemoryError>> + Send + 'async_trait>>

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

Realms with store state (panel realm picker).

fn record_by_id<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, realm: &'life1 str, memory_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<MemoryRecord>, AgentMemoryError>> + Send + 'async_trait>>

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

One record by id, any status.

fn records_page<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, realm: &'life1 str, scope_kind: Option<&'life2 str>, scope_key: Option<&'life3 str>, status_kind: Option<&'life4 str>, limit: usize, cursor: Option<(u64, String)>, ) -> Pin<Box<dyn Future<Output = Result<PanelRecordsPage, AgentMemoryError>> + Send + 'async_trait>>

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

Panel record listing: optional scope/status filters, newest-updated first, keyset cursor. Any status is visible here — the panel is an inspection surface and renders status explicitly.

fn supersede_chain<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, realm: &'life1 str, memory_id: &'life2 str, max_len: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<MemoryRecord>, AgentMemoryError>> + Send + 'async_trait>>

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

Supersede lineage around one record, oldest first: ancestors via the supersedes pointer, the record itself, then committed successors via the Superseded { by } status link. When the tip has no committed successor, records claiming to supersede it (e.g. a quarantined supersede that left the prior active, §10.1) are appended without recursing — claims are visible but never extend the walk. Bounded by max_len, cycle-safe.

fn injection_log_for_record<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, realm: &'life1 str, record_id: &'life2 str, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<InjectionLogEntry>, AgentMemoryError>> + Send + 'async_trait>>

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

Newest-first injection-ledger rows for one record (panel usage view).

fn dream_runs<'life0, 'life1, 'async_trait>( &'life0 self, realm: &'life1 str, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<PersistedDreamRun>, AgentMemoryError>> + Send + 'async_trait>>

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

Persisted dream runs, newest first.

fn open_dream_audit_verdicts<'life0, 'life1, 'async_trait>( &'life0 self, realm: &'life1 str, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<DreamAuditVerdict>, AgentMemoryError>> + Send + 'async_trait>>

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

Open (unresolved) audit verdicts, newest first — the operator review queue. One row per (run, record); the console dedups by record.

fn dream_history<'life0, 'life1, 'async_trait>( &'life0 self, realm: &'life1 str, max_runs: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<DreamRunAudit>, AgentMemoryError>> + Send + 'async_trait>>

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

Dream-run summaries reconstructed from steward audit rows, newest run first. Bounded scan; runs older than the scan window fall off the panel, which is acceptable for a history summary surface.

impl SelectedRecordFetch for SqliteAgentMemoryStore

Body fetch for selector-chosen ids (§8.3): a plain by-id read over the composed scopes, wire-compat projected, returned in ids order. Only active records in the requested scopes qualify — the selector judged a manifest of exactly those.

fn fetch_records<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, scopes: &'life1 [MemoryScope], ids: &'life2 [String], ) -> Pin<Box<dyn Future<Output = Result<Vec<AgentMemoryRecord>, AgentMemoryError>> + Send + 'async_trait>>

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

fn fetch_records_annotated<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, scopes: &'life1 [MemoryScope], ids: &'life2 [String], ) -> Pin<Box<dyn Future<Output = Result<Vec<AnnotatedRecord>, AgentMemoryError>> + Send + 'async_trait>>

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

Bodies plus §7.2 provenance labels. The default delegates to Self::fetch_records with no provenance so existing stores keep compiling; stores that know each record’s scope and trust tier should override so injected bodies carry their labels.

impl StagedMemoryStore for SqliteAgentMemoryStore

fn stage<'life0, 'async_trait>( &'life0 self, batch: StagedMutationBatch, ) -> Pin<Box<dyn Future<Output = Result<StageToken, AgentMemoryError>> + Send + 'async_trait>>

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

Validate the batch against current store state and persist it, unapplied, under a token. Stale tokens are garbage-collected.

fn commit<'life0, 'async_trait>( &'life0 self, token: StageToken, ) -> Pin<Box<dyn Future<Output = Result<CommitReceipt, AgentMemoryError>> + Send + 'async_trait>>

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

Re-validate and apply the staged batch in a single transaction, writing one audit entry per op and burning the token.

impl StewardStore for SqliteAgentMemoryStore

fn scope_floors(&self) -> (usize, usize)

The per-scope retention floors this store warns against (§7.3); rendered into the dream’s orient overview as floor pressure.

fn scope_overview<'life0, 'life1, 'async_trait>( &'life0 self, realm: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<ScopeOverview>, AgentMemoryError>> + Send + 'async_trait>>

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

Per-scope counts and byte totals for a realm — the orient phase’s one cheap aggregate.

fn pending_proposals<'life0, 'life1, 'async_trait>( &'life0 self, realm: &'life1 str, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<PendingProposal>, AgentMemoryError>> + Send + 'async_trait>>

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

Pending/held proposals, oldest first (§8.5 promotion queue).

fn set_proposal_status<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, realm: &'life1 str, proposal_id: &'life2 str, status: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<(), AgentMemoryError>> + Send + 'async_trait>>

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

Record a dream verdict on a proposal: accepted, rejected, or held (held stays in the pending queue for the next dream).

fn quarantined_records<'life0, 'life1, 'async_trait>( &'life0 self, realm: &'life1 str, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<MemoryRecord>, AgentMemoryError>> + Send + 'async_trait>>

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

Quarantined records, newest first — the dream’s review queue (§8.5). The steward is the one stage that reads these bodies wholesale; the caller renders them defanged.

fn records_by_ids<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, realm: &'life1 str, ids: &'life2 [String], ) -> Pin<Box<dyn Future<Output = Result<Vec<MemoryRecord>, AgentMemoryError>> + Send + 'async_trait>>

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

Records by id, any status — the gather phase’s bounded body fetch. Missing ids are skipped (the model may cite stale ids).

fn recent_records<'life0, 'life1, 'async_trait>( &'life0 self, realm: &'life1 str, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<MemoryRecord>, AgentMemoryError>> + Send + 'async_trait>>

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

Most recently updated records in a realm, any scope, active or quarantined — the gather phase filters (e.g. recent distillates by author) host-side.

fn injection_log<'life0, 'life1, 'async_trait>( &'life0 self, realm: &'life1 str, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<InjectionLogEntry>, AgentMemoryError>> + Send + 'async_trait>>

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

Newest-first injection-ledger rows for a realm (§9.2). Read surface for the steward’s usage audit and the console Memory panel.

fn record_pending_harvest<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, realm: &'life1 str, identity: &'life2 str, session_key: Option<&'life3 str>, cause: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<(), AgentMemoryError>> + Send + 'async_trait>>

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

Record a retired identity for the next dream’s exit-interview harvest (§8.5). Idempotent per (identity, retired_at_ms).

fn pending_harvests<'life0, 'life1, 'async_trait>( &'life0 self, realm: &'life1 str, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<PendingHarvest>, AgentMemoryError>> + Send + 'async_trait>>

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

Pending exit-interview harvests, oldest first.

fn mark_harvest_complete<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, realm: &'life1 str, identity: &'life2 str, retired_at_ms: u64, ) -> Pin<Box<dyn Future<Output = Result<(), AgentMemoryError>> + Send + 'async_trait>>

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

Mark one exit-interview harvest done.

fn record_pending_promotion<'life0, 'life1, 'async_trait>( &'life0 self, realm: &'life1 str, promotion: PendingPromotion, ) -> Pin<Box<dyn Future<Output = Result<(), AgentMemoryError>> + Send + 'async_trait>>

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

Record a gated quarantine-promotion: gating pending_id → staged batch token (§10.2). Only a gating approval commits the token.

fn pending_promotion_by_id<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, realm: &'life1 str, pending_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<PendingPromotion>, AgentMemoryError>> + Send + 'async_trait>>

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

Look up a still-pending gated promotion by its gating pending id.

fn pending_promotions<'life0, 'life1, 'async_trait>( &'life0 self, realm: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<PendingPromotion>, AgentMemoryError>> + Send + 'async_trait>>

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

All still-pending gated promotions (dream-start reconciliation).

fn resolve_pending_promotion<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, realm: &'life1 str, pending_id: &'life2 str, status: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<(), AgentMemoryError>> + Send + 'async_trait>>

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

Resolve a gated promotion: committed, denied, or expired.

fn rekey_pending_promotion<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, realm: &'life1 str, old_pending_id: &'life2 str, new_pending_id: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<(), AgentMemoryError>> + Send + 'async_trait>>

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

Re-key a gated promotion after a gating escalation minted a successor pending entry.

fn discard_stage<'life0, 'async_trait>( &'life0 self, token: StageToken, ) -> Pin<Box<dyn Future<Output = Result<(), AgentMemoryError>> + Send + 'async_trait>>

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

Discard a staged-but-uncommitted batch (denied/expired gated promotions; §8.5 crash semantics keep this safe — an unapplied stage row is never visible).

fn save_dream_run<'life0, 'life1, 'async_trait>( &'life0 self, realm: &'life1 str, run: PersistedDreamRun, ) -> Pin<Box<dyn Future<Output = Result<(), AgentMemoryError>> + Send + 'async_trait>>

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

Persist one completed dream run (idempotent on run_id).

fn save_dream_audit_verdicts<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, realm: &'life1 str, run_id: &'life2 str, verdicts: Vec<(String, String, String)>, ) -> Pin<Box<dyn Future<Output = Result<(), AgentMemoryError>> + Send + 'async_trait>>

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

Record the usage-audit verdicts of one dream run. Only non-clean verdicts belong here (the review queue); load-bearing records are counted in the run detail, not queued.

impl TaintableStore for SqliteAgentMemoryStore

§10.1 firewall control surface. The gate/resolver/sink slots are shared across clones (inner Arc<Mutex<..>>), so wiring once covers every handle.

fn set_llm_write_gate(&self, gate: Arc<dyn LlmWriteGate>)

Install the §10.1 LLM write gate. Wiring installs it at startup, before any member can dispatch a write.

fn set_llm_write_gate_if_absent(&self, gate: Arc<dyn LlmWriteGate>) -> bool

Install the §10.1 gate only when none is present. Returns whether this call installed the gate.

fn set_evidence_resolver(&self, resolver: Arc<dyn EvidenceRefResolver>)

Install the §10.2 evidence-ref resolver. The steward wiring installs it at startup; from then on every staged retier to agent_verified must cite evidence that resolves against the session store.

fn set_event_sink(&self, sink: Arc<dyn MemoryEventSink>)

Wire the §9.3 timeline sink for quarantined-write events.

fn set_event_sink_if_absent(&self, sink: Arc<dyn MemoryEventSink>) -> bool

Wire the §9.3 sink only when none is present. Returns whether this call installed the sink.

impl TombstoneSource for SqliteAgentMemoryStore

fn recent_tombstones<'life0, 'life1, 'async_trait>( &'life0 self, scope: &'life1 MemoryScope, since_ms: u64, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<TombstoneMeta>, AgentMemoryError>> + Send + 'async_trait>>

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

Recent tombstones for the Distiller’s pre-injected “never re-create these” list (§8.4). The mechanical backstop for exact recreation is the staged validator’s content-hash check; this list closes the paraphrase gap at the prompt level.