Memory Architecture

// src/memory/store/mod.rs
pub trait NoteStore: Send + Sync { /* ... */ }
pub trait RawMemoryStore: Send + Sync { /* ... */ }
pub trait DreamStore: Send + Sync { /* ... */ }
pub trait CompressionStore: Send + Sync { /* ... */ }

pub struct SqliteMemoryBackend {
    db: Arc<Mutex<Connection>>,
}

pub type MemoryBackend = Arc<SqliteMemoryBackend>;

-- Created per embedding dimension
CREATE VIRTUAL TABLE notes_vec_768 USING vec0(
    embedding float[768]
);
CREATE VIRTUAL TABLE notes_vec_1024 USING vec0(
    embedding float[1024]
);
CREATE VIRTUAL TABLE notes_vec_1536 USING vec0(
    embedding float[1536]
);

// src/memory/note_retrieval/mod.rs
#[async_trait]
pub trait NoteFactRetrieval: Send + Sync {
    async fn retrieve(
        &self,
        query: &str,
        agent_id: &str,
        limit: usize,
    ) -> Result<Vec<ScoredFact<MemoryFact>>, AlephError>;
}

Query
  ├── Vector Search (sqlite-vec) → candidates with distance scores
  ├── FTS Search (FTS5) → candidates with match scores
  └── RRF Fusion → unified ranked list

RRF_score = Σ 1 / (k + rank_i)

Raw Memories (is_processed = false)
  → SessionCompactor: per-session compaction
  → NoteIndexer: create/update knowledge notes
  → mark is_processed = true

[Consolidate] → [Drift] → [Lint] → [Decay] → [DailyDigest]

[Consolidate] → [Drift] → [Synthesis] → [Lint] → [Decay] → [DailyDigest]

// src/memory/dreaming/mod.rs
pub fn ensure_dream_daemon();
pub fn record_activity();  // Call on user activity to reset idle timer

// src/memory/assembler/mod.rs
pub struct MemoryEnvelope {
    pub system_slots: Vec<MemorySlot>,      // Always-injected facts
    pub user_slots: Vec<MemorySlot>,        // User-query relevant facts
    pub scratchpad: Option<String>,         // Working notes
}

pub struct MemorySlot {
    pub content: String,
    pub source: String,
    pub score: f32,
}

#[async_trait]
pub trait WorkingMemoryAssembler: Send + Sync {
    async fn assemble(
        &self,
        query: &str,
        agent_id: &str,
        session_id: Option<&str>,
        budget: AssemblyBudget,
    ) -> Result<MemoryEnvelope, AlephError>;
}

pub struct AssemblyBudget {
    pub max_tokens: usize,      // Target token budget for assembled memory
    pub min_score: f32,         // Minimum fact score threshold
    pub max_facts: usize,       // Maximum number of facts to include
}

// src/memory/curated/mod.rs
pub struct CuratedHotMemory {
    pub facts: Vec<CuratedFact>,
    pub frozen_at: i64,
}

pub struct CuratedFact {
    pub content: String,
    pub priority: u8,        // 1-10, higher = more important
    pub source: String,
}

// src/memory/extensions/mod.rs
#[async_trait]
pub trait MemoryExtension: Send + Sync {
    fn name(&self) -> &str;
    
    async fn on_memory_created(
        &self,
        event: &MemoryEvent,
        backend: &MemoryBackend,
    ) -> Result<(), AlephError>;
    
    async fn on_memory_retrieved(
        &self,
        query: &str,
        facts: &[MemoryFact],
        backend: &MemoryBackend,
    ) -> Result<Vec<MemoryFact>, AlephError>;
    
    async fn on_session_end(
        &self,
        session_id: &str,
        backend: &MemoryBackend,
    ) -> Result<(), AlephError>;
}

pub struct ExtensionRegistry {
    extensions: Vec<Box<dyn MemoryExtension>>,
}

// src/memory/reflector/mod.rs
pub struct MemoryReflector {
    assembler: Arc<dyn WorkingMemoryAssembler>,
    llm: Arc<dyn LlmBackend>,
}

impl MemoryReflector {
    pub async fn reflect(
        &self,
        query: &str,
        agent_id: &str,
    ) -> Result<ReflectionResult, AlephError>;
}

pub struct ReflectionResult {
    pub answer: String,
    pub sources: Vec<MemorySource>,
    pub confidence: f32,
}

// src/memory/events/mod.rs
pub struct MemoryEvent {
    pub id: i64,
    pub event_type: MemoryEventType,
    pub note_path: String,
    pub timestamp: i64,
    pub payload: String,  // JSON
}

pub enum MemoryEventType {
    NoteCreated,
    NoteUpdated,
    NoteDeleted,
    LinkAdded,
    LinkRemoved,
    TagChanged,
}

// src/memory/namespace/mod.rs
pub struct MemoryNamespace {
    pub id: String,
    pub parent: Option<String>,
    pub isolation_level: IsolationLevel,
}

pub enum IsolationLevel {
    Full,       // Completely isolated
    Inherited,  // Can read parent, writes isolated
    Shared,     // Read-write shared with parent
}