agentic_reality/engine/write/
stakes.rs

1//! Stakes write operations.
2
3use crate::engine::write::WriteEngine;
4use crate::types::error::{RealityError, RealityResult};
5use crate::types::stakes::*;
6
7impl<'a> WriteEngine<'a> {
8    /// Set the stakes level.
9    pub fn set_stakes_level(&mut self, stakes: StakesLevel) -> RealityResult<()> {
10        let awareness = self
11            .engine
12            .stakes_store
13            .consequences
14            .get_or_insert_with(|| ConsequenceAwareness {
15                stakes: StakesLevel::Minimal {
16                    can_experiment: true,
17                },
18                consequence_map: vec![],
19                irreversible: vec![],
20                safety_margins: SafetyMargins {
21                    overall: 1.0,
22                    by_domain: Default::default(),
23                    guardrails: vec![],
24                },
25                history: vec![],
26            });
27        awareness.stakes = stakes;
28        self.engine.mark_dirty();
29        Ok(())
30    }
31
32    /// Add a potential consequence.
33    pub fn add_consequence(&mut self, consequence: Consequence) -> RealityResult<()> {
34        let awareness = self
35            .engine
36            .stakes_store
37            .consequences
38            .as_mut()
39            .ok_or_else(|| RealityError::NotInitialized("consequence awareness".into()))?;
40        awareness.consequence_map.push(consequence);
41        self.engine.mark_dirty();
42        Ok(())
43    }
44
45    /// Remove a consequence by effect description.
46    pub fn remove_consequence(&mut self, effect: &str) -> RealityResult<()> {
47        let awareness = self
48            .engine
49            .stakes_store
50            .consequences
51            .as_mut()
52            .ok_or_else(|| RealityError::NotInitialized("consequence awareness".into()))?;
53        awareness.consequence_map.retain(|c| c.effect != effect);
54        self.engine.mark_dirty();
55        Ok(())
56    }
57
58    /// Add an irreversible action.
59    pub fn add_irreversible_action(&mut self, action: IrreversibleAction) -> RealityResult<()> {
60        let awareness = self
61            .engine
62            .stakes_store
63            .consequences
64            .as_mut()
65            .ok_or_else(|| RealityError::NotInitialized("consequence awareness".into()))?;
66        awareness.irreversible.push(action);
67        self.engine.mark_dirty();
68        Ok(())
69    }
70
71    /// Update safety margins.
72    pub fn update_safety_margins(&mut self, margins: SafetyMargins) -> RealityResult<()> {
73        let awareness = self
74            .engine
75            .stakes_store
76            .consequences
77            .as_mut()
78            .ok_or_else(|| RealityError::NotInitialized("consequence awareness".into()))?;
79        awareness.safety_margins = margins;
80        self.engine.mark_dirty();
81        Ok(())
82    }
83
84    /// Add a guardrail.
85    pub fn add_guardrail(&mut self, guardrail: Guardrail) -> RealityResult<()> {
86        let awareness = self
87            .engine
88            .stakes_store
89            .consequences
90            .as_mut()
91            .ok_or_else(|| RealityError::NotInitialized("consequence awareness".into()))?;
92        awareness.safety_margins.guardrails.push(guardrail);
93        self.engine.mark_dirty();
94        Ok(())
95    }
96
97    /// Remove a guardrail by name.
98    pub fn remove_guardrail(&mut self, name: &str) -> RealityResult<()> {
99        let awareness = self
100            .engine
101            .stakes_store
102            .consequences
103            .as_mut()
104            .ok_or_else(|| RealityError::NotInitialized("consequence awareness".into()))?;
105        awareness
106            .safety_margins
107            .guardrails
108            .retain(|g| g.name != name);
109        self.engine.mark_dirty();
110        Ok(())
111    }
112
113    /// Update the risk field.
114    pub fn update_risk_field(&mut self, risk_field: RiskFieldPerception) -> RealityResult<()> {
115        self.engine.stakes_store.risk_field = Some(risk_field);
116        self.engine.mark_dirty();
117        Ok(())
118    }
119
120    /// Update blast radius awareness.
121    pub fn update_blast_radius(&mut self, blast: BlastRadiusAwareness) -> RealityResult<()> {
122        self.engine.stakes_store.blast_radius = Some(blast);
123        self.engine.mark_dirty();
124        Ok(())
125    }
126
127    /// Record a consequence that occurred.
128    pub fn record_consequence(&mut self, record: ConsequenceRecord) -> RealityResult<()> {
129        let awareness = self
130            .engine
131            .stakes_store
132            .consequences
133            .as_mut()
134            .ok_or_else(|| RealityError::NotInitialized("consequence awareness".into()))?;
135        awareness.history.push(record);
136        self.engine.mark_dirty();
137        Ok(())
138    }
139}
agentic_reality/engine/write/stakes.rs

agentic_reality/engine/write/
stakes.rs
