mimirs_sleeptime/

reflection.rs

//! Sleep-time agent for memory reflection
//!
//! Implements Letta-inspired sleep-time agents that reflect on episodic history
//! and produce distilled memory blocks.

use mimirs_core::{Goal, MemoryAgent, MimirError, RecallQuery};
use mimirs_oracle::{Forseti, Ginnunga};
use std::sync::Weak;
use std::time::Duration;

/// Sleep-time agent configuration
#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
pub struct SleepConfig {
    /// Minimum idle time before triggering sleep-time reflection
    pub min_idle_duration: Duration,
    /// Maximum number of memories to reflect on per session
    pub max_memories_per_session: usize,
    /// Whether to automatically consolidate after reflection
    pub auto_consolidate: bool,
}

impl Default for SleepConfig {
    fn default() -> Self {
        Self {
            min_idle_duration: Duration::from_secs(300), // 5 minutes
            max_memories_per_session: 100,
            auto_consolidate: true,
        }
    }
}

/// GoalSystem - Autonomous Goal Persistence (L6).
#[derive(Debug, Clone, Default)]
pub struct GoalSystem {
    /// Active cognitive attractors.
    pub active_goals: Vec<Goal>,
}

impl GoalSystem {
    /// SelectFocus - Select the highest priority goal based on persistence and weight.
    pub fn select_focus(&self) -> Option<&Goal> {
        self.active_goals.iter().max_by(|a, b| {
            let sa = a.priority * a.persistence;
            let sb = b.priority * b.persistence;
            debug_assert!(sa.is_finite() && sb.is_finite());
            sa.partial_cmp(&sb).unwrap_or(std::cmp::Ordering::Equal)
        })
    }
}

/// Nott - The reflection engine.
pub struct Nott {
    /// The memory agent to operate on (Weak to prevent cycles)
    well_agent: Weak<dyn MemoryAgent>,
    /// Autonomous goal manager.
    pub goals: GoalSystem,
    /// Contradiction detector.
    pub ginnunga: Ginnunga,
    /// Verifiability oracle.
    pub forseti: Forseti,
    /// Configuration for sleep-time behavior
    _config: SleepConfig,
    /// Event bus for signaling (optional, can be attached later)
    pub bus: Option<mimirs_ha::EventBus>,
    /// Agent identifier for signal attribution
    pub agent_id: Option<mimirs_core::AgentId>,
    /// Distillation configuration
    pub distillation_config: crate::distillation::DistillationConfig,
}

impl Nott {
    /// Opna - Creates a new Nott sleep-time agent.
    pub fn new(agent: Weak<dyn MemoryAgent>, config: SleepConfig) -> Self {
        Self {
            well_agent: agent,
            goals: GoalSystem::default(),
            ginnunga: Ginnunga::default(),
            forseti: Forseti::default(),
            _config: config,
            bus: None,
            agent_id: None,
            distillation_config: crate::distillation::DistillationConfig::default(),
        }
    }

    /// Attaches an event bus for real-time signaling.
    pub fn with_bus(mut self, bus: mimirs_ha::EventBus) -> Self {
        self.bus = Some(bus);
        self
    }

    /// Attaches an agent ID for signal attribution.
    pub fn with_agent_id(mut self, id: mimirs_core::AgentId) -> Self {
        self.agent_id = Some(id);
        self
    }

    /// Drauma - Start the reflection loop (dreaming).
    /// Minimized L = αE + βC + δH (Entropy, Contradiction, Hallucination/Incoherence)
    pub async fn drauma(&self) -> Result<(), MimirError> {
        let agent = self
            .well_agent
            .upgrade()
            .ok_or_else(|| MimirError::Uninitialized("Agent dropped".to_string()))?;

        let agent_id = self.agent_id.unwrap_or_default();

        tracing::info!("Nott is starting the reflection loop (Drauma)");

        // 1. Fetch Episodic history
        let query = RecallQuery::new("")
            .with_limit(self._config.max_memories_per_session)
            .with_memory_class(mimirs_core::MemoryClass::Episodic);

        let results = agent.recall(query).await?;
        if results.is_empty() {
            tracing::debug!("No episodic memories to reflect on");
            return Ok(());
        }

        // 2. Identify Contradictions (C) and evaluate Verifiability
        for (i, res_a) in results.iter().enumerate() {
            for res_b in results.iter().skip(i + 1) {
                let contradiction_score = self.ginnunga.greina(&res_a.memory, &res_b.memory);
                if contradiction_score > self.ginnunga.contradiction_threshold {
                    tracing::warn!(
                        "Contradiction detected between {} and {}: score {}",
                        res_a.id,
                        res_b.id,
                        contradiction_score
                    );

                    // Emit conflict signal
                    if let Some(ref bus) = self.bus {
                        let _ = bus.broadcast(mimirs_ha::MemorySignal::ConflictDetected {
                            agent_id,
                            memory_a: res_a.id,
                            memory_b: res_b.id,
                            score: contradiction_score,
                        });
                    }
                }
            }

            // 3. Evaluate and potentially promote verifiability stage
            let mut current_memory = agent.get_memory(res_a.id).await?;
            let new_stage = if let Some(ref rho) = current_memory.rho {
                self.forseti.domur(rho)
            } else {
                current_memory.verifiability
            };

            if new_stage > current_memory.verifiability {
                tracing::info!(
                    "Promoting memory {} from {:?} to {:?}",
                    res_a.id,
                    current_memory.verifiability,
                    new_stage
                );

                // Update memory in the well
                current_memory.verifiability = new_stage;
                agent.update_memory(current_memory).await?;

                // Emit verifiability change signal
                if let Some(ref bus) = self.bus {
                    let _ = bus.broadcast(mimirs_ha::MemorySignal::VerifiabilityChanged {
                        agent_id,
                        memory_id: res_a.id,
                        new_stage,
                    });
                }
            }
        }

        // 4. Perform Manifold Distillation (Phase 9)
        tracing::info!("Nott is distilling episodic manifold into Drauma blocks");
        let mut full_memories = Vec::new();
        for r in results.iter() {
            if let Ok(m) = agent.get_memory(r.id).await {
                full_memories.push(m);
            }
        }

        match crate::distillation::Drauma::distill(&full_memories, &self.distillation_config) {
            Ok(drauma) => {
                tracing::info!(
                    "Successfully distilled {} memories into block {}",
                    full_memories.len(),
                    drauma.id
                );

                // Save the distilled block to the agent's context
                agent.attach_block(drauma.block).await?;

                // Emit distillation signal
                if let Some(ref bus) = self.bus {
                    let _ = bus.broadcast(mimirs_ha::MemorySignal::ConsolidationCompleted {
                        agent_id,
                        memories_processed: full_memories.len(),
                    });
                }
            }
            Err(e) => tracing::error!("Distillation failed: {}", e),
        }

        // 5. Update Goal weights (simulated based on reflection results)
        if let Some(focus) = self.goals.select_focus() {
            tracing::info!("Current cognitive focus: {}", focus.id);
        }

        Ok(())
    }
}