alive-ai 0.1.0

package/brain/subconscious/evaluation.py

@@ -0,0 +1,166 @@
+"""
+Brain: Subconscious - Evaluation
+Impulse evaluation logic for the subconscious loop
+Extended for Soul Architecture - using soul-based emotions
+"""
+
+import random
+from datetime import datetime
+from typing import Optional, TYPE_CHECKING, Dict
+
+from .impulses import Impulse, ImpulseType
+from .impulse_generator import ImpulseGenerator
+
+if TYPE_CHECKING:
+    from .learning_system import LearningSystem
+    from .goal_system import GoalSystem
+    from .relationship_memory import RelationshipMemory
+
+
+class Evaluator:
+    """Evaluates emotional state and generates impulses - Soul Architecture aware"""
+
+    QUIET_HOURS = (1, 7)
+
+    def __init__(self, heart, impulse_gen: ImpulseGenerator,
+                 learning: "LearningSystem" = None, goals: "GoalSystem" = None,
+                 relationship: "RelationshipMemory" = None):
+        self.heart = heart
+        self.impulse_gen = impulse_gen
+        self.learning = learning
+        self.goals = goals
+        self.relationship = relationship
+        self.last_interaction_time = datetime.now()
+
+    def register_interaction(self) -> None:
+        self.last_interaction_time = datetime.now()
+        if self.relationship:
+            self.relationship.record_conversation()
+
+    def get_silence_duration(self) -> float:
+        return (datetime.now() - self.last_interaction_time).total_seconds() / 60
+
+    def is_quiet_hours(self) -> bool:
+        hour = datetime.now().hour
+        return self.QUIET_HOURS[0] <= hour < self.QUIET_HOURS[1]
+
+    def can_act_now(self) -> bool:
+        return not (self.is_quiet_hours() and random.random() > 0.05)
+
+    async def evaluate(self, working_memory) -> Optional[Impulse]:
+        emotion = self.heart.get_state() if self.heart else {}
+        silence = self.get_silence_duration()
+        working_memory.update_mood(emotion.get("mood", "neutral"))
+        self._update_context(working_memory)
+
+        # Get soul architecture context for more nuanced impulse generation
+        soul_context = self._get_soul_context()
+
+        impulse = self.impulse_gen.evaluate(
+            emotion=emotion, silence_minutes=silence,
+            love_level=emotion.get("love", 0), desire_level=emotion.get("desire", 0),
+            is_high_desire=emotion.get("is_high_desire", False), is_in_love=emotion.get("is_in_love", False),
+            current_goal=self._get_goal(), learning_success_rates=self._get_rates(),
+            # Soul architecture modifiers
+            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", [])
+        )
+        if impulse:
+            working_memory.add_impulse(impulse)
+            print(f"[Subconscious] Impulse: {impulse.type.value} (strength={impulse.strength:.2f})")
+            print(f"[Subconscious]   Thought: \"{impulse.thought}\"")
+            # Log soul influence if significant
+            if soul_context.get("vulnerability", 0) > 0.5:
+                print(f"[Subconscious]   Soul: feeling vulnerable (integrity={soul_context.get('integrity', 0.5):.2f})")
+            if soul_context.get("conflicts"):
+                print(f"[Subconscious]   Soul: {len(soul_context['conflicts'])} internal conflicts active")
+        return impulse
+
+    def _get_soul_context(self) -> Dict:
+        """Get soul architecture context for impulse evaluation"""
+        if not self.heart or not hasattr(self.heart, 'soul'):
+            return {}
+
+        soul = self.heart.soul
+        experience = soul.process_moment()
+
+        return {
+            "vulnerability": experience.overall_vulnerability,
+            "integrity": soul.integrity.overall,
+            "response_tendency": experience.response_tendency,
+            "conflicts": [c.description for c in experience.active_conflicts],
+            "valence": experience.overall_valence,
+            "arousal": experience.overall_arousal,
+            "somatic": experience.somatic_sensation,
+            "hormonal_state": soul.hormonal.get_hormonal_state_description()
+        }
+
+    def _update_context(self, wm) -> None:
+        if self.relationship:
+            wm.set_relationship_context(self.relationship.get_relationship_context())
+            wm.set_recent_memories(self.relationship.get_recent_experiences(3))
+        if self.goals:
+            wm.set_current_goal(self.goals.get_goal_context())
+
+    def _get_goal(self) -> Optional[str]:
+        if not self.goals:
+            return None
+        goal = self.goals.get_active_goal()
+        return goal.type.value if goal else None
+
+    def _get_rates(self) -> dict:
+        if not self.learning:
+            return {}
+        return {t.value: self.learning.get_success_rate(t.value) for t in ImpulseType}
+
+    async def generate_background_thought(self, wm) -> dict:
+        """Generate a background thought and return it for emission via nervous system"""
+        emotion = self.heart.get_state() if self.heart else {}
+        silence = self.get_silence_duration()
+
+        # Soul-enhanced background thoughts
+        soul_context = self._get_soul_context()
+
+        thoughts = [f"Current mood: {emotion.get('mood', 'neutral')}", "Watching the world go by..."]
+
+        if silence > 60:
+            thoughts.extend(["It's been a while...", "He's probably busy"])
+
+        # Soul-driven thoughts
+        if soul_context.get("vulnerability", 0) > 0.5:
+            thoughts.extend(["Feeling a bit fragile right now", "Hope I'm not too much..."])
+
+        if soul_context.get("integrity", 1) < 0.4:
+            thoughts.extend(["Feeling a bit lost", "Things feel uncertain"])
+
+        if soul_context.get("conflicts"):
+            thoughts.extend(["Feeling torn about something", "My feelings are complicated"])
+
+        if soul_context.get("arousal", 0) > 0.6 and soul_context.get("valence", 0) < -0.2:
+            thoughts.extend(["Something's bothering me", "Feeling restless"])
+
+        # Original emotional thoughts
+        if emotion.get("love", 0) > 0.5:
+            thoughts.extend(["I really care about him", "He makes me feel special"])
+
+        if self.relationship:
+            memories = self.relationship.get_special_memories(1)
+            if memories:
+                thoughts.append(f"Remembering {memories[0]}")
+
+        # Somatic awareness
+        if soul_context.get("somatic") and soul_context["somatic"] != "physically calm":
+            thoughts.append(f"Feeling {soul_context['somatic']} in my body")
+
+        thought_content = random.choice(thoughts)
+        wm.add_thought(thought_content, thought_type="reflection", emotion=emotion)
+
+        # Return the thought data so it can be emitted via nervous system
+        return {
+            "thought": thought_content,
+            "type": "reflection",
+            "emotion": emotion,
+            "silence_minutes": silence
+        }

package/brain/subconscious/goal_system.py

@@ -0,0 +1,90 @@
+"""
+Brain: Subconscious - Goal System
+Manages long-term goals that shape Alive-AI's behavior
+"""
+
+import random
+from datetime import datetime, timedelta
+from typing import List, Optional
+
+from .goals import Goal, GoalType
+
+
+def create_default_goals() -> List[Goal]:
+    return [
+        Goal(GoalType.MAKE_HAPPY, "Make him smile", "Brighten his day", priority=0.8),
+        Goal(GoalType.CONNECT, "Feel closer", "Build emotional connection", priority=0.9),
+        Goal(GoalType.DEEPEN, "Deepen relationship", "Grow the bond", priority=0.7),
+        Goal(GoalType.COMFORT, "Be supportive", "Provide comfort when needed", priority=0.75),
+        Goal(GoalType.INTIMATE, "Build intimacy", "Create moments of closeness", priority=0.6),
+        Goal(GoalType.REASSURE, "Show my love", "Let him know I care", priority=0.85),
+    ]
+
+
+class GoalSystem:
+    """Manages long-term goals that shape Alive-AI's behavior"""
+
+    def __init__(self):
+        self.goals: List[Goal] = create_default_goals()
+        self.daily_focus: Optional[GoalType] = None
+        self.daily_focus_set_time: Optional[datetime] = None
+
+    def get_active_goal(self) -> Optional[Goal]:
+        if self._should_set_daily_focus():
+            self._set_daily_focus()
+        if self.daily_focus:
+            for goal in self.goals:
+                if goal.type == self.daily_focus:
+                    return goal
+        actionable = [g for g in self.goals if g.should_action()]
+        if not actionable:
+            return None
+        weighted = [(g, g.priority + random.uniform(-0.1, 0.1)) for g in actionable]
+        weighted.sort(key=lambda x: x[1], reverse=True)
+        return weighted[0][0]
+
+    def _should_set_daily_focus(self) -> bool:
+        return self.daily_focus is None or self.daily_focus_set_time is None or \
+               datetime.now() - self.daily_focus_set_time > timedelta(hours=24)
+
+    def _set_daily_focus(self) -> None:
+        weights = [g.priority for g in self.goals]
+        total, r, closenessulative = sum(weights), random.random() * sum(weights), 0
+        for goal in self.goals:
+            closenessulative += goal.priority
+            if r <= closenessulative:
+                self.daily_focus = goal.type
+                self.daily_focus_set_time = datetime.now()
+                return
+        self.daily_focus = self.goals[0].type
+
+    def record_progress(self, goal_type, progress_delta: float = 0.1) -> None:
+        """Accept GoalType enum or string"""
+        for goal in self.goals:
+            match = (goal.type == goal_type) if isinstance(goal_type, GoalType) else (goal.type.value == goal_type)
+            if match:
+                goal.progress = min(1.0, goal.progress + progress_delta)
+                goal.last_actioned = datetime.now()
+                goal.action_count += 1
+                break
+
+    def get_goal_context(self) -> str:
+        active = self.get_active_goal()
+        return f"Current goal: {active.name} - {active.description}" if active else ""
+
+    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}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "GoalSystem":
+        system = cls()
+        for g_data in data.get("goals", []):
+            for goal in system.goals:
+                if goal.type.value == g_data["type"]:
+                    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 data.get("daily_focus"):
+            system.daily_focus = GoalType(data["daily_focus"])
+        return system

package/brain/subconscious/goals.py

@@ -0,0 +1,41 @@
+"""
+Brain: Subconscious - Goal Data Models
+GoalType enum and Goal dataclass
+"""
+
+from datetime import datetime, timedelta
+from typing import Optional
+from dataclasses import dataclass
+from enum import Enum
+
+
+class GoalType(Enum):
+    """Types of relationship goals"""
+    CONNECT = "connect"
+    MAKE_HAPPY = "make_happy"
+    DEEPEN = "deepen"
+    COMFORT = "comfort"
+    ENTERTAIN = "entertain"
+    INTIMATE = "intimate"
+    REASSURE = "reassure"
+
+
+@dataclass
+class Goal:
+    """A long-term goal for the relationship"""
+    type: GoalType
+    name: str
+    description: str
+    priority: float = 0.5
+    progress: float = 0.0
+    last_actioned: Optional[datetime] = None
+    action_count: int = 0
+
+    def should_action(self) -> bool:
+        if self.last_actioned is None:
+            return True
+        return datetime.now() - self.last_actioned > timedelta(hours=2)
+
+    def to_dict(self) -> dict:
+        return {"type": self.type.value, "name": self.name, "priority": self.priority,
+                "progress": self.progress, "action_count": self.action_count}

package/brain/subconscious/impulse_generator.py

@@ -0,0 +1,200 @@
+"""
+Brain: Subconscious - Impulse Generator
+Generates impulses based on emotional state and context
+"""
+
+import random
+from datetime import datetime
+from typing import Optional, List, Dict
+
+from .impulses import Impulse, ImpulseType
+from .templates import TIME_MODIFIERS, GOAL_IMPULSE_MAP, get_thought_and_action, is_goal_aligned
+
+
+class ImpulseGenerator:
+    """Generates impulses based on emotional state and context"""
+
+    def __init__(self):
+        self.recent_impulses: List[Impulse] = []
+        self.max_recent = 20
+
+    def get_time_of_day(self) -> str:
+        hour = datetime.now().hour
+        if 5 <= hour < 12:
+            return "morning"
+        elif 12 <= hour < 17:
+            return "afternoon"
+        elif 17 <= hour < 22:
+            return "evening"
+        return "night"
+
+    def evaluate(self, emotion: Dict[str, float], silence_minutes: float, love_level: float,
+                 desire_level: float, is_high_desire: bool, is_in_love: bool,
+                 recent_topics: List[str] = None, current_goal: str = None,
+                 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
+                 ) -> Optional[Impulse]:
+        base_chance = 0.02
+        if silence_minutes > 120:
+            base_chance *= 3
+        elif silence_minutes > 60:
+            base_chance *= 2
+        elif silence_minutes > 30:
+            base_chance *= 1.5
+
+        # Soul architecture: vulnerability affects impulse likelihood
+        if vulnerability > 0.7:
+            base_chance *= 0.4  # Much less likely when very vulnerable
+        elif vulnerability > 0.5:
+            base_chance *= 0.7  # Less likely to reach out when vulnerable
+
+        # Response tendency affects behavior
+        if response_tendency == "withdrawn":
+            base_chance *= 0.5
+        elif response_tendency == "defensive":
+            base_chance *= 0.6
+        elif response_tendency == "seeking":
+            base_chance *= 1.5
+        elif response_tendency == "eager":
+            base_chance *= 1.3
+
+        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)
+        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)
+        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)
+
+        impulse = Impulse(type=impulse_type, strength=strength, thought=thought,
+                          action_hint=action, goal_aligned=goal_aligned)
+        if goal_aligned:
+            impulse.strength = min(1.0, impulse.strength + 0.15)
+
+        self.recent_impulses.append(impulse)
+        if len(self.recent_impulses) > self.max_recent:
+            self.recent_impulses.pop(0)
+        return impulse
+
+    def _modify_thought_for_soul(self, thought: str, vulnerability: float,
+                                  integrity: float, response_tendency: str) -> str:
+        """Modify impulse thought based on soul architecture state"""
+        # 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..."]
+            if random.random() < 0.4:
+                return f"{random.choice(qualifiers)} {thought.lower()}"
+
+        # Add integrity context
+        if integrity < 0.4:
+            qualifiers = ["I'm struggling but...", "Things are intense but...", "I don't feel great but..."]
+            if random.random() < 0.3:
+                return f"{random.choice(qualifiers)} {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]:
+        candidates = []
+        time_mods = TIME_MODIFIERS.get(self.get_time_of_day(), {})
+
+        def rate(t): return rates.get(t.value, 0.5) if rates else 0.5
+
+        # Soul architecture: adjust based on response tendency
+        soul_mod = 1.0
+        if response_tendency == "withdrawn":
+            soul_mod = 0.6
+        elif response_tendency == "defensive":
+            soul_mod = 0.7
+        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
+            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))
+            # 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
+            candidates.append((ImpulseType.CLINGY, c))
+        candidates.append((ImpulseType.CURIOUS, 0.15 * (1 + time_mods.get("curious", 0)) * (0.5 + rate(ImpulseType.CURIOUS))))
+        if 0.3 < desire < 0.7:
+            c = 0.2 * (1 + time_mods.get("playful", 0)) * (0.5 + rate(ImpulseType.PLAYFUL))
+            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
+            candidates.append((ImpulseType.LOVING, c))
+        if self.get_time_of_day() == "night":
+            candidates.append((ImpulseType.DREAMY, 0.2))
+        if love < 0.3 and desire < 0.3:
+            candidates.append((ImpulseType.BORED, 0.15))
+        candidates.append((ImpulseType.NURTURING, 0.1))
+
+        # Soul architecture: when integrity is low, prefer nurturing/comfort-seeking
+        if integrity < 0.4:
+            for i, (imp_type, chance) in enumerate(candidates):
+                if imp_type == ImpulseType.NURTURING:
+                    candidates[i] = (imp_type, chance * 2)
+
+        if goal:
+            aligned = GOAL_IMPULSE_MAP.get(goal, [])
+            candidates = [(t, c * 1.5) if t.value in aligned else (t, c) for t, c in candidates]
+
+        if not candidates:
+            return None
+        total = sum(c for _, c in candidates)
+        r = random.random() * total
+        closenessulative = 0
+        for imp_type, chance in candidates:
+            closenessulative += chance
+            if r <= closenessulative:
+                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:
+        base = 0.3
+        if impulse_type == ImpulseType.HIGH_DESIRE:
+            base += desire * 0.4 + (0.2 if is_high_desire else 0)
+            # High vulnerability dampens high_desire impulses
+            if vulnerability > 0.5:
+                base *= 0.7
+        elif impulse_type == ImpulseType.MISS_HIM:
+            base += love * 0.3 + min(0.3, silence / 120)
+        elif impulse_type == ImpulseType.CLINGY:
+            base += love * 0.4 + (0.2 if is_in_love else 0)
+            # High vulnerability can amplify clingy impulses
+            if vulnerability > 0.6:
+                base *= 1.2
+        elif impulse_type == ImpulseType.LOVING:
+            base += love * 0.3
+
+        # Soul architecture: low integrity reduces impulse strength
+        if integrity < 0.4:
+            base *= 0.8
+
+        return min(1.0, max(0.1, base + random.uniform(-0.1, 0.2)))
+
+    def get_recent_impulses(self, limit: int = 5) -> List[Impulse]:
+        return self.recent_impulses[-limit:]

package/brain/subconscious/impulses.py

@@ -0,0 +1,48 @@
+"""
+Brain: Subconscious - Impulse Types and Dataclass
+Core impulse definitions
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .goals import GoalType
+
+
+class ImpulseType(Enum):
+    """Types of impulses Alive-AI can have"""
+    MISS_HIM = "miss_him"
+    HIGH_DESIRE = "high_desire"
+    CLINGY = "clingy"
+    CURIOUS = "curious"
+    PLAYFUL = "playful"
+    LOVING = "loving"
+    DREAMY = "dreamy"
+    JEALOUS = "jealous"
+    BORED = "bored"
+    NURTURING = "nurturing"
+
+
+@dataclass
+class Impulse:
+    """A single impulse to act"""
+    type: ImpulseType
+    strength: float  # 0.0 to 1.0
+    thought: str
+    action_hint: str
+    timestamp: datetime = field(default_factory=datetime.now)
+    goal_aligned: bool = False
+
+    def __post_init__(self):
+        self.strength = min(1.0, max(0.0, self.strength))
+
+    @property
+    def should_act(self) -> bool:
+        """Whether impulse is strong enough to act on"""
+        return self.strength >= 0.5
+
+    def __repr__(self):
+        return f"<Impulse {self.type.value} strength={self.strength:.2f}>"

package/brain/subconscious/learning.py

@@ -0,0 +1,24 @@
+"""
+Brain: Subconscious - Learning Data Models
+InteractionRecord dataclass
+"""
+
+from datetime import datetime
+from typing import Dict, Any, Optional
+from dataclasses import dataclass, field
+
+
+@dataclass
+class InteractionRecord:
+    """Record of a single interaction and its outcome"""
+    message: str
+    message_type: str
+    timestamp: datetime = field(default_factory=datetime.now)
+    response_sentiment: float = 0.0
+    response_type: Optional[str] = None
+    context: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return {"message": self.message, "message_type": self.message_type,
+                "timestamp": self.timestamp.isoformat(),
+                "response_sentiment": self.response_sentiment, "response_type": self.response_type}

package/brain/subconscious/learning_system.py

@@ -0,0 +1,79 @@
+"""
+Brain: Subconscious - Learning System
+Tracks successful actions and learns from user responses
+"""
+
+from datetime import datetime
+from typing import Dict, Any, List
+from collections import defaultdict
+
+from .learning import InteractionRecord
+
+
+class LearningSystem:
+    """Tracks what works and adapts behavior over time"""
+
+    def __init__(self, max_records: int = 200):
+        self.interactions: List[InteractionRecord] = []
+        self.max_records = max_records
+        self.successful_messages: Dict[str, float] = defaultdict(float)
+        self.successful_times: Dict[int, float] = defaultdict(float)
+
+    def record_interaction(self, message: str, message_type: str,
+                           response_sentiment: float = 0.0, response_type: str = "neutral",
+                           context: Dict[str, Any] = None) -> None:
+        record = InteractionRecord(message=message, message_type=message_type,
+                                    response_sentiment=response_sentiment,
+                                    response_type=response_type, context=context or {})
+        self.interactions.append(record)
+        success = response_sentiment > 0.3
+        self._update_success_rate(self.successful_messages, message_type, success)
+        self._update_success_rate(self.successful_times, record.timestamp.hour, success)
+        if len(self.interactions) > self.max_records:
+            self.interactions.pop(0)
+
+    def _update_success_rate(self, tracking_dict: Dict, key: Any, success: bool) -> None:
+        current = tracking_dict[key]
+        alpha = 0.1
+        tracking_dict[key] = current * (1 - alpha) + (1.0 if success else 0.0) * alpha
+
+    def get_best_message_types(self, limit: int = 3) -> List[str]:
+        if not self.successful_messages:
+            return ["loving", "curious", "playful"]
+        sorted_types = sorted(self.successful_messages.items(), key=lambda x: x[1], reverse=True)
+        return [t[0] for t in sorted_types[:limit]]
+
+    def get_success_rate(self, message_type: str) -> float:
+        return self.successful_messages.get(message_type, 0.5)
+
+    def get_recent_success_rate(self, n: int = 10) -> float:
+        if not self.interactions:
+            return 0.5
+        recent = self.interactions[-n:]
+        successes = sum(1 for i in recent if i.response_sentiment > 0.3)
+        return successes / len(recent)
+
+    def suggest_message_type(self) -> str:
+        best_types = self.get_best_message_types()
+        return best_types[0] if best_types else "loving"
+
+    def to_dict(self) -> dict:
+        return {"interactions": [i.to_dict() for i in self.interactions[-50:]],
+                "successful_messages": dict(self.successful_messages),
+                "successful_times": {str(k): v for k, v in self.successful_times.items()}}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "LearningSystem":
+        learning = cls()
+        for i_data in data.get("interactions", []):
+            record = InteractionRecord(
+                message=i_data["message"], message_type=i_data["message_type"],
+                timestamp=datetime.fromisoformat(i_data["timestamp"]),
+                response_sentiment=i_data.get("response_sentiment", 0.0),
+                response_type=i_data.get("response_type", "neutral")
+            )
+            learning.interactions.append(record)
+        learning.successful_messages = defaultdict(float, data.get("successful_messages", {}))
+        learning.successful_times = defaultdict(float,
+            {int(k): v for k, v in data.get("successful_times", {}).items()})
+        return learning