Struct MnemoEngine 

pub struct MnemoEngine {

    pub storage: Arc<dyn StorageBackend>,
    pub index: Arc<dyn VectorIndex>,
    pub embedding: Arc<dyn EmbeddingProvider>,
    pub full_text: Option<Arc<dyn FullTextIndex>>,
    pub default_agent_id: String,
    pub default_org_id: Option<String>,
    pub encryption: Option<Arc<ContentEncryption>>,
    pub cold_storage: Option<Arc<dyn ColdStorage>>,
    pub cache: Option<Arc<MemoryCache>>,
    pub embed_events: bool,
    pub ttl_working_seconds: u64,
    pub procedural_importance_floor: f32,
    pub poisoning_policy: PoisoningPolicy,
    pub provenance_signer: Option<Arc<ProvenanceSigner>>,
}

Fields

storage: Arc<dyn StorageBackend>

index: Arc<dyn VectorIndex>

embedding: Arc<dyn EmbeddingProvider>

full_text: Option<Arc<dyn FullTextIndex>>

default_agent_id: String

default_org_id: Option<String>

encryption: Option<Arc<ContentEncryption>>

cold_storage: Option<Arc<dyn ColdStorage>>

cache: Option<Arc<MemoryCache>>

embed_events: bool

ttl_working_seconds: u64

Default TTL applied to Working-tier memories whose remember request does not supply an explicit ttl_seconds. Defaults to 1 hour.

procedural_importance_floor: f32

Importance floor enforced on write for Procedural-tier memories. Defaults to 0.8.

poisoning_policy: PoisoningPolicy

Poisoning policy read by check_for_anomaly. Defaults to the v0.3.2 behaviour (no z-score outlier gate). Override with MnemoEngine::with_poisoning_policy.

provenance_signer: Option<Arc<ProvenanceSigner>>

v0.4.0-rc3 (Task B1) — when set, every recall(req) with req.with_provenance == Some(true) returns an HMAC-signed ReadProvenance receipt. None keeps the recall hot-path overhead at zero. Attach via MnemoEngine::with_provenance_signer.

Implementations

impl MnemoEngine

pub fn new( storage: Arc<dyn StorageBackend>, index: Arc<dyn VectorIndex>, embedding: Arc<dyn EmbeddingProvider>, default_agent_id: String, default_org_id: Option<String>, ) -> Self

pub fn with_provenance_signer(self, signer: Arc<ProvenanceSigner>) -> Self

Attach a provenance::ProvenanceSigner (Task B1) so callers can request signed read-receipts via RecallRequest.with_provenance = Some(true).

pub fn with_poisoning_policy(self, policy: PoisoningPolicy) -> Self

Attach a poisoning::PoisoningPolicy to the engine. See poisoning::PoisoningPolicy::with_outlier_threshold for the v0.3.3 z-score outlier gate.

pub fn with_ttl_working_seconds(self, seconds: u64) -> Self

Override the default 1-hour TTL applied to Working-tier memories when a caller does not supply an explicit ttl_seconds.

pub fn with_procedural_importance_floor(self, floor: f32) -> Self

Override the default 0.8 importance floor applied to Procedural memories on write.

pub fn with_full_text(self, ft: Arc<dyn FullTextIndex>) -> Self

pub fn with_encryption(self, enc: Arc<ContentEncryption>) -> Self

pub fn with_cold_storage(self, cs: Arc<dyn ColdStorage>) -> Self

pub fn with_cache(self, c: Arc<MemoryCache>) -> Self

pub fn with_event_embeddings(self) -> Self

pub async fn remember( &self, request: RememberRequest, ) -> Result<RememberResponse>

pub async fn recall(&self, request: RecallRequest) -> Result<RecallResponse>

pub async fn forget(&self, request: ForgetRequest) -> Result<ForgetResponse>

pub async fn forget_subject( &self, request: ForgetSubjectRequest, ) -> Result<ForgetSubjectResponse>

Subject-scoped erasure for GDPR / DPDPA compliance. See forget::forget_subject for strategy semantics.

pub async fn run_ttl_sweep(&self) -> Result<TtlReport>

Hard-delete every memory whose expires_at is in the past and emit one MemoryExpired audit event per deletion.

pub async fn run_reflection_pass( &self, agent_id: Option<String>, ) -> Result<ReflectionReport>

Auto-Dream-compatible reflection pass: date absolutization, external rewrite acceptance, semantic dedup, low-importance conflict resolution, and stale archival. See reflection::run_reflection_pass.

pub async fn run_reflection_pass_with_mode( &self, agent_id: Option<String>, mode: ReflectionMode, force: bool, ) -> Result<ReflectionReport>

Reflection pass that honours the new ReflectionMode gate (v0.3.1). Use Coordinated to avoid double-work when Auto Dream is also running.

pub async fn replay_quarantine( &self, agent_id: Option<String>, since: Option<&str>, ) -> Result<Vec<QuarantineReplayEntry>>

List quarantined memories for operator review. See poisoning::replay_quarantine.

pub async fn share(&self, request: ShareRequest) -> Result<ShareResponse>

pub async fn checkpoint( &self, request: CheckpointRequest, ) -> Result<CheckpointResponse>

pub async fn branch(&self, request: BranchRequest) -> Result<BranchResponse>

pub async fn merge(&self, request: MergeRequest) -> Result<MergeResponse>

pub async fn replay(&self, request: ReplayRequest) -> Result<ReplayResponse>

pub async fn run_decay_pass( &self, agent_id: Option<String>, archive_threshold: f32, forget_threshold: f32, ) -> Result<DecayPassResult>

pub async fn run_consolidation( &self, agent_id: Option<String>, min_cluster_size: usize, ) -> Result<ConsolidationResult>

pub async fn verify_integrity( &self, agent_id: Option<String>, thread_id: Option<&str>, ) -> Result<ChainVerificationResult>

pub async fn trace_causality( &self, event_id: Uuid, max_depth: usize, ) -> Result<CausalChain>

pub async fn trace_causality_with_options( &self, event_id: Uuid, max_depth: usize, direction: TraceDirection, event_type_filter: Option<EventType>, ) -> Result<CausalChain>

pub async fn verify_event_integrity( &self, agent_id: Option<String>, thread_id: Option<&str>, ) -> Result<ChainVerificationResult>

pub async fn detect_conflicts( &self, agent_id: Option<String>, threshold: f32, ) -> Result<ConflictDetectionResult>

pub async fn resolve_conflict( &self, conflict_pair: &ConflictPair, strategy: ResolutionStrategy, ) -> Result<()>