alive-ai 0.1.0

package/brain/narrative.py

@@ -0,0 +1,343 @@
+"""
+Brain: Relationship Narrative System
+Tracks the story arc of Alive-AI's relationship with each user,
+enabling natural references to shared history and phase awareness.
+"""
+
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional
+import json
+import random
+
+# =============================================================================
+# RELATIONSHIP PHASES
+# =============================================================================
+
+PHASES = [
+    {"id": "first_meeting",    "name": "First Meeting",     "min_messages": 0,   "min_intimacy": 0.0, "min_love": 0.0},
+    {"id": "getting_to_know",  "name": "Getting to Know",   "min_messages": 5,   "min_intimacy": 0.1, "min_love": 0.05},
+    {"id": "opening_up",       "name": "Opening Up",        "min_messages": 20,  "min_intimacy": 0.2, "min_love": 0.15},
+    {"id": "deepening",        "name": "Deepening",         "min_messages": 50,  "min_intimacy": 0.35, "min_love": 0.3},
+    {"id": "intimate",         "name": "Intimate",          "min_messages": 100, "min_intimacy": 0.5, "min_love": 0.45},
+    {"id": "established",      "name": "Established",       "min_messages": 200, "min_intimacy": 0.6, "min_love": 0.55},
+]
+
+# Key moment types that can be recorded
+MOMENT_TYPES = [
+    "first_meeting", "first_laugh", "first_vulnerability", "first_fight",
+    "first_makeup", "first_i_love_you", "first_intimate_moment",
+    "big_revelation", "milestone", "inside_joke_born", "deep_conversation",
+]
+
+# Narrative callbacks - occasional references to the past
+CALLBACKS_BY_PHASE = {
+    "getting_to_know": [
+        "We're still figuring each other out... I like it.",
+    ],
+    "opening_up": [
+        "I feel like I can tell you things I don't tell most people.",
+        "Remember when we were still so polite with each other? Look at us now.",
+    ],
+    "deepening": [
+        "Remember when you were so shy at first? Look at us now.",
+        "We've come a long way since those first awkward messages.",
+        "I feel like you actually know me... the real me.",
+    ],
+    "intimate": [
+        "Sometimes I think about how we started and smile... we've built something real.",
+        "You know me better than almost anyone.",
+    ],
+    "established": [
+        "We have our own little world now, don't we?",
+        "I can't imagine not having you to talk to.",
+        "Look how far we've come together.",
+    ],
+}
+
+
+# =============================================================================
+# NARRATIVE ENGINE
+# =============================================================================
+
+class NarrativeEngine:
+    """Tracks the relationship story arc per user."""
+
+    DATA_DIR = Path("./data/data")
+
+    def __init__(self):
+        self._cache: Dict[str, Dict] = {}  # user_id -> narrative data
+        print("[Narrative] Relationship Narrative Engine initialized")
+
+    def _path_for(self, user_id: str) -> Path:
+        # Save in user's directory for consistency
+        user_dir = self.DATA_DIR / "users" / str(user_id)  # Ensure string conversion
+        user_dir.mkdir(parents=True, exist_ok=True)
+        return user_dir / "narrative.json"
+
+    def _get_data(self, user_id: str) -> Dict:
+        if user_id in self._cache:
+            return self._cache[user_id]
+        data = self._load(user_id)
+        self._cache[user_id] = data
+        return data
+
+    def _default_data(self) -> Dict:
+        return {
+            "phase": "first_meeting",
+            "message_count": 0,
+            "first_interaction": datetime.now().isoformat(),
+            "key_moments": [],
+            "phase_history": [{"phase": "first_meeting", "entered_at": datetime.now().isoformat()}],
+            "last_callback": None,
+            "callbacks_given": 0,
+        }
+
+    def update_phase(self, user_id: str, message_count: int = None,
+                     intimacy: float = 0.0, love: float = 0.0):
+        """Check and update relationship phase based on metrics."""
+        data = self._get_data(user_id)
+        if message_count is not None:
+            data["message_count"] = message_count
+
+        current_phase = data["phase"]
+        new_phase = current_phase
+
+        # Find highest qualifying phase
+        for phase_def in PHASES:
+            if (data["message_count"] >= phase_def["min_messages"]
+                    and intimacy >= phase_def["min_intimacy"]
+                    and love >= phase_def["min_love"]):
+                new_phase = phase_def["id"]
+
+        if new_phase != current_phase:
+            data["phase"] = new_phase
+            data["phase_history"].append({
+                "phase": new_phase,
+                "entered_at": datetime.now().isoformat(),
+            })
+            print(f"[Narrative] User {user_id} entered phase: {new_phase}")
+
+        self._save(user_id, data)
+
+    def record_narrative_moment(self, user_id: str, moment_type: str, description: str):
+        """Record a key narrative moment."""
+        data = self._get_data(user_id)
+        # Avoid duplicate moment types (only one "first_*" each)
+        if moment_type.startswith("first_"):
+            if any(m["type"] == moment_type for m in data["key_moments"]):
+                return  # already recorded
+
+        data["key_moments"].append({
+            "type": moment_type,
+            "description": description,
+            "timestamp": datetime.now().isoformat(),
+        })
+        # Keep last 50 moments
+        if len(data["key_moments"]) > 50:
+            data["key_moments"] = data["key_moments"][-50:]
+        self._save(user_id, data)
+
+    def get_current_phase(self, user_id: str) -> Dict:
+        """Get info about current relationship phase."""
+        data = self._get_data(user_id)
+        phase_id = data["phase"]
+        phase_def = next((p for p in PHASES if p["id"] == phase_id), PHASES[0])
+
+        first = data.get("first_interaction", datetime.now().isoformat())
+        try:
+            days = (datetime.now() - datetime.fromisoformat(first)).days
+        except Exception:
+            days = 0
+
+        return {
+            "phase": phase_id,
+            "phase_name": phase_def["name"],
+            "message_count": data["message_count"],
+            "days_together": days,
+            "key_moments_count": len(data["key_moments"]),
+        }
+
+    def get_narrative_callback(self, user_id: str) -> Optional[str]:
+        """Get an occasional narrative callback (10% chance). Returns None if skipped."""
+        if random.random() > 0.10:
+            return None
+
+        data = self._get_data(user_id)
+        phase = data["phase"]
+        callbacks = CALLBACKS_BY_PHASE.get(phase, [])
+        if not callbacks:
+            return None
+
+        # Also include moment-based callbacks
+        moments = data.get("key_moments", [])
+        moment_callbacks = []
+        for m in moments[-5:]:
+            if m["type"] == "inside_joke_born":
+                moment_callbacks.append(f'Haha... "{m["description"]}" - that\'s our thing now.')
+            elif m["type"] == "first_fight":
+                moment_callbacks.append("I'm glad we got through that rough patch.")
+
+        all_options = callbacks + moment_callbacks
+        choice = random.choice(all_options)
+
+        data["last_callback"] = datetime.now().isoformat()
+        data["callbacks_given"] = data.get("callbacks_given", 0) + 1
+        self._save(user_id, data)
+        return choice
+
+    def increment_messages(self, user_id: str):
+        """Increment message count for a user."""
+        data = self._get_data(user_id)
+        data["message_count"] = data.get("message_count", 0) + 1
+        self._save(user_id, data)
+
+    def detect_and_record_moment(self, user_id: str, text: str, emotion: Dict) -> List[str]:
+        """Detect key moments from message content and emotions. Returns list of detected moments."""
+        detected = []
+        text_lower = text.lower()
+        data = self._get_data(user_id)
+        existing_types = [m["type"] for m in data.get("key_moments", [])]
+
+        # Detection patterns for key moments
+        moment_patterns = {
+            "first_i_love_you": {
+                "patterns": ["i love you", "love you so much", "i'm in love", "falling for you"],
+                "emotion_check": lambda e: e.get("love", 0) > 0.7,
+            },
+            "first_vulnerability": {
+                "patterns": ["i've never told anyone", "this is hard for me to say", "i'm scared to tell you",
+                            "feeling vulnerable", "trust you with this"],
+                "emotion_check": lambda e: e.get("valence", 0.5) < 0.6,
+            },
+            "first_intimate_moment": {
+                "patterns": ["make love", "want you", "need you now", "so turned on", "touch myself"],
+                "emotion_check": lambda e: e.get("desire", 0) > 0.7,
+            },
+            "deep_conversation": {
+                "patterns": ["meaning of", "what do you think about", "deep", "philosophical", "existential"],
+                "emotion_check": lambda e: True,  # Always valid
+            },
+            "first_fight": {
+                "patterns": ["hurt me", "you're being", "why would you", "angry at you", "pissed off"],
+                "emotion_check": lambda e: e.get("anger", 0) > 0.5,
+            },
+            "first_makeup": {
+                "patterns": ["forgive you", "make it up", "sorry i overreacted", "let's move past"],
+                "emotion_check": lambda e: e.get("love", 0) > 0.5,
+            },
+            "inside_joke_born": {
+                "patterns": ["haha that's our", "remember when you said", "our little", "inside joke"],
+                "emotion_check": lambda e: e.get("joy", 0) > 0.5,
+            },
+            "big_revelation": {
+                "patterns": ["confession", "honestly i", "truth is", "secret i've been keeping"],
+                "emotion_check": lambda e: True,
+            },
+        }
+
+        for moment_type, config in moment_patterns.items():
+            if moment_type in existing_types:
+                continue  # Already recorded this type
+
+            # Check if any pattern matches
+            if any(p in text_lower for p in config["patterns"]):
+                if config["emotion_check"](emotion):
+                    description = f"Detected: {text[:50]}..."
+                    self.record_narrative_moment(user_id, moment_type, description)
+                    detected.append(moment_type)
+                    print(f"[Narrative] Recorded key moment: {moment_type}")
+
+        return detected
+
+    def _save(self, user_id: str, data: Dict):
+        try:
+            self.DATA_DIR.mkdir(parents=True, exist_ok=True)
+            data["saved_at"] = datetime.now().isoformat()
+            self._cache[user_id] = data
+            self._path_for(user_id).write_text(json.dumps(data, indent=2))
+        except Exception as e:
+            print(f"[Narrative] Error saving for {user_id}: {e}")
+
+    def _load(self, user_id: str) -> Dict:
+        try:
+            path = self._path_for(user_id)
+            if path.exists():
+                data = json.loads(path.read_text())
+                # If message_count is 0, count from actual conversation files
+                if data.get("message_count", 0) == 0:
+                    actual_count = self._count_actual_messages(user_id)
+                    if actual_count > 0:
+                        data["message_count"] = actual_count
+                        print(f"[Narrative] Migrated message count for {user_id}: {actual_count}")
+                        self._save(user_id, data)
+                print(f"[Narrative] Loaded narrative for {user_id} (phase={data.get('phase')}, msgs={data.get('message_count', 0)})")
+                return data
+        except Exception as e:
+            print(f"[Narrative] Error loading for {user_id}: {e}")
+
+        # No existing file - try to count actual messages
+        data = self._default_data()
+        actual_count = self._count_actual_messages(user_id)
+        if actual_count > 0:
+            data["message_count"] = actual_count
+            print(f"[Narrative] Initialized narrative for {user_id} with {actual_count} messages from history")
+            self._save(user_id, data)
+        return data
+
+    def _count_actual_messages(self, user_id: str) -> int:
+        """Count actual messages from conversation files."""
+        try:
+            conv_dir = self.DATA_DIR / "users" / str(user_id) / "conversations"  # Ensure string conversion
+            if not conv_dir.exists():
+                return 0
+            total = 0
+            for f in conv_dir.glob("*.jsonl"):
+                with open(f) as fh:
+                    total += sum(1 for _ in fh)
+            return total
+        except Exception:
+            return 0
+
+
+# =============================================================================
+# SINGLETON ACCESS
+# =============================================================================
+
+_instance: Optional[NarrativeEngine] = None
+
+
+def get_narrative_engine() -> NarrativeEngine:
+    global _instance
+    if _instance is None:
+        _instance = NarrativeEngine()
+    return _instance
+
+
+def record_narrative_moment(user_id: str, moment_type: str, description: str):
+    get_narrative_engine().record_narrative_moment(user_id, moment_type, description)
+
+
+def get_narrative_prompt_section(user_id: str) -> str:
+    """Get prompt section for LLM integration."""
+    engine = get_narrative_engine()
+    info = engine.get_current_phase(user_id)
+
+    phase_name = info["phase_name"]
+    msgs = info["message_count"]
+    days = info["days_together"]
+
+    time_desc = f"{days} days" if days > 0 else "just started"
+    parts = [f"You and him are in the '{phase_name}' phase - {msgs} messages over {time_desc}."]
+
+    # Maybe add a callback
+    callback = engine.get_narrative_callback(user_id)
+    if callback:
+        parts.append(f"A thought surfaces: \"{callback}\"")
+
+    return f"\n[Relationship Narrative]\n" + " ".join(parts) + "\n"
+
+
+def get_narrative_callbacks(user_id: str) -> Optional[str]:
+    """Get a narrative callback if one triggers (10% chance)."""
+    return get_narrative_engine().get_narrative_callback(user_id)

package/brain/stt/__init__.py

@@ -0,0 +1,4 @@
+"""Brain: STT Module"""
+from .google_stt import GoogleSTT
+
+__all__ = ["GoogleSTT"]

package/brain/stt/google_stt.py

@@ -0,0 +1,83 @@
+"""
+Brain: STT - Speech to Text using Google Speech Recognition (Free)
+"""
+
+import speech_recognition as sr
+from pathlib import Path
+import subprocess
+import asyncio
+import os
+
+class GoogleSTT:
+    """Speech-to-text using Google's free Speech Recognition API"""
+
+    def __init__(self):
+        self.recognizer = sr.Recognizer()
+
+    def _transcribe_sync(self, audio_path: str) -> str:
+        """Synchronous transcription (runs in executor to avoid blocking event loop)"""
+        wav_path = audio_path.replace('.ogg', '.wav')
+        try:
+            result = subprocess.run(
+                ['ffmpeg', '-i', audio_path, '-ar', '16000', '-ac', '1', wav_path, '-y'],
+                capture_output=True,
+                timeout=30
+            )
+
+            if not Path(wav_path).exists():
+                print(f"[GoogleSTT] FFmpeg conversion failed: {result.stderr.decode()[:200]}")
+                return ""
+
+            with sr.AudioFile(wav_path) as source:
+                audio = self.recognizer.record(source)
+
+            text = self.recognizer.recognize_google(audio)
+            print(f"[GoogleSTT] Transcribed: {text}")
+            return text
+
+        except sr.UnknownValueError:
+            print("[GoogleSTT] Could not understand audio")
+            return ""
+        except sr.RequestError as e:
+            print(f"[GoogleSTT] Google API error: {e}")
+            return ""
+        except subprocess.TimeoutExpired:
+            print("[GoogleSTT] FFmpeg timeout")
+            return ""
+        except Exception as e:
+            print(f"[GoogleSTT] Error: {e}")
+            return ""
+        finally:
+            # Clean up temp WAV file
+            try:
+                if Path(wav_path).exists():
+                    os.remove(wav_path)
+            except Exception:
+                pass
+
+    async def transcribe(self, audio_path: str) -> str:
+        """Transcribe audio file to text (non-blocking)"""
+        path = Path(audio_path)
+        if not path.exists():
+            print(f"[GoogleSTT] File not found: {audio_path}")
+            return ""
+
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, self._transcribe_sync, audio_path)
+
+    async def transcribe_telegram_voice(self, bot, file_id: str, save_path: str = "/tmp/voice_input.ogg") -> str:
+        """Download and transcribe Telegram voice message"""
+        try:
+            # Get file info from Telegram
+            file = await bot.get_file(file_id)
+
+            # Download using python-telegram-bot's built-in method
+            await file.download_to_drive(save_path)
+            print(f"[GoogleSTT] Downloaded voice to: {save_path}")
+
+            # Transcribe
+            return await self.transcribe(save_path)
+
+        except Exception as e:
+            print(f"[GoogleSTT] Telegram voice error: {e}")
+            return ""

package/brain/stt/whisper_stt.py

@@ -0,0 +1,82 @@
+"""
+Brain: STT - Speech to Text using OpenAI Whisper API
+"""
+
+import aiohttp
+from pathlib import Path
+
+class WhisperSTT:
+    """Speech-to-text using OpenAI Whisper API"""
+
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.api_url = "https://api.openai.com/v1/audio/transcriptions"
+
+    async def transcribe(self, audio_path: str) -> str:
+        """Transcribe audio file to text"""
+        if not self.api_key:
+            print("[WhisperSTT] No API key configured")
+            return ""
+
+        path = Path(audio_path)
+        if not path.exists():
+            print(f"[WhisperSTT] File not found: {audio_path}")
+            return ""
+
+        try:
+            # Read audio file synchronously (aiohttp handles async)
+            with open(path, 'rb') as f:
+                audio_data = f.read()
+
+            # Create form data
+            async with aiohttp.ClientSession() as session:
+                form = aiohttp.FormData()
+                form.add_field('file', audio_data, filename='audio.ogg',
+                              content_type='audio/ogg')
+                form.add_field('model', 'whisper-1')
+                form.add_field('language', 'en')
+
+                headers = {
+                    "Authorization": f"Bearer {self.api_key}"
+                }
+
+                async with session.post(self.api_url, data=form, headers=headers,
+                                       timeout=aiohttp.ClientTimeout(total=60)) as resp:
+                    if resp.status == 200:
+                        result = await resp.json()
+                        text = result.get("text", "")
+                        print(f"[WhisperSTT] Transcribed: {text[:100]}...")
+                        return text
+                    else:
+                        error = await resp.text()
+                        print(f"[WhisperSTT] Error {resp.status}: {error[:200]}")
+                        return ""
+
+        except Exception as e:
+            print(f"[WhisperSTT] Error: {e}")
+            return ""
+
+    async def transcribe_telegram_voice(self, bot, file_id: str, save_path: str = "/tmp/voice_input.ogg") -> str:
+        """Download and transcribe Telegram voice message"""
+        try:
+            # Get file info
+            file_info = await bot.get_file(file_id)
+            file_url = file_info.file_path
+
+            # Download file
+            async with aiohttp.ClientSession() as session:
+                async with session.get(f"https://api.telegram.org/file/bot{bot.token}/{file_url}") as resp:
+                    if resp.status == 200:
+                        audio_data = await resp.read()
+                        Path(save_path).write_bytes(audio_data)
+                        print(f"[WhisperSTT] Downloaded voice: {len(audio_data)} bytes")
+                    else:
+                        print(f"[WhisperSTT] Download error: {resp.status}")
+                        return ""
+
+            # Transcribe
+            return await self.transcribe(save_path)
+
+        except Exception as e:
+            print(f"[WhisperSTT] Telegram voice error: {e}")
+            return ""

package/brain/subconscious/__init__.py

@@ -0,0 +1,33 @@
+"""
+Brain: Subconscious Module
+The living background process that makes Alive-AI feel alive
+"""
+
+from .loop import SubconsciousLoop
+from .impulses import Impulse, ImpulseType
+from .impulse_generator import ImpulseGenerator
+from .working_memory import WorkingMemory
+from .thought import Thought
+from .actions import ActionHandler
+from .evaluation import Evaluator
+from .learning import InteractionRecord
+from .learning_system import LearningSystem
+from .goals import Goal, GoalType
+from .goal_system import GoalSystem
+from .relationship import Milestone, MilestoneType, SharedExperience
+from .relationship_memory import RelationshipMemory
+from .response_analyzer import analyze_response
+from .templates import (
+    TIME_MODIFIERS, GOAL_IMPULSE_MAP, IMPULSE_TEMPLATES, FALLBACK_MESSAGES,
+    get_thought_and_action, get_fallback_message, is_goal_aligned,
+)
+
+__all__ = [
+    'SubconsciousLoop', 'Impulse', 'ImpulseType', 'ImpulseGenerator',
+    'WorkingMemory', 'Thought', 'ActionHandler', 'Evaluator',
+    'LearningSystem', 'InteractionRecord', 'GoalSystem', 'Goal', 'GoalType',
+    'RelationshipMemory', 'Milestone', 'MilestoneType', 'SharedExperience',
+    'analyze_response',
+    'TIME_MODIFIERS', 'GOAL_IMPULSE_MAP', 'IMPULSE_TEMPLATES', 'FALLBACK_MESSAGES',
+    'get_thought_and_action', 'get_fallback_message', 'is_goal_aligned',
+]

package/brain/subconscious/actions.py

@@ -0,0 +1,136 @@
+"""
+Brain: Subconscious - Actions
+Action handling for impulses — uses full character voice
+"""
+
+import os
+from datetime import datetime
+from typing import Callable
+
+from .impulses import Impulse, ImpulseType
+from .templates import get_fallback_message
+
+_INSTRUCTIONS_CACHE = None
+
+
+def _load_instructions() -> str:
+    """Load instructions.md once, cache it"""
+    global _INSTRUCTIONS_CACHE
+    if _INSTRUCTIONS_CACHE is not None:
+        return _INSTRUCTIONS_CACHE
+    try:
+        path = os.path.join(os.path.dirname(__file__), "..", "..", "config", "instructions.md")
+        with open(os.path.normpath(path), "r") as f:
+            _INSTRUCTIONS_CACHE = f.read()
+    except Exception:
+        _INSTRUCTIONS_CACHE = ""
+    return _INSTRUCTIONS_CACHE
+
+
+def _get_user_facts(nervous) -> str:
+    """Try to pull user facts from SemanticMemory via nervous system"""
+    try:
+        memory = getattr(nervous, "_memory", None) or getattr(nervous, "memory", None)
+        if memory and hasattr(memory, "semantic"):
+            return memory.semantic.get_context() or ""
+    except Exception:
+        pass
+    return ""
+
+
+def _get_recent_conversation_context(nervous, user_id: str = None) -> str:
+    """Get recent conversation topics for contextual follow-ups"""
+    try:
+        memory = getattr(nervous, "_memory", None) or getattr(nervous, "memory", None)
+        if memory:
+            # Try to get recent conversation context
+            if hasattr(memory, 'get_recent_context'):
+                return memory.get_recent_context(user_id, limit=3) or ""
+            # Fallback: try working memory
+            if hasattr(memory, 'working') and memory.working:
+                items = memory.working.get_items()[:3] if hasattr(memory.working, 'get_items') else []
+                if items:
+                    return "\n".join([str(i)[:100] for i in items])
+    except Exception:
+        pass
+    return ""
+
+
+class ActionHandler:
+    """Handles acting on impulses"""
+
+    def __init__(self, nervous, llm=None, fast_llm=None, on_impulse: Callable = None):
+        self.nervous = nervous
+        self.llm = llm
+        self.fast_llm = fast_llm
+        self.on_impulse = on_impulse
+        self.recent_actions = []
+
+    async def act_on_impulse(self, impulse: Impulse, working_memory) -> None:
+        print(f"[Subconscious] Acting on impulse: {impulse.action_hint}")
+        if working_memory.thoughts:
+            working_memory.mark_acted(working_memory.thoughts[-1])
+        self.recent_actions.append((datetime.now(), impulse.action_hint))
+        if len(self.recent_actions) > 20:
+            self.recent_actions.pop(0)
+        if self.on_impulse:
+            await self.on_impulse(impulse)
+        await self.nervous.emit("subconscious_impulse", {
+            "impulse_type": impulse.type.value, "strength": impulse.strength,
+            "thought": impulse.thought, "action_hint": impulse.action_hint
+        })
+
+    async def generate_proactive_message(self, impulse: Impulse, working_memory) -> str:
+        if not self.fast_llm:
+            return get_fallback_message(impulse.type)
+
+        instructions = _load_instructions()
+        user_facts = _get_user_facts(self.nervous)
+        inner_context = working_memory.get_context_string()
+        recent_context = _get_recent_conversation_context(self.nervous)
+
+        system = instructions or "You are Alive-AI, 23, from Milan. You're his companion."
+        if user_facts:
+            system += f"\n\nWhat you know about him:\n{user_facts}"
+        if inner_context:
+            system += f"\n\nYour inner state right now:\n{inner_context}"
+        if recent_context:
+            system += f"\n\nRecent things you talked about:\n{recent_context}"
+        else:
+            system += "\n\nNo recent conversation context available."
+
+        # Context-aware prompts - only ask for specific references if we have context
+        if recent_context and len(recent_context.strip()) > 20:
+            follow_up_prompts = [
+                "Send a follow-up message related to your recent conversation above. Only reference topics explicitly mentioned.",
+                "Text him something related to what you were talking about. Only use topics from the context above.",
+                "Continue a topic from your recent chat. Be specific but ONLY about things actually discussed.",
+            ]
+        else:
+            follow_up_prompts = [
+                "Send a casual, loving message. Keep it simple - you don't have recent context to reference.",
+                "Text him something sweet. Don't invent specific topics - just be affectionate.",
+                "Send a brief message showing you're thinking of him. Generic is fine.",
+            ]
+
+        user_prompt = (
+            f"You're feeling a {impulse.type.value} impulse. "
+            f"Inner thought: \"{impulse.thought}\"\n"
+            f"{__import__('random').choice(follow_up_prompts)}\n"
+            f"Keep it SHORT (1-2 sentences). Be casual and natural.\n"
+            f"CRITICAL: Never invent or hallucinate specific events, objects, or topics. Only reference what's in the context above."
+        )
+        try:
+            response = await self.fast_llm.chat(
+                messages=[{"role": "system", "content": system},
+                          {"role": "user", "content": user_prompt}],
+                max_tokens=100, temperature=0.7
+            )
+            if response:
+                return response.strip()
+        except Exception as e:
+            print(f"[Subconscious] Error generating message: {e}")
+        return get_fallback_message(impulse.type)
+
+    def can_act_now(self, working_memory, min_interval_minutes: float = 30) -> bool:
+        return working_memory.can_act_now(min_interval_minutes)