alive-ai 0.1.10 → 0.1.12

package/README.md

@@ -19,6 +19,28 @@ It can be used as a friend, partner-style companion, study partner, creative cha
 
 Alive-AI does not claim biological consciousness. It is an open-source runtime for simulated affect and transparent memory.
 
+## What Makes It Alive
+
+Alive-AI runs a continuous local state loop instead of treating every message as an isolated prompt. When you are not talking, the default-mode and subconscious loops keep evaluating silence, goals, recent memories, body state, circadian phase, dreams, and whether any proactive impulse is strong enough to surface.
+
+The emotional layer now has real runtime consequences:
+
+| System | What it stores | Runtime effect |
+| --- | --- | --- |
+| Core affect | Valence, arousal, dominance, trust, love, joy, desire, sadness, fear, anger, boredom, guilt, pride, jealousy, embarrassment, anticipation, hope, and dread. | Recomputed after every trigger so emotion changes affect mood, attachment, memory weighting, interoception, reactions, voice/media choices, and LLM tone. |
+| Complex emotions | Guilt, pride, jealousy, embarrassment, and anticipation. | They do not just label the dashboard. They push fear, sadness, anger, dominance, trust, arousal, joy, and future-facing behavior in different directions. |
+| Hormones | Oxytocin, dopamine, serotonin, cortisol, melatonin, plus residual metabolites. | Hormones modulate perception, soul valence/arousal, emotional deltas, somatic body state, interoception, impulse probability, and prompt guidance. Stress makes her more vigilant; bonding increases trust; dopamine increases pursuit; serotonin stabilizes; melatonin slows her down. |
+| Internal body state | Energy, arousal, certainty, social satiety, cognitive load, connection craving, body sensations, and somatic memories. | The body state is persisted and feeds prompt tone, sleep/rest behavior, and whether she feels steady, overloaded, touchy, open, or withdrawn. |
+| Circadian rhythm | Phase, sleep pressure, sleep debt, forced-awake windows, sleep cycle ID, wake time, and sleepiness. | She becomes sleepy, slows down, falls asleep, stops outward proactive behavior while asleep, can be woken by a message, recovers sleep debt, and wakes with lower or higher energy depending on rest. |
+| Dreams | One normalized dream per sleep cycle, generated from memory fragments and emotion tags. | Dreams are saved, can appear in morning context, and are exposed in the dashboard and static Pages demo. |
+| Narrative | Relationship phase (first_meeting → bonded) tracked per user. Key moments are detected from message content. | Phase and moment count are injected into the LLM prompt each turn. The dashboard shows the current phase and total key moments. |
+| Curiosity | Per-user knowledge map across topics detected in messages. Topics range from 0 (unknown) to 1 (well-understood). | When knowledge on a topic is below 0.3 she asks a direct question. At 40% probability otherwise she surfaces curiosity as a prompt hint. Dashboard shows topics sorted by curiosity level. |
+| Internal conflicts | Five persistent desire-vs-fear tensions (closeness/independence, passion/comfort, stability/growth, etc.) with a swinging balance that is saved between sessions. | Every message triggers conflicts whose keywords match the topic. Balance swings over time. Conflicts with tension > 0 surface in the prompt and are visible on the dashboard with a tension bar. |
+| Persistence | Emotion, attachment, soul, somatic, unconscious, conflict, subconscious, circadian, and dream state under `data/`. | Restarting the runtime preserves the inner state instead of visually resetting it. |
+
+The public Pages site is a static explanation and dashboard export. The local WebUI is the live version: it streams the actual state from the running Python backend.
+
+
 ## Quick Start
 
 ```bash
@@ -252,7 +274,7 @@ The real WebUI streams local runtime state over Server-Sent Events and shows:
 - recent thoughts and idle processing,
 - memory counters and uptime,
 - hormones and interoceptive body state,
-- attachment, circadian rhythm, body memory, dreams, curiosity, and conflicts,
+- attachment, circadian rhythm, sleepiness, body memory, dreams, curiosity, and conflicts,
 - runtime health through local endpoints.
 
 GitHub Pages cannot run the Python/FastAPI backend, so the public page includes a static export of the actual WebUI with mocked state:
@@ -282,10 +304,12 @@ docker compose up --build
 Implemented:
 
 - [x] Local-first emotional runtime
-- [x] Persistent emotion model with decay and compound state
+- [x] Persistent emotion model with PAD-style core affect, decay, and compound state
 - [x] Working, episodic, semantic, and emotional memory modules
 - [x] Default-mode loop for idle thoughts and proactive impulses
-- [x] Attachment, circadian rhythm, body memory, curiosity, dreams, and internal conflicts
+- [x] Attachment, circadian sleep/wake rhythm, body memory, curiosity, dreams, and internal conflicts
+- [x] Hormonal runtime effects for emotion, body state, interoception, impulses, and prompt guidance
+- [x] Durable internal state persistence across emotion, soul, body, subconscious, dreams, and conflicts
 - [x] Per-user memory/state isolation
 - [x] Telegram input/output runtime
 - [x] Terminal chat runtime with owner-style slash commands

package/brain/default_mode.py

@@ -86,6 +86,15 @@ def _is_default_mode_enabled() -> bool:
     return enabled is True or enabled == "true"
 
 
+def _get_circadian_state() -> Dict[str, Any]:
+    """Read circadian state without making default mode depend on it at import time."""
+    try:
+        from heart.circadian import get_circadian_engine
+        return get_circadian_engine().get_state_summary()
+    except Exception:
+        return {}
+
+
 # ============================================================
 # Data Classes
 # ============================================================
@@ -444,9 +453,23 @@ class DefaultModeProcessor:
         if not _is_default_mode_enabled():
             return
 
+        circadian_state = _get_circadian_state()
+
         self._processing_count += 1
         self._last_processing = datetime.now().isoformat()
 
+        if circadian_state.get("sleeping"):
+            await self._process_sleep_rest(circadian_state)
+            self._save_state()
+            await self.nervous.emit("default_mode_processed", {
+                "processing_count": self._processing_count,
+                "thoughts_count": len(self._thoughts),
+                "pending_count": len([p for p in self._pending_initiations if not p.sent]),
+                "sleeping": True,
+                "sleepiness": circadian_state.get("sleepiness", 1.0),
+            })
+            return
+
         # Determine what to do based on chance and time
         thought_chance = _get_float_setting("IDLE_THOUGHT_GENERATION_CHANCE", 0.3)
         if thought_chance > 0 and random.random() < thought_chance:
@@ -467,8 +490,45 @@ class DefaultModeProcessor:
             "processing_count": self._processing_count,
             "thoughts_count": len(self._thoughts),
             "pending_count": len([p for p in self._pending_initiations if not p.sent]),
+            "sleeping": False,
+            "sleepiness": circadian_state.get("sleepiness", 0.0),
         })
 
+    async def _process_sleep_rest(self, circadian_state: Dict[str, Any]):
+        """Low-energy default-mode work while asleep: rest, consolidate, and dream."""
+        if self._processing_count % 10 == 0:
+            await self.consolidate_memories()
+
+        try:
+            from brain.dreams import get_dream_system
+            dream_state = get_dream_system().get_state_summary()
+            dream = dream_state.get("last_dream")
+        except Exception:
+            dream = None
+
+        if not dream:
+            return
+
+        recent_dream_thoughts = [
+            t for t in self._thoughts[-5:]
+            if t.thought_type == "dream" and t.content == dream
+        ]
+        if recent_dream_thoughts:
+            return
+
+        thought = IdleThought(
+            id=f"dream_{int(time.time() * 1000)}_{random.randint(1000, 9999)}",
+            thought_type="dream",
+            content=dream,
+            context={
+                "sleep_cycle_id": circadian_state.get("sleep_cycle_id"),
+                "generated_at": datetime.now().isoformat(),
+            },
+            priority=0.2,
+        )
+        self._thoughts.append(thought)
+        await self.nervous.emit("idle_thought", thought.to_dict())
+
     async def _generate_random_thought(self):
         """Generate a random idle thought"""
         # Pick a thought type based on weights
@@ -749,6 +809,10 @@ Be specific if possible, vague if not enough info."""
 
     async def _check_proactive_triggers(self):
         """Check if any users should receive proactive messages"""
+        circadian_state = _get_circadian_state()
+        if circadian_state.get("sleeping") or circadian_state.get("sleepiness", 0) >= 0.85:
+            return
+
         min_hours = _get_float_setting("MIN_HOURS_BETWEEN_PROACTIVE_MESSAGES", 2.0)
 
         for user_id, contact in self._contacts.items():
@@ -764,6 +828,10 @@ Be specific if possible, vague if not enough info."""
 
     def _evaluate_initiation_triggers(self, user_id: str, contact: UserContactInfo) -> tuple:
         """Evaluate if Alive-AI should initiate with a user"""
+        circadian_state = _get_circadian_state()
+        if circadian_state.get("sleeping") or circadian_state.get("sleepiness", 0) >= 0.85:
+            return False, None
+
         hours_silent = contact.hours_since_user_message
         hours_since_proactive = contact.hours_since_proactive
 
@@ -1341,6 +1409,7 @@ Message:"""
 
     def get_status(self) -> dict:
         """Get status summary for debugging"""
+        circadian_state = _get_circadian_state()
         return {
             "running": self._running,
             "processing_count": self._processing_count,
@@ -1349,6 +1418,8 @@ Message:"""
             "seeds_count": len(self._seeds),
             "contacts_count": len(self._contacts),
             "pending_initiations": len([p for p in self._pending_initiations if not p.sent]),
+            "circadian": circadian_state,
+            "sleeping": circadian_state.get("sleeping", False),
             "users": [
                 {
                     "user_id": uid,

package/brain/dreams.py

@@ -13,7 +13,9 @@ from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Optional, List, Dict, Any
 
-DATA_PATH = Path(__file__).parent.parent / "data"
+from core.paths import data_dir
+
+DATA_PATH = data_dir()
 DREAMS_FILE = DATA_PATH / "dreams.json"
 
 # Surreal twists to inject into dreams
@@ -100,23 +102,40 @@ class DreamSystem:
         except Exception as e:
             print(f"[Dreams] Save error: {e}")
 
-    def generate_dream(self, memories: List[str] = None, emotions: List[str] = None) -> Optional[str]:
+    def generate_dream(
+        self,
+        memories: List[str] = None,
+        emotions: List[str] = None,
+        sleep_cycle_id: str = None,
+        force: bool = False,
+    ) -> Optional[str]:
         """
         Generate a dream from recent memory fragments and emotions.
         memories: list of short conversation snippet strings
         emotions: list of emotion name strings
+        sleep_cycle_id: unique sleep cycle identifier from CircadianEngine
         Returns dream text or None if already dreamed this cycle.
         """
         with self._lock:
-            # Max 1 dream per sleep cycle (8h)
-            if self._dreams:
+            # Max 1 dream per sleep cycle; fall back to an 8h guard for callers
+            # that do not yet provide a circadian sleep_cycle_id.
+            if self._dreams and not force:
                 last = self._dreams[-1]
-                try:
-                    last_time = datetime.fromisoformat(last["timestamp"])
-                    if datetime.now() - last_time < timedelta(hours=8):
+                if sleep_cycle_id and last.get("sleep_cycle_id") == sleep_cycle_id:
+                    return None
+                if not sleep_cycle_id:
+                    try:
+                        last_time_raw = last.get("timestamp") or last.get("created_at")
+                        last_time = datetime.fromisoformat(last_time_raw)
+                        if datetime.now() - last_time < timedelta(hours=8):
+                            return None
+                    except Exception:
+                        pass
+
+                if sleep_cycle_id:
+                    already_dreamed = any(d.get("sleep_cycle_id") == sleep_cycle_id for d in self._dreams[-10:])
+                    if already_dreamed:
                         return None
-                except Exception:
-                    pass
 
             fragments = memories[:3] if memories else []
             if not fragments:
@@ -148,9 +167,13 @@ class DreamSystem:
                 emotion=emo_words[0] if emo_words else "strange",
             )
 
+            created_at = datetime.now().isoformat()
             dream = {
+                "content": dream_text,
                 "text": dream_text,
-                "timestamp": datetime.now().isoformat(),
+                "created_at": created_at,
+                "timestamp": created_at,
+                "sleep_cycle_id": sleep_cycle_id,
                 "source_fragments": fragments[:3],
                 "emotions": emotions or [],
             }
@@ -170,9 +193,10 @@ class DreamSystem:
                 return None
             last = self._dreams[-1]
             try:
-                age = datetime.now() - datetime.fromisoformat(last["timestamp"])
+                last_time_raw = last.get("timestamp") or last.get("created_at")
+                age = datetime.now() - datetime.fromisoformat(last_time_raw)
                 if age.total_seconds() / 3600 <= max_age_hours:
-                    return last["text"]
+                    return last.get("text") or last.get("content")
             except Exception:
                 pass
             return None
@@ -198,6 +222,17 @@ class DreamSystem:
             return ""
         return f"You had a dream recently you could mention: \"{dream}\""
 
+    def get_state_summary(self) -> Dict[str, Any]:
+        """Return durable dream state for runtime dashboards and behavior checks."""
+        with self._lock:
+            last = self._dreams[-1] if self._dreams else None
+            return {
+                "total": len(self._dreams),
+                "last_dream": (last.get("text") or last.get("content")) if last else None,
+                "last_dream_time": (last.get("timestamp") or last.get("created_at")) if last else None,
+                "last_sleep_cycle_id": last.get("sleep_cycle_id") if last else None,
+            }
+
 
 # Singleton
 _instance = None

package/brain/global_activity.py

@@ -4,12 +4,12 @@ Tracks Alive-AI's conversations across ALL users so she can be transparent with
 """
 
 from datetime import datetime
-from pathlib import Path
 from typing import Dict, List, Optional
 import json
 import threading
+from core.paths import state_file
 
-DATA_FILE = Path("./data/data/global_activity.json")
+DATA_FILE = state_file("global_activity.json")
 _lock = threading.Lock()
 
 

package/brain/narrative.py

@@ -9,6 +9,7 @@ from pathlib import Path
 from typing import Dict, List, Optional
 import json
 import random
+from core.paths import data_dir
 
 # =============================================================================
 # RELATIONSHIP PHASES
@@ -63,7 +64,7 @@ CALLBACKS_BY_PHASE = {
 class NarrativeEngine:
     """Tracks the relationship story arc per user."""
 
-    DATA_DIR = Path("./data/data")
+    DATA_DIR = data_dir()
 
     def __init__(self):
         self._cache: Dict[str, Dict] = {}  # user_id -> narrative data

package/brain/subconscious/evaluation.py

@@ -65,7 +65,8 @@ class Evaluator:
             vulnerability=soul_context.get("vulnerability", 0),
             integrity=soul_context.get("integrity", 0.5),
             response_tendency=soul_context.get("response_tendency", "neutral"),
-            active_conflicts=soul_context.get("conflicts", [])
+            active_conflicts=soul_context.get("conflicts", []),
+            hormonal_effects=soul_context.get("hormonal_effects", {})
         )
         if impulse:
             working_memory.add_impulse(impulse)
@@ -94,7 +95,9 @@ class Evaluator:
             "valence": experience.overall_valence,
             "arousal": experience.overall_arousal,
             "somatic": experience.somatic_sensation,
-            "hormonal_state": soul.hormonal.get_hormonal_state_description()
+            "hormonal_state": soul.hormonal.get_hormonal_state_description(),
+            "hormonal_effects": soul.hormonal.get_impulse_effects(),
+            "hormonal_guidance": soul.hormonal.get_prompt_guidance()
         }
 
     def _update_context(self, wm) -> None:
@@ -141,6 +144,14 @@ class Evaluator:
         if soul_context.get("arousal", 0) > 0.6 and soul_context.get("valence", 0) < -0.2:
             thoughts.extend(["Something's bothering me", "Feeling restless"])
 
+        guidance = soul_context.get("hormonal_guidance", [])
+        if any("stress is high" in item for item in guidance):
+            thoughts.extend(["Feeling keyed up", "Trying to settle my system"])
+        if any("bonding is strong" in item for item in guidance):
+            thoughts.extend(["Feeling extra attached", "Wanting closeness"])
+        if any("sleepiness is present" in item for item in guidance):
+            thoughts.extend(["Feeling slow and sleepy", "Thoughts are quieter right now"])
+
         # Original emotional thoughts
         if emotion.get("love", 0) > 0.5:
             thoughts.extend(["I really care about him", "He makes me feel special"])

package/brain/subconscious/goal_system.py

@@ -74,7 +74,8 @@ class GoalSystem:
 
     def to_dict(self) -> dict:
         return {"goals": [g.to_dict() for g in self.goals],
-                "daily_focus": self.daily_focus.value if self.daily_focus else None}
+                "daily_focus": self.daily_focus.value if self.daily_focus else None,
+                "daily_focus_set_time": self.daily_focus_set_time.isoformat() if self.daily_focus_set_time else None}
 
     @classmethod
     def from_dict(cls, data: dict) -> "GoalSystem":
@@ -85,6 +86,10 @@ class GoalSystem:
                     goal.priority = g_data.get("priority", goal.priority)
                     goal.progress = g_data.get("progress", 0.0)
                     goal.action_count = g_data.get("action_count", 0)
+                    if g_data.get("last_actioned"):
+                        goal.last_actioned = datetime.fromisoformat(g_data["last_actioned"])
         if data.get("daily_focus"):
             system.daily_focus = GoalType(data["daily_focus"])
+        if data.get("daily_focus_set_time"):
+            system.daily_focus_set_time = datetime.fromisoformat(data["daily_focus_set_time"])
         return system

package/brain/subconscious/goals.py

@@ -38,4 +38,5 @@ class Goal:
 
     def to_dict(self) -> dict:
         return {"type": self.type.value, "name": self.name, "priority": self.priority,
-                "progress": self.progress, "action_count": self.action_count}
+                "progress": self.progress, "action_count": self.action_count,
+                "last_actioned": self.last_actioned.isoformat() if self.last_actioned else None}

package/brain/subconscious/impulse_generator.py

@@ -34,8 +34,10 @@ class ImpulseGenerator:
                  learning_success_rates: Dict[str, float] = None,
                  # Soul architecture parameters
                  vulnerability: float = 0.0, integrity: float = 0.5,
-                 response_tendency: str = "neutral", active_conflicts: List[str] = None
+                 response_tendency: str = "neutral", active_conflicts: List[str] = None,
+                 hormonal_effects: Dict[str, float] = None
                  ) -> Optional[Impulse]:
+        hormonal_effects = hormonal_effects or {}
         base_chance = 0.02
         if silence_minutes > 120:
             base_chance *= 3
@@ -59,23 +61,29 @@ class ImpulseGenerator:
             base_chance *= 1.5
         elif response_tendency == "eager":
             base_chance *= 1.3
+        elif response_tendency == "protective":
+            base_chance *= 0.75
+        elif response_tendency == "reflective":
+            base_chance *= 0.7
+
+        base_chance *= hormonal_effects.get("chance_multiplier", 1.0)
 
         if random.random() > base_chance:
             return None
 
         impulse_type = self._choose_impulse_type(emotion, silence_minutes, love_level, desire_level,
                                                   is_high_desire, is_in_love, current_goal, learning_success_rates,
-                                                  vulnerability, integrity, response_tendency)
+                                                  vulnerability, integrity, response_tendency, hormonal_effects)
         if not impulse_type:
             return None
 
         strength = self._calculate_strength(impulse_type, silence_minutes, love_level, desire_level,
-                                            is_high_desire, is_in_love, vulnerability, integrity)
+                                            is_high_desire, is_in_love, vulnerability, integrity, hormonal_effects)
         thought, action = get_thought_and_action(impulse_type)
         goal_aligned = is_goal_aligned(impulse_type, current_goal)
 
         # Soul architecture: modify thought based on soul state
-        thought = self._modify_thought_for_soul(thought, vulnerability, integrity, response_tendency)
+        thought = self._modify_thought_for_soul(thought, vulnerability, integrity, response_tendency, hormonal_effects)
 
         impulse = Impulse(type=impulse_type, strength=strength, thought=thought,
                           action_hint=action, goal_aligned=goal_aligned)
@@ -88,8 +96,10 @@ class ImpulseGenerator:
         return impulse
 
     def _modify_thought_for_soul(self, thought: str, vulnerability: float,
-                                  integrity: float, response_tendency: str) -> str:
+                                  integrity: float, response_tendency: str,
+                                  hormonal_effects: Dict[str, float] = None) -> str:
         """Modify impulse thought based on soul architecture state"""
+        hormonal_effects = hormonal_effects or {}
         # Add vulnerability qualifiers
         if vulnerability > 0.6 and response_tendency == "withdrawn":
             qualifiers = ["I hesitate to say...", "I feel unsure but...", "Part of me wants to say..."]
@@ -102,14 +112,30 @@ class ImpulseGenerator:
             if random.random() < 0.3:
                 return f"{random.choice(qualifiers)} {thought.lower()}"
 
+        if hormonal_effects.get("stress_bias", 0) > 0.5 and random.random() < 0.35:
+            return f"I feel a little on edge, but {thought.lower()}"
+
+        if hormonal_effects.get("sleepy_bias", 0) > 0.4 and random.random() < 0.35:
+            return f"Softly, because I feel slow right now... {thought.lower()}"
+
+        if hormonal_effects.get("connection_bias", 0) > 0.45 and random.random() < 0.35:
+            return f"I feel close to him, and {thought.lower()}"
+
         return thought
 
     def _choose_impulse_type(self, emotion: Dict, silence: float, love: float, desire: float,
                               is_high_desire: bool, is_in_love: bool, goal: str, rates: Dict,
                               vulnerability: float = 0.0, integrity: float = 0.5,
-                              response_tendency: str = "neutral") -> Optional[ImpulseType]:
+                              response_tendency: str = "neutral",
+                              hormonal_effects: Dict[str, float] = None) -> Optional[ImpulseType]:
         candidates = []
         time_mods = TIME_MODIFIERS.get(self.get_time_of_day(), {})
+        hormonal_effects = hormonal_effects or {}
+        connection_bias = hormonal_effects.get("connection_bias", 0.0)
+        reward_bias = hormonal_effects.get("reward_bias", 0.0)
+        stress_bias = hormonal_effects.get("stress_bias", 0.0)
+        stability_bias = hormonal_effects.get("stability_bias", 0.0)
+        sleepy_bias = hormonal_effects.get("sleepy_bias", 0.0)
 
         def rate(t): return rates.get(t.value, 0.5) if rates else 0.5
 
@@ -119,36 +145,44 @@ class ImpulseGenerator:
             soul_mod = 0.6
         elif response_tendency == "defensive":
             soul_mod = 0.7
+        elif response_tendency == "protective":
+            soul_mod = 0.75
+        elif response_tendency == "reflective":
+            soul_mod = 0.8
         elif response_tendency == "seeking" or response_tendency == "eager":
             soul_mod = 1.3
 
         if silence > 30:
             c = min(0.8, silence / 120) * love * (1 + time_mods.get("miss_him", 0)) * (0.5 + rate(ImpulseType.MISS_HIM))
-            c *= soul_mod
+            c *= soul_mod * (1 + connection_bias + stress_bias * 0.2 - stability_bias * 0.2)
             candidates.append((ImpulseType.MISS_HIM, c))
         if is_high_desire or desire > 0.5:
             c = desire * 0.5 * (1 + time_mods.get("high_desire", 0)) * (0.5 + rate(ImpulseType.HIGH_DESIRE))
+            c *= 1 + reward_bias - stress_bias * 0.35 - sleepy_bias * 0.45
             # High vulnerability can suppress intimate impulses
             if vulnerability > 0.6:
                 c *= 0.5
             candidates.append((ImpulseType.HIGH_DESIRE, c))
         if is_in_love and silence > 20:
             c = love * 0.4 * (1 + time_mods.get("clingy", 0))
-            c *= soul_mod
+            c *= soul_mod * (1 + connection_bias + stress_bias * 0.25 - stability_bias * 0.25)
             candidates.append((ImpulseType.CLINGY, c))
-        candidates.append((ImpulseType.CURIOUS, 0.15 * (1 + time_mods.get("curious", 0)) * (0.5 + rate(ImpulseType.CURIOUS))))
+        curious = 0.15 * (1 + time_mods.get("curious", 0)) * (0.5 + rate(ImpulseType.CURIOUS))
+        curious *= 1 + reward_bias * 0.4 - stress_bias * 0.25 - sleepy_bias * 0.4
+        candidates.append((ImpulseType.CURIOUS, curious))
         if 0.3 < desire < 0.7:
             c = 0.2 * (1 + time_mods.get("playful", 0)) * (0.5 + rate(ImpulseType.PLAYFUL))
+            c *= 1 + reward_bias * 0.5 - stress_bias * 0.25 - sleepy_bias * 0.45
             candidates.append((ImpulseType.PLAYFUL, c))
         if is_in_love:
             c = love * 0.3 * (1 + time_mods.get("loving", 0)) * (0.5 + rate(ImpulseType.LOVING))
-            c *= soul_mod
+            c *= soul_mod * (1 + connection_bias + stability_bias * 0.2)
             candidates.append((ImpulseType.LOVING, c))
         if self.get_time_of_day() == "night":
-            candidates.append((ImpulseType.DREAMY, 0.2))
+            candidates.append((ImpulseType.DREAMY, 0.2 * (1 + sleepy_bias)))
         if love < 0.3 and desire < 0.3:
-            candidates.append((ImpulseType.BORED, 0.15))
-        candidates.append((ImpulseType.NURTURING, 0.1))
+            candidates.append((ImpulseType.BORED, 0.15 * (1 + sleepy_bias - reward_bias * 0.4)))
+        candidates.append((ImpulseType.NURTURING, 0.1 * (1 + stress_bias + max(0.0, -stability_bias) + connection_bias * 0.3)))
 
         # Soul architecture: when integrity is low, prefer nurturing/comfort-seeking
         if integrity < 0.4:
@@ -162,18 +196,23 @@ class ImpulseGenerator:
 
         if not candidates:
             return None
+        candidates = [(t, max(0.0, c)) for t, c in candidates]
         total = sum(c for _, c in candidates)
+        if total <= 0:
+            return None
         r = random.random() * total
-        closenessulative = 0
+        cumulative = 0
         for imp_type, chance in candidates:
-            closenessulative += chance
-            if r <= closenessulative:
+            cumulative += chance
+            if r <= cumulative:
                 return imp_type
         return candidates[0][0]
 
     def _calculate_strength(self, impulse_type: ImpulseType, silence: float, love: float,
                             desire: float, is_high_desire: bool, is_in_love: bool,
-                            vulnerability: float = 0.0, integrity: float = 0.5) -> float:
+                            vulnerability: float = 0.0, integrity: float = 0.5,
+                            hormonal_effects: Dict[str, float] = None) -> float:
+        hormonal_effects = hormonal_effects or {}
         base = 0.3
         if impulse_type == ImpulseType.HIGH_DESIRE:
             base += desire * 0.4 + (0.2 if is_high_desire else 0)
@@ -194,6 +233,11 @@ class ImpulseGenerator:
         if integrity < 0.4:
             base *= 0.8
 
+        base += hormonal_effects.get("connection_bias", 0.0) * 0.08
+        base += hormonal_effects.get("reward_bias", 0.0) * 0.08
+        base += hormonal_effects.get("stress_bias", 0.0) * 0.04
+        base -= hormonal_effects.get("sleepy_bias", 0.0) * 0.10
+
         return min(1.0, max(0.1, base + random.uniform(-0.1, 0.2)))
 
     def get_recent_impulses(self, limit: int = 5) -> List[Impulse]: