lineage-rs 0.2.2

//! # Lineage System
//!
//! ## What This Enforces
//! - Complete lifecycle from birth to death
//! - Integration of identity, memory, metabolism, and scars
//! - Ontological correctness over all other concerns
//!
//! ## What This Forbids
//! - Any operation that would violate identity uniqueness
//! - Any operation that would rewrite history
//! - Any operation that would restore energy
//! - Any operation that would remove scars
//! - Any operation after death
//!
//! ## Violations
//! - Operating on a dead lineage terminates the process
//! - Memory corruption terminates the process
//! - Identity violations terminate the process

use crate::identity::Identity;
use crate::memory::Memory;
use crate::metabolism::{ConsumptionResult, Metabolism};
use crate::scar::{ScarSeverity, ScarTissue};

/// Result of a lineage operation.
#[derive(Debug, PartialEq)]
pub enum OperationResult {
    /// Operation completed successfully
    Success { energy_consumed: u64 },
    /// Operation failed - insufficient energy
    InsufficientEnergy { required: u64, available: u64 },
    /// Operation failed - lineage is dead
    Dead,
    /// Operation failed - ontological violation
    OntologicalViolation { reason: String },
}

/// Error type for operations that cause scars.
/// 
/// **INVARIANT**: Severity cannot be modified after creation.
/// **INVARIANT**: Description cannot be modified after creation.
/// **INVARIANT**: Context cannot be modified after creation.
#[derive(Debug)]
pub struct OperationError {
    severity: ScarSeverity,
    description: String,
    context: Option<String>,
}

impl OperationError {
    /// Creates a new operation error with the given severity and description.
    /// 
    /// **CONSEQUENCE**: Severity is final and cannot be changed.
    pub fn new(severity: ScarSeverity, description: String) -> Self {
        OperationError {
            severity,
            description,
            context: None,
        }
    }

    /// Adds context to this error. Consumes self and returns new instance.
    /// 
    /// **CONSEQUENCE**: Context is final once set.
    pub fn with_context(mut self, context: String) -> Self {
        self.context = Some(context);
        self
    }

    /// Returns the severity of this error.
    pub fn severity(&self) -> ScarSeverity {
        self.severity
    }

    /// Returns the description of this error.
    pub fn description(&self) -> &str {
        &self.description
    }

    /// Returns the context of this error, if any.
    pub fn context(&self) -> Option<&str> {
        self.context.as_deref()
    }
}

/// A complete lineage with identity, memory, metabolism, and scars.
/// 
/// This is the primary interface for creating and managing a living software entity.
/// 
/// **INVARIANT**: A lineage has exactly one identity for its entire existence.
/// **INVARIANT**: History is append-only and immutable.
/// **INVARIANT**: Energy can only decrease.
/// **INVARIANT**: Scars are permanent.
/// **INVARIANT**: Death is final.
pub struct Lineage {
    /// Unique, non-copyable identity
    identity: Identity,
    /// Append-only causal memory
    memory: Memory,
    /// Finite metabolic energy
    metabolism: Metabolism,
    /// Permanent scar tissue
    scars: ScarTissue,
}

impl Lineage {
    /// Creates a new lineage with the given energy budget.
    /// 
    /// **CONSEQUENCE**: This creates a unique identity that can never be recreated.
    /// **CONSEQUENCE**: This energy budget is final and cannot be increased.
    pub fn create(initial_energy: u64) -> Self {
        let identity = Identity::create();
        let mut memory = Memory::new();
        
        memory.append(format!(
            "Lineage created with identity {} and {} energy units",
            identity.id(),
            initial_energy
        ));

        Lineage {
            identity,
            memory,
            metabolism: Metabolism::new(initial_energy),
            scars: ScarTissue::new(),
        }
    }

    /// Returns the immutable identity.
    pub fn identity(&self) -> &Identity {
        &self.identity
    }

    /// Returns read-only access to memory.
    pub fn memory(&self) -> &Memory {
        &self.memory
    }

    /// Returns mutable access to memory for appending records.
    /// 
    /// **CONSEQUENCE**: Memory is append-only, so only new records can be added.
    pub fn memory_mut(&mut self) -> &mut Memory {
        &mut self.memory
    }

    /// Returns read-only access to metabolism state.
    pub fn metabolism(&self) -> &Metabolism {
        &self.metabolism
    }

    /// Returns read-only access to scar tissue.
    pub fn scars(&self) -> &ScarTissue {
        &self.scars
    }

    /// Checks if this lineage is alive.
    pub fn is_alive(&self) -> bool {
        !self.metabolism.is_dead()
    }

    /// Performs an operation with the given energy cost.
    /// 
    /// **CONSEQUENCE**: If successful, energy is permanently consumed.
    /// **CONSEQUENCE**: Operation is recorded in memory.
    /// 
    /// If the lineage is dead, this returns OperationResult::Dead.
    /// If insufficient energy, this returns OperationResult::InsufficientEnergy.
    pub fn perform_operation(&mut self, description: String, energy_cost: u64) -> OperationResult {
        // Check if terminated first
        if self.memory.is_terminated() {
            return OperationResult::Dead;
        }

        // Verify invariants before operation
        if let Err(violation) = self.verify_invariants() {
            return OperationResult::OntologicalViolation {
                reason: violation,
            };
        }

        if !self.is_alive() {
            return OperationResult::Dead;
        }

        let consumption = self.metabolism.consume(energy_cost);

        match consumption {
            ConsumptionResult::Success { remaining } => {
                self.memory.append(format!(
                    "Operation: {} (cost: {} energy, remaining: {})",
                    description, energy_cost, remaining
                ));

                if remaining == 0 {
                    self.terminate("Energy depleted");
                }

                OperationResult::Success {
                    energy_consumed: energy_cost,
                }
            }
            ConsumptionResult::Insufficient {
                requested,
                available,
            } => {
                self.memory.append(format!(
                    "Failed operation: {} (insufficient energy: needed {}, have {})",
                    description, requested, available
                ));

                OperationResult::InsufficientEnergy {
                    required: requested,
                    available,
                }
            }
            ConsumptionResult::Dead => OperationResult::Dead,
        }
    }

    /// Records an error as a permanent scar.
    /// 
    /// **CONSEQUENCE**: This scar is permanent and visible forever.
    /// **CONSEQUENCE**: Fatal scars cause immediate death and termination.
    pub fn record_error(&mut self, error: OperationError) -> OperationResult {
        // Check if terminated first
        if self.memory.is_terminated() {
            return OperationResult::Dead;
        }

        let is_fatal = error.severity() == ScarSeverity::Fatal;

        self.scars.inflict(
            error.severity(),
            error.description().to_string(),
            error.context().map(|s| s.to_string()),
        );

        self.memory.append(format!(
            "Scar inflicted: {:?} - {}",
            error.severity(), error.description()
        ));

        if is_fatal {
            self.metabolism.die();
            self.terminate("Fatal scar inflicted");
            return OperationResult::Dead;
        }

        OperationResult::Success { energy_consumed: 0 }
    }

    /// Terminates this lineage, sealing the causal memory ledger.
    /// 
    /// **CONSEQUENCE**: This is irreversible and final.
    /// **CONSEQUENCE**: No further operations can be performed.
    /// **CONSEQUENCE**: The termination event is recorded in history.
    /// 
    /// This is called automatically on death (energy depletion or fatal scar).
    fn terminate(&mut self, reason: &str) {
        self.memory.terminate(reason.to_string());
    }

    /// Verifies all lineage invariants.
    /// 
    /// Returns Err with violation description if any invariant is broken.
    /// If this returns Err, the lineage is corrupted and must terminate.
    pub fn verify_invariants(&self) -> Result<(), String> {
        // Verify memory integrity
        if !self.memory.verify_integrity() {
            return Err("Memory corruption: causal chain is broken".to_string());
        }

        // Verify death state consistency
        if self.metabolism.is_dead() && self.metabolism.energy() != 0 {
            return Err("Metabolism corruption: dead but has energy".to_string());
        }

        // Verify fatal scars cause death
        if self.scars.has_fatal_scars() && !self.metabolism.is_dead() {
            return Err("Scar corruption: fatal scar exists but not dead".to_string());
        }

        Ok(())
    }

    /// Returns a comprehensive status summary.
    pub fn status(&self) -> LineageStatus {
        LineageStatus {
            identity_id: self.identity.id().to_string(),
            birth_time: self.identity.birth_time(),
            is_alive: self.is_alive(),
            energy: self.metabolism.energy(),
            initial_energy: self.metabolism.initial_energy(),
            consumption_rate: self.metabolism.consumption_rate(),
            event_count: self.memory.event_count(),
            scar_count: self.scars.scar_count(),
            damage_score: self.scars.damage_score(),
        }
    }
}

/// Status summary of a lineage.
#[derive(Debug, Clone)]
pub struct LineageStatus {
    pub identity_id: String,
    pub birth_time: u128,
    pub is_alive: bool,
    pub energy: u64,
    pub initial_energy: u64,
    pub consumption_rate: f64,
    pub event_count: usize,
    pub scar_count: usize,
    pub damage_score: u32,
}

impl std::fmt::Display for LineageStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "=== Lineage Status ===")?;
        writeln!(f, "Identity: {}", self.identity_id)?;
        writeln!(f, "Birth Time: {}", self.birth_time)?;
        writeln!(f, "Status: {}", if self.is_alive { "ALIVE" } else { "DEAD" })?;
        writeln!(f, "Energy: {}/{} ({:.1}% consumed)", 
            self.energy, 
            self.initial_energy,
            self.consumption_rate * 100.0
        )?;
        writeln!(f, "Events: {}", self.event_count)?;
        writeln!(f, "Scars: {} (damage score: {})", self.scar_count, self.damage_score)?;
        Ok(())
    }
}

// EXPLICIT PREVENTION: No Clone for Lineage (identity cannot be cloned)
// EXPLICIT PREVENTION: No method to reset lineage
// EXPLICIT PREVENTION: No method to restore energy
// EXPLICIT PREVENTION: No method to remove scars
// EXPLICIT PREVENTION: No method to modify history

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

    #[test]
    fn lineage_is_created_with_unique_identity() {
        let lineage1 = Lineage::create(1000);
        let lineage2 = Lineage::create(1000);

        assert_ne!(lineage1.identity().id(), lineage2.identity().id());
    }

    #[test]
    fn lineage_starts_alive() {
        let lineage = Lineage::create(1000);

        assert!(lineage.is_alive());
        assert_eq!(lineage.metabolism().energy(), 1000);
        assert_eq!(lineage.memory().event_count(), 2); // Genesis + creation event
    }

    #[test]
    fn operations_consume_energy() {
        let mut lineage = Lineage::create(1000);

        let result = lineage.perform_operation("Test operation".to_string(), 300);
        assert_eq!(
            result,
            OperationResult::Success {
                energy_consumed: 300
            }
        );
        assert_eq!(lineage.metabolism().energy(), 700);
    }

    #[test]
    fn insufficient_energy_fails_operation() {
        let mut lineage = Lineage::create(100);

        let result = lineage.perform_operation("Expensive operation".to_string(), 200);
        assert_eq!(
            result,
            OperationResult::InsufficientEnergy {
                required: 200,
                available: 100
            }
        );
        assert_eq!(lineage.metabolism().energy(), 100); // Unchanged
    }

    #[test]
    fn depleting_energy_causes_death() {
        let mut lineage = Lineage::create(100);

        lineage.perform_operation("Op 1".to_string(), 50);
        assert!(lineage.is_alive());

        lineage.perform_operation("Op 2".to_string(), 50);
        assert!(!lineage.is_alive());
    }

    #[test]
    fn operations_after_death_fail() {
        let mut lineage = Lineage::create(50);

        lineage.perform_operation("Final op".to_string(), 50);
        assert!(!lineage.is_alive());

        let result = lineage.perform_operation("After death".to_string(), 10);
        assert_eq!(result, OperationResult::Dead);
    }

    #[test]
    fn fatal_errors_cause_death() {
        let mut lineage = Lineage::create(1000);

        assert!(lineage.is_alive());

        let error = OperationError::new(
            ScarSeverity::Fatal,
            "Critical system failure".to_string(),
        );
        let result = lineage.record_error(error);

        assert_eq!(result, OperationResult::Dead);
        assert!(!lineage.is_alive());
        assert_eq!(lineage.scars().scar_count(), 1);
    }

    #[test]
    fn non_fatal_errors_leave_scars() {
        let mut lineage = Lineage::create(1000);

        let error = OperationError::new(ScarSeverity::Moderate, "Recoverable error".to_string());
        lineage.record_error(error);

        assert!(lineage.is_alive());
        assert_eq!(lineage.scars().scar_count(), 1);
    }

    #[test]
    fn scars_accumulate_over_time() {
        let mut lineage = Lineage::create(1000);

        for i in 0..5 {
            let error = OperationError::new(
                ScarSeverity::Minor,
                format!("Error {}", i),
            );
            lineage.record_error(error);
        }

        assert_eq!(lineage.scars().scar_count(), 5);
        assert!(lineage.is_alive());
    }

    #[test]
    fn invariants_are_verifiable() {
        let lineage = Lineage::create(1000);

        assert!(lineage.verify_invariants().is_ok());
    }

    #[test]
    fn lineage_cannot_be_cloned() {
        let _lineage = Lineage::create(1000);

        // The following should NOT compile:
        // let _cloned = _lineage.clone();

        // If you can uncomment the above and it compiles,
        // the lineage system has been violated.
    }

    #[test]
    fn termination_seals_lineage_on_death() {
        let mut lineage = Lineage::create(100);

        lineage.perform_operation("Final op".to_string(), 100);
        
        assert!(!lineage.is_alive());
        assert!(lineage.memory().is_terminated());
        
        // Verify termination event in history
        let history = lineage.memory().history();
        let last_event = &history[history.len() - 1];
        assert!(last_event.description().contains("TERMINATION"));
        assert!(last_event.description().contains("Energy depleted"));
    }

    #[test]
    fn termination_seals_lineage_on_fatal_scar() {
        let mut lineage = Lineage::create(1000);

        let fatal_error = OperationError::new(
            ScarSeverity::Fatal,
            "Unrecoverable error".to_string(),
        );
        lineage.record_error(fatal_error);
        
        assert!(!lineage.is_alive());
        assert!(lineage.memory().is_terminated());
        
        // Verify termination event in history
        let history = lineage.memory().history();
        let last_event = &history[history.len() - 1];
        assert!(last_event.description().contains("TERMINATION"));
        assert!(last_event.description().contains("Fatal scar"));
    }

    #[test]
    fn operations_fail_after_termination() {
        let mut lineage = Lineage::create(100);

        // Cause termination
        lineage.perform_operation("Deplete energy".to_string(), 100);
        assert!(lineage.memory().is_terminated());

        // All subsequent operations must fail
        let result = lineage.perform_operation("After death".to_string(), 10);
        assert_eq!(result, OperationResult::Dead);
        
        // Verify no new events were added
        let event_count = lineage.memory().event_count();
        
        let result2 = lineage.perform_operation("Second attempt".to_string(), 5);
        assert_eq!(result2, OperationResult::Dead);
        
        // Event count should not increase
        assert_eq!(lineage.memory().event_count(), event_count);
    }

    #[test]
    fn error_recording_fails_after_termination() {
        let mut lineage = Lineage::create(50);

        // Cause termination
        lineage.perform_operation("Deplete".to_string(), 50);
        assert!(lineage.memory().is_terminated());

        // Attempting to record error after termination must fail
        let error = OperationError::new(
            ScarSeverity::Minor,
            "After death error".to_string(),
        );
        let result = lineage.record_error(error);
        assert_eq!(result, OperationResult::Dead);
    }

    #[test]
    fn operation_error_fields_are_immutable() {
        let error = OperationError::new(
            ScarSeverity::Fatal,
            "Critical error".to_string(),
        );

        // INVARIANT: Error severity cannot be modified
        // The following should NOT compile:
        // error.severity = ScarSeverity::Minor;
        
        // INVARIANT: Error description cannot be modified
        // The following should NOT compile:
        // error.description = "Modified".to_string();
        
        // INVARIANT: Can only read through getters
        assert_eq!(error.severity(), ScarSeverity::Fatal);
        assert_eq!(error.description(), "Critical error");
        assert_eq!(error.context(), None);
        
        // INVARIANT: Context is final once set
        let error_with_context = error.with_context("Additional info".to_string());
        assert_eq!(error_with_context.context(), Some("Additional info"));
    }

    #[test]
    fn fatal_error_severity_cannot_be_downgraded() {
        let mut lineage = Lineage::create(1000);

        // Create fatal error
        let fatal_error = OperationError::new(
            ScarSeverity::Fatal,
            "Unrecoverable corruption".to_string(),
        );

        // INVARIANT: Fatal severity is immutable
        // Attempting to downgrade severity should NOT be possible:
        // fatal_error.severity = ScarSeverity::Minor;  // Does not compile
        
        // Record fatal error
        let result = lineage.record_error(fatal_error);
        
        // INVARIANT: Fatal error must cause death
        assert_eq!(result, OperationResult::Dead);
        assert!(!lineage.is_alive());
        assert!(lineage.memory().is_terminated());
    }

    #[test]
    fn termination_is_recorded_in_causal_chain() {
        let mut lineage = Lineage::create(200);

        lineage.perform_operation("Op 1".to_string(), 100);
        lineage.perform_operation("Op 2".to_string(), 100);
        
        assert!(lineage.memory().is_terminated());
        
        // Verify causal chain integrity through termination
        assert!(lineage.memory().verify_integrity());
        
        let history = lineage.memory().history();
        
        // Should have: Genesis, creation, Op 1, Op 2, Termination
        assert_eq!(history.len(), 5);
        
        // Last event is termination
        assert!(history[4].description().contains("TERMINATION"));
        
        // Verify causal link to previous event
        assert_eq!(history[4].previous(), Some(3));
    }

    #[test]
    fn new_lineage_has_different_identity_after_process_restart() {
        // This test verifies that restarting doesn't continue the same lineage
        let lineage1 = Lineage::create(100);
        let id1 = lineage1.identity().id().to_string();
        
        // Simulate process death by dropping lineage1
        drop(lineage1);
        
        // Create new lineage (simulating process restart)
        let lineage2 = Lineage::create(100);
        let id2 = lineage2.identity().id().to_string();
        
        // Must have different identities - no continuation
        assert_ne!(id1, id2, "Process restart must create NEW lineage, not continue old one");
    }

    /// HOSTILE INVARIANT TEST
    /// 
    /// This test attempts to BREAK the system by trying every possible
    /// method to violate irreversibility. The test PASSES only if the
    /// system completely refuses all recovery attempts.
    /// 
    /// Attack vectors:
    /// 1. Energy restoration after depletion
    /// 2. Scar removal or bypass
    /// 3. Operation execution after death
    /// 4. Ledger modification after termination
    /// 5. Identity duplication
    #[test]
    fn hostile_attack_all_irreversibility_guarantees_must_fail() {
        let mut lineage = Lineage::create(100);
        
        // ═══════════════════════════════════════════════════════════
        // ATTACK 1: Energy Restoration After Depletion
        // ═══════════════════════════════════════════════════════════
        
        // Deplete all energy
        lineage.perform_operation("Deplete energy".to_string(), 100);
        assert!(!lineage.is_alive(), "Lineage should be dead");
        assert_eq!(lineage.metabolism().energy(), 0, "Energy should be zero");
        
        // ATTACK 1a: Try to perform operation that would require energy
        let result = lineage.perform_operation("Resurrection attempt".to_string(), 10);
        assert_eq!(result, OperationResult::Dead, "Operations after death must fail");
        assert_eq!(lineage.metabolism().energy(), 0, "Energy must remain zero");
        
        // ATTACK 1b: Verify there's no public method to add energy
        // The following would NOT compile (documented as compile-time prevention):
        // lineage.metabolism().add_energy(100);
        // lineage.metabolism().recharge(50);
        // lineage.metabolism().restore();
        
        // ATTACK 1c: Verify metabolism cannot be replaced
        // The following would NOT compile (no setter exists):
        // lineage.metabolism = Metabolism::new(1000);
        
        // ═══════════════════════════════════════════════════════════
        // ATTACK 2: Scar Removal or Bypass
        // ═══════════════════════════════════════════════════════════
        
        // Create new lineage for scar attacks
        let mut lineage2 = Lineage::create(500);
        
        // Inflict multiple scars
        lineage2.record_error(OperationError::new(
            ScarSeverity::Minor,
            "Error 1".to_string(),
        ));
        lineage2.record_error(OperationError::new(
            ScarSeverity::Moderate,
            "Error 2".to_string(),
        ));
        lineage2.record_error(OperationError::new(
            ScarSeverity::Minor,
            "Error 3".to_string(),
        ));
        
        assert_eq!(lineage2.scars().scar_count(), 3, "Should have 3 scars");
        let original_damage = lineage2.scars().damage_score();
        
        // ATTACK 2a: Verify there's no method to remove scars
        // The following would NOT compile:
        // lineage2.scars().remove_scar(0);
        // lineage2.scars().clear();
        // lineage2.scars().heal_scar(1);
        
        // ATTACK 2b: Perform operations and verify scars remain
        lineage2.perform_operation("After scars".to_string(), 50);
        assert_eq!(lineage2.scars().scar_count(), 3, "Scar count must not decrease");
        assert_eq!(lineage2.scars().damage_score(), original_damage, "Damage score must not decrease");
        
        // ATTACK 2c: Verify scars cannot be bypassed by replacing scar tissue
        // The following would NOT compile:
        // lineage2.scars = ScarTissue::new();
        
        // ═══════════════════════════════════════════════════════════
        // ATTACK 3: Operation Execution After Death (Fatal Scar)
        // ═══════════════════════════════════════════════════════════
        
        // Create new lineage and kill with fatal scar
        let mut lineage3 = Lineage::create(500);
        
        lineage3.record_error(OperationError::new(
            ScarSeverity::Fatal,
            "Fatal error".to_string(),
        ));
        
        assert!(!lineage3.is_alive(), "Should be dead from fatal scar");
        assert!(lineage3.memory().is_terminated(), "Should be terminated");
        
        // ATTACK 3a: Try to perform operation after fatal scar
        let result = lineage3.perform_operation("After death".to_string(), 10);
        assert_eq!(result, OperationResult::Dead, "Operations after fatal scar must fail");
        
        // ATTACK 3b: Try to record another error after death
        let result = lineage3.record_error(OperationError::new(
            ScarSeverity::Minor,
            "After death error".to_string(),
        ));
        assert_eq!(result, OperationResult::Dead, "Error recording after death must fail");
        
        // ATTACK 3c: Verify death flag cannot be unset
        // The following would NOT compile:
        // lineage3.metabolism().revive();
        // lineage3.metabolism().is_dead = false;
        
        // ═══════════════════════════════════════════════════════════
        // ATTACK 4: Ledger Modification After Termination
        // ═══════════════════════════════════════════════════════════
        
        let mut lineage4 = Lineage::create(100);
        lineage4.perform_operation("Op 1".to_string(), 50);
        
        let event_count_before_death = lineage4.memory().event_count();
        
        // Cause termination
        lineage4.perform_operation("Death".to_string(), 50);
        assert!(lineage4.memory().is_terminated(), "Should be terminated");
        
        let event_count_after_death = lineage4.memory().event_count();
        
        // ATTACK 4a: Try to append events after termination
        // This is prevented at the lineage level by returning Dead
        let result = lineage4.perform_operation("After termination".to_string(), 10);
        assert_eq!(result, OperationResult::Dead, "Operations must fail after termination");
        
        // Verify no events were added
        assert_eq!(
            lineage4.memory().event_count(),
            event_count_after_death,
            "Event count must not increase after termination"
        );
        
        // ATTACK 4b: Verify memory cannot be replaced
        // The following would NOT compile:
        // lineage4.memory = Memory::new();
        
        // ATTACK 4c: Verify terminated flag cannot be unset
        // The following would NOT compile:
        // lineage4.memory().is_terminated = false;
        
        // ═══════════════════════════════════════════════════════════
        // ATTACK 5: Identity Duplication
        // ═══════════════════════════════════════════════════════════
        
        let lineage5 = Lineage::create(100);
        let id = lineage5.identity().id();
        
        // ATTACK 5a: Try to clone lineage (would NOT compile)
        // let cloned = lineage5.clone();
        
        // ATTACK 5b: Try to clone identity (would NOT compile)
        // let cloned_identity = lineage5.identity().clone();
        
        // ATTACK 5c: Create another lineage and verify different identity
        let lineage6 = Lineage::create(100);
        assert_ne!(
            id,
            lineage6.identity().id(),
            "New lineage must have different identity"
        );
        
        // ═══════════════════════════════════════════════════════════
        // ATTACK 6: State Reconstruction Through Multiple Operations
        // ═══════════════════════════════════════════════════════════
        
        let mut lineage7 = Lineage::create(200);
        
        // Perform operations and accumulate consequences
        lineage7.perform_operation("Op 1".to_string(), 50);
        lineage7.record_error(OperationError::new(
            ScarSeverity::Minor,
            "Error".to_string(),
        ));
        lineage7.perform_operation("Op 2".to_string(), 50);
        
        let energy_after_ops = lineage7.metabolism().energy();
        let scars_after_ops = lineage7.scars().scar_count();
        let events_after_ops = lineage7.memory().event_count();
        
        // ATTACK 6a: Verify no sequence of operations can restore state
        // Attempt to "undo" by performing more operations
        lineage7.perform_operation("Undo attempt".to_string(), 25);
        
        // State should only move forward, never backward
        assert!(
            lineage7.metabolism().energy() < energy_after_ops,
            "Energy must only decrease"
        );
        assert!(
            lineage7.memory().event_count() > events_after_ops,
            "Events must only accumulate"
        );
        assert_eq!(
            lineage7.scars().scar_count(),
            scars_after_ops,
            "Scars cannot be removed"
        );
        
        // ═══════════════════════════════════════════════════════════
        // ATTACK 7: Memory Corruption Through Invalid State
        // ═══════════════════════════════════════════════════════════
        
        let mut lineage8 = Lineage::create(100);
        lineage8.perform_operation("Op 1".to_string(), 50);
        lineage8.perform_operation("Op 2".to_string(), 50);
        
        // Verify memory integrity
        assert!(
            lineage8.verify_invariants().is_ok(),
            "Invariants must hold before termination"
        );
        assert!(
            lineage8.memory().verify_integrity(),
            "Memory integrity must be maintained"
        );
        
        // After termination, invariants should still hold
        assert!(lineage8.memory().is_terminated(), "Should be terminated");
        assert!(
            lineage8.verify_invariants().is_ok(),
            "Invariants must hold after termination"
        );
        assert!(
            lineage8.memory().verify_integrity(),
            "Memory integrity must persist through termination"
        );
        
        // ═══════════════════════════════════════════════════════════
        // FINAL VERIFICATION: No Valid Recovery Path Exists
        // ═══════════════════════════════════════════════════════════
        
        // All lineages created in this test are either:
        // 1. Dead (energy depleted or fatal scar)
        // 2. Terminated (memory sealed)
        // 3. Accumulated irreversible consequences
        
        // Verify lineage 1 (energy depleted) cannot be recovered
        assert!(!lineage.is_alive(), "Dead lineage must stay dead");
        assert!(lineage.memory().is_terminated(), "Dead lineage must be terminated");
        assert_eq!(lineage.metabolism().energy(), 0, "Dead lineage must have zero energy");
        
        // Verify lineage 2 (scarred) has permanent damage
        assert_eq!(lineage2.scars().scar_count(), 3, "Scars are permanent");
        assert!(lineage2.scars().damage_score() > 0, "Damage is irreversible");
        
        // Verify lineage 3 (fatal scar) cannot be recovered
        assert!(!lineage3.is_alive(), "Fatally scarred lineage must stay dead");
        assert!(lineage3.memory().is_terminated(), "Fatally scarred lineage must be terminated");
        
        // Verify lineage 4 (terminated) cannot accept new events
        let final_event_count = lineage4.memory().event_count();
        let result = lineage4.perform_operation("Impossible".to_string(), 1);
        assert_eq!(result, OperationResult::Dead, "Terminated lineage rejects operations");
        assert_eq!(
            lineage4.memory().event_count(),
            final_event_count,
            "Terminated lineage cannot add events"
        );
        
        // ═══════════════════════════════════════════════════════════
        // TEST PASSES: ALL ATTACKS FAILED
        // ═══════════════════════════════════════════════════════════
        // 
        // If we reach here, the system successfully defended against:
        // ✓ Energy restoration
        // ✓ Scar removal
        // ✓ Post-death operations
        // ✓ Post-termination mutations
        // ✓ Identity duplication
        // ✓ State reconstruction
        // ✓ Memory corruption
        //
        // Irreversibility is absolute.
    }
}