agentic_reality/engine/write/
temporal.rs

1//! Temporal write operations.
2
3use crate::engine::write::WriteEngine;
4use crate::types::error::{RealityError, RealityResult};
5use crate::types::ids::{EventId, TimelineId};
6use crate::types::temporal::*;
7
8impl<'a> WriteEngine<'a> {
9    /// Ground the agent's time awareness.
10    pub fn ground_time(&mut self, awareness: TemporalAwareness) -> RealityResult<()> {
11        self.engine.temporal_store.awareness = Some(awareness);
12        self.engine.mark_dirty();
13        Ok(())
14    }
15
16    /// Update temporal context.
17    pub fn update_temporal_context(&mut self, context: TemporalContext) -> RealityResult<()> {
18        let awareness = self
19            .engine
20            .temporal_store
21            .awareness
22            .as_mut()
23            .ok_or_else(|| RealityError::NotInitialized("temporal awareness".into()))?;
24        awareness.context = context;
25        self.engine.mark_dirty();
26        Ok(())
27    }
28
29    /// Add a causal event.
30    pub fn add_causal_event(&mut self, event: CausalEvent) -> RealityResult<EventId> {
31        let id = event.id;
32        let graph = self
33            .engine
34            .temporal_store
35            .causality
36            .get_or_insert_with(|| CausalityGraph {
37                events: vec![],
38                root_causes: vec![],
39                leaf_effects: vec![],
40            });
41        graph.events.push(event);
42        self.engine.mark_dirty();
43        Ok(id)
44    }
45
46    /// Link two events causally.
47    pub fn link_causality(&mut self, cause: &EventId, effect: &EventId) -> RealityResult<()> {
48        let graph = self
49            .engine
50            .temporal_store
51            .causality
52            .as_mut()
53            .ok_or_else(|| RealityError::NotInitialized("causality graph".into()))?;
54        if let Some(evt) = graph.events.iter_mut().find(|e| e.id == *cause) {
55            if !evt.effects.contains(effect) {
56                evt.effects.push(*effect);
57            }
58        }
59        if let Some(evt) = graph.events.iter_mut().find(|e| e.id == *effect) {
60            if !evt.causes.contains(cause) {
61                evt.causes.push(*cause);
62            }
63        }
64        self.engine.mark_dirty();
65        Ok(())
66    }
67
68    /// Add a deadline.
69    pub fn add_deadline(&mut self, deadline: Deadline) -> RealityResult<()> {
70        let awareness = self
71            .engine
72            .temporal_store
73            .awareness
74            .as_mut()
75            .ok_or_else(|| RealityError::NotInitialized("temporal awareness".into()))?;
76        awareness.context.deadlines.push(deadline);
77        self.engine.mark_dirty();
78        Ok(())
79    }
80
81    /// Remove a deadline by ID.
82    pub fn remove_deadline(&mut self, id: &str) -> RealityResult<()> {
83        let awareness = self
84            .engine
85            .temporal_store
86            .awareness
87            .as_mut()
88            .ok_or_else(|| RealityError::NotInitialized("temporal awareness".into()))?;
89        awareness.context.deadlines.retain(|d| d.id != id);
90        self.engine.mark_dirty();
91        Ok(())
92    }
93
94    /// Update a deadline.
95    pub fn update_deadline(&mut self, deadline: Deadline) -> RealityResult<()> {
96        let awareness = self
97            .engine
98            .temporal_store
99            .awareness
100            .as_mut()
101            .ok_or_else(|| RealityError::NotInitialized("temporal awareness".into()))?;
102        if let Some(d) = awareness
103            .context
104            .deadlines
105            .iter_mut()
106            .find(|d| d.id == deadline.id)
107        {
108            *d = deadline;
109        }
110        self.engine.mark_dirty();
111        Ok(())
112    }
113
114    /// Add a timeline.
115    pub fn add_timeline(&mut self, timeline: Timeline) -> RealityResult<TimelineId> {
116        let id = timeline.id;
117        self.engine.temporal_store.timelines.push(timeline);
118        self.engine.mark_dirty();
119        Ok(id)
120    }
121
122    /// Record an event on a timeline.
123    pub fn record_timeline_event(
124        &mut self,
125        timeline_id: &TimelineId,
126        event: TimelineEvent,
127    ) -> RealityResult<()> {
128        let timeline = self
129            .engine
130            .temporal_store
131            .timelines
132            .iter_mut()
133            .find(|t| t.id == *timeline_id)
134            .ok_or_else(|| RealityError::NotFound(format!("timeline {}", timeline_id)))?;
135        timeline.events.push(event);
136        self.engine.mark_dirty();
137        Ok(())
138    }
139
140    /// Resolve a timeline conflict.
141    pub fn resolve_timeline_conflict(
142        &mut self,
143        timeline_id: &TimelineId,
144        conflict_idx: usize,
145    ) -> RealityResult<()> {
146        let timeline = self
147            .engine
148            .temporal_store
149            .timelines
150            .iter_mut()
151            .find(|t| t.id == *timeline_id)
152            .ok_or_else(|| RealityError::NotFound(format!("timeline {}", timeline_id)))?;
153        if let Some(conflict) = timeline.conflicts.get_mut(conflict_idx) {
154            conflict.resolved = true;
155        }
156        self.engine.mark_dirty();
157        Ok(())
158    }
159}
agentic_reality/engine/write/temporal.rs

agentic_reality/engine/write/
temporal.rs
