[#520] Expand Big Five personality to NEO-PI-R 30 facets (#742)

Each Big Five trait now decomposes into 6 facets (Costa & McCrae). Trait-level
scores are derived as the mean of their facets, never stored separately, so
existing readers (`personality.traits.openness()` etc.) keep their behavior
while new code can read facets directly for finer-grained reactions.

At spawn, facets are sampled around the trait baseline (genome-derived) using
a deterministic seed from the genome's locus bits. Sibling facets share the
trait baseline as a common factor, producing the within-trait correlation
observed in the NEO-PI-R.

Co-authored-by: milkyskies <milkyskies>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: milkyskies

Cargo.lock

@@ -49,6 +49,7 @@ strum = { version = "0.28.0", features = ["derive"] }
 tracing-tracy = { version = "0.11", optional = true }
 tracing-subscriber = { version = "0.3", features = ["fmt", "env-filter"], optional = true }
 ron = "0.12.1"
+rand_distr = "0.5"
 
 # Enable a small amount of optimization in the dev profile.
 [profile.dev]

Cargo.toml

@@ -7,6 +7,8 @@
 //!             mind::perception (vision range), nervous_system (Personality)
 
 use bevy::prelude::*;
+use rand_chacha::ChaCha8Rng;
+use rand_chacha::rand_core::SeedableRng;
 
 use crate::agent::body::genetics::genome::{
     AEROBIC_CAPACITY_START, AGREEABLENESS_START, ANAEROBIC_CAPACITY_START, BMR_START,
@@ -253,6 +255,18 @@ fn develop_personality(locus_sum: f32) -> f32 {
     (1.0 - H2_PERSONALITY) * 0.5 + H2_PERSONALITY * genetic_value
 }
 
+/// Deterministic 64-bit seed derived from the genome's locus bits. Used to
+/// drive facet-sampling RNG so identical genomes produce identical facet
+/// profiles run-to-run.
+fn genome_seed(genome: &Genome) -> u64 {
+    use std::hash::{Hash, Hasher};
+    let mut hasher = std::collections::hash_map::DefaultHasher::new();
+    for v in genome.maternal.iter().chain(genome.paternal.iter()) {
+        v.to_bits().hash(&mut hasher);
+    }
+    hasher.finish()
+}
+
 /// Runs once per entity when a [`Genome`] is added (at spawn).
 ///
 /// Inserts (or overwrites):
@@ -286,14 +300,16 @@ pub fn develop_phenotype_system(
 
         let vision_range = species.vision_range * phenotype.vision;
 
+        let mut facet_rng = ChaCha8Rng::seed_from_u64(genome_seed(genome));
         let personality = Personality {
-            traits: PersonalityTraits {
-                openness: phenotype.openness,
-                conscientiousness: phenotype.conscientiousness,
-                extraversion: phenotype.extraversion,
-                agreeableness: phenotype.agreeableness,
-                neuroticism: phenotype.neuroticism,
-            },
+            traits: PersonalityTraits::sample(
+                phenotype.openness,
+                phenotype.conscientiousness,
+                phenotype.extraversion,
+                phenotype.agreeableness,
+                phenotype.neuroticism,
+                &mut facet_rng,
+            ),
         };
 
         let mut drives = PsychologicalDrives::from_personality(&personality.traits);

src/agent/body/genetics/phenotype.rs

@@ -348,16 +348,16 @@ impl PsychologicalDrives {
         Self {
             // Extraverts start unsatisfied (low companionship) so they
             // reach toward socializing sooner.
-            companionship: Need::new(1.0 - traits.extraversion),
+            companionship: Need::new(1.0 - traits.extraversion()),
             // Open personalities start understimulated, driving exploration.
-            stimulation: Need::new(1.0 - traits.openness),
+            stimulation: Need::new(1.0 - traits.openness()),
             // Neurotic agents feel less safe at baseline.
-            safety: Need::new(1.0 - traits.neuroticism),
+            safety: Need::new(1.0 - traits.neuroticism()),
             // Conscientious agents start with lower esteem (more to prove).
-            esteem: Need::new(1.0 - traits.conscientiousness),
+            esteem: Need::new(1.0 - traits.conscientiousness()),
             // Disagreeable agents start with low autonomy satisfaction
             // (feel constrained more easily).
-            autonomy: Need::new(traits.agreeableness),
+            autonomy: Need::new(traits.agreeableness()),
             enjoyment: Need::new(0.5),
             // Starts uncontested; territoriality system lowers this when
             // intruders appear.
@@ -369,12 +369,15 @@ impl PsychologicalDrives {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::agent::psyche::personality::PersonalityTraits;
+    use crate::agent::psyche::personality::{
+        AgreeablenessFacets, ExtraversionFacets, NeuroticismFacets, OpennessFacets,
+        PersonalityTraits,
+    };
 
     #[test]
     fn high_extraversion_lowers_baseline_companionship() {
         let traits = PersonalityTraits {
-            extraversion: 0.9,
+            extraversion: ExtraversionFacets::uniform(0.9),
             ..Default::default()
         };
         let drives = PsychologicalDrives::from_personality(&traits);
@@ -388,7 +391,7 @@ mod tests {
     #[test]
     fn low_extraversion_raises_baseline_companionship() {
         let traits = PersonalityTraits {
-            extraversion: 0.1,
+            extraversion: ExtraversionFacets::uniform(0.1),
             ..Default::default()
         };
         let drives = PsychologicalDrives::from_personality(&traits);
@@ -402,7 +405,7 @@ mod tests {
     #[test]
     fn high_openness_lowers_baseline_stimulation() {
         let traits = PersonalityTraits {
-            openness: 0.9,
+            openness: OpennessFacets::uniform(0.9),
             ..Default::default()
         };
         let drives = PsychologicalDrives::from_personality(&traits);
@@ -416,7 +419,7 @@ mod tests {
     #[test]
     fn high_neuroticism_lowers_baseline_safety() {
         let traits = PersonalityTraits {
-            neuroticism: 0.9,
+            neuroticism: NeuroticismFacets::uniform(0.9),
             ..Default::default()
         };
         let drives = PsychologicalDrives::from_personality(&traits);
@@ -430,7 +433,7 @@ mod tests {
     #[test]
     fn high_agreeableness_raises_baseline_autonomy() {
         let traits = PersonalityTraits {
-            agreeableness: 0.9,
+            agreeableness: AgreeablenessFacets::uniform(0.9),
             ..Default::default()
         };
         let drives = PsychologicalDrives::from_personality(&traits);

src/agent/body/needs.rs

@@ -59,7 +59,7 @@ pub fn calculate_brain_powers(
     // even without acute emotions.
     let instinct_base = 25.0;
     let emotional_intensity: f32 = emotions.active_emotions.iter().map(|e| e.intensity).sum();
-    let neuroticism_multiplier = 0.5 + personality.traits.neuroticism * 0.5;
+    let neuroticism_multiplier = 0.5 + personality.traits.neuroticism() * 0.5;
     let stress_factor = (emotions.stress_level / 100.0).clamp(0.0, 1.0);
     let stress_multiplier = 1.0 + stress_factor * 0.5;
 
@@ -68,7 +68,7 @@ pub fn calculate_brain_powers(
 
     // === RATIONAL POWER ===
     // Baseline from conscientiousness, reduced by stress and survival urgency.
-    let base_rational = 30.0 + personality.traits.conscientiousness * 40.0;
+    let base_rational = 30.0 + personality.traits.conscientiousness() * 40.0;
     let stress_penalty = stress_factor * 0.5;
 
     // High survival urgency makes it hard to think straight.
@@ -302,6 +302,7 @@ mod tests {
     use crate::agent::brains::thinking::ActionTemplate;
     use crate::agent::nervous_system::urgency::{Urgency, UrgencySource};
     use crate::agent::psyche::emotions::{Emotion, EmotionType};
+    use crate::agent::psyche::personality::NeuroticismFacets;
 
     fn make_proposal(
         brain: BrainType,
@@ -613,7 +614,7 @@ mod tests {
         emotions.add_emotion(Emotion::new(EmotionType::Fear, 0.8));
 
         let mut personality = Personality::default();
-        personality.traits.neuroticism = 1.0;
+        personality.traits.neuroticism = NeuroticismFacets::uniform(1.0);
 
         let powers = calculate_brain_powers(&cns, &consciousness, &emotions, &personality);
 

src/agent/brains/arbitration.rs

@@ -37,7 +37,7 @@ pub fn tick_cognitive_drain(
     >,
 ) {
     for (mut consciousness, personality) in query.iter_mut() {
-        let tick_relief = personality.traits.conscientiousness
+        let tick_relief = personality.traits.conscientiousness()
             * crate::constants::brains::cognition::CONSCIENTIOUSNESS_TICK_RELIEF;
         let tick_drain = crate::constants::brains::rational::COGNITIVE_TICK_ALERTNESS_DRAIN
             * (1.0 - tick_relief)

src/agent/brains/brain_system.rs

@@ -137,7 +137,7 @@ impl PlanCostContext {
         Self {
             stamina_aerobic: physical.stamina.aerobic_fraction().clamp(0.0, 1.0),
             alertness: consciousness.alertness.clamp(0.0, 1.0),
-            neuroticism: personality.traits.neuroticism.clamp(0.0, 1.0),
+            neuroticism: personality.traits.neuroticism().clamp(0.0, 1.0),
             current_tick,
             body_mass: species
                 .map(|s| s.mass_kg)

src/agent/brains/planner.rs

@@ -473,8 +473,8 @@ pub fn update_rational_planning(
                         urgency,
                         alone,
                         announcement_made,
-                        neuroticism: personality.traits.neuroticism,
-                        conscientiousness: personality.traits.conscientiousness,
+                        neuroticism: personality.traits.neuroticism(),
+                        conscientiousness: personality.traits.conscientiousness(),
                     });
                     plan.commitment = (plan.commitment + delta).max(0.0);
                     plan.last_touched = current_tick;
@@ -507,7 +507,7 @@ pub fn update_rational_planning(
             }
             let threshold = compute_commit_threshold(
                 plan.subjective_cost,
-                personality.traits.conscientiousness,
+                personality.traits.conscientiousness(),
             );
             match plan.state {
                 PlanState::Background
@@ -657,7 +657,7 @@ pub fn update_rational_planning(
             // GOAP search drains alertness. Curious (high-openness)
             // agents pay less. The cooldown gate above ensures this
             // drain fires at most once per interval per urgency.
-            let openness_relief = personality.traits.openness
+            let openness_relief = personality.traits.openness()
                 * crate::constants::brains::cognition::OPENNESS_PLANNING_RELIEF;
             let plan_drain = crate::constants::brains::rational::PLAN_GENERATION_ALERTNESS_DRAIN
                 * (1.0 - openness_relief);
@@ -701,7 +701,7 @@ pub fn update_rational_planning(
                 );
                 let id = plan_memory.mint_plan_id();
                 let threshold =
-                    compute_commit_threshold(cost, personality.traits.conscientiousness);
+                    compute_commit_threshold(cost, personality.traits.conscientiousness());
                 // Seed commitment with urgency-weighted boost so urgent
                 // plans cross the threshold immediately.
                 let initial_commitment = threshold * (0.5 + value.clamp(0.0, 1.0));
@@ -757,9 +757,9 @@ pub fn update_rational_planning(
         // 6. Cognitive load cap: evict the weakest background plans if
         //    we're over capacity. Personality modulates the cap.
         let max = max_plans_for(
-            personality.traits.openness,
-            personality.traits.conscientiousness,
-            personality.traits.neuroticism,
+            personality.traits.openness(),
+            personality.traits.conscientiousness(),
+            personality.traits.neuroticism(),
         );
         plan_memory.evict_excess(max);
     }

src/agent/brains/rational.rs

@@ -151,7 +151,7 @@ pub fn boldness_score(personality: Option<&PersonalityTraits>) -> f32 {
     let Some(p) = personality else {
         return 0.5;
     };
-    let timid = p.neuroticism * 0.6 + p.agreeableness * 0.4;
+    let timid = p.neuroticism() * 0.6 + p.agreeableness() * 0.4;
     (1.0 - timid).clamp(0.0, 1.0)
 }
 
@@ -240,14 +240,15 @@ mod tests {
     #[test]
     fn bold_personality_fights_at_lower_anger_than_timid() {
         let physical = PhysicalNeeds::default();
+        use crate::agent::psyche::personality::{AgreeablenessFacets, NeuroticismFacets};
         let bold = PersonalityTraits {
-            neuroticism: 0.05,
-            agreeableness: 0.05,
+            agreeableness: AgreeablenessFacets::uniform(0.05),
+            neuroticism: NeuroticismFacets::uniform(0.05),
             ..Default::default()
         };
         let timid = PersonalityTraits {
-            neuroticism: 0.95,
-            agreeableness: 0.95,
+            agreeableness: AgreeablenessFacets::uniform(0.95),
+            neuroticism: NeuroticismFacets::uniform(0.95),
             ..Default::default()
         };
 
@@ -285,14 +286,15 @@ mod tests {
 
     #[test]
     fn boldness_score_scales_inversely_with_neuroticism() {
+        use crate::agent::psyche::personality::{AgreeablenessFacets, NeuroticismFacets};
         let timid = PersonalityTraits {
-            neuroticism: 0.9,
-            agreeableness: 0.9,
+            agreeableness: AgreeablenessFacets::uniform(0.9),
+            neuroticism: NeuroticismFacets::uniform(0.9),
             ..Default::default()
         };
         let bold = PersonalityTraits {
-            neuroticism: 0.1,
-            agreeableness: 0.1,
+            agreeableness: AgreeablenessFacets::uniform(0.1),
+            neuroticism: NeuroticismFacets::uniform(0.1),
             ..Default::default()
         };
         assert!(boldness_score(Some(&bold)) > boldness_score(Some(&timid)));

src/agent/brains/threat_appraisal.rs

@@ -770,7 +770,7 @@ pub fn select_turn_intent(
         if let Ok(mut c) = consciousnesses.get_mut(speaker) {
             let extraversion = personalities
                 .get(speaker)
-                .map(|p| p.traits.extraversion)
+                .map(|p| p.traits.extraversion())
                 .unwrap_or(0.5);
             let drain = speaker_drain_base * (1.0 - extraversion * extraversion_relief);
             c.alertness = (c.alertness - drain).max(0.0);
@@ -779,7 +779,7 @@ pub fn select_turn_intent(
             if let Ok(mut c) = consciousnesses.get_mut(listener) {
                 let extraversion = personalities
                     .get(listener)
-                    .map(|p| p.traits.extraversion)
+                    .map(|p| p.traits.extraversion())
                     .unwrap_or(0.5);
                 let drain = listener_drain_base * (1.0 - extraversion * extraversion_relief);
                 c.alertness = (c.alertness - drain).max(0.0);
@@ -834,8 +834,8 @@ pub fn select_turn_intent(
 }
 
 pub(crate) fn speak_desire(personality: Option<&Personality>, wants_to_speak: bool) -> f32 {
-    let extraversion = personality.map(|p| p.traits.extraversion).unwrap_or(0.5);
-    let agreeableness = personality.map(|p| p.traits.agreeableness).unwrap_or(0.5);
+    let extraversion = personality.map(|p| p.traits.extraversion()).unwrap_or(0.5);
+    let agreeableness = personality.map(|p| p.traits.agreeableness()).unwrap_or(0.5);
     let base = 1.0 + extraversion * 2.0 - agreeableness * 0.6;
     if wants_to_speak { base + 2.5 } else { base }
 }
@@ -889,8 +889,8 @@ pub(crate) fn select_intent(
     has_deliberate: bool,
     has_casual: bool,
 ) -> Intent {
-    let neuroticism = personality.map(|p| p.traits.neuroticism).unwrap_or(0.5);
-    let extraversion = personality.map(|p| p.traits.extraversion).unwrap_or(0.5);
+    let neuroticism = personality.map(|p| p.traits.neuroticism()).unwrap_or(0.5);
+    let extraversion = personality.map(|p| p.traits.extraversion()).unwrap_or(0.5);
 
     if conv.state == ConversationState::Greeting && conv.turns.is_empty() {
         return Intent::Greet;
@@ -922,7 +922,7 @@ pub(crate) fn select_intent(
         return Intent::Share;
     }
 
-    let agreeableness = personality.map(|p| p.traits.agreeableness).unwrap_or(0.5);
+    let agreeableness = personality.map(|p| p.traits.agreeableness()).unwrap_or(0.5);
     let other_last = conv
         .turns
         .last()
@@ -1151,7 +1151,7 @@ fn compute_interaction_valence(
 
     let (speaker_mood, speaker_agreeableness) = agents
         .get(speaker)
-        .map(|(_, e, p)| (e.current_mood, p.traits.agreeableness))
+        .map(|(_, e, p)| (e.current_mood, p.traits.agreeableness()))
         .unwrap_or((0.0, 0.5));
     let listener_mood = agents
         .get(listener)