mindfry 1.9.0

Memory with a Conscience
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Shutdown Experience Recording
//!
//! Every shutdown is recorded as a memory experience.
//! Intensity varies by shutdown type, affecting decay rate.

use serde::{Deserialize, Serialize};

/// Reason for shutdown - each type has different intensity
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ShutdownReason {
    /// Normal, clean exit - neutral memory (fast decay)
    Graceful,
    /// Signal-based exit (SIGTERM, SIGINT) - mild scar
    Signal {
        /// Signal number that caused the exit
        signal: i32,
    },
    /// Crash - trauma (slow decay)
    Crash {
        /// Error message describing the crash
        message: String,
    },
    /// Entering coma state - prolonged inactivity
    Coma {
        /// Duration of downtime in seconds
        downtime_seconds: u64,
    },
}

impl ShutdownReason {
    /// Get intensity level (affects decay rate)
    /// Lower = faster decay, Higher = slower decay (scar)
    pub fn intensity(&self) -> f32 {
        match self {
            ShutdownReason::Graceful => 0.1,      // Fast decay - forgets easily
            ShutdownReason::Signal { .. } => 0.4, // Medium - remembers for a while
            ShutdownReason::Crash { .. } => 0.8,  // Slow - scar remains
            ShutdownReason::Coma { .. } => 0.9,   // Very slow - deep memory
        }
    }

    /// Get the target lineage key for this shutdown type
    pub fn lineage_key(&self) -> &'static str {
        match self {
            ShutdownReason::Graceful => super::lineages::SHUTDOWN_GRACEFUL,
            ShutdownReason::Signal { .. } => super::lineages::SHUTDOWN_FORCED,
            ShutdownReason::Crash { .. } => super::lineages::SHOCK,
            ShutdownReason::Coma { .. } => super::lineages::COMA,
        }
    }

    /// Get description for logging
    pub fn description(&self) -> String {
        match self {
            ShutdownReason::Graceful => "graceful shutdown".into(),
            ShutdownReason::Signal { signal } => format!("forced (signal {})", signal),
            ShutdownReason::Crash { message } => format!("crash: {}", message),
            ShutdownReason::Coma { downtime_seconds } => {
                format!("coma: {}s downtime", downtime_seconds)
            }
        }
    }
}

/// Tracks shutdown experiences
#[derive(Default)]
pub struct ShutdownTracker {
    /// Last shutdown reason (if any)
    pub last_reason: Option<ShutdownReason>,
    /// Timestamp of last shutdown
    pub last_timestamp: Option<u64>,
}

impl ShutdownTracker {
    /// Record a shutdown event
    pub fn record(&mut self, reason: ShutdownReason, timestamp: u64) {
        self.last_reason = Some(reason);
        self.last_timestamp = Some(timestamp);
    }

    /// Check if last shutdown was traumatic
    pub fn was_traumatic(&self) -> bool {
        self.last_reason
            .as_ref()
            .map(|r| r.intensity() > 0.5)
            .unwrap_or(false)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_shutdown_intensity() {
        assert!(ShutdownReason::Graceful.intensity() < 0.2);
        assert!(
            ShutdownReason::Crash {
                message: "test".into()
            }
            .intensity()
                > 0.7
        );
    }

    #[test]
    fn test_traumatic_detection() {
        let mut tracker = ShutdownTracker::default();

        tracker.record(ShutdownReason::Graceful, 1000);
        assert!(!tracker.was_traumatic());

        tracker.record(
            ShutdownReason::Crash {
                message: "panic".into(),
            },
            2000,
        );
        assert!(tracker.was_traumatic());
    }
}