Crate exo_temporal 

exo-temporal: Temporal Memory Coordinator

Causal memory coordination for the EXO-AI cognitive substrate.

This crate implements temporal memory with:

• Short-term volatile buffer
• Long-term consolidated store
• Causal graph tracking antecedent relationships
• Memory consolidation with salience-based filtering
• Predictive anticipation and pre-fetching

Architecture

┌─────────────────────────────────────────────────────────┐
│                  TemporalMemory                         │
├─────────────────────────────────────────────────────────┤
│ ┌─────────────┐  ┌─────────────┐  ┌─────────────┐      │
│ │ Short-Term  │  │ Long-Term   │  │   Causal    │      │
│ │   Buffer    │→ │    Store    │  │    Graph    │      │
│ └─────────────┘  └─────────────┘  └─────────────┘      │
│        ↓                ↑                 ↑             │
│ ┌─────────────────────────────────────────────┐         │
│ │          Consolidation Engine               │         │
│ │  (Salience computation & filtering)         │         │
│ └─────────────────────────────────────────────┘         │
│        ↓                                                │
│ ┌─────────────────────────────────────────────┐         │
│ │       Anticipation & Prefetch               │         │
│ └─────────────────────────────────────────────┘         │
└─────────────────────────────────────────────────────────┘

Example

use exo_temporal::{TemporalMemory, TemporalConfig};
use exo_core::Pattern;

// Create temporal memory
let memory = TemporalMemory::new(TemporalConfig::default());

// Store pattern with causal context
let pattern = Pattern::new(vec![1.0, 2.0, 3.0], metadata);
let id = memory.store(pattern, &[]).unwrap();

// Causal query
let results = memory.causal_query(
    &query,
    reference_time,
    CausalConeType::Past,
);

// Trigger consolidation
memory.consolidate();

Re-exports

pub use anticipation::anticipate;

pub use anticipation::AnticipationHint;

pub use anticipation::PrefetchCache;

pub use anticipation::SequentialPatternTracker;

pub use anticipation::TemporalPhase;

pub use causal::CausalConeType;

pub use causal::CausalGraph;

pub use causal::CausalGraphStats;

pub use consolidation::compute_salience;

pub use consolidation::compute_salience_batch;

pub use consolidation::consolidate;

pub use consolidation::ConsolidationConfig;

pub use consolidation::ConsolidationResult;

pub use consolidation::ConsolidationStats;

pub use long_term::LongTermConfig;

pub use long_term::LongTermStats;

pub use long_term::LongTermStore;

pub use short_term::ShortTermBuffer;

pub use short_term::ShortTermConfig;

pub use short_term::ShortTermStats;

pub use types::*;

Modules

anticipation

Predictive anticipation and pre-fetching

causal

Causal graph for tracking antecedent relationships

consolidation

Memory consolidation: short-term -> long-term

long_term

Long-term consolidated memory store

short_term

Short-term volatile memory buffer

types

Core type definitions for temporal memory

Structs

TemporalConfig

Configuration for temporal memory

TemporalMemory

Temporal memory coordinator

TemporalStats

Temporal memory statistics

Enums

TemporalError

Error type for temporal memory operations

Type Aliases

Result

Result type for temporal operations