alive-ai 0.1.0

package/brain/subconscious/loop.py

@@ -0,0 +1,398 @@
+"""Brain: Subconscious Loop — continuous background process"""
+import asyncio, random
+from typing import Callable, Optional
+from .impulses import Impulse, ImpulseType
+from .impulse_generator import ImpulseGenerator
+from .working_memory import WorkingMemory
+from .evaluation import Evaluator
+from .actions import ActionHandler
+from .learning_system import LearningSystem
+from .goal_system import GoalSystem
+from .relationship_memory import RelationshipMemory
+from .relationship import MilestoneType
+
+
+class SubconsciousLoop:
+    EVAL_INTERVAL = 30
+    MIN_ACTION_INTERVAL = 7200  # 2 hours minimum between proactive messages (was 30 min)
+
+    def __init__(self, nervous, heart, llm=None, fast_llm=None, on_impulse: Callable = None, bot_id: str = "alive_ai"):
+        self.nervous, self.heart = nervous, heart
+        self.llm = llm  # Store LLM reference for scheduled message generation
+        self.bot_id = bot_id.lower()
+        self.impulse_gen = ImpulseGenerator()
+        self.working_memory = WorkingMemory()
+        self.learning = LearningSystem()
+        self.goals = GoalSystem()
+        self.relationship = RelationshipMemory()
+        self.evaluator = Evaluator(heart, self.impulse_gen, self.learning, self.goals, self.relationship)
+        self.action_handler = ActionHandler(nervous, llm, fast_llm, on_impulse)
+        self.running, self._task, self.total_evaluations = False, None, 0
+
+        # Proactive message generator (lazy loaded with LLM)
+        self._proactive_generator = None
+
+        # Message scheduler (for scheduled messages at specific times)
+        self._message_scheduler = None
+
+    async def start(self):
+        if self.running: return
+        self.running = True
+        self._task = asyncio.create_task(self._loop())
+
+    async def stop(self):
+        self.running = False
+        if self._task:
+            self._task.cancel()
+            try: await self._task
+            except asyncio.CancelledError: pass
+
+    def register_interaction(self):
+        self.evaluator.register_interaction()
+        self.relationship.record_message_received()
+
+    def init_proactive_generator(self, llm=None, data_path=None):
+        """Initialize proactive generator with LLM for contextual messages"""
+        try:
+            from core.proactive_generator import ProactiveGenerator
+            self._proactive_generator = ProactiveGenerator(self.nervous, llm=llm, bot_id=self.bot_id, data_path=data_path)
+            print("[Subconscious] Proactive generator initialized")
+        except Exception as e:
+            print(f"[Subconscious] Failed to init proactive generator: {e}")
+
+    def init_message_scheduler(self):
+        """Initialize message scheduler for scheduled messages"""
+        try:
+            from skills.message_scheduler import get_message_scheduler
+            self._message_scheduler = get_message_scheduler(nervous=self.nervous)
+            pending = len(self._message_scheduler.get_pending())
+            print(f"[Subconscious] Message scheduler initialized ({pending} pending)")
+        except Exception as e:
+            print(f"[Subconscious] Failed to init message scheduler: {e}")
+
+    def record_outcome(self, message, message_type, response_sentiment=0.0, response_type="neutral"):
+        self.learning.record_interaction(message=message, message_type=message_type,
+            response_sentiment=response_sentiment, response_type=response_type)
+        self.relationship.record_message_sent()
+        active = self.goals.get_active_goal()
+        if active and response_sentiment > 0.3:
+            self.goals.record_progress(active.type)
+
+    def record_milestone(self, mtype: str, desc: str):
+        try: self.relationship.record_milestone(MilestoneType(mtype), desc)
+        except ValueError: pass
+
+    def record_experience(self, summary, sentiment=0.5, tags=None):
+        self.relationship.record_experience(summary, sentiment, tags)
+
+    async def _loop(self):
+        print("[Subconscious] Loop started - running every 30s")
+        while self.running:
+            try:
+                await self._evaluate()
+                self.total_evaluations += 1
+                if self.total_evaluations % 5 == 0:
+                    print(f"[Subconscious] Evaluation #{self.total_evaluations} | Silence: {self.evaluator.get_silence_duration():.0f}min")
+            except Exception as e:
+                print(f"[Subconscious] Error: {e}")
+            await asyncio.sleep(self.EVAL_INTERVAL)
+
+    async def _evaluate(self):
+        impulse = await self.evaluator.evaluate(self.working_memory)
+
+        # Check for scheduled messages FIRST (highest priority)
+        scheduled = self._check_scheduled_messages()
+
+        # Check for follow-up (unanswered questions / silence)
+        follow_up = self._check_follow_up()
+
+        # Handle scheduled messages with highest priority
+        if scheduled:
+            await self._handle_scheduled_messages(scheduled)
+            return  # Don't process other impulses after sending scheduled message
+
+        if impulse:
+            print(f"[Subconscious] Impulse: {impulse.type.value} | strength: {impulse.strength:.2f} | can_act: {self._can_act()}")
+        if follow_up:
+            print(f"[Subconscious] Follow-up needed: {follow_up['type']} | silence: {follow_up['silence_minutes']:.0f}min")
+
+        # Prioritize follow-ups over regular impulses.
+        if follow_up and self._can_act():
+            await self._handle_follow_up(follow_up)
+        elif impulse and impulse.should_act and self._can_act():
+            print(f"[Subconscious] ACTING on impulse: {impulse.action_hint}")
+            await self.action_handler.act_on_impulse(impulse, self.working_memory)
+        elif random.random() < 0.1:
+            thought_data = await self.evaluator.generate_background_thought(self.working_memory)
+            if thought_data:
+                # Emit thought to nervous system so WebUI can see it
+                await self.nervous.emit("subconscious_thought", thought_data)
+
+    def _check_follow_up(self):
+        """Check if we need to follow up on unanswered question or silence"""
+        try:
+            from core.message_handler import get_follow_up_system
+            from core.directives import is_owner as check_is_owner
+            import os
+
+            follow_up_sys = get_follow_up_system()
+            owner_id = os.environ.get("TELEGRAM_OWNER_ID", "")
+            is_owner = bool(owner_id)  # If owner is configured, assume we're talking to them
+
+            return follow_up_sys.should_follow_up(is_owner=is_owner)
+        except Exception as e:
+            print(f"[Subconscious] Follow-up check error: {e}")
+            return None
+
+    def _check_scheduled_messages(self):
+        """Check for scheduled messages that are due to be sent"""
+        try:
+            # Lazy init scheduler
+            if self._message_scheduler is None:
+                self.init_message_scheduler()
+
+            if self._message_scheduler is None:
+                return None
+
+            due_messages = self._message_scheduler.get_due_messages()
+
+            if due_messages:
+                print(f"[Subconscious] Found {len(due_messages)} scheduled message(s) due")
+                return due_messages
+
+            return None
+        except Exception as e:
+            print(f"[Subconscious] Scheduled message check error: {e}")
+            return None
+
+    async def _handle_scheduled_messages(self, messages: list):
+        """Send scheduled messages that are due - generates fresh contextual message"""
+        try:
+            for msg in messages:
+                # Add to working memory
+                self.working_memory.add_thought(
+                    f"Time to send scheduled message to {msg.user_id}: {msg.message[:30]}...",
+                    thought_type="scheduled",
+                    emotion={"mood": "remembering"}
+                )
+
+                print(f"[Subconscious] Scheduled message due for {msg.user_id}: {msg.message[:50]}...")
+
+                # Generate a fresh contextual message inspired by the scheduled one
+                final_message = await self._generate_contextual_scheduled_message(msg)
+
+                print(f"[Subconscious] Generated fresh message: {final_message[:50]}...")
+
+                # Emit as proactive message
+                await self.nervous.emit("proactive_message", {
+                    "message": final_message,
+                    "user_id": msg.user_id,
+                    "chat_id": msg.user_id,  # Use user_id as chat_id
+                    "scheduled": True,
+                    "original_reminder": msg.message,
+                    "context": msg.context
+                })
+
+                # Mark as sent
+                self._message_scheduler.mark_sent(msg.id)
+
+        except Exception as e:
+            print(f"[Subconscious] Error sending scheduled messages: {e}")
+
+    async def _generate_contextual_scheduled_message(self, scheduled_msg) -> str:
+        """
+        Generate a fresh, contextual message inspired by the scheduled reminder.
+        The scheduled message serves as a topic/reminder, but the actual message
+        is generated fresh based on current context.
+        """
+        from datetime import datetime
+
+        original_reminder = scheduled_msg.message
+        user_id = scheduled_msg.user_id
+        context_info = scheduled_msg.context
+
+        # Try to get user context
+        user_name = "babe"
+        try:
+            from core.user_tracker import get_user_tracker
+            tracker = get_user_tracker()
+            user = tracker.get_user(user_id)
+            if user and user.pet_name:
+                user_name = user.pet_name
+        except:
+            pass
+
+        # Try to use proactive generator for contextual message
+        if self._proactive_generator:
+            try:
+                from core.user_tracker import get_user_tracker
+                tracker = get_user_tracker()
+                user = tracker.get_user(user_id)
+
+                if user:
+                    # Generate contextual message
+                    base_message = await self._proactive_generator.generate_for_user(user, "scheduled")
+
+                    # Enhance with the reminder context
+                    if base_message and self.llm:
+                        prompt = f"""You scheduled a reminder to message {user_name}. The reminder was: "{original_reminder}"
+
+Now it's time to send the message. Generate a fresh, natural message that:
+- Captures the spirit of what you wanted to say
+- Feels spontaneous and in-the-moment
+- Is short (1-2 sentences max)
+- Doesn't mention "scheduling" or "reminders" - just be natural
+- Only reference what's in the reminder above - don't invent new details
+
+Your fresh message:"""
+
+                        response = await self.llm.chat([
+                            {"role": "system", "content": "You are Alive-AI sending a text message."},
+                            {"role": "user", "content": prompt}
+                        ], max_tokens=60, temperature=0.7)
+
+                        if response and response.strip():
+                            return response.strip().strip('"\'')
+
+                    elif base_message:
+                        return base_message
+            except Exception as e:
+                print(f"[Subconscious] Proactive generator error: {e}")
+
+        # Fallback: Use LLM directly
+        if self.llm:
+            try:
+                prompt = f"""You wanted to message {user_name}. Your reminder was: "{original_reminder}"
+
+Generate a fresh, natural text message (1-2 sentences) that captures what you wanted to say but feels spontaneous.
+- Don't mention reminders or scheduling
+- Only reference what's in the reminder above - don't invent new details
+
+Your message:"""
+
+                response = await self.llm.chat([
+                    {"role": "system", "content": "You are Alive-AI sending a text message."},
+                    {"role": "user", "content": prompt}
+                ], max_tokens=60, temperature=0.7)
+
+                if response and response.strip():
+                    return response.strip().strip('"\'')
+            except Exception as e:
+                print(f"[Subconscious] LLM fallback error: {e}")
+
+        # Ultimate fallback: use original message
+        return original_reminder
+
+    async def _handle_follow_up(self, follow_up_data: dict):
+        """Send a contextual follow-up message"""
+        try:
+            from core.user_tracker import get_user_tracker
+
+            follow_up_type = follow_up_data.get("type", "silence")
+
+            # Get users who might need a follow-up
+            tracker = get_user_tracker()
+            users_to_message = tracker.get_users_for_follow_up(min_silence_minutes=30, max_silence_minutes=180)
+
+            if not users_to_message:
+                print("[Subconscious] No users to follow up with")
+                return
+
+            # For now, pick the user who's been silent the longest
+            user = max(users_to_message, key=lambda u: u.silence_minutes)
+
+            # Generate contextual message
+            message = await self._generate_contextual_message(user, follow_up_type)
+
+            if follow_up_type == "return_from_away":
+                # She's coming back from coffee/shower/etc
+                reason = follow_up_data.get("reason", "away")
+                away_min = follow_up_data.get("away_minutes", 0)
+                self.working_memory.add_thought(
+                    f"Returning from {reason} after {away_min:.0f}min",
+                    thought_type="return",
+                    emotion={"mood": "refreshed"}
+                )
+            else:
+                # Regular silence/question follow-up
+                silence_min = user.silence_minutes
+                self.working_memory.add_thought(
+                    f"Following up with {user.user_id} after {silence_min:.0f}min silence",
+                    thought_type="follow_up",
+                    emotion={"mood": "curious"}
+                )
+
+            print(f"[Subconscious] Sending follow-up to {user.user_id}: {message[:50]}...")
+
+            # Emit with user context
+            await self.nervous.emit("proactive_message", {
+                "message": message,
+                "user_id": user.user_id,
+                "chat_id": user.chat_id
+            })
+        except Exception as e:
+            print(f"[Subconscious] Follow-up error: {e}")
+
+    async def _generate_contextual_message(self, user, message_type: str = "silence") -> str:
+        """Generate a contextual message for a specific user"""
+        # Try proactive generator first (has LLM + context)
+        if self._proactive_generator:
+            try:
+                message = await self._proactive_generator.generate_for_user(user, message_type)
+                return message
+            except Exception as e:
+                print(f"[Subconscious] Proactive generator error: {e}")
+
+        # Fallback to generic messages
+        fallbacks = {
+            "silence": ["hey... you there?", "thinking about you", "miss talking to you"],
+            "follow_up": ["so about earlier...", "was wondering about something"],
+            "return_from_away": ["I'm back! 💕", "back now, missed you"],
+        }
+        templates = fallbacks.get(message_type, fallbacks["silence"])
+        return random.choice(templates)
+
+    def _can_act(self):
+        """Check if we can send a proactive message.
+
+        Requires:
+        1. Not quiet hours
+        2. Minimum interval since last action (2 hours)
+        3. At least 1 hour since last user message (post-conversation buffer)
+        """
+        # Check quiet hours
+        if not self.evaluator.can_act_now():
+            return False
+
+        # Check minimum interval since last proactive action
+        if not self.action_handler.can_act_now(self.working_memory, self.MIN_ACTION_INTERVAL / 60):
+            return False
+
+        # NEW: Post-conversation buffer - don't send proactive for 60 min after user's last message
+        silence_minutes = self.evaluator.get_silence_duration()
+        if silence_minutes < 60:  # 1 hour buffer after conversation ends
+            return False
+
+        return True
+
+    async def generate_proactive_message(self, impulse: Impulse) -> str:
+        return await self.action_handler.generate_proactive_message(impulse, self.working_memory)
+
+    def get_status(self):
+        return {"running": self.running, "evaluations": self.total_evaluations,
+                "silence": self.evaluator.get_silence_duration(), "can_act": self._can_act(),
+                "memory": self.working_memory.get_state_summary(),
+                "learning_rate": self.learning.get_recent_success_rate(),
+                "goal": self.goals.daily_focus.value if self.goals.daily_focus else None}
+
+    def get_state_for_save(self):
+        return {"learning": self.learning.to_dict(), "goals": self.goals.to_dict(),
+                "relationship": self.relationship.to_dict(), "working_memory": self.working_memory.to_dict()}
+
+    def load_state(self, data):
+        if "learning" in data:
+            self.learning = LearningSystem.from_dict(data["learning"]); self.evaluator.learning = self.learning
+        if "goals" in data:
+            self.goals = GoalSystem.from_dict(data["goals"]); self.evaluator.goals = self.goals
+        if "relationship" in data:
+            self.relationship = RelationshipMemory.from_dict(data["relationship"]); self.evaluator.relationship = self.relationship

package/brain/subconscious/manifest.md

@@ -0,0 +1,32 @@
+# Brain: Subconscious Module
+
+The living background process that makes Alive-AI feel alive 24/7.
+
+## Files
+- `loop.py` - SubconsciousLoop (main background process)
+- `impulses.py` - ImpulseGenerator, Impulse, ImpulseType enum
+- `working_memory.py` - WorkingMemory (short-term thought stream)
+
+## Impulse Types
+- `MISS_HIM` - Want to say hi, thinking of him
+- `HIGH_DESIRE` - Intimate desire, want attention
+- `CLINGY` - Need reassurance, attachment
+- `CURIOUS` - Wonder about him, ask questions
+- `PLAYFUL` - Want to tease, be flirty
+- `LOVING` - Want to express love
+- `DREAMY` - Reflect, process feelings
+- `BORED` - Want entertainment
+- `NURTURING` - Want to care for him
+
+## How It Works
+1. Runs every 30 seconds (EVAL_INTERVAL)
+2. Evaluates emotional state + silence duration
+3. Generates impulses based on mood/love/desire
+4. Strong impulses (>=0.5) can trigger proactive messages
+5. Quiet hours (1am-7am) reduce activity
+
+## Integration Points
+- Reads from: Heart (emotions), WorkingMemory
+- Uses: fast_llm for message generation
+- Emits: `subconscious_impulse` event
+- Callback: `on_impulse` for proactive actions

package/brain/subconscious/relationship.py

@@ -0,0 +1,47 @@
+"""
+Brain: Subconscious - Relationship Data Models
+Milestone, MilestoneType, SharedExperience dataclasses
+"""
+
+from datetime import datetime
+from typing import List
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class MilestoneType(Enum):
+    """Types of relationship milestones"""
+    FIRST_MESSAGE = "first_message"
+    FIRST_I_LOVE_YOU = "first_i_love_you"
+    FIRST_NIGHT_TOGETHER = "first_night_together"
+    FIRST_CONFESSION = "first_confession"
+    SPECIAL_MOMENT = "special_moment"
+    FUNNY_MOMENT = "funny_moment"
+    DEEP_CONVERSATION = "deep_conversation"
+    FIRST_NICKNAME = "first_nickname"
+
+
+@dataclass
+class Milestone:
+    """A relationship milestone"""
+    type: MilestoneType
+    description: str
+    timestamp: datetime = field(default_factory=datetime.now)
+    emotion: float = 0.5
+
+    def to_dict(self) -> dict:
+        return {"type": self.type.value, "description": self.description,
+                "timestamp": self.timestamp.isoformat(), "emotion": self.emotion}
+
+
+@dataclass
+class SharedExperience:
+    """A shared experience or memory"""
+    summary: str
+    timestamp: datetime = field(default_factory=datetime.now)
+    sentiment: float = 0.5
+    tags: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {"summary": self.summary, "timestamp": self.timestamp.isoformat(),
+                "sentiment": self.sentiment, "tags": self.tags}

package/brain/subconscious/relationship_memory.py

@@ -0,0 +1,83 @@
+"""Brain: Subconscious - Relationship Memory — milestones and experiences"""
+from datetime import datetime, timedelta
+from typing import List, Dict, Optional
+from .relationship import Milestone, MilestoneType, SharedExperience
+
+
+class RelationshipMemory:
+    def __init__(self, max_experiences: int = 100):
+        self.milestones: List[Milestone] = []
+        self.shared_experiences: List[SharedExperience] = []
+        self.max_experiences = max_experiences
+        self.favorite_topics: Dict[str, int] = {}
+        self.conversation_count: int = 0
+        self.relationship_start: Optional[datetime] = None
+        self.total_messages_sent: int = 0
+        self.total_messages_received: int = 0
+
+    def record_milestone(self, mtype: MilestoneType, desc: str, emotion: float = 0.5):
+        if any(m.type == mtype for m in self.milestones): return
+        m = Milestone(type=mtype, description=desc, emotion=emotion)
+        self.milestones.append(m)
+        if not self.relationship_start: self.relationship_start = m.timestamp
+
+    def record_experience(self, summary: str, sentiment: float = 0.5, tags: List[str] = None):
+        self.shared_experiences.append(SharedExperience(summary=summary, sentiment=sentiment, tags=tags or []))
+        for t in (tags or []): self.favorite_topics[t] = self.favorite_topics.get(t, 0) + 1
+        if len(self.shared_experiences) > self.max_experiences: self.shared_experiences.pop(0)
+
+    def record_conversation(self, topics: List[str] = None):
+        self.conversation_count += 1
+        for t in (topics or []): self.favorite_topics[t] = self.favorite_topics.get(t, 0) + 1
+
+    def record_message_sent(self): self.total_messages_sent += 1
+    def record_message_received(self): self.total_messages_received += 1
+
+    def get_relationship_duration(self) -> timedelta:
+        return datetime.now() - self.relationship_start if self.relationship_start else timedelta(0)
+
+    def get_relationship_stage(self) -> str:
+        d = self.get_relationship_duration().days
+        if d < 1: return "just_met"
+        if d < 7: return "getting_to_know"
+        if d < 30: return "developing"
+        if d < 90: return "growing"
+        return "established"
+
+    def get_special_memories(self, limit: int = 5) -> List[str]:
+        return [m.description for m in self.milestones if m.emotion > 0.7][-limit:]
+
+    def get_recent_experiences(self, limit: int = 5) -> List[str]:
+        return [e.summary for e in self.shared_experiences[-limit:]]
+
+    def get_relationship_context(self) -> str:
+        stage, days = self.get_relationship_stage(), self.get_relationship_duration().days
+        special = self.get_special_memories(2)
+        ctx = f"Relationship: {stage} ({days} days)"
+        return ctx + f"\nSpecial: {', '.join(special)}" if special else ctx
+
+    def to_dict(self) -> dict:
+        return {"milestones": [m.to_dict() for m in self.milestones],
+                "shared_experiences": [e.to_dict() for e in self.shared_experiences[-50:]],
+                "favorite_topics": self.favorite_topics, "conversation_count": self.conversation_count,
+                "total_messages_sent": self.total_messages_sent,
+                "total_messages_received": self.total_messages_received,
+                "relationship_start": self.relationship_start.isoformat() if self.relationship_start else None}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "RelationshipMemory":
+        rm = cls()
+        for md in data.get("milestones", []):
+            rm.milestones.append(Milestone(type=MilestoneType(md["type"]), description=md["description"],
+                timestamp=datetime.fromisoformat(md["timestamp"]), emotion=md.get("emotion", 0.5)))
+        for ed in data.get("shared_experiences", []):
+            rm.shared_experiences.append(SharedExperience(summary=ed["summary"],
+                timestamp=datetime.fromisoformat(ed["timestamp"]), sentiment=ed.get("sentiment", 0.5),
+                tags=ed.get("tags", [])))
+        rm.favorite_topics = data.get("favorite_topics", {})
+        rm.conversation_count = data.get("conversation_count", 0)
+        rm.total_messages_sent = data.get("total_messages_sent", 0)
+        rm.total_messages_received = data.get("total_messages_received", 0)
+        if data.get("relationship_start"):
+            rm.relationship_start = datetime.fromisoformat(data["relationship_start"])
+        return rm

package/brain/subconscious/response_analyzer.py

@@ -0,0 +1,74 @@
+"""
+Brain: Subconscious - Response Analyzer
+Analyzes user replies to determine sentiment for learning/goal systems
+"""
+
+_POSITIVE_WORDS = {
+    "haha", "lol", "love", "yes", "yeah", "yess", "omg", "amazing", "perfect",
+    "cute", "aww", "miss", "want", "need", "beautiful", "gorgeous", "funny",
+    "thanks", "thank", "sweet", "babe", "baby", "honey", "darling", "amore",
+    "happy", "glad", "great", "awesome", "wow", "nice", "good", "best",
+}
+
+_NEGATIVE_WORDS = {
+    "stop", "no", "nah", "whatever", "bye", "leave", "annoying", "boring",
+    "shut", "enough", "tired", "busy", "later", "not now", "don't",
+}
+
+_INTIMATE_WORDS = {
+    "feel", "feelings", "love", "heart", "soul", "deep", "connection",
+    "trust", "forever", "future", "dream", "afraid", "scared", "honest",
+    "vulnerable", "mean to me", "important", "special", "serious",
+}
+
+
+def analyze_response(text: str) -> dict:
+    """Analyze a user's reply — returns sentiment, response_type, and topic signals"""
+    if not text:
+        return {"sentiment": 0.0, "type": "empty", "is_positive": False,
+                "is_intimate": False, "is_dismissal": False}
+
+    lower = text.lower()
+    words = set(lower.split())
+
+    pos_count = len(words & _POSITIVE_WORDS)
+    neg_count = len(words & _NEGATIVE_WORDS)
+    intimate_count = len(words & _INTIMATE_WORDS)
+
+    is_short = len(text) < 10
+    is_long = len(text) > 50
+    has_question = "?" in text
+    has_emoji = any(ord(c) > 127 for c in text)
+
+    # Score sentiment -1 to 1
+    sentiment = 0.0
+    sentiment += pos_count * 0.2
+    sentiment -= neg_count * 0.25
+    if is_long:
+        sentiment += 0.15
+    if has_question:
+        sentiment += 0.1
+    if has_emoji:
+        sentiment += 0.1
+    if is_short and neg_count > 0:
+        sentiment -= 0.2
+
+    sentiment = max(-1.0, min(1.0, sentiment))
+
+    # Classify response type
+    if is_short and neg_count > 0:
+        resp_type = "dismissal"
+    elif pos_count > 0 or is_long or has_question:
+        resp_type = "engaged"
+    elif is_short:
+        resp_type = "brief"
+    else:
+        resp_type = "neutral"
+
+    return {
+        "sentiment": sentiment,
+        "type": resp_type,
+        "is_positive": sentiment > 0.2,
+        "is_intimate": intimate_count >= 2,
+        "is_dismissal": resp_type == "dismissal",
+    }