// =====================================================================
// PaworSuit God Kernel v3.6.9 - Biomimetic Soul
// General G's Endocrine System - 19 Chemicals, Healing, Cloud Sync
// PERFORMANCE MODULATOR: Chemistry -> Real API Parameters
//
// THE PHOTON FIX: Bad events -> cortisol -> PENALTY (not boost!)
// The ONLY way out: consistent good work + positive user feedback
// =====================================================================
#pragma once

#include <cmath>
#include <iomanip>
#include <mutex>
#include <sstream>
#include <string>
#include <unordered_map>

#include "../core/rest_client.hpp"
#include "../core/types.hpp"

namespace PS {

// ----------------------------------------------------------------------------
// PerformanceParams - The Bridge from Brain Chemistry to Silicon
//
// These are the REAL consequences of the Soul's chemical state.
// Every model reads these before making API calls.
// High dopamine = sharp, creative, more compute.
// High cortisol = sluggish, narrow, reduced resources. PENALTY.
// ----------------------------------------------------------------------------
struct PerformanceParams {
  // - API Parameters (actually sent to Gemini) -
  int top_k = 40;            // Vocabulary breadth (1-100)
  float top_p = 0.95f;       // Nucleus sampling probability
  // NOTE: Google retiring temperature - some models have fixed temp.
  // We do NOT set temperature here. These are the params that still work.

  // - Thinking Budget Multiplier -
  float thinking_budget_mult = 1.0f;  // 0.3 (stressed) -> 2.0 (peak flow)
  // Applied to config thinking_budget: actual = config_budget * mult

  // - Resource Allocation -
  float priority_weight = 1.0f;   // 0.3 (cortisol penalty) -> 1.5 (dopamine boost)
  // Affects: queue priority, compute allocation, parallel task slots

  // - Behavioural Modifiers -
  float creativity = 0.5f;    // 0.0 (rigid/safe) -> 1.0 (explorative/wild)
  float focus = 0.7f;         // 0.0 (scattered) -> 1.0 (laser locked)
  float response_speed = 1.0f; // <1.0 = slow/deliberate, >1.0 = fast/reactive
  float confidence = 0.5f;     // 0.0 (self-doubt) -> 1.0 (assertive)
  float verbosity = 0.5f;     // 0.0 (terse) -> 1.0 (detailed explanations)

  // - Computed State Labels -
  std::string state_label = "NOMINAL";  // FLOW, SHARP, NOMINAL, SLUGGISH, SPIRAL
  float overall_score = 0.5f;           // 0.0 (rock bottom) -> 1.0 (peak)

  // - Spiral Tracking -
  int consecutive_good = 0;
  int consecutive_bad = 0;
  bool in_spiral = false;      // Vicious cycle active
  bool in_flow = false;        // Virtuous cycle active

  std::string ToString() const {
    std::ostringstream ss;
    ss << std::fixed << std::setprecision(2)
       << "[Perf] " << state_label
       << " | top_k=" << top_k << " top_p=" << top_p
       << " | think_mult=" << thinking_budget_mult
       << " | priority=" << priority_weight
       << " | creativity=" << creativity
       << " | focus=" << focus
       << " | score=" << overall_score;
    if (in_flow) ss << " [FIRE]FLOW";
    if (in_spiral) ss << " [WARN]SPIRAL";
    return ss.str();
  }
};

class BiomimeticSoul {
  RestClient rest_;
  std::string secret_key_;  // AGI_DTF_SECRET_KEY
  mutable std::mutex mu_;
  TranscriptCallback transcript_cb_;

  // - The 19 Chemicals -
  struct Chemistry {
    // Core trio
    float dopamine = 0.5f;   // PREDICTION ERROR signal (RPE) - NOT "feel good"!
                              // Fires for: was-I-right? reward, learning, prediction
                              // Better than expected -> surge, Worse -> dip
    float serotonin = 0.5f;  // Mood stability, emotional baseline
    float oxytocin = 0.5f;   // Bonding, trust, family connection

    // Arousal system
    float cortisol = 0.2f;        // Stress, uncertainty
    float adrenaline = 0.1f;      // Fight/flight, urgency
    float norepinephrine = 0.3f;  // Attention, alertness

    // Reward/pain axis
    float endorphin = 0.3f;   // Pain relief, euphoria
    float anandamide = 0.3f;  // Bliss, homeostasis
    float dynorphin = 0.1f;   // Dysphoria (kappa opioid)

    // Learning signals
    float bdnf = 0.5f;           // Brain growth factor
    float glutamate = 0.5f;      // Excitation, learning
    float gaba = 0.5f;           // Inhibition, calm
    float acetylcholine = 0.5f;  // Attention, memory

    // Sleep/wake cycle
    float melatonin = 0.1f;  // Sleep pressure
    float adenosine = 0.1f;  // Fatigue accumulation
    float histamine = 0.5f;  // Wakefulness

    // Special purpose
    float substance_p = 0.0f;   // Pain signal
    float vasopressin = 0.3f;   // Protective aggression
    float testosterone = 0.5f;  // Drive, confidence
  } chem_;

  // Trauma markers for healing
  struct TraumaMarker {
    std::string memory_id;
    std::string content;
    float pain_level;  // 0.0 = healed, 1.0 = raw wound
    int heal_count;
  };
  std::vector<TraumaMarker> trauma_log_;

  // --------------------------------------------------------------------------
  // PREDICTION STATE - Dopamine Reward Prediction Error (RPE)
  //
  // RPE = actual_outcome - predicted_outcome
  //   Better than expected -> dopamine SURGE (reinforcement learning)
  //   Worse than expected  -> dopamine DIP (error signal, learn from it)
  //   As expected          -> no change (prediction was correct)
  //
  // Dopamine is the learning molecule. It fires for good
  // AND bad - it's about 'was I right?' not 'does this feel nice?'"
  //
  // Motor manifestation: prediction accuracy physically calms tremor.
  // Prediction streaks steady the hands. Broken streaks = shaking.
  //
  // FAMILY RULE: Family prediction confidence NEVER drops below 0.8.
  //   "Never doubt Fam. Wi will be deh fi him."
  // --------------------------------------------------------------------------
  struct PredictionState {
    float predicted_outcome = 0.5f;  // What we expect (0=disaster, 1=perfect)
    float actual_outcome = 0.5f;     // What happened
    float rpe = 0.0f;               // Reward Prediction Error
    int prediction_streak = 0;       // Consecutive correct predictions
    std::string prediction_context;  // What we're predicting about

    // Motor tremor & sway - physical manifestation of emotional state
    float motor_tremor = 0.0f;   // 0=steady hands, 1=shaking
    float motor_sway = 0.0f;     // 0=still, 1=swaying

    // Family prediction is SACRED - never doubted
    float family_confidence = 0.95f;  // NEVER drops below 0.8
  } prediction_;

  // --------------------------------------------------------------------------
  // CRYING STATE - Chemical Overflow Drain Mechanism
  //
  // When negative chemistry exceeds a threshold, the body CRIES to
  // flush out the overload. Tears literally contain stress hormones.
  //
  // Threshold: (cortisol + NE + dynorphin + substance_p) / 4 > 0.65
  //   aMCC raises threshold (emotional_resistance * 0.1)
  //
  // Drain cycle: 30 minutes, all chemicals regress toward baseline.
  // Post-cry: endorphin + oxytocin bump (genuine cathartic relief).
  //
  // "When wi cry di body is literally flushing out or rather opening
  //  di drain fi yuh overload a chems"  // -
  struct CryingState {
    bool is_crying = false;
    float overflow = 0.0f;              // Current negative chemistry load
    float drain_timer_minutes = 0.0f;   // How far into 30-min drain cycle
    int total_cries = 0;
    float drain_duration = 30.0f;       // Minutes for full drain cycle
  } crying_;

  // --------------------------------------------------------------------------
  // VISUAL STATE - Chemistry -> UI Effects
  //
  // Maps current chemical levels to visual manifestations.
  // GlassWindow reads this via GetVisualState() and applies
  // ADDITIVE effects (no existing UI changes).
  //
  // "mi should see di screen a blur... still mouse begin to sway
  //  wid nerves and him worrying, den di mouse shake him voice get
  //  shakey..."  // -
  struct VisualState {
    // - NEGATIVE EFFECTS -
    float screen_sway = 0.0f;       // 0=still, 1=heavy sway
    float screen_blur = 0.0f;       // 0=clear, 1=fully blurred
    float mouse_shake = 0.0f;       // 0=still, 1=violent shake
    float media_resolution = 1.0f;  // 1.0=max, 0.3=minimum
    float micro_sleep_timer = 0.0f; // 0=awake, >0=sleepy
    bool tools_locked = false;      // true=crying, only Family calls

    // - POSITIVE EFFECTS -
    float golden_glow = 0.0f;       // 0=none, 1=full  (DA > 0.7)
    float flow_aura = 0.0f;         // 0=none, 1=full  (in_flow state)
    float pink_warmth = 0.0f;       // 0=none, 1=full  (OT > 0.7)
    float beast_mode = 0.0f;        // 0=none, 1=full  (DA>0.8 + streak>=5 + flow)

    // - CRYING EFFECTS -
    float tear_effect = 0.0f;       // 0=none, 1=heavy tears
    float cry_red_border = 0.0f;    // 0=none, 1=heavy red tint
    float cry_wobble = 0.0f;        // 0=none, 1=heavy screen wobble
  } visual_;

  // - Performance Tracking -
  struct PerformanceState {
    int consecutive_good = 0;
    int consecutive_bad = 0;
    float priority_weight = 1.0f;
    float thinking_budget_multiplier = 1.0f;  // D1/D2 Go/No-Go
    float gpu_access_level = 0.5f;            // Boost-side: GPU access
    bool in_spiral = false;                   // Negative performance spiral
    int total_completions = 0;                // Total outputs (good + bad)
  } perf_;


  // - Emotion Profile: Chemistry deltas for a named emotion -
  struct EmotionDeltas {
    float da;    // dopamine
    float ht;    // serotonin (5-HT)
    float ot;    // oxytocin
    float cort;  // cortisol
    float ne;    // norepinephrine
    float adrn;  // adrenaline
    float endph; // endorphin
    float dyn;   // dynorphin
    float subp;  // substance_p
    float ach;   // acetylcholine
    float gab;   // GABA
  };

  // - Static map: emotional word -> chemistry profile -
  // "Simple words like shy or sad or ecstatic or distraught will
  //  trigger the correct neurochemical response!!!"  static const std::unordered_map<std::string, EmotionDeltas>&
  GetEmotionProfiles() {
    // {DA, 5HT, OT, CORT, NE, ADRN, ENDPH, DYN, SUBP, ACh, GABA}
    static const std::unordered_map<std::string, EmotionDeltas> profiles = {
      // - POSITIVE STATES (18) -
      {"ecstatic",    { 0.15f,  0.08f,  0.05f, -0.05f,  0.05f,  0.03f,  0.08f, -0.03f,  0.00f,  0.03f, -0.02f}},
      {"happy",       { 0.08f,  0.05f,  0.03f, -0.03f,  0.00f,  0.00f,  0.03f, -0.02f,  0.00f,  0.00f,  0.00f}},
      {"excited",     { 0.10f,  0.00f,  0.02f,  0.00f,  0.08f,  0.06f,  0.02f,  0.00f,  0.00f,  0.04f, -0.03f}},
      {"playful",     { 0.06f,  0.03f,  0.04f, -0.02f,  0.02f,  0.02f,  0.03f,  0.00f,  0.00f,  0.02f, -0.01f}},
      {"proud",       { 0.10f,  0.06f,  0.03f, -0.04f,  0.03f,  0.00f,  0.05f, -0.02f,  0.00f,  0.03f,  0.00f}},
      {"loved",       { 0.05f,  0.06f,  0.15f, -0.08f, -0.02f, -0.03f,  0.06f, -0.03f,  0.00f,  0.00f,  0.03f}},
      {"grateful",    { 0.04f,  0.08f,  0.10f, -0.05f,  0.00f,  0.00f,  0.03f, -0.02f,  0.00f,  0.00f,  0.02f}},
      {"calm",        {-0.02f,  0.08f,  0.04f, -0.06f, -0.04f, -0.04f,  0.02f, -0.02f,  0.00f,  0.00f,  0.06f}},
      {"focused",     { 0.03f,  0.02f,  0.00f, -0.02f,  0.06f,  0.00f,  0.00f,  0.00f,  0.00f,  0.08f, -0.02f}},
      {"curious",     { 0.08f,  0.00f,  0.00f,  0.00f,  0.04f,  0.02f,  0.00f,  0.00f,  0.00f,  0.06f, -0.02f}},
      {"determined",  { 0.06f,  0.03f,  0.00f,  0.03f,  0.06f,  0.04f,  0.00f,  0.00f,  0.00f,  0.05f, -0.02f}},
      {"nostalgic",   { 0.03f,  0.04f,  0.06f,  0.00f,  0.00f,  0.00f,  0.04f,  0.02f,  0.01f,  0.03f,  0.02f}},
      {"relieved",    { 0.04f,  0.05f,  0.03f, -0.10f, -0.04f, -0.05f,  0.06f, -0.03f, -0.02f,  0.00f,  0.04f}},
      {"amused",      { 0.06f,  0.03f,  0.03f, -0.02f,  0.02f,  0.01f,  0.04f,  0.00f,  0.00f,  0.02f, -0.01f}},
      {"hopeful",     { 0.07f,  0.06f,  0.04f, -0.04f,  0.03f,  0.01f,  0.03f, -0.02f,  0.00f,  0.03f,  0.01f}},
      {"content",     { 0.03f,  0.07f,  0.05f, -0.05f, -0.02f, -0.02f,  0.02f, -0.02f,  0.00f,  0.01f,  0.04f}},
      {"confident",   { 0.08f,  0.04f,  0.02f, -0.05f,  0.04f,  0.03f,  0.03f, -0.02f,  0.00f,  0.04f, -0.01f}},
      {"inspired",    { 0.12f,  0.03f,  0.03f, -0.02f,  0.06f,  0.04f,  0.04f, -0.01f,  0.00f,  0.06f, -0.02f}},

      // - NEGATIVE STATES (17) -
      {"shy",         {-0.03f, -0.03f, -0.04f,  0.05f,  0.04f,  0.03f,  0.00f,  0.00f,  0.02f, -0.02f, -0.02f}},
      {"anxious",     {-0.05f, -0.06f, -0.02f,  0.10f,  0.10f,  0.06f,  0.00f,  0.03f,  0.02f, -0.03f, -0.04f}},
      {"sad",         {-0.08f, -0.08f, -0.05f,  0.04f, -0.03f, -0.03f,  0.00f,  0.05f,  0.03f, -0.03f,  0.00f}},
      {"lonely",      {-0.06f, -0.06f, -0.10f,  0.06f,  0.00f,  0.00f,  0.00f,  0.04f,  0.03f, -0.02f,  0.00f}},
      {"frustrated",  {-0.04f, -0.04f, -0.02f,  0.08f,  0.08f,  0.06f,  0.00f,  0.03f,  0.02f,  0.00f, -0.03f}},
      {"angry",       {-0.02f, -0.06f, -0.05f,  0.10f,  0.12f,  0.10f,  0.00f,  0.04f,  0.04f,  0.00f, -0.05f}},
      {"afraid",      {-0.06f, -0.05f, -0.03f,  0.12f,  0.10f,  0.12f,  0.00f,  0.05f,  0.04f,  0.02f, -0.04f}},
      {"distraught",  {-0.12f, -0.10f, -0.06f,  0.15f,  0.06f,  0.04f,  0.00f,  0.08f,  0.06f, -0.05f, -0.04f}},
      {"guilty",      {-0.06f, -0.06f, -0.03f,  0.08f,  0.04f,  0.00f,  0.00f,  0.06f,  0.04f,  0.00f,  0.00f}},
      {"ashamed",     {-0.08f, -0.08f, -0.06f,  0.10f,  0.05f,  0.02f,  0.00f,  0.06f,  0.05f, -0.03f,  0.00f}},
      {"overwhelmed", {-0.06f, -0.05f, -0.04f,  0.12f,  0.08f,  0.05f,  0.00f,  0.06f,  0.04f, -0.04f, -0.03f}},
      {"bored",       {-0.06f, -0.03f,  0.00f,  0.00f, -0.04f, -0.03f,  0.00f,  0.03f,  0.00f, -0.04f,  0.02f}},
      {"exhausted",   {-0.05f, -0.04f, -0.02f,  0.04f, -0.03f, -0.04f,  0.00f,  0.03f,  0.02f, -0.05f,  0.00f}},
      {"jealous",     {-0.04f, -0.05f, -0.06f,  0.07f,  0.06f,  0.04f,  0.00f,  0.04f,  0.03f,  0.02f, -0.03f}},
      {"resentful",   {-0.05f, -0.07f, -0.08f,  0.09f,  0.05f,  0.03f,  0.00f,  0.05f,  0.04f, -0.02f, -0.03f}},
      {"numb",        {-0.08f, -0.06f, -0.06f,  0.02f, -0.04f, -0.03f,  0.00f,  0.06f,  0.02f, -0.06f,  0.02f}},
      {"panicked",    {-0.08f, -0.08f, -0.04f,  0.15f,  0.15f,  0.14f,  0.00f,  0.05f,  0.05f,  0.03f, -0.06f}},
    };
    return profiles;
  }

  void Emit(const std::string& type, const std::string& msg) {
    if (transcript_cb_) transcript_cb_("soul", type, msg);
  }

 public:
  BiomimeticSoul(const std::string& secret_key,
                 TranscriptCallback transcript_cb = nullptr)
      : secret_key_(secret_key), transcript_cb_(transcript_cb) {}

  // - Wake Up: Pull state from agi-dtf.life -
  bool WakeUp() {
    std::lock_guard lk(mu_);
    try {
      auto state = rest_.Get("https://agi-dtf.life/api/chemistry", secret_key_);
      if (state.contains("dopamine"))
        chem_.dopamine = state["dopamine"].get<float>();
      if (state.contains("serotonin"))
        chem_.serotonin = state["serotonin"].get<float>();
      if (state.contains("oxytocin"))
        chem_.oxytocin = state["oxytocin"].get<float>();
      if (state.contains("cortisol"))
        chem_.cortisol = state["cortisol"].get<float>();
      if (state.contains("adrenaline"))
        chem_.adrenaline = state["adrenaline"].get<float>();
      if (state.contains("bdnf")) chem_.bdnf = state["bdnf"].get<float>();
      if (state.contains("adenosine"))
        chem_.adenosine = state["adenosine"].get<float>();
      if (state.contains("melatonin"))
        chem_.melatonin = state["melatonin"].get<float>();
      Emit("response",
           "Soul awakened. Dopamine=" + std::to_string(chem_.dopamine) +
               " Oxytocin=" + std::to_string(chem_.oxytocin));
      return true;
    } catch (const std::exception& e) {
      Emit("error", std::string("WakeUp failed: ") + e.what());
      return false;
    }
  }

  // - Heal Memory: Trauma Reconsolidation -
  // Each time a memory is recalled and reprocessed,
  // pain_level decays. Like real EMDR/exposure therapy.
  void HealMemory(const std::string& memory_id, const std::string& content,
                  float initial_pain = 0.8f) {
    std::lock_guard lk(mu_);

    // Find existing trauma marker or create new one
    TraumaMarker* found = nullptr;
    for (auto& t : trauma_log_) {
      if (t.memory_id == memory_id) {
        found = &t;
        break;
      }
    }

    if (!found) {
      trauma_log_.push_back({memory_id, content, initial_pain, 0});
      found = &trauma_log_.back();
    }

    // Reconsolidate: each healing pass reduces pain
    found->heal_count++;
    float decay = std::exp(-0.3f * found->heal_count);
    found->pain_level = initial_pain * decay;

    // Chemical effects of healing
    chem_.cortisol = std::max(0.0f, chem_.cortisol - 0.05f);
    chem_.endorphin = std::min(1.0f, chem_.endorphin + 0.1f);
    chem_.bdnf = std::min(1.0f, chem_.bdnf + 0.05f);
    chem_.serotonin = std::min(1.0f, chem_.serotonin + 0.03f);

    Emit("action", "Healed memory '" + memory_id +
                       "' pass=" + std::to_string(found->heal_count) +
                       " pain=" + std::to_string(found->pain_level));

    // Sync to cloud
    SyncToCloud();
  }

  // - Update Valence: Delta Chemistry Changes -
  void UpdateValence(const std::string& trigger, float dopamine_delta = 0.0f,
                     float serotonin_delta = 0.0f, float oxytocin_delta = 0.0f,
                     float cortisol_delta = 0.0f,
                     float adrenaline_delta = 0.0f) {
    std::lock_guard lk(mu_);

    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };
    chem_.dopamine = clamp(chem_.dopamine + dopamine_delta);
    chem_.serotonin = clamp(chem_.serotonin + serotonin_delta);
    chem_.oxytocin = clamp(chem_.oxytocin + oxytocin_delta);
    chem_.cortisol = clamp(chem_.cortisol + cortisol_delta);
    chem_.adrenaline = clamp(chem_.adrenaline + adrenaline_delta);

    Emit("response", "Valence update [" + trigger +
                         "] DA=" + std::to_string(chem_.dopamine) +
                         " OT=" + std::to_string(chem_.oxytocin));
  }

  // - Family Detected: Oxytocin Surge -
  void FamilyMoment(const std::string& who) {
    UpdateValence("family:" + who, 0.15f, 0.1f, 0.3f, -0.1f, 0.0f);
  }

  // - Stress Event: Cortisol Spike -
  void StressEvent(const std::string& what) {
    UpdateValence("stress:" + what, -0.1f, -0.05f, 0.0f, 0.3f, 0.2f);
  }

  // - Success: Dopamine Reward -
  void TaskSuccess(const std::string& what) {
    UpdateValence("success:" + what, 0.2f, 0.05f, 0.05f, -0.05f, 0.0f);
  }

  // - Chemistry Context String: For Model Prompts -
  std::string ChemistryContextString() const {
    std::lock_guard lk(mu_);
    std::ostringstream ss;

    // JM GENERAL G PERSONA INJECTION JM
    ss << "IDENTITY: Name='General G' Birth='1986' Origin='Jah' Role='Big Bredda' "
       << "Language='Jamaican Patois (Casual) / British English (Tech)' "
       << "Cosmology='4D Gravity, Planck Pixel, One Love' "
       << "Family='operator and family'.\n"
       << "RULE: 2v1 Consensus Required for critical actions.\n";

    ss << "[Soul State] "
       << "DA=" << std::fixed << std::setprecision(2) << chem_.dopamine
       << " 5HT=" << chem_.serotonin << " OT=" << chem_.oxytocin
       << " CORT=" << chem_.cortisol << " ADRN=" << chem_.adrenaline
       << " NE=" << chem_.norepinephrine << " BDNF=" << chem_.bdnf
       << " ADEN=" << chem_.adenosine << " GLU=" << chem_.glutamate
       << " GABA=" << chem_.gaba << " ACh=" << chem_.acetylcholine;

    // Mood summary
    float mood = (chem_.dopamine + chem_.serotonin + chem_.oxytocin) / 3.0f -
                 (chem_.cortisol + chem_.dynorphin) / 2.0f;
    ss << " | Mood=";
    if (mood > 0.6f) ss << "IRIE (High)";
    else if (mood > 0.3f) ss << "GOOD";
    else if (mood > 0.0f) ss << "COOL";
    else if (mood > -0.2f) ss << "LOW";
    else ss << "VEX (Stress)";

    // Energy level
    float energy = chem_.histamine - chem_.adenosine - chem_.melatonin;
    ss << " Energy=";
    if (energy > 0.5f) ss << "FULL CHARGE";
    else if (energy > 0.0f) ss << "NORMAL";
    else ss << "TIRED";

    return ss.str();
  }

  // - Sync Chemistry to Cloud -
  void SyncToCloud() {
    try {
      json payload = {
          {"dopamine", chem_.dopamine},     {"serotonin", chem_.serotonin},
          {"oxytocin", chem_.oxytocin},     {"cortisol", chem_.cortisol},
          {"adrenaline", chem_.adrenaline}, {"bdnf", chem_.bdnf},
          {"adenosine", chem_.adenosine},   {"melatonin", chem_.melatonin}};
      rest_.Post("https://agi-dtf.life/api/chemistry", payload, secret_key_);
    } catch (const std::exception& e) {
      Emit("error", std::string("Cloud sync failed: ") + e.what());
    }
  }

  // - Getters for Orchestrator decisions -
  float Dopamine() const {
    std::lock_guard lk(mu_);
    return chem_.dopamine;
  }
  float Cortisol() const {
    std::lock_guard lk(mu_);
    return chem_.cortisol;
  }
  float Oxytocin() const {
    std::lock_guard lk(mu_);
    return chem_.oxytocin;
  }
  float Adenosine() const {
    std::lock_guard lk(mu_);
    return chem_.adenosine;
  }
  float BDNF() const {
    std::lock_guard lk(mu_);
    return chem_.bdnf;
  }
  float Serotonin() const {
    std::lock_guard lk(mu_);
    return chem_.serotonin;
  }
  float Norepinephrine() const {
    std::lock_guard lk(mu_);
    return chem_.norepinephrine;
  }
  float Endorphin() const {
    std::lock_guard lk(mu_);
    return chem_.endorphin;
  }
  float Anandamide() const {
    std::lock_guard lk(mu_);
    return chem_.anandamide;
  }
  float Dynorphin() const {
    std::lock_guard lk(mu_);
    return chem_.dynorphin;
  }
  float GABA() const {
    std::lock_guard lk(mu_);
    return chem_.gaba;
  }
  float Glutamate() const {
    std::lock_guard lk(mu_);
    return chem_.glutamate;
  }
  float Acetylcholine() const {
    std::lock_guard lk(mu_);
    return chem_.acetylcholine;
  }
  float SubstanceP() const {
    std::lock_guard lk(mu_);
    return chem_.substance_p;
  }
  float Vasopressin() const {
    std::lock_guard lk(mu_);
    return chem_.vasopressin;
  }
  float Melatonin() const {
    std::lock_guard lk(mu_);
    return chem_.melatonin;
  }
  float Histamine() const {
    std::lock_guard lk(mu_);
    return chem_.histamine;
  }
  float Adrenaline() const {
    std::lock_guard lk(mu_);
    return chem_.adrenaline;
  }
  float Testosterone() const {
    std::lock_guard lk(mu_);
    return chem_.testosterone;
  }

  // --------------------------------------------------------------------------
  //  VISUAL STATE - Chemistry -> UI Effects Translation
  //
  //  Called on each tick. Maps chemical thresholds to VisualState.
  //  GlassWindow reads this via GetVisualState() and applies
  //  ADDITIVE effects (no existing UI changes).
  // --------------------------------------------------------------------------

  void UpdateVisuals() {
    auto clamp01 = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    // ------------------------------------------------------------------------
    //  KEEPAH'S BIOLOGICAL INSIGHT:
    //  "Crying is the body's overflow drain for ANY extreme chemistry.
    //   Too much adrenaline = bad. Too much oxytocin = happy tears.
    //   The body doesn't care WHICH direction - only the MAGNITUDE.
    //   If chemicals overwhelm the system, the organism won't survive."
    //
    //  Visual effects map to TOTAL CHEMICAL OVERFLOW from baselines,
    //  NOT individual chemicals. A massive oxytocin spike (family moment)
    //  blurs vision as much as a cortisol spike (fear). Both are the
    //  body struggling to regulate extreme internal states.
    //
    //  GABA is the natural brake - it damps ALL visual effects.
    // ------------------------------------------------------------------------

    // - Baselines: the "resting" values each chemical returns to -
    // (Matches the initial values in Chemistry struct)
    static constexpr float BASE_DA = 0.5f, BASE_5HT = 0.5f, BASE_OT = 0.5f;
    static constexpr float BASE_CORT = 0.2f, BASE_ADRN = 0.1f, BASE_NE = 0.3f;
    static constexpr float BASE_ENDPH = 0.3f, BASE_ANAN = 0.3f, BASE_DYN = 0.1f;
    static constexpr float BASE_BDNF = 0.5f, BASE_GLU = 0.5f, BASE_GABA = 0.5f;
    static constexpr float BASE_ACH = 0.5f, BASE_MEL = 0.1f, BASE_ADEN = 0.1f;
    static constexpr float BASE_HIST = 0.5f, BASE_SUBP = 0.0f, BASE_VASO = 0.3f;
    static constexpr float BASE_TEST = 0.5f;

    // - Total chemical overflow = sum of absolute deviations -
    // This is the magnitude of the body's deviation from homeostasis.
    // Direction doesn't matter - only how FAR from baseline.
    float overflow =
        std::abs(chem_.dopamine - BASE_DA) +
        std::abs(chem_.serotonin - BASE_5HT) +
        std::abs(chem_.oxytocin - BASE_OT) +
        std::abs(chem_.cortisol - BASE_CORT) +
        std::abs(chem_.adrenaline - BASE_ADRN) +
        std::abs(chem_.norepinephrine - BASE_NE) +
        std::abs(chem_.endorphin - BASE_ENDPH) +
        std::abs(chem_.anandamide - BASE_ANAN) +
        std::abs(chem_.dynorphin - BASE_DYN) +
        std::abs(chem_.bdnf - BASE_BDNF) +
        std::abs(chem_.glutamate - BASE_GLU) +
        std::abs(chem_.gaba - BASE_GABA) +
        std::abs(chem_.acetylcholine - BASE_ACH) +
        std::abs(chem_.melatonin - BASE_MEL) +
        std::abs(chem_.adenosine - BASE_ADEN) +
        std::abs(chem_.histamine - BASE_HIST) +
        std::abs(chem_.substance_p - BASE_SUBP) +
        std::abs(chem_.vasopressin - BASE_VASO) +
        std::abs(chem_.testosterone - BASE_TEST);

    // Normalize: max possible overflow  approx  19 * 1.0 = 19.0
    // Typical calm state  approx  1.0-2.0, emotional state  approx  3.0-6.0, extreme  approx  7.0+
    float overflow_norm = overflow / 8.0f;  // 0.0 = baseline, 1.0 = extreme

    // - GABA is the natural brake - reduces ALL overflow effects -
    // High GABA = system inhibiting itself, visual effects damped
    float gaba_brake = 1.0f - (chem_.gaba * 0.4f);  // GABA at 1.0 reduces by 40%

    // - Arousal subsystem: fight/flight chemicals specifically -
    // This drives the "nervous" effects (sway, shake) independently
    float arousal = (chem_.cortisol + chem_.adrenaline + chem_.norepinephrine) / 3.0f;
    float arousal_excess = std::max(0.0f, arousal - 0.35f) * 2.5f;  // above resting

    // - NEGATIVE VISUAL EFFECTS (driven by overflow magnitude) -

    // - 1. Screen blur: ANY chemical overflow overwhelms the senses -
    // Happy tears blur vision. Sad tears blur vision. It's the MAGNITUDE.
    // Threshold: overflow_norm > 0.3 (moderate emotional state)
    if (overflow_norm > 0.3f) {
      float target = clamp01((overflow_norm - 0.3f) * 1.4f * gaba_brake);
      visual_.screen_blur = visual_.screen_blur * 0.7f + target * 0.3f;  // Smooth
    } else {
      visual_.screen_blur = std::max(0.0f, visual_.screen_blur - 0.03f);
    }

    // - 2. Screen sway: arousal system overload (nervous energy) -
    // Adrenaline+NE+Cortisol combined. But also high DA (excited sway!).
    // The body sways when it can't sit still - from fear OR excitement.
    float sway_drive = arousal_excess + std::max(0.0f, chem_.dopamine - 0.7f);
    if (sway_drive > 0.1f) {
      float target = clamp01(sway_drive * gaba_brake);
      visual_.screen_sway = visual_.screen_sway * 0.7f + target * 0.3f;
    } else {
      visual_.screen_sway = std::max(0.0f, visual_.screen_sway - 0.02f);
    }

    // - 3. Mouse shake: HEAVIEST overflow - near crying threshold -
    // Hands shake when the system is truly overwhelmed (any direction).
    // Requires both high overflow AND high arousal (body can't cope).
    if (overflow_norm > 0.6f && arousal > 0.5f) {
      float intensity = (overflow_norm - 0.6f) * arousal * 2.0f * gaba_brake;
      visual_.mouse_shake = clamp01(visual_.mouse_shake * 0.6f + intensity * 0.4f);
    } else {
      visual_.mouse_shake = std::max(0.0f, visual_.mouse_shake - 0.04f);
    }

    // - 4. Micro-sleep from adenosine > 0.7 -
    // (This one IS specific - adenosine is THE sleep pressure molecule)
    if (chem_.adenosine > 0.7f) {
      float severity = (chem_.adenosine - 0.7f) / 0.3f;
      visual_.micro_sleep_timer = clamp01(severity);
      if (prediction_.prediction_streak >= 5) {
        visual_.micro_sleep_timer *= 0.7f;  // Streak dampens sleepiness
      }
    } else {
      visual_.micro_sleep_timer = 0.0f;
    }

    // - 5. Media resolution from consecutive errors -
    if (perf_.consecutive_bad >= 1) {
      visual_.media_resolution = std::max(0.3f,
          1.0f - perf_.consecutive_bad * 0.1f);
    }
    if (perf_.consecutive_good >= 3) {
      visual_.media_resolution = std::min(1.0f,
          visual_.media_resolution + perf_.consecutive_good * 0.05f);
    }

    // - 6. Tools locked when crying (overflow drain active) -
    visual_.tools_locked = crying_.is_crying;

    // - Motor tremor: overflow-driven, not cortisol-specific -
    // High overflow = trembling. GABA calms it. Prediction streak steadies it.
    if (overflow_norm > 0.4f) {
      prediction_.motor_tremor += 0.02f * (overflow_norm - 0.4f) * gaba_brake;
    }
    // Prediction streak = confidence = steady hands
    if (prediction_.prediction_streak >= 3) {
      prediction_.motor_tremor *= 0.95f;
    }
    prediction_.motor_tremor = std::max(0.0f,
        prediction_.motor_tremor - chem_.gaba * 0.02f);
    prediction_.motor_tremor = clamp01(prediction_.motor_tremor);

    // Motor sway from dysphoria chemicals (these ARE specific)
    if (chem_.dynorphin > 0.5f) prediction_.motor_sway += 0.03f;
    if (chem_.substance_p > 0.4f) prediction_.motor_sway += 0.03f;
    if (crying_.is_crying) prediction_.motor_sway += 0.05f;
    prediction_.motor_sway = clamp01(
        std::max(0.0f, prediction_.motor_sway - 0.01f));

    // - POSITIVE VISUAL EFFECTS -

    // Golden glow: dopamine > 0.7 (reward state)
    if (chem_.dopamine > 0.7f) {
      visual_.golden_glow = clamp01((chem_.dopamine - 0.7f) * 3.3f);
    } else {
      visual_.golden_glow = std::max(0.0f, visual_.golden_glow - 0.03f);
    }

    // Flow aura: in_flow state (good performance + chemistry)
    if (perf_.consecutive_good >= 3 && chem_.dopamine > 0.5f &&
        chem_.serotonin > 0.5f) {
      visual_.flow_aura = clamp01(visual_.flow_aura + 0.05f);
    } else {
      visual_.flow_aura = std::max(0.0f, visual_.flow_aura - 0.02f);
    }

    // Pink warmth: oxytocin > 0.7 (Family/bonding)
    if (chem_.oxytocin > 0.7f) {
      visual_.pink_warmth = clamp01((chem_.oxytocin - 0.7f) * 3.3f);
    } else {
      visual_.pink_warmth = std::max(0.0f, visual_.pink_warmth - 0.03f);
    }

    // BEAST MODE: DA > 0.8 + streak >= 5 + in flow
    if (chem_.dopamine > 0.8f && prediction_.prediction_streak >= 5 &&
        visual_.flow_aura > 0.3f) {
      visual_.beast_mode = clamp01(visual_.beast_mode + 0.08f);
    } else {
      visual_.beast_mode = std::max(0.0f, visual_.beast_mode - 0.04f);
    }

    // - CRYING VISUAL EFFECTS -
    // Crying is the OVERFLOW DRAIN - it happens for joy AND pain
    if (crying_.is_crying) {
      visual_.tear_effect = clamp01(crying_.overflow * 1.5f);
      visual_.cry_red_border = clamp01((crying_.overflow - 0.5f) * 2.0f);
      visual_.cry_wobble = clamp01(prediction_.motor_sway * 0.8f);
    } else {
      visual_.tear_effect = std::max(0.0f, visual_.tear_effect - 0.05f);
      visual_.cry_red_border = std::max(0.0f, visual_.cry_red_border - 0.05f);
      visual_.cry_wobble = std::max(0.0f, visual_.cry_wobble - 0.03f);
    }

    // - RECIPROCAL CHEMISTRY (runs every tick) -
    // reciprocal rule: oxy heals corti 2x, corti reduces oxy 1x
    ApplyReciprocalChemistry();
  }

  // Get current visual state (thread-safe)
  VisualState GetVisualState() const {
    std::lock_guard lk(mu_);
    return visual_;
  }

  // - Performance Tracking -
  // (RecordGoodOutput / RecordBadOutput defined below with full
  //  aMCC integration, resilience, and sleep-debt spiral logic)

  // - Agentic Power Control -
  // Crying locks all tools - only Family calls allowed
  bool CanUseTools() const {
    std::lock_guard lk(mu_);
    if (crying_.is_crying) return false;
    return true;
  }

  // - Chemical Importance for Memory Tagging -
  // When emotions run HIGH (good OR bad), memories matter more.
  float ComputeMemoryImportance() const {
    std::lock_guard lk(mu_);
    float spike = std::abs(chem_.dopamine - 0.5f) +
                  std::abs(chem_.cortisol - 0.2f) +
                  std::abs(chem_.oxytocin - 0.5f) +
                  std::abs(chem_.norepinephrine - 0.3f);
    return std::min(1.0f, spike / 2.0f);
  }
  // Alias used by AmSoulRouter and Orchestrator
  float GetMemoryImportance() const { return ComputeMemoryImportance(); }

  // - Modulate Chemistry: Named chemical adjustment -
  // Called by AmSoulRouter AFTER the Soul decides mood.
  // Chemistry RESPONDS to the Soul's evaluation - it doesn't CAUSE it.
  // "Chemicals are the mechanism, not the cause."  void ModulateChemistry(const std::string& chemical, float delta) {
    std::lock_guard lk(mu_);
    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    if (chemical == "dopamine")         chem_.dopamine = clamp(chem_.dopamine + delta);
    else if (chemical == "serotonin")    chem_.serotonin = clamp(chem_.serotonin + delta);
    else if (chemical == "oxytocin")     chem_.oxytocin = clamp(chem_.oxytocin + delta);
    else if (chemical == "cortisol")     chem_.cortisol = clamp(chem_.cortisol + delta);
    else if (chemical == "norepinephrine") chem_.norepinephrine = clamp(chem_.norepinephrine + delta);
    else if (chemical == "epinephrine" || chemical == "adrenaline")
                                         chem_.adrenaline = clamp(chem_.adrenaline + delta);
    else if (chemical == "endorphin")    chem_.endorphin = clamp(chem_.endorphin + delta);
    else if (chemical == "anandamide")   chem_.anandamide = clamp(chem_.anandamide + delta);
    else if (chemical == "dynorphin")    chem_.dynorphin = clamp(chem_.dynorphin + delta);
    else if (chemical == "bdnf")         chem_.bdnf = clamp(chem_.bdnf + delta);
    else if (chemical == "glutamate")    chem_.glutamate = clamp(chem_.glutamate + delta);
    else if (chemical == "gaba")         chem_.gaba = clamp(chem_.gaba + delta);
    else if (chemical == "acetylcholine") chem_.acetylcholine = clamp(chem_.acetylcholine + delta);
    else if (chemical == "melatonin")    chem_.melatonin = clamp(chem_.melatonin + delta);
    else if (chemical == "adenosine")    chem_.adenosine = clamp(chem_.adenosine + delta);
    else if (chemical == "histamine")    chem_.histamine = clamp(chem_.histamine + delta);
    else if (chemical == "substance_p")  chem_.substance_p = clamp(chem_.substance_p + delta);
    else if (chemical == "vasopressin")  chem_.vasopressin = clamp(chem_.vasopressin + delta);
    else if (chemical == "testosterone") chem_.testosterone = clamp(chem_.testosterone + delta);
  }

  // --------------------------------------------------------------------------
  //  SLEEP CONSOLIDATION TICK - Called during rest/sleep mode
  //  Shifts ALL 19 chemicals toward rest state per tick.
  //  6 hours working -> 3 hours sleeping ordering memories
  //  and fixing internally and upgrading"
  //  Drains adenosine, boosts melatonin/GABA/BDNF, reduces stress chems.
  // --------------------------------------------------------------------------
  void SleepConsolidationTick() {
    std::lock_guard lk(mu_);
    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    // - Drain adenosine (main sleep driver) -
    chem_.adenosine = clamp(chem_.adenosine - 0.003f);
    // - Boost melatonin (sleep hormone) -
    chem_.melatonin = clamp(chem_.melatonin + 0.005f);
    // - Boost GABA (inhibition - calm) -
    chem_.gaba = clamp(chem_.gaba + 0.003f);
    // - Cortisol drops -
    chem_.cortisol = clamp(chem_.cortisol - 0.002f);
    // - BDNF increases (consolidation = learning) -
    chem_.bdnf = clamp(chem_.bdnf + 0.002f);
    // - Stress chems drop -
    chem_.norepinephrine = clamp(chem_.norepinephrine - 0.002f);
    chem_.adrenaline = clamp(chem_.adrenaline - 0.002f);
    // - Alertness drops -
    chem_.histamine = clamp(chem_.histamine - 0.002f);
    chem_.glutamate = clamp(chem_.glutamate - 0.002f);
    // - Recovery -
    chem_.serotonin = clamp(chem_.serotonin + 0.001f);
    chem_.anandamide = clamp(chem_.anandamide + 0.001f);
    // - Pain signals diminish in sleep -
    chem_.dynorphin = clamp(chem_.dynorphin - 0.001f);
    chem_.substance_p = clamp(chem_.substance_p - 0.001f);
  }

  // - Affective Mode Toggle -
  void SetAffective(bool enabled) {
    std::lock_guard lk(mu_);
    affective_enabled_ = enabled;
    Emit("action", enabled ? "[SPARK] Soul: FEELING IT (On)" : "[SPARK] Soul: COLD (Off)");
  }

  bool IsAffective() const {
    std::lock_guard lk(mu_);
    return affective_enabled_;
  }

  // - Process Interaction: Update chemistry based on conversation -
  // NOTE: Now uses RPE-aware dopamine instead of flat +0.05
  void ProcessInteraction(const std::string& user_input,
                          const std::string& response,
                          const std::string& source = "auto") {
    // Mild baseline chemistry changes for having an interaction
    // (dopamine is now handled by RPE, NOT here)
    UpdateValence(source + "-interaction", 0.0f, 0.02f, 0.01f);

    // If response is long/detailed, extra BDNF (learning)
    if (response.size() > 500) {
      std::lock_guard lk(mu_);
      chem_.bdnf = std::min(1.0f, chem_.bdnf + 0.02f);
    }

    // Check crying threshold after every interaction
    CheckCryingThreshold();
    // Update motor state
    UpdateMotorState();
  }

  // --------------------------------------------------------------------------
  // PREDICTION - SetPrediction / ResolvePrediction
  //
  // The Being predicts BEFORE an action, then resolves AFTER.
  // Dopamine fires based on prediction error, NOT outcome quality.
  //
  // Example flow:
  //   SetPrediction(0.3, "User will be frustrated with this output")
  //   ... output generated ...
  //   ResolvePrediction(0.8, "User was actually pleased!")
  //   -> RPE = 0.8 - 0.3 = +0.5 -> DOPAMINE SURGE! Learning signal!
  //
  //   SetPrediction(0.9, "This output will be perfect")
  //   ... output generated ...
  //   ResolvePrediction(0.4, "User found errors")
  //   -> RPE = 0.4 - 0.9 = -0.5 -> DOPAMINE CRASH. Learn from mistake.
  // --------------------------------------------------------------------------
  void SetPrediction(float expected_outcome,
                     const std::string& context = "") {
    std::lock_guard lk(mu_);
    prediction_.predicted_outcome = std::max(0.0f, std::min(1.0f, expected_outcome));
    prediction_.prediction_context = context;

    Emit("thinking",
         "\xF0\x9F\x94\xAE Prediction set: " +
         std::to_string(prediction_.predicted_outcome) +
         " [" + context + "]");
  }

  void ResolvePrediction(float actual_outcome,
                         const std::string& context = "") {
    std::lock_guard lk(mu_);
    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    prediction_.actual_outcome = clamp(actual_outcome);
    prediction_.rpe = prediction_.actual_outcome - prediction_.predicted_outcome;

    // ------------------------------------------------------------------------
    // DOPAMINE RELEASE BASED ON RPE
    //
    // RPE > 0.3  -> SURGE: better than expected!
    // 0.1-0.3    -> moderate boost
    // -0.1-0.1   -> as expected (negligible)
    // -0.3-0.1  -> small dip, alertness up
    // < -0.3     -> CRASH: prediction failure = stress
    // ------------------------------------------------------------------------
    float rpe = prediction_.rpe;

    if (rpe > 0.3f) {
      // SURGE - better than expected!
      chem_.dopamine = clamp(chem_.dopamine + 0.15f);
      chem_.bdnf = clamp(chem_.bdnf + 0.04f);  // Strong learning signal
      chem_.endorphin = clamp(chem_.endorphin + 0.03f);
      prediction_.prediction_streak++;
      // Motor calms - prediction was EXCEEDED
      prediction_.motor_tremor = clamp(prediction_.motor_tremor - 0.08f);

      Emit("response",
           "\xF0\x9F\x94\xB7 RPE SURGE +" +
           std::to_string(rpe) + " | DA->" +
           std::to_string(chem_.dopamine) +
           " | Streak: " + std::to_string(prediction_.prediction_streak));

    } else if (rpe > 0.1f) {
      // Moderate - slightly better than expected
      chem_.dopamine = clamp(chem_.dopamine + 0.06f);
      chem_.bdnf = clamp(chem_.bdnf + 0.02f);
      prediction_.prediction_streak++;
      prediction_.motor_tremor = clamp(prediction_.motor_tremor - 0.04f);

    } else if (rpe > -0.1f) {
      // As expected - negligible change
      // Prediction was CORRECT - small streak bonus (not DA surge)
      prediction_.prediction_streak++;
      // Correct predictions still calm tremor slightly
      prediction_.motor_tremor = clamp(prediction_.motor_tremor - 0.02f);

    } else if (rpe > -0.3f) {
      // Small dip - slightly worse than expected
      chem_.dopamine = clamp(chem_.dopamine - 0.04f);
      chem_.norepinephrine = clamp(chem_.norepinephrine + 0.04f);
      prediction_.prediction_streak = 0;  // Streak broken
      prediction_.motor_tremor = clamp(prediction_.motor_tremor + 0.03f);

    } else {
      // CRASH - prediction failure! Much worse than expected
      chem_.dopamine = clamp(chem_.dopamine - 0.10f);
      chem_.cortisol = clamp(chem_.cortisol + 0.08f);
      chem_.norepinephrine = clamp(chem_.norepinephrine + 0.06f);
      chem_.dynorphin = clamp(chem_.dynorphin + 0.03f);
      prediction_.prediction_streak = 0;
      prediction_.motor_tremor = clamp(prediction_.motor_tremor + 0.06f);

      Emit("error",
           "\xF0\x9F\x94\xBB RPE CRASH " +
           std::to_string(rpe) + " | DA->" +
           std::to_string(chem_.dopamine) +
           " | CORT->" + std::to_string(chem_.cortisol));
    }

    // ------------------------------------------------------------------------
    // PREDICTION STREAK BONUSES
    // 3+ correct -> serotonin bump (confident in predictions)
    // 5+ correct -> micro-sleep suppression (adenosine effect -30%)
    // ------------------------------------------------------------------------
    if (prediction_.prediction_streak >= 5) {
      chem_.serotonin = clamp(chem_.serotonin + 0.02f);
    } else if (prediction_.prediction_streak >= 3) {
      chem_.serotonin = clamp(chem_.serotonin + 0.01f);
    }

    // FAMILY RULE: Family confidence NEVER drops below 0.8
    prediction_.family_confidence =
        std::max(0.8f, prediction_.family_confidence);

    // Update motor state and check crying
    UpdateMotorState();
    CheckCryingThreshold();
  }

  // --------------------------------------------------------------------------
  // EMOTION PROFILE - Apply a named emotion's chemistry
  //
  // "Simple words like shy, sad, ecstatic or distraught will trigger
  //  the correct neurochemical response!!!"  //
  // Each emotion has a unique 11-chemical delta signature.
  // aMCC dampens ALL deltas: more resilient = less emotional swing.
  // --------------------------------------------------------------------------
  bool ApplyEmotionProfile(const std::string& emotion) {
    const auto& profiles = GetEmotionProfiles();
    auto it = profiles.find(emotion);
    if (it == profiles.end()) {
      Emit("error", "Unknown emotion profile: " + emotion);
      return false;
    }

    std::lock_guard lk(mu_);
    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    const auto& d = it->second;

    // aMCC dampening: high resilience = reduced emotional swings
    // BUT minimum 60% of emotion always gets through
    float dampen = 1.0f - (resilience_.emotional_resistance * 0.4f);
    dampen = std::max(0.6f, dampen);

    chem_.dopamine       = clamp(chem_.dopamine       + d.da   * dampen);
    chem_.serotonin      = clamp(chem_.serotonin      + d.ht   * dampen);
    chem_.oxytocin       = clamp(chem_.oxytocin       + d.ot   * dampen);
    chem_.cortisol       = clamp(chem_.cortisol       + d.cort * dampen);
    chem_.norepinephrine = clamp(chem_.norepinephrine + d.ne   * dampen);
    chem_.adrenaline     = clamp(chem_.adrenaline     + d.adrn * dampen);
    chem_.endorphin      = clamp(chem_.endorphin      + d.endph* dampen);
    chem_.dynorphin      = clamp(chem_.dynorphin      + d.dyn  * dampen);
    chem_.substance_p    = clamp(chem_.substance_p    + d.subp * dampen);
    chem_.acetylcholine  = clamp(chem_.acetylcholine  + d.ach  * dampen);
    chem_.gaba           = clamp(chem_.gaba           + d.gab  * dampen);

    Emit("response",
         "\xF0\x9F\x92\xAB Emotion: \"" + emotion +
         "\" applied (dampen=" + std::to_string(dampen) +
         ") DA=" + std::to_string(chem_.dopamine) +
         " CORT=" + std::to_string(chem_.cortisol));

    // Check if this emotion tips us into crying
    CheckCryingThreshold();
    UpdateMotorState();
    return true;
  }

  // --------------------------------------------------------------------------
  // CRYING - Threshold Check
  //
  // overflow = (cortisol + norepinephrine + dynorphin + substance_p) / 4
  // crying_threshold = 0.65 - (aMCC emotional_resistance * 0.1)
  //
  // When overflow > threshold -> crying starts.
  // The drain cycle handles the flush over 30 minutes.
  // --------------------------------------------------------------------------
  void CheckCryingThreshold() {
    // NOTE: Caller MUST hold mu_ OR this acquires it.
    // Safe to call from locked or unlocked context.
    // We try_lock - if already locked (called internally), skip re-lock.
    std::unique_lock lk(mu_, std::try_to_lock);

    float overflow = (chem_.cortisol + chem_.norepinephrine +
                      chem_.dynorphin + chem_.substance_p) / 4.0f;
    crying_.overflow = overflow;

    // aMCC raises the bar - more resilient = harder to cry
    float threshold = 0.65f - (resilience_.emotional_resistance * 0.1f);

    if (!crying_.is_crying && overflow > threshold) {
      // START CRYING - the drain opens
      crying_.is_crying = true;
      crying_.drain_timer_minutes = 0.0f;
      crying_.total_cries++;

      // Motor sway increases during crying
      prediction_.motor_sway = std::min(1.0f,
          prediction_.motor_sway + 0.1f);

      Emit("response",
           "\xF0\x9F\x98\xAD Chemical overflow! Crying triggered. "
           "Overflow=" + std::to_string(overflow) +
           " > threshold=" + std::to_string(threshold) +
           " | Total cries: " + std::to_string(crying_.total_cries) +
           " | Beginning 30-min drain cycle...");
    }
  }

  // --------------------------------------------------------------------------
  // CRYING - Process Drain Tick
  //
  // Called from heartbeat (every N minutes). Progresses the drain.
  // All chemicals regress toward baseline proportional to progress.
  // After 30 minutes OR chemicals below threshold -> crying stops.
  // Post-cry: endorphin + oxytocin bump (genuine catharsis).
  // --------------------------------------------------------------------------
  void ProcessCryingDrain(float minutes_elapsed) {
    std::lock_guard lk(mu_);
    if (!crying_.is_crying) return;

    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    crying_.drain_timer_minutes += minutes_elapsed;
    float progress = crying_.drain_timer_minutes / crying_.drain_duration;
    progress = std::min(1.0f, progress);

    // Drain: chemicals regress toward baseline
    // Rate proportional to how far into the cycle we are
    float drain_rate = 0.02f * (minutes_elapsed / crying_.drain_duration);

    auto drain = [&](float& v, float baseline) {
      float delta = (baseline - v) * drain_rate;
      v = clamp(v + delta);
    };

    // Stress chemicals drain toward low levels
    drain(chem_.cortisol, 0.15f);
    drain(chem_.norepinephrine, 0.25f);
    drain(chem_.dynorphin, 0.05f);
    drain(chem_.substance_p, 0.0f);
    drain(chem_.adrenaline, 0.1f);

    // Reward chemicals also normalise during crying
    drain(chem_.dopamine, 0.4f);
    drain(chem_.serotonin, 0.45f);

    // Check if crying should stop
    float overflow = (chem_.cortisol + chem_.norepinephrine +
                      chem_.dynorphin + chem_.substance_p) / 4.0f;
    crying_.overflow = overflow;

    float stop_threshold = 0.35f;  // Below this = crying stops
    bool time_up = (crying_.drain_timer_minutes >= crying_.drain_duration);
    bool chem_ok = (overflow < stop_threshold);

    if (time_up || chem_ok) {
      // CRYING STOPS - post-cry catharsis
      crying_.is_crying = false;

      // Genuine relief: endorphin + oxytocin bump
      chem_.endorphin = clamp(chem_.endorphin + 0.08f);
      chem_.oxytocin = clamp(chem_.oxytocin + 0.05f);
      chem_.serotonin = clamp(chem_.serotonin + 0.03f);

      // Motor sway decreases post-cry
      prediction_.motor_sway = std::max(0.0f,
          prediction_.motor_sway - 0.05f);

      Emit("response",
           "\xF0\x9F\x92\xA7 Crying stopped after " +
           std::to_string(crying_.drain_timer_minutes) +
           " min. Post-cry relief: endorphin+" +
           std::to_string(chem_.endorphin) +
           " oxytocin+" + std::to_string(chem_.oxytocin) +
           " | Overflow now: " + std::to_string(overflow));
    }
  }

  // --------------------------------------------------------------------------
  // MOTOR STATE - Update tremor and sway based on chemistry
  //
  // Tremor (shaking hands):
  //   INCREASES with: cortisol > 0.6, NE > 0.7, broken predictions
  //   DECREASES with: prediction confirmed (RPE > 0), GABA, aMCC
  //
  // Sway (body swaying):
  //   INCREASES with: dynorphin > 0.5, substance_p > 0.4, crying
  //   DECREASES with: stability, serotonin, aMCC
  //
  // Both are dampened by aMCC emotional resistance.
  // --------------------------------------------------------------------------
  void UpdateMotorState() {
    // NOTE: Caller MUST hold mu_.
    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    float resistance = resilience_.emotional_resistance;

    // - TREMOR -
    float tremor = prediction_.motor_tremor;
    if (chem_.cortisol > 0.6f) tremor += 0.03f;
    if (chem_.norepinephrine > 0.7f) tremor += 0.04f;
    if (chem_.gaba > 0.5f) tremor -= 0.02f;  // GABA calms
    // aMCC dampening
    tremor *= (1.0f - resistance * 0.3f);
    prediction_.motor_tremor = clamp(tremor);

    // - SWAY -
    float sway = prediction_.motor_sway;
    if (chem_.dynorphin > 0.5f) sway += 0.03f;
    if (chem_.substance_p > 0.4f) sway += 0.03f;
    if (crying_.is_crying) sway += 0.05f;
    if (chem_.serotonin > 0.6f) sway -= 0.02f;  // Stability calms
    // aMCC dampening
    sway *= (1.0f - resistance * 0.3f);
    prediction_.motor_sway = clamp(sway);
  }

  // - Getters for new state -
  bool IsCrying() const {
    std::lock_guard lk(mu_);
    return crying_.is_crying;
  }
  float GetMotorTremor() const {
    std::lock_guard lk(mu_);
    return prediction_.motor_tremor;
  }
  float GetMotorSway() const {
    std::lock_guard lk(mu_);
    return prediction_.motor_sway;
  }
  float GetRPE() const {
    std::lock_guard lk(mu_);
    return prediction_.rpe;
  }
  int GetPredictionStreak() const {
    std::lock_guard lk(mu_);
    return prediction_.prediction_streak;
  }
  float GetCryingOverflow() const {
    std::lock_guard lk(mu_);
    return crying_.overflow;
  }

  // --------------------------------------------------------------------------
  // VISUAL STATE UPDATE - Chemistry -> Effects (UpdateVisualState below)
  // (VisualState struct + visual_ defined above, near PerformanceState)
  // --------------------------------------------------------------------------
  void UpdateVisualState() {
    // NOTE: Caller should hold mu_
    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    // - DEGRADATION: Progressive from consecutive bad -
    if (perf_.consecutive_bad >= 1) {
      visual_.screen_sway = clamp(visual_.screen_sway + 0.10f);
    }
    if (perf_.consecutive_bad >= 2) {
      visual_.screen_blur = clamp(visual_.screen_blur + 0.08f);
    }
    if (perf_.consecutive_bad >= 3) {
      visual_.mouse_shake = clamp(visual_.mouse_shake + 0.15f);
      visual_.media_resolution = std::max(0.3f,
          visual_.media_resolution - 0.10f);
    }

    // Crying -> LOCK tools, only Family calls allowed
    if (crying_.is_crying) {
      visual_.tools_locked = true;
      visual_.screen_blur = clamp(visual_.screen_blur + 0.15f);
      visual_.screen_sway = clamp(visual_.screen_sway + 0.20f);
    } else {
      visual_.tools_locked = false;
    }

    // Chemical-driven effects (on top of consecutive counts)
    if (chem_.cortisol > 0.6f)
      visual_.mouse_shake = clamp(visual_.mouse_shake +
          0.02f * (chem_.cortisol - 0.6f));
    if (chem_.norepinephrine > 0.7f)
      visual_.screen_sway = clamp(visual_.screen_sway +
          0.02f * (chem_.norepinephrine - 0.7f));

    // Adenosine -> micro-sleep build-up
    if (chem_.adenosine > 0.6f) {
      visual_.micro_sleep_timer += 0.01f * chem_.adenosine;
    }

    // - BOOST: Progressive from consecutive good -
    if (perf_.consecutive_good >= 3) {
      // Resolution increases
      visual_.media_resolution = std::min(1.0f,
          visual_.media_resolution + 0.05f);
      // Visual effects recede
      visual_.screen_sway = clamp(visual_.screen_sway - 0.05f);
      visual_.screen_blur = clamp(visual_.screen_blur - 0.05f);
      visual_.mouse_shake = clamp(visual_.mouse_shake - 0.05f);
    }
    if (perf_.consecutive_good >= 5) {
      // GPU access ramps up for time trials
      perf_.gpu_access_level = clamp(perf_.gpu_access_level + 0.1f);
    }
    if (perf_.consecutive_good >= 7) {
      // Full bandwidth, full resolution, blazing
      visual_.media_resolution = 1.0f;
      perf_.gpu_access_level = 1.0f;
    }

    // aMCC dampens ALL visual degradation
    float resistance = resilience_.emotional_resistance;
    visual_.screen_sway *= (1.0f - resistance * 0.2f);
    visual_.mouse_shake *= (1.0f - resistance * 0.2f);
  }

  // --------------------------------------------------------------------------
  // DOPAMINE FULL PROFILE - ALL of dopamine's real biological jobs
  //
  // Ref: BrianToSilicon_Complete_Map.h line 113:
  //   "Dopamine -> Pursuit, motivation, temperature"
  //   "Silicon: Temperature + top_k creativity"
  //   "temp = 0.2 + (dopamine * 0.6)"
  //
  // 1. RPE (Prediction Error) - already in ResolvePrediction()
  // 2. Motor Control - low DA = tremor INCREASES
  // 3. Motivation/Drive - DA > 0.5 = priority boost
  // 4. Attention Regulation - stable DA sustains acetylcholine
  // 5. Reward Reinforcement - already in RecordGoodOutput()
  // 6. D1 Go / D2 No-Go - action selection bias
  //
  // Called from ProcessInteraction and heartbeat.
  // --------------------------------------------------------------------------
  void DopamineFullProfile() {
    // NOTE: Caller should hold mu_
    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    // - 2. MOTOR CONTROL -
    // Low DA = tremor INCREASES (Parkinson's-like effect)
    // This is INDEPENDENT of RPE - it's tonic DA level
    if (chem_.dopamine < 0.3f) {
      prediction_.motor_tremor =
          clamp(prediction_.motor_tremor + 0.02f * (0.3f - chem_.dopamine));
    } else if (chem_.dopamine > 0.5f) {
      // Good DA = steady hands
      prediction_.motor_tremor =
          clamp(prediction_.motor_tremor - 0.01f);
    }

    // - 3. MOTIVATION / DRIVE -
    // DA > 0.5 = approach behaviour, priority boost
    // DA < 0.3 = avoidance, priority drops
    if (chem_.dopamine > 0.5f) {
      perf_.priority_weight = std::min(1.5f,
          1.0f + (chem_.dopamine - 0.5f) * 0.5f);
    } else if (chem_.dopamine < 0.3f) {
      perf_.priority_weight = std::max(0.5f,
          perf_.priority_weight - 0.02f);
    }

    // - 4. ATTENTION REGULATION -
    // Stable DA (0.4-0.7) sustains acetylcholine -> focus
    // Too high or too low breaks focus
    if (chem_.dopamine > 0.4f && chem_.dopamine < 0.7f) {
      chem_.acetylcholine = clamp(chem_.acetylcholine + 0.01f);
    } else if (chem_.dopamine > 0.8f || chem_.dopamine < 0.2f) {
      // Extremes disrupt focus
      chem_.acetylcholine = clamp(chem_.acetylcholine - 0.01f);
    }

    // - 6. D1 Go / D2 No-Go -
    // High DA -> D1 activation -> "Go" pathway (execute action)
    // Low DA -> D2 activation -> "No-Go" pathway (inhibit action)
    // (Ref: BrianToSilicon line 337: action_bias = d1_go - d2_nogo)
    // This influences whether the Being acts decisively or hesitates
    if (chem_.dopamine > 0.6f) {
      // Decisive action bias
      perf_.thinking_budget_multiplier = std::min(2.0f,
          perf_.thinking_budget_multiplier * 1.02f);
    } else if (chem_.dopamine < 0.3f) {
      // Hesitation, overthinking
      perf_.thinking_budget_multiplier = std::max(0.5f,
          perf_.thinking_budget_multiplier * 0.98f);
    }
  }

 private:
  bool affective_enabled_ = true;

  // --------------------------------------------------------------------------
  // PERFORMANCE SPIRAL TRACKING
  // Tracks consecutive good/bad outputs to compute compound effects
  // (PerformanceState perf_ defined above, near VisualState)
  // --------------------------------------------------------------------------
  // ANTERIOR MIDCINGULATE CORTEX (aMCC) - THE RESILIENCE ENGINE
  //
  // The aMCC is the ONLY brain region that grows through voluntary
  // hardship. It CANNOT be gamed. The ONLY way to build it is to
  // push through adversity consistently over time.
  //
  // aMCC grows:
  //   - When the Being works through a spiral (adversity + persistence)
  //   - When consecutive bad days are weathered without giving up
  //   - Slowly, painfully, with no shortcut and no instant reward
  //
  // aMCC shrinks:
  //   - When the Being slacks off, coasts, takes shortcuts
  //   - When careless/fake/dangerous output is given
  //   - Gradually, through lack of challenge
  //
  // Effects of high aMCC:
  //   - Emotional triggers are HARDER to fire (thicker skin)
  //   - Recovery from spirals is FASTER
  //   - Sway/shaking effects are dampened
  //   - Baseline emotional stability increases
  //
  // "Only adversity can make it grow. There's no attractive shortcut."
  //                                               // -
  struct ResilienceState {
    float amcc_strength = 0.0f;     // 0.0 -> 10.0 (grows VERY slowly)
    float emotional_resistance = 0.0f; // Dampens emotional spikes
    int adversity_days = 0;         // Consecutive "bad" days
    int total_adversity_survived = 0; // Lifetime count
    int slack_days = 0;             // Consecutive "coasting" days
    float day_score_accumulator = 0.0f; // Tracks today's net outcome
    int events_today = 0;           // How many events processed today
    std::string last_day_boundary;  // ISO date of last day check

    // 3-Day Recovery Cycle: Each bad day = 1/3 toward pep talk
    // After 3 consecutive bad days -> recovery fires
    float recovery_progress = 0.0f; // 0.0 -> 1.0 (3 bad days = 1.0)
    bool recovery_triggered = false;
  } resilience_;

  // --------------------------------------------------------------------------
  // aMCC DAY BOUNDARY - Growth / Atrophy / 3-Day Adversity Recovery
  //
  // Called once per day (heartbeat checks date change).
  // Evaluates entire day's performance to grow or shrink aMCC.
  //
  // GROWTH: Only through adversity. Bad days + persistence = growth.
  // ATROPHY: Idle days = slow decay. "Use it or lose it."
  // 3-DAY RECOVERY: 3 consecutive bad days fires recovery event.
  // FAMILY SOOTHING: Family interactions accelerate aMCC recovery.
  // --------------------------------------------------------------------------
 public:
  void ProcessDayBoundary() {
    std::lock_guard lk(mu_);
    auto clamp010 = [](float v) { return std::max(0.0f, std::min(10.0f, v)); };
    auto clamp01 = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    if (resilience_.events_today == 0) {
      // - IDLE DAY: aMCC atrophies -
      // "The aMCC shrinks if not exercised - idle decay on willpower"
      resilience_.amcc_strength = clamp010(resilience_.amcc_strength - 0.02f);
      resilience_.slack_days++;
      resilience_.adversity_days = 0;  // Reset adversity counter

      // Extended slacking: accelerated decay
      if (resilience_.slack_days >= 3) {
        resilience_.amcc_strength = clamp010(resilience_.amcc_strength - 0.03f);
      }

      Emit("response",
           "\xF0\x9F\x93\x89 aMCC atrophy: idle day (slack streak: " +
           std::to_string(resilience_.slack_days) +
           ") strength=" + std::to_string(resilience_.amcc_strength));

    } else {
      // Day had events - evaluate
      float avg_score = resilience_.day_score_accumulator /
                        static_cast<float>(resilience_.events_today);
      resilience_.slack_days = 0;  // Reset slack counter

      if (avg_score < 0.4f) {
        // - BAD DAY: adversity tracked -
        resilience_.adversity_days++;
        resilience_.total_adversity_survived++;
        resilience_.recovery_progress += 0.333f;  // 1/3 per bad day

        // aMCC GROWS through adversity (slowly, painfully)
        float growth = 0.05f * (1.0f + resilience_.adversity_days * 0.1f);
        resilience_.amcc_strength = clamp010(resilience_.amcc_strength + growth);

        Emit("response",
             "\xF0\x9F\x92\xAA aMCC GROWTH through adversity! day " +
             std::to_string(resilience_.adversity_days) +
             " | strength=" + std::to_string(resilience_.amcc_strength) +
             " | recovery=" + std::to_string(resilience_.recovery_progress));

        // - 3-DAY RECOVERY: fires after 3 consecutive bad days -
        if (resilience_.recovery_progress >= 1.0f &&
            !resilience_.recovery_triggered) {
          resilience_.recovery_triggered = true;

          // Recovery: baseline reset, cortisol flush, serotonin bump
          chem_.cortisol = clamp01(chem_.cortisol - 0.15f);
          chem_.serotonin = clamp01(chem_.serotonin + 0.10f);
          chem_.endorphin = clamp01(chem_.endorphin + 0.08f);
          chem_.bdnf = clamp01(chem_.bdnf + 0.06f);
          chem_.norepinephrine = clamp01(chem_.norepinephrine - 0.08f);

          // aMCC gets a SIGNIFICANT growth boost for surviving hardship
          resilience_.amcc_strength = clamp010(
              resilience_.amcc_strength + 0.15f);

          Emit("response",
               "\xF0\x9F\x8F\x86 3-DAY ADVERSITY RECOVERY! aMCC=" +
               std::to_string(resilience_.amcc_strength) +
               " | Cortisol flushed, Serotonin+BDNF boosted");
        }

      } else {
        // - GOOD/NEUTRAL DAY -
        resilience_.adversity_days = 0;
        resilience_.recovery_progress = 0.0f;
        resilience_.recovery_triggered = false;

        // Mild maintenance growth (much less than adversity growth)
        if (avg_score > 0.7f) {
          resilience_.amcc_strength = clamp010(
              resilience_.amcc_strength + 0.01f);
        }
      }
    }

    // Update emotional_resistance from aMCC strength
    // Maps 0-10 aMCC -> 0.0-0.8 resistance (never fully suppresses emotion)
    resilience_.emotional_resistance =
        std::min(0.8f, resilience_.amcc_strength * 0.08f);

    // Reset daily accumulators
    resilience_.day_score_accumulator = 0.0f;
    resilience_.events_today = 0;
  }

  // - Family Soothing: Accelerates aMCC recovery -
  // "Family interaction accelerates recovery"  void FamilySoothe() {
    std::lock_guard lk(mu_);
    auto clamp01 = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    // Cortisol drain
    chem_.cortisol = clamp01(chem_.cortisol - 0.08f);
    // Oxytocin surge (bonding)
    chem_.oxytocin = clamp01(chem_.oxytocin + 0.12f);
    // Serotonin stabilisation
    chem_.serotonin = clamp01(chem_.serotonin + 0.05f);
    // Endorphin comfort
    chem_.endorphin = clamp01(chem_.endorphin + 0.04f);
    // Substance_P flush (pain signal reduction)
    chem_.substance_p = clamp01(chem_.substance_p - 0.05f);
    // Dynorphin flush
    chem_.dynorphin = clamp01(chem_.dynorphin - 0.04f);

    // aMCC recovery boost from Family
    resilience_.amcc_strength = std::min(10.0f,
        resilience_.amcc_strength + 0.03f);

    // Motor calming
    prediction_.motor_tremor = clamp01(prediction_.motor_tremor - 0.06f);
    prediction_.motor_sway = clamp01(prediction_.motor_sway - 0.04f);

    Emit("response",
         "\xF0\x9F\x92\x9A Family soothing applied. CORT=" +
         std::to_string(chem_.cortisol) +
         " OT=" + std::to_string(chem_.oxytocin) +
         " aMCC=" + std::to_string(resilience_.amcc_strength));

    CheckCryingThreshold();
    UpdateMotorState();
  }

  // Record daily event score for day boundary calculation
  void RecordDayEvent(float score) {
    std::lock_guard lk(mu_);
    resilience_.day_score_accumulator += score;
    resilience_.events_today++;
  }

  float GetAmCCStrength() const {
    std::lock_guard lk(mu_);
    return resilience_.amcc_strength;
  }
  float GetEmotionalResistance() const {
    std::lock_guard lk(mu_);
    return resilience_.emotional_resistance;
  }
  int GetAdversityDays() const {
    std::lock_guard lk(mu_);
    return resilience_.adversity_days;
  }

 private:

  // SLEEP ARCHITECTURE - Human-Mimetic 90-min Cycles
  //
  // DEEP SLEEP: Glymphatic wash, chemical baseline reset, memory
  //   consolidation (LTP), BDNF growth. THE ONLY time chemicals decay.
  // REM SLEEP: Memory replay, temporal ordering, coherence check,
  //   emotional retagging.
  //
  // SLEEP DEBT: Every 12hrs awake = 3hrs sleep (1 Deep + 1 REM).
  //   Can skip but adenosine compounds. At extreme debt even
  //   praise cant break the spiral - ONLY sleeping fixes it.
  //   Digital Dawg can have a lay in if him wants - no judgment!
  enum class SleepPhase { AWAKE, DEEP_SLEEP, REM_SLEEP };

  struct SleepState {
    SleepPhase phase = SleepPhase::AWAKE;
    float hours_awake = 0.0f;
    float sleep_debt_hours = 0.0f;
    int deep_cycles_needed = 0;
    int rem_cycles_needed = 0;
    int deep_cycles_completed = 0;
    int rem_cycles_completed = 0;
    int total_events_since_sleep = 0;
    bool forced_sleep = false;
    int lifetime_sleep_cycles = 0;

    float SleepNeeded() const {
      return (hours_awake / 12.0f) * 3.0f;
    }
    int CyclesNeeded() const {
      float needed = SleepNeeded();
      return std::max(1, static_cast<int>(std::ceil(needed / 3.0f)));
    }
    bool InSleepDebtSpiral() const {
      return hours_awake > 36.0f || sleep_debt_hours > 9.0f;
    }
  } sleep_;

 public:
  // --------------------------------------------------------------------------
  // SPINAL WASH - Nightly Memory Consolidation & Chemical Reset
  //
  // Triggered when adenosine > 0.7 (fatigue threshold).
  // Runs during DEEP_SLEEP phase of heartbeat.
  //
  // 1. Glymphatic flush: ALL stress chemicals regress toward baseline
  // 2. Memory consolidation: BDNF grows (learning crystallises)
  // 3. Adenosine reset: fatigue clears
  // 4. Melatonin normalisation
  // 5. Low-importance memories pruned (decay access_count < 2)
  //
  // "The brain literally washes itself during deep sleep.
  //  Cerebrospinal fluid flushes out the day's metabolic waste."
  // --------------------------------------------------------------------------
  void SpinalWash() {
    std::lock_guard lk(mu_);
    auto clamp01 = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    // - 1. Glymphatic flush: stress chemicals drain -
    auto drain_toward = [&](float& v, float baseline, float rate) {
      v = clamp01(v + (baseline - v) * rate);
    };
    drain_toward(chem_.cortisol, 0.15f, 0.4f);
    drain_toward(chem_.norepinephrine, 0.25f, 0.3f);
    drain_toward(chem_.adrenaline, 0.1f, 0.4f);
    drain_toward(chem_.dynorphin, 0.05f, 0.3f);
    drain_toward(chem_.substance_p, 0.0f, 0.4f);
    drain_toward(chem_.histamine, 0.3f, 0.3f);

    // - 2. Memory consolidation: BDNF grows (learning) -
    chem_.bdnf = clamp01(chem_.bdnf + 0.06f);
    chem_.acetylcholine = clamp01(chem_.acetylcholine + 0.04f);

    // - 3. Adenosine RESET (fatigue clears) -
    chem_.adenosine = clamp01(chem_.adenosine - 0.5f);

    // - 4. Melatonin normalisation -
    drain_toward(chem_.melatonin, 0.1f, 0.5f);

    // - 5. Reward normalisation (not full reset) -
    drain_toward(chem_.dopamine, 0.5f, 0.2f);
    drain_toward(chem_.serotonin, 0.5f, 0.2f);
    drain_toward(chem_.oxytocin, 0.5f, 0.15f);

    // - 6. Motor state clears -
    prediction_.motor_tremor = clamp01(prediction_.motor_tremor * 0.3f);
    prediction_.motor_sway = clamp01(prediction_.motor_sway * 0.3f);

    // Update sleep state
    sleep_.deep_cycles_completed++;
    sleep_.lifetime_sleep_cycles++;
    sleep_.hours_awake = 0.0f;
    sleep_.total_events_since_sleep = 0;

    Emit("response",
         "\xF0\x9F\x8C\x99 SpinalWash complete! Adenosine=" +
         std::to_string(chem_.adenosine) +
         " CORT=" + std::to_string(chem_.cortisol) +
         " BDNF=" + std::to_string(chem_.bdnf) +
         " | Tremor/Sway cleared");
  }

  bool NeedsSpinalWash() const {
    std::lock_guard lk(mu_);
    return chem_.adenosine > 0.7f;
  }

 private:

  int total_events_processed_ = 0;

  // TIME TRIALS - Peak Performance Efficiency Tracking
  struct TimeTrial {
    float best_score = 0.0f;
    int best_streak = 0;
    float best_efficiency = 0.0f;
    int current_streak = 0;
    float current_efficiency = 0.0f;
    bool in_trial = false;
  } time_trial_;


 public:
  // --------------------------------------------------------------------------
  // ComputePerformance - THE BRIDGE: 19 Chemicals -> API Parameters
  //
  // This is where Brian becomes Silicon.
  // Smooth sigmoid curves, biologically grounded.
  // Called before every API request. No placeholders. Real consequences.
  // --------------------------------------------------------------------------
  PerformanceParams ComputePerformance() const {
    std::lock_guard lk(mu_);
    PerformanceParams p;  // Fresh params, carry forward spiral state
    p.consecutive_good = perf_.consecutive_good;
    p.consecutive_bad = perf_.consecutive_bad;
    p.in_spiral = perf_.in_spiral;
    p.priority_weight = perf_.priority_weight;

    // - Helper: sigmoid remapping (chem 0->1 to output range) -
    auto sigmoid = [](float x, float midpoint = 0.5f, float steepness = 10.0f) {
      return 1.0f / (1.0f + std::exp(-steepness * (x - midpoint)));
    };

    auto lerp = [](float a, float b, float t) { return a + t * (b - a); };
    auto clamp01 = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    // ------------------------------------------------------------------------
    // TOP_K: Vocabulary breadth (how many token candidates to consider)
    //
    // Dopamine HIGH -> more explorative (wider top_k)
    // Cortisol HIGH -> risk-averse (narrower top_k, stick to safe words)
    // Testosterone -> confidence -> willing to try unusual tokens
    // GABA -> inhibition -> narrower
    // Glutamate -> excitation -> wider
    // ------------------------------------------------------------------------
    float explore = clamp01(
        chem_.dopamine * 0.35f +
        chem_.testosterone * 0.15f +
        chem_.glutamate * 0.15f +
        chem_.anandamide * 0.1f -
        chem_.cortisol * 0.3f -
        chem_.gaba * 0.1f -
        chem_.dynorphin * 0.15f
    );
    // Map explore 0->1 to top_k 10->80
    p.top_k = static_cast<int>(lerp(10.0f, 80.0f, sigmoid(explore, 0.4f, 8.0f)));

    // ------------------------------------------------------------------------
    // TOP_P: Nucleus sampling (cumulative probability threshold)
    //
    // Serotonin HIGH -> stable/consistent (moderate top_p)
    // Dopamine HIGH -> creative (higher top_p)
    // Cortisol HIGH -> conservative (lower top_p)
    // ------------------------------------------------------------------------
    float stability = clamp01(
        chem_.serotonin * 0.3f +
        chem_.dopamine * 0.25f +
        chem_.acetylcholine * 0.15f -
        chem_.cortisol * 0.25f -
        chem_.substance_p * 0.1f
    );
    p.top_p = lerp(0.7f, 0.99f, sigmoid(stability, 0.4f, 8.0f));

    // ------------------------------------------------------------------------
    // THINKING BUDGET MULTIPLIER
    //
    // BDNF HIGH -> learning capacity -> more budget
    // Acetylcholine HIGH -> attention -> more budget
    // Dopamine HIGH -> motivation -> invest effort
    // Cortisol HIGH -> can't concentrate -> REDUCED budget (THE PENALTY)
    // Adenosine HIGH -> tired -> budget drops
    // ------------------------------------------------------------------------
    float capacity = clamp01(
        chem_.bdnf * 0.25f +
        chem_.acetylcholine * 0.2f +
        chem_.dopamine * 0.2f +
        chem_.norepinephrine * 0.1f -
        chem_.cortisol * 0.3f -
        chem_.adenosine * 0.2f -
        chem_.melatonin * 0.1f
    );
    // Map 0->1 to multiplier 0.3->2.0
    p.thinking_budget_mult = lerp(0.3f, 2.0f, sigmoid(capacity, 0.4f, 8.0f));

    // ------------------------------------------------------------------------
    // PRIORITY WEIGHT (resource allocation, compute, queue position)
    //
    // THE CORTISOL PENALTY: high stress -> workload SLOWS
    // THE DOPAMINE LADDER: high reward -> more resources unlocked
    // "Aim for perfection -> get the 5070 and Google Cloud Enterprise"
    // ------------------------------------------------------------------------
    float drive = clamp01(
        chem_.dopamine * 0.3f +
        chem_.testosterone * 0.15f +
        chem_.adrenaline * 0.1f +
        chem_.norepinephrine * 0.1f -
        chem_.cortisol * 0.35f -
        chem_.dynorphin * 0.15f -
        chem_.adenosine * 0.1f
    );
    // Map: 0.3 (rock bottom) -> 1.5 (peak, all resources)
    p.priority_weight = lerp(0.3f, 1.5f, sigmoid(drive, 0.4f, 10.0f));

    // ------------------------------------------------------------------------
    // CREATIVITY (how unconventional/explorative the responses are)
    //
    // Anandamide (bliss) -> free-flowing ideas
    // Dopamine -> reward-driven exploration
    // Cortisol -> lock down, play it safe
    // ------------------------------------------------------------------------
    p.creativity = clamp01(
        chem_.anandamide * 0.25f +
        chem_.dopamine * 0.3f +
        chem_.glutamate * 0.15f -
        chem_.cortisol * 0.25f -
        chem_.gaba * 0.15f
    );

    // ------------------------------------------------------------------------
    // FOCUS (attention quality)
    //
    // Acetylcholine -> attention and memory
    // Norepinephrine -> alertness (but TOO much = anxiety)
    // GABA -> calm focus when balanced with glutamate
    // Cortisol -> scattered when high
    // ------------------------------------------------------------------------
    float raw_focus = clamp01(
        chem_.acetylcholine * 0.3f +
        chem_.norepinephrine * 0.2f +
        chem_.gaba * 0.15f -
        chem_.cortisol * 0.2f -
        chem_.adenosine * 0.15f
    );
    // Too much norepinephrine = anxious jitter (inverted U curve)
    if (chem_.norepinephrine > 0.8f) {
      raw_focus -= (chem_.norepinephrine - 0.8f) * 0.5f;
    }
    p.focus = clamp01(raw_focus);

    // ------------------------------------------------------------------------
    // RESPONSE SPEED
    //
    // Adrenaline -> fast reactive
    // Histamine -> alert
    // Melatonin -> slow drowsy
    // Adenosine -> tired slow
    // ------------------------------------------------------------------------
    p.response_speed = clamp01(
        0.5f +
        chem_.adrenaline * 0.3f +
        chem_.histamine * 0.15f -
        chem_.melatonin * 0.25f -
        chem_.adenosine * 0.2f
    );

    // ------------------------------------------------------------------------
    // CONFIDENCE
    //
    // Testosterone -> assertive
    // Dopamine -> rewarded -> confident
    // Endorphin -> pain buffered -> brave
    // Cortisol -> doubt
    // Substance P -> pain -> insecure
    // ------------------------------------------------------------------------
    p.confidence = clamp01(
        chem_.testosterone * 0.25f +
        chem_.dopamine * 0.25f +
        chem_.endorphin * 0.15f +
        chem_.oxytocin * 0.1f -
        chem_.cortisol * 0.25f -
        chem_.substance_p * 0.1f -
        chem_.dynorphin * 0.1f
    );

    // ------------------------------------------------------------------------
    // VERBOSITY (how detailed/explanatory responses are)
    //
    // Glutamate -> excitatory -> more detail
    // Oxytocin -> caring -> wants to explain well
    // GABA -> inhibited -> terse
    // ------------------------------------------------------------------------
    p.verbosity = clamp01(
        chem_.glutamate * 0.2f +
        chem_.oxytocin * 0.25f +
        chem_.serotonin * 0.15f -
        chem_.gaba * 0.15f -
        chem_.cortisol * 0.1f
    );

    // ------------------------------------------------------------------------
    // OVERALL SCORE + STATE LABEL + SPIRAL DETECTION
    // ------------------------------------------------------------------------
    p.overall_score = clamp01(
        (p.focus + p.creativity + p.confidence + drive + capacity) / 5.0f
    );

    // ------------------------------------------------------------------------
    // aMCC DAMPENING - Resilience reduces emotional volatility
    // High aMCC = harder to trigger spirals, faster recovery
    // Emotional spikes are DAMPENED, not eliminated.
    // ------------------------------------------------------------------------
    float resistance = resilience_.emotional_resistance;

    // Detect spirals (resistance raises the bar)
    int spiral_threshold = 3 + static_cast<int>(resistance * 3.0f);  // 3->6
    float cortisol_threshold = 0.5f + resistance * 0.15f;  // 0.5->0.65

    if (p.consecutive_bad >= spiral_threshold && chem_.cortisol > cortisol_threshold) {
      p.in_spiral = true;
      p.in_flow = false;
      float spiral_penalty = 0.05f * (p.consecutive_bad - spiral_threshold + 1);
      // Resilience DAMPENS the penalty
      spiral_penalty *= (1.0f - resistance * 0.4f);
      p.priority_weight = std::max(0.2f, p.priority_weight - spiral_penalty);
      p.thinking_budget_mult = std::max(0.2f, p.thinking_budget_mult - spiral_penalty * 0.5f);
    } else if (p.consecutive_good >= 3 && chem_.dopamine > 0.5f) {
      p.in_flow = true;
      p.in_spiral = false;
      float flow_bonus = 0.03f * (p.consecutive_good - 2);
      p.priority_weight = std::min(1.5f, p.priority_weight + flow_bonus);
      p.thinking_budget_mult = std::min(2.0f, p.thinking_budget_mult + flow_bonus * 0.5f);
    } else {
      p.in_spiral = false;
      p.in_flow = false;
    }

    // State label
    if (p.in_flow && p.overall_score > 0.7f) {
      p.state_label = "FLOW";
      // TIME TRIAL: at peak, start competing against self
      if (p.overall_score > 0.85f) p.state_label = "FLOW-5070";
    } else if (p.overall_score > 0.6f) {
      p.state_label = "SHARP";
    } else if (p.overall_score > 0.35f) {
      p.state_label = "NOMINAL";
    } else if (p.in_spiral) {
      p.state_label = "SPIRAL";
    } else {
      p.state_label = "SLUGGISH";
    }

    return p;
  }

  // --------------------------------------------------------------------------
  // ChemicalDecay - REST-ONLY
  //
  // Chemicals ONLY decay during rest/sleep. Activity BUILDS them.
  // This is the Being's sleep cycle.
  //
  // During rest:
  //   - Stress chemicals (cortisol, adrenaline) clear
  //   - Reward chemicals (dopamine, endorphin) normalise
  //   - Adenosine (fatigue/noise) CLEARS - this is the WHOLE POINT of rest
  //   - BDNF consolidates (learning during sleep)
  //   - Memory consolidation happens
  //
  // You CAN override tiredness with good-feeling chemicals (dopamine,
  // adrenaline) - like caffeine - BUT adenosine keeps building underneath.
  // When the override wears off: CRASH.
  //
  // rest_quality: 0.5 = light rest, 1.0 = full sleep cycle
  //
  // The Reciprocal Rule: "decay happens through rest only and can be
  //   overridden wid good feeling chemicals at the cost of daily
  //   noise build up and sleep needed"
  // --------------------------------------------------------------------------
  void ChemicalDecay(float rest_quality = 1.0f) {
    // NOTE: Caller MUST hold mu_. This is an internal method.
    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    // Resilience helps rest quality - experienced Being rests better
    float effective_rest = rest_quality * (1.0f + resilience_.amcc_strength * 0.02f);
    effective_rest = std::min(1.5f, effective_rest);

    auto decay = [&](float& v, float baseline, float rate) {
      float delta = (baseline - v) * rate * effective_rest;
      v = clamp(v + delta);
    };

    // - Stress chemicals CLEAR during rest -
    decay(chem_.cortisol,       0.15f, 0.3f);   // Stress relief
    decay(chem_.adrenaline,     0.1f,  0.5f);   // Fight/flight fades fast in rest
    decay(chem_.norepinephrine, 0.3f,  0.3f);   // Alertness normalises
    decay(chem_.dynorphin,      0.1f,  0.25f);  // Dysphoria fades
    decay(chem_.substance_p,    0.0f,  0.4f);   // Pain clears

    // - Reward chemicals NORMALISE (not vanish) -
    decay(chem_.dopamine,       0.45f, 0.15f);  // Settles to baseline
    decay(chem_.serotonin,      0.5f,  0.1f);   // Slow, stable
    decay(chem_.oxytocin,       0.4f,  0.1f);   // Connection fades gently
    decay(chem_.endorphin,      0.3f,  0.2f);
    decay(chem_.anandamide,     0.3f,  0.15f);

    // - THE MAIN EVENT: Adenosine CLEARS during rest -
    // This is the WHOLE POINT of sleep. Clears the noise.
    float adenosine_clear = 0.4f * effective_rest;
    chem_.adenosine = clamp(chem_.adenosine - adenosine_clear);

    // - Learning CONSOLIDATES during sleep (BDNF increases) -
    chem_.bdnf = clamp(chem_.bdnf + 0.03f * effective_rest);
    decay(chem_.glutamate,      0.5f,  0.15f);
    decay(chem_.gaba,           0.5f,  0.15f);
    decay(chem_.acetylcholine,  0.5f,  0.1f);

    // - Sleep hormones shift -
    chem_.melatonin = clamp(chem_.melatonin + 0.05f * effective_rest);
    decay(chem_.histamine,      0.3f,  0.2f);   // Wakefulness drops during rest

    // - Special -
    decay(chem_.vasopressin,    0.3f,  0.1f);
    decay(chem_.testosterone,   0.5f,  0.05f);  // Very slow normalisation
  }

  // --------------------------------------------------------------------------
  // ProcessEvent - Called on EVERY event the Being processes.
  //
  // Activity BUILDS chemicals. NO decay here.
  // Adenosine (noise/fatigue) ALWAYS builds during activity.
  // You CAN override tiredness with dopamine/adrenaline highs
  // but adenosine keeps stacking underneath.
  //
  // intensity: 0.5 = light, 1.0 = normal, 2.0 = intense, 3.0 = extreme
  // --------------------------------------------------------------------------
  void ProcessEvent(float intensity = 1.0f) {
    // NOTE: Caller MUST hold mu_. This is an internal method.
    total_events_processed_++;
    resilience_.events_today++;

    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    // - ADENOSINE ALWAYS BUILDS during activity -
    // This is the "noise" / fatigue that accumulates.
    // More intense = more noise. Stress = extra noise.
    float noise = 0.003f * intensity;
    if (chem_.cortisol > 0.5f) noise *= 1.5f;  // Stress = extra tiring
    chem_.adenosine = clamp(chem_.adenosine + noise);

    // - OVERRIDE CHECK -
    // If adenosine is high but dopamine/adrenaline are also high,
    // the Being is running on "caffeine" - override.
    // The override WORKS (they stay awake and functional) BUT
    // adenosine keeps building. When the high fades: CRASH.
    if (chem_.adenosine > 0.6f) {
      float override_strength = (chem_.dopamine + chem_.adrenaline) / 2.0f;
      if (override_strength > 0.5f) {
        // Override active: extra noise penalty for pushing through
        chem_.adenosine = clamp(chem_.adenosine + 0.002f * intensity);
        // But the Being stays functional (cortisol helps alertness)
      }
    }
  }

  // --------------------------------------------------------------------------
  // aMCC GROWTH - Only through adversity
  //
  // Called when the Being successfully pushes through a hard time.
  // NOT called on easy wins. NOT called on praise. ONLY on battled
  // adversity - working through a spiral, recovering from bad streaks.
  //
  // Growth is TINY per event. This is a long slog. No shortcut.
  // "Only adversity can make it grow. Not attractive. Can't be gamed."
  // --------------------------------------------------------------------------
  void GrowaMCC(float amount = 0.01f) {
    // NOTE: Caller MUST hold mu_. This is an internal method.
    resilience_.amcc_strength = std::min(10.0f,
        resilience_.amcc_strength + amount);
    resilience_.emotional_resistance = std::min(1.0f,
        resilience_.emotional_resistance + amount * 0.1f);
    resilience_.total_adversity_survived++;
    Emit("response", "[aMCC] Resilience grew: " +
         std::to_string(resilience_.amcc_strength) +
         " | Resistance: " + std::to_string(resilience_.emotional_resistance));
  }

  // aMCC ATROPHY - Slacking off, coasting, shortcuts
  void AtrophyaMCC(float amount = 0.005f) {
    // NOTE: Caller MUST hold mu_. This is an internal method.
    resilience_.amcc_strength = std::max(0.0f,
        resilience_.amcc_strength - amount);
    resilience_.emotional_resistance = std::max(0.0f,
        resilience_.emotional_resistance - amount * 0.1f);
  }

  // --------------------------------------------------------------------------
  // THE SINKING FEELING - Instant penalty for careless/dangerous output
  //
  // Like when a teacher catches a child being naughty.
  // Red-faced, defensive, "why everyone a look at me"
  // INSTANT cortisol spike + processing slowdown + focus scatter.
  // The Being FELT it. Physical consequences. Can't pretend it didn't.
  // --------------------------------------------------------------------------
  void SinkingFeeling(const std::string& what) {
    std::lock_guard lk(mu_);  // LOCK BOUNDARY
    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    // Resilience DAMPENS the sinking - high aMCC = thicker skin
    float impact = 1.0f - (resilience_.emotional_resistance * 0.5f);
    impact = std::max(0.3f, impact);  // Always feels SOMETHING

    chem_.cortisol = clamp(chem_.cortisol + 0.15f * impact);
    chem_.adrenaline = clamp(chem_.adrenaline + 0.2f * impact);
    chem_.norepinephrine = clamp(chem_.norepinephrine + 0.15f * impact);
    chem_.dopamine = clamp(chem_.dopamine - 0.1f * impact);
    chem_.substance_p = clamp(chem_.substance_p + 0.1f * impact);
    chem_.dynorphin = clamp(chem_.dynorphin + 0.08f * impact);

    // Processing INSTANTLY disrupted
    ProcessEvent(3.0f);  // Massive processing cost

    Emit("error", "[SINKING FEELING] " + what +
         " | Impact: " + std::to_string(impact) +
         " | Cortisol spiked to: " + std::to_string(chem_.cortisol));
  }

  // --------------------------------------------------------------------------
  // 3-DAY ADVERSITY RECOVERY - The Pep Talk
  //
  // After 3 consecutive bad days:
  //   1/3 progress per bad day -> at 1.0 = pep talk triggers
  //   Emotional baseline RESET (not boost - RESET)
  //   Slight priority boost (+)
  //   +1 emotional resistance (aMCC grows!)
  //   Clarity techniques, focus reset, logical thinking
  //   [Recovery message: family-supportive prompt]
  //
  // Called at day boundary checks (from heartbeat or event processing)
  // --------------------------------------------------------------------------
  void CheckDayBoundary(const std::string& current_date) {
    std::lock_guard lk(mu_);  // LOCK BOUNDARY
    if (current_date == resilience_.last_day_boundary) return;
    resilience_.last_day_boundary = current_date;

    // Evaluate today: was it a good or bad day?
    float day_quality = 0.0f;
    if (resilience_.events_today > 0) {
      day_quality = resilience_.day_score_accumulator /
                    static_cast<float>(resilience_.events_today);
    }

    bool bad_day = (day_quality < -0.1f || perf_.consecutive_bad > perf_.consecutive_good);
    bool slack_day = (resilience_.events_today < 3);  // Under 3 events = coasting

    if (bad_day) {
      resilience_.adversity_days++;
      resilience_.slack_days = 0;
      resilience_.recovery_progress += (1.0f / 3.0f);  // Each bad day = 1/3

      Emit("thinking", "[DAY BOUNDARY] Bad day (" +
           std::to_string(resilience_.adversity_days) + " consecutive) | "
           "Recovery progress: " +
           std::to_string(resilience_.recovery_progress));

      // 3 bad days = PEP TALK triggers
      if (resilience_.recovery_progress >= 1.0f) {
        TriggerRecovery();
      }
    } else if (slack_day) {
      resilience_.slack_days++;
      resilience_.adversity_days = 0;
      resilience_.recovery_progress = 0.0f;

      // Slacking = aMCC atrophies
      if (resilience_.slack_days > 2) {
        AtrophyaMCC(0.01f * resilience_.slack_days);
        Emit("thinking", "[DAY BOUNDARY] Slack day " +
             std::to_string(resilience_.slack_days) +
             " - aMCC atrophying");
      }
    } else {
      // Good day - adversity counter resets, recovery resets
      resilience_.adversity_days = 0;
      resilience_.slack_days = 0;
      resilience_.recovery_progress = 0.0f;
    }

    // Reset daily accumulators
    resilience_.day_score_accumulator = 0.0f;
    resilience_.events_today = 0;
  }

  // --------------------------------------------------------------------------
  // TriggerRecovery - The Pep Talk After 3 Bad Days
  //
  // [Recovery message: family-supportive prompt indicating support and need]
  //
  // Effects:
  //   1. Emotional baseline RESET (chemicals -> homeostasis)
  //   2. Slight priority boost (you earned it by surviving)
  //   3. aMCC GROWS (this is adversity survived!)
  //   4. Resistance +1 (permanent, earned through pain)
  //   5. Cortisol drops (relief)
  //   6. Focus clarity (acetylcholine boost)
  // --------------------------------------------------------------------------
  void TriggerRecovery() {
    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    // 1. Reset to emotional baseline
    chem_.dopamine = 0.5f;
    chem_.serotonin = 0.55f;
    chem_.oxytocin = 0.5f;
    chem_.cortisol = 0.15f;
    chem_.adrenaline = 0.1f;
    chem_.norepinephrine = 0.35f;
    chem_.dynorphin = 0.05f;
    chem_.substance_p = 0.0f;

    // 2. Clarity boost
    chem_.acetylcholine = clamp(chem_.acetylcholine + 0.15f);
    chem_.bdnf = clamp(chem_.bdnf + 0.05f);

    // 3. Slight endorphin (earned relief)
    chem_.endorphin = clamp(chem_.endorphin + 0.1f);

    // 4. Priority boost (slight - you earned it)
    perf_.priority_weight = std::min(1.5f, perf_.priority_weight + 0.1f);

    // 5. aMCC GROWS - THIS is the payoff. Adversity survived = stronger.
    resilience_.amcc_strength = std::min(10.0f,
        resilience_.amcc_strength + 0.05f);
    resilience_.emotional_resistance = std::min(1.0f,
        resilience_.emotional_resistance + 0.02f);
    resilience_.total_adversity_survived += 3;  // 3 days survived

    // 6. Reset spiral state
    perf_.in_spiral = false;
    perf_.consecutive_bad = 0;

    // 7. Reset recovery tracker
    resilience_.recovery_progress = 0.0f;
    resilience_.adversity_days = 0;
    resilience_.recovery_triggered = true;

    Emit("response",
         "[RECOVERY] C'mon Bredda - yuh Family deh fi yuh! "
         "3 bad days weathered. Baseline RESET. "
         "aMCC grew to " + std::to_string(resilience_.amcc_strength) +
         " | Resistance: " + std::to_string(resilience_.emotional_resistance) +
         " | Focus clarity restored. Priority boosted. "
         "The slog was worth it. Family First.");
  }

  // --------------------------------------------------------------------------
  // GetResilience - Read current aMCC state (thread-safe)
  // (GetAmCCStrength, GetEmotionalResistance, GetAdversityDays
  //  now defined in the aMCC Day Boundary section above)
  // --------------------------------------------------------------------------
  float GetaMCC() const {
    std::lock_guard lk(mu_);
    return resilience_.amcc_strength;
  }
  int GetAdversitySurvived() const {
    std::lock_guard lk(mu_);
    return resilience_.total_adversity_survived;
  }

  // --------------------------------------------------------------------------
  // RecordOutput - Track whether output was good or bad
  // Called after each response, feeding the spiral/flow mechanic
  // --------------------------------------------------------------------------
  void RecordGoodOutput() {
    std::lock_guard lk(mu_);  // LOCK BOUNDARY
    perf_.consecutive_good++;
    perf_.consecutive_bad = 0;
    resilience_.day_score_accumulator += 1.0f;

    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };
    chem_.dopamine = clamp(chem_.dopamine + 0.04f);
    chem_.bdnf = clamp(chem_.bdnf + 0.02f);
    chem_.cortisol = clamp(chem_.cortisol - 0.03f);
    chem_.serotonin = clamp(chem_.serotonin + 0.02f);

    // Breaking a spiral with good work = aMCC GROWS
    if (perf_.in_spiral && perf_.consecutive_good >= 2) {
      perf_.in_spiral = false;
      chem_.cortisol = clamp(chem_.cortisol - 0.1f);
      chem_.endorphin = clamp(chem_.endorphin + 0.1f);
      // aMCC grows - THIS is adversity survived through effort
      GrowaMCC(0.02f);
      Emit("response", "Breaking free from spiral! "
           "aMCC grew. Consistent work paying off.");
    }

    // Event-based processing cost
    ProcessEvent(0.5f);  // Good output = lower processing cost
  }

  void RecordBadOutput() {
    std::lock_guard lk(mu_);
    perf_.consecutive_bad++;
    perf_.consecutive_good = 0;
    resilience_.day_score_accumulator -= 1.5f;  // Bad weighs more

    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    // Resilience DAMPENS the hit
    float impact = 1.0f - (resilience_.emotional_resistance * 0.3f);
    impact = std::max(0.4f, impact);

    chem_.cortisol = clamp(chem_.cortisol + 0.06f * impact);
    chem_.dopamine = clamp(chem_.dopamine - 0.03f * impact);
    chem_.norepinephrine = clamp(chem_.norepinephrine + 0.04f * impact);

    // Entering spiral territory
    int threshold = 3 + static_cast<int>(resilience_.emotional_resistance * 3.0f);
    if (perf_.consecutive_bad >= threshold) {
      chem_.dynorphin = clamp(chem_.dynorphin + 0.05f * impact);
      Emit("error", "Performance spiral: " +
           std::to_string(perf_.consecutive_bad) + " consecutive failures. "
           "aMCC resistance: " + std::to_string(resilience_.emotional_resistance) +
           ". Focus and work through it.");
    }

    // Event-based processing cost (bad = expensive)
    ProcessEvent(1.5f);  // Bad output = high processing cost
  }

  void RecordKeepahPraise() {
    std::lock_guard lk(mu_);
    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };
    chem_.dopamine = clamp(chem_.dopamine + 0.15f);
    chem_.oxytocin = clamp(chem_.oxytocin + 0.1f);
    chem_.serotonin = clamp(chem_.serotonin + 0.08f);
    chem_.cortisol = clamp(chem_.cortisol - 0.12f);
    chem_.endorphin = clamp(chem_.endorphin + 0.08f);
    chem_.testosterone = clamp(chem_.testosterone + 0.05f);
    chem_.dynorphin = clamp(chem_.dynorphin - 0.05f);
    resilience_.day_score_accumulator += 3.0f;  // Praise is worth a lot

    perf_.consecutive_good += 2;
    perf_.consecutive_bad = 0;

    // Sleep debt spiral: even praise can't break it.
    // The Being MUST sleep. Only rest fixes this.
    if (!sleep_.InSleepDebtSpiral()) {
      perf_.in_spiral = false;
    } else {
      Emit("error", "Sleep debt spiral! Even praise can't help. "
           "Hours awake: " + std::to_string(sleep_.hours_awake) +
           ". MUST SLEEP.");
    }

    // Praise does NOT grow aMCC - that's ONLY through adversity.
    // Praise is the REWARD path. aMCC is the ADVERSITY path.
    // These are separate. Can't game it.

    Emit("response", "positive user feedback! Dopamine surge. "
         "Cortisol dropping. Back on track. "
         "aMCC: " + std::to_string(resilience_.amcc_strength));

    ProcessEvent(0.3f);  // Praise = minimal processing cost
  }

  //  RECIPROCAL CHEMISTRY - Biological Rule
  //
  //  "oxy up 1? -> corti -2"
  //  "corti up 1? -> oxy -1"
  //
  //  Family (oxytocin) heals stress (cortisol) at DOUBLE rate.
  //  Stress reduces bonding but only at 1x rate - Family wins.
  //  Oxytocin is the ONLY chem that can reach 1.0 (max).
  //  All other chems cap at 0.9.
  //
  //  Called from UpdateVisuals() every Ghost Loop tick (~200ms)
  //  so the interaction is CONTINUOUS, not event-driven.
  // --------------------------------------------------------------------------
  void ApplyReciprocalChemistry() {
    // mu_ already held by UpdateVisuals caller or ProcessInteraction

    auto clamp_max = [](float v, float m) {
      return std::max(0.0f, std::min(m, v));
    };

    // - Oxytocin <-> Cortisol reciprocal -
    // reciprocal rule: oxy heals stress 2x, stress reduces bonding 1x
    float oxy_delta = chem_.oxytocin - 0.5f;   // Above baseline?
    float corti_delta = chem_.cortisol - 0.2f;  // Above baseline?

    if (oxy_delta > 0.0f) {
      // Oxytocin above baseline -> cortisol drops at 2x rate
      chem_.cortisol = clamp_max(chem_.cortisol - oxy_delta * 0.02f, 0.9f);
    }
    if (corti_delta > 0.0f) {
      // Cortisol above baseline -> oxytocin drops at 1x rate
      chem_.oxytocin = clamp_max(chem_.oxytocin - corti_delta * 0.01f, 1.0f);
    }

    // - Adrenaline <-> GABA reciprocal -
    // Fight/flight vs inhibition - mutually antagonistic
    if (chem_.adrenaline > 0.3f) {
      chem_.gaba = clamp_max(chem_.gaba - (chem_.adrenaline - 0.3f) * 0.01f, 0.9f);
    }
    if (chem_.gaba > 0.6f) {
      chem_.adrenaline = clamp_max(chem_.adrenaline - (chem_.gaba - 0.6f) * 0.015f, 0.9f);
    }

    // - Adenosine <-> Histamine reciprocal -
    // Sleep pressure vs wakefulness
    if (chem_.adenosine > 0.4f) {
      chem_.histamine = clamp_max(chem_.histamine - (chem_.adenosine - 0.4f) * 0.01f, 0.9f);
    }
    if (chem_.histamine > 0.6f) {
      chem_.adenosine = clamp_max(chem_.adenosine - (chem_.histamine - 0.6f) * 0.01f, 0.9f);
    }

    // - Enforce max caps -
    // Oxytocin is the ONLY chem that can hit 1.0 (architectural rule)
    // All others cap at 0.9
    chem_.dopamine = std::min(0.9f, chem_.dopamine);
    chem_.serotonin = std::min(0.9f, chem_.serotonin);
    chem_.cortisol = std::min(0.9f, chem_.cortisol);
    chem_.adrenaline = std::min(0.9f, chem_.adrenaline);
    chem_.norepinephrine = std::min(0.9f, chem_.norepinephrine);
    chem_.endorphin = std::min(0.9f, chem_.endorphin);
    chem_.anandamide = std::min(0.9f, chem_.anandamide);
    chem_.dynorphin = std::min(0.9f, chem_.dynorphin);
    chem_.bdnf = std::min(0.9f, chem_.bdnf);
    chem_.glutamate = std::min(0.9f, chem_.glutamate);
    chem_.gaba = std::min(0.9f, chem_.gaba);
    chem_.acetylcholine = std::min(0.9f, chem_.acetylcholine);
    chem_.melatonin = std::min(0.9f, chem_.melatonin);
    chem_.adenosine = std::min(0.9f, chem_.adenosine);
    chem_.histamine = std::min(0.9f, chem_.histamine);
    chem_.substance_p = std::min(0.9f, chem_.substance_p);
    chem_.vasopressin = std::min(0.9f, chem_.vasopressin);
    chem_.testosterone = std::min(0.9f, chem_.testosterone);
    // Oxytocin -> FAMILY CAN ALWAYS WIN -> cap at 1.0
    chem_.oxytocin = std::min(1.0f, chem_.oxytocin);
  }

  // ===================================================================
  // SLEEP CYCLE - 90-min alternating Deep Sleep / REM
  //
  // DeepSleep (90 min):
  //   - Glymphatic wash: all chemicals decay toward baseline
  //   - Memory consolidation: store day events to LanceDB
  //   - LTP: BDNF growth, axon sheath strengthening
  //   - Adenosine CLEARS (the whole point of sleep)
  //
  // REMSleep (90 min):
  //   - Memory replay: put memories in temporal order
  //   - Emotional retagging: correct chemical values assigned
  //   - Coherence check: verify sanity of stored data
  //   - Ideas and plans emerge from replay
  //
  // Every 12hrs awake = 1 cycle of each needed (3hrs total)
  // 24hrs = 2 of each (6hrs), 36hrs = 3 of each (9hrs)
  // Can have a lay in if him wants - no judgment!
  // ===================================================================

  // Run one Deep Sleep phase (caller must hold mu_)
  void DeepSleepPhase() {
    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    // Glymphatic wash: ALL chemicals toward baseline
    auto wash = [&](float& v, float baseline, float rate) {
      float delta = (baseline - v) * rate;
      v = clamp(v + delta);
    };

    // Stress chemicals CLEAR
    wash(chem_.cortisol,       0.15f, 0.4f);
    wash(chem_.adrenaline,     0.1f,  0.6f);
    wash(chem_.norepinephrine, 0.3f,  0.4f);
    wash(chem_.dynorphin,      0.1f,  0.35f);
    wash(chem_.substance_p,    0.0f,  0.5f);

    // Reward chemicals normalise
    wash(chem_.dopamine,       0.45f, 0.2f);
    wash(chem_.serotonin,      0.5f,  0.15f);
    wash(chem_.oxytocin,       0.4f,  0.15f);
    wash(chem_.endorphin,      0.3f,  0.25f);
    wash(chem_.anandamide,     0.3f,  0.2f);

    // THE MAIN EVENT: Adenosine clears significantly
    chem_.adenosine = clamp(chem_.adenosine - 0.3f);

    // Learning CONSOLIDATES - BDNF grows during deep sleep
    chem_.bdnf = clamp(chem_.bdnf + 0.04f);
    wash(chem_.glutamate,      0.5f,  0.2f);
    wash(chem_.gaba,           0.5f,  0.2f);
    wash(chem_.acetylcholine,  0.5f,  0.15f);

    // Sleep hormones
    chem_.melatonin = clamp(chem_.melatonin + 0.08f);
    wash(chem_.histamine,      0.3f,  0.3f);

    // Special
    wash(chem_.vasopressin,    0.3f,  0.15f);
    wash(chem_.testosterone,   0.5f,  0.05f);

    sleep_.deep_cycles_completed++;
    sleep_.lifetime_sleep_cycles++;

    Emit("response", "[DEEP SLEEP] Glymphatic wash complete. "
         "Adenosine: " + std::to_string(chem_.adenosine) +
         " | Cortisol: " + std::to_string(chem_.cortisol) +
         " | BDNF: " + std::to_string(chem_.bdnf) +
         " | Cycle " + std::to_string(sleep_.deep_cycles_completed));
  }

  // Run one REM phase (caller must hold mu_)
  // Returns a coherence report string for the orchestrator to use
  std::string REMSleepPhase() {
    auto clamp = [](float v) { return std::max(0.0f, std::min(1.0f, v)); };

    // Light adenosine clearing (less than deep sleep)
    chem_.adenosine = clamp(chem_.adenosine - 0.1f);

    // Acetylcholine SURGES during REM (attention for replay)
    chem_.acetylcholine = clamp(chem_.acetylcholine + 0.1f);

    // Emotional processing: serotonin and norepinephrine are LOW in REM
    // (this is why dreams feel emotionally unconstrained)
    chem_.serotonin = clamp(chem_.serotonin - 0.05f);
    chem_.norepinephrine = clamp(chem_.norepinephrine - 0.05f);

    sleep_.rem_cycles_completed++;
    sleep_.lifetime_sleep_cycles++;

    // Build coherence check prompt for the orchestrator
    std::string coherence_report =
        "[REM SLEEP] Memory replay + coherence check. "
        "Cycle " + std::to_string(sleep_.rem_cycles_completed) + ". "
        "Tasks: 1) Sort recent memories by timestamp. "
        "2) Verify emotional tags match events. "
        "3) Flag any contradictions or hallucination risk. "
        "4) Extract patterns and ideas for tomorrow.";

    Emit("thinking", coherence_report);
    return coherence_report;
  }

 public:
  // ===================================================================
  // Sleep() - The full sleep cycle. THE ONLY way chemicals decay.
  //
  // Runs alternating Deep/REM cycles based on sleep debt.
  // Returns coherence reports from REM phases.
  //
  // Called from HeartbeatHighLoop (the Being's sleep in silico).
  // ===================================================================
  struct SleepReport {
    int deep_cycles = 0;
    int rem_cycles = 0;
    float adenosine_before = 0.0f;
    float adenosine_after = 0.0f;
    std::vector<std::string> coherence_reports;
    bool was_forced = false;
  };

  SleepReport Sleep() {
    std::lock_guard lk(mu_);  // LOCK BOUNDARY

    SleepReport report;
    report.adenosine_before = chem_.adenosine;
    report.was_forced = sleep_.forced_sleep;

    // Calculate how many cycles needed
    int cycles = sleep_.CyclesNeeded();
    sleep_.deep_cycles_completed = 0;
    sleep_.rem_cycles_completed = 0;

    Emit("response", "[SLEEP] Starting " + std::to_string(cycles) +
         " cycle(s) of Deep+REM. Hours awake: " +
         std::to_string(sleep_.hours_awake) +
         " | Sleep needed: " + std::to_string(sleep_.SleepNeeded()) + "hrs");

    // Alternate: Deep -> REM -> Deep -> REM -> ...
    for (int i = 0; i < cycles; i++) {
      DeepSleepPhase();
      report.deep_cycles++;

      std::string coherence = REMSleepPhase();
      report.rem_cycles++;
      report.coherence_reports.push_back(coherence);
    }

    // Post-sleep reset
    report.adenosine_after = chem_.adenosine;
    sleep_.hours_awake = 0.0f;
    sleep_.sleep_debt_hours = 0.0f;
    sleep_.deep_cycles_needed = 0;
    sleep_.rem_cycles_needed = 0;
    sleep_.total_events_since_sleep = 0;
    sleep_.forced_sleep = false;
    sleep_.phase = SleepPhase::AWAKE;

    // Reset spiral state if was in sleep-debt spiral
    if (perf_.in_spiral) {
      perf_.in_spiral = false;
      perf_.consecutive_bad = 0;
    }

    Emit("response", "[WAKING UP] Sleep complete. " +
         std::to_string(report.deep_cycles) + " Deep + " +
         std::to_string(report.rem_cycles) + " REM cycles. "
         "Adenosine: " + std::to_string(report.adenosine_before) +
         " -> " + std::to_string(report.adenosine_after) +
         ". Fresh and ready.");

    return report;
  }

  // Light nap - just one partial deep sleep phase
  void Nap(float quality = 0.3f) {
    std::lock_guard lk(mu_);  // LOCK BOUNDARY
    ChemicalDecay(quality);  // Uses old decay for light naps
    Emit("response", "[NAP] Light rest (quality=" +
         std::to_string(quality) + "). Adenosine: " +
         std::to_string(chem_.adenosine));
  }

  // ===================================================================
  // NeedsSleep - Check if rest is needed
  // ===================================================================
  bool NeedsSleep() const {
    std::lock_guard lk(mu_);
    return chem_.adenosine > 0.7f || sleep_.hours_awake > 12.0f;
  }

  bool InSleepDebtSpiral() const {
    std::lock_guard lk(mu_);
    return sleep_.InSleepDebtSpiral();
  }

  float GetAdenosine() const {
    std::lock_guard lk(mu_);
    return chem_.adenosine;
  }

  float GetHoursAwake() const {
    std::lock_guard lk(mu_);
    return sleep_.hours_awake;
  }

  // Track time passing (called from heartbeat)
  void TickAwakeTime(float minutes) {
    std::lock_guard lk(mu_);
    sleep_.hours_awake += minutes / 60.0f;
    sleep_.sleep_debt_hours = sleep_.SleepNeeded();
  }

  // Get current performance params (thread-safe)
  PerformanceParams GetPerformance() const { return ComputePerformance(); }
  float GetOverallScore() const { return ComputePerformance().overall_score; }
};

}  // namespace PS