Skip to main content

agentic_reality/engine/query/
coherence.rs

1//! Coherence query operations.
2
3use crate::engine::query::QueryEngine;
4use crate::types::coherence::*;
5use crate::types::error::{RealityError, RealityResult};
6use crate::types::ids::TransitionId;
7
8impl<'a> QueryEngine<'a> {
9    pub fn get_coherence_state(&self) -> RealityResult<&CoherenceState> {
10        self.engine
11            .coherence_store
12            .state
13            .as_ref()
14            .ok_or_else(|| RealityError::NotInitialized("coherence state".into()))
15    }
16
17    pub fn get_coherence_level(&self) -> RealityResult<&CoherenceLevel> {
18        Ok(&self.get_coherence_state()?.level)
19    }
20
21    pub fn get_violations(&self) -> RealityResult<&[CoherenceViolation]> {
22        Ok(&self.get_coherence_state()?.violations)
23    }
24
25    pub fn get_pending_transitions(&self) -> RealityResult<&[PendingTransition]> {
26        let trans = self
27            .engine
28            .coherence_store
29            .transitions
30            .as_ref()
31            .ok_or_else(|| RealityError::NotInitialized("transition state".into()))?;
32        Ok(&trans.pending)
33    }
34
35    pub fn get_transition(&self, id: &TransitionId) -> RealityResult<&PendingTransition> {
36        let trans = self
37            .engine
38            .coherence_store
39            .transitions
40            .as_ref()
41            .ok_or_else(|| RealityError::NotInitialized("transition state".into()))?;
42        trans
43            .pending
44            .iter()
45            .find(|t| t.id == *id)
46            .ok_or_else(|| RealityError::NotFound(format!("transition {}", id)))
47    }
48
49    pub fn get_transition_history(&self) -> RealityResult<&[CompletedTransition]> {
50        let trans = self
51            .engine
52            .coherence_store
53            .transitions
54            .as_ref()
55            .ok_or_else(|| RealityError::NotInitialized("transition state".into()))?;
56        Ok(&trans.history)
57    }
58
59    pub fn is_coherent(&self) -> bool {
60        self.engine
61            .coherence_store
62            .state
63            .as_ref()
64            .map(|s| matches!(s.level, CoherenceLevel::Full { .. }))
65            .unwrap_or(true)
66    }
67
68    pub fn get_coherence_checks(&self) -> RealityResult<&[CoherenceCheck]> {
69        Ok(&self.get_coherence_state()?.checks)
70    }
71}