1use serde::{Deserialize, Serialize};
4use std::collections::HashMap;
5
6use super::ids::{EventId, TimelineId};
7
8#[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#[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#[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#[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#[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#[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}