Skip to main content

agentic_reality/types/
temporal.rs

1//! Temporal grounding types — "When am I?"
2
3use serde::{Deserialize, Serialize};
4use std::collections::HashMap;
5
6use super::ids::{EventId, TimelineId};
7
8/// Temporal awareness — the agent's sense of time.
9#[derive(Debug, Clone, Serialize, Deserialize)]
10pub struct TemporalAwareness {
11    pub wall_clock: i64,
12    pub monotonic_ns: u64,
13    pub time_source: TimeSource,
14    pub time_confidence: f64,
15    pub drift: Option<TimeDrift>,
16    pub context: TemporalContext,
17}
18
19#[derive(Debug, Clone, Serialize, Deserialize)]
20pub enum TimeSource {
21    System,
22    Ntp { server: String, offset_ms: f64 },
23    Gps,
24    Consensus { participants: u32 },
25    External { source: String },
26    Unknown,
27}
28
29#[derive(Debug, Clone, Serialize, Deserialize)]
30pub struct TimeDrift {
31    pub offset_ms: f64,
32    pub direction: DriftDirection,
33    pub source: String,
34    pub detected_at: i64,
35}
36
37#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
38pub enum DriftDirection {
39    Ahead,
40    Behind,
41    Oscillating,
42}
43
44/// Temporal context — where in various timelines.
45#[derive(Debug, Clone, Serialize, Deserialize)]
46pub struct TemporalContext {
47    pub session_start: i64,
48    pub session_duration_secs: u64,
49    pub request_count: u64,
50    pub deadlines: Vec<Deadline>,
51    pub time_budget: Option<TimeBudget>,
52    pub causal_position: Option<CausalPosition>,
53}
54
55#[derive(Debug, Clone, Serialize, Deserialize)]
56pub struct Deadline {
57    pub id: String,
58    pub name: String,
59    pub due_at: i64,
60    pub priority: DeadlinePriority,
61    pub remaining_secs: i64,
62    pub met: Option<bool>,
63}
64
65#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
66pub enum DeadlinePriority {
67    Low,
68    Medium,
69    High,
70    Critical,
71}
72
73#[derive(Debug, Clone, Serialize, Deserialize)]
74pub struct TimeBudget {
75    pub total_secs: u64,
76    pub used_secs: u64,
77    pub remaining_secs: u64,
78    pub extensions_allowed: bool,
79}
80
81#[derive(Debug, Clone, Serialize, Deserialize)]
82pub struct CausalPosition {
83    pub depth: u32,
84    pub breadth: u32,
85    pub root_event: Option<EventId>,
86}
87
88/// Causal event in the causality graph.
89#[derive(Debug, Clone, Serialize, Deserialize)]
90pub struct CausalEvent {
91    pub id: EventId,
92    pub event_type: CausalEventType,
93    pub description: String,
94    pub timestamp: i64,
95    pub causes: Vec<EventId>,
96    pub effects: Vec<EventId>,
97    pub metadata: HashMap<String, String>,
98}
99
100#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
101pub enum CausalEventType {
102    Action,
103    Observation,
104    Decision,
105    ExternalEvent,
106    SystemEvent,
107    Error,
108}
109
110/// Causality graph.
111#[derive(Debug, Clone, Serialize, Deserialize)]
112pub struct CausalityGraph {
113    pub events: Vec<CausalEvent>,
114    pub root_causes: Vec<EventId>,
115    pub leaf_effects: Vec<EventId>,
116}
117
118/// Timeline for tracking coherence across multiple timelines.
119#[derive(Debug, Clone, Serialize, Deserialize)]
120pub struct Timeline {
121    pub id: TimelineId,
122    pub name: String,
123    pub events: Vec<TimelineEvent>,
124    pub conflicts: Vec<TimelineConflict>,
125    pub coherent: bool,
126}
127
128#[derive(Debug, Clone, Serialize, Deserialize)]
129pub struct TimelineEvent {
130    pub event_id: EventId,
131    pub timestamp: i64,
132    pub description: String,
133    pub timeline_id: TimelineId,
134}
135
136#[derive(Debug, Clone, Serialize, Deserialize)]
137pub struct TimelineConflict {
138    pub timelines: Vec<TimelineId>,
139    pub description: String,
140    pub severity: ConflictSeverity,
141    pub resolved: bool,
142}
143
144#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
145pub enum ConflictSeverity {
146    Minor,
147    Moderate,
148    Major,
149    Critical,
150}
151
152/// Unified timeline merging multiple timelines.
153#[derive(Debug, Clone, Serialize, Deserialize)]
154pub struct UnifiedTimeline {
155    pub timelines: Vec<TimelineId>,
156    pub merged_events: Vec<TimelineEvent>,
157    pub unresolved_conflicts: Vec<TimelineConflict>,
158    pub coherence_score: f64,
159}