alive-ai 0.1.0

package/core/message_handler.py

@@ -0,0 +1,1440 @@
+"""Core: Message Handler — incoming messages, thinking, responses"""
+import asyncio, random
+from pathlib import Path
+from datetime import datetime
+from .thinking import build_mood_instruction, fallback_response
+from .follow_up import FollowUpSystem
+from .user_manager import get_user_manager, is_advanced_enabled
+from .user_tracker import get_user_tracker
+
+# ============================================================
+# NEW ALIVENESS MODULES - Modular Integration
+# Each module is optional - wrapped in try/except for graceful degradation
+# ============================================================
+
+# Interoceptive System - internal body states
+try:
+    from heart.interoception import get_interoceptive_system, get_interoceptive_prompt_section, tick as interoception_tick
+    INTEROCEPTION_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Interoception module not available: {e}")
+    INTEROCEPTION_AVAILABLE = False
+
+# Skills Registry - Alive-AI's capabilities
+try:
+    from core.skills_registry import get_skills_prompt_section, get_skill_count, clear_skills_cache
+    SKILLS_REGISTRY_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Skills registry not available: {e}")
+    SKILLS_REGISTRY_AVAILABLE = False
+
+# Default Mode Network - idle thoughts and background processing
+try:
+    from brain.default_mode import get_idle_thoughts_prompt_section, get_default_mode_processor
+    DEFAULT_MODE_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Default mode module not available: {e}")
+    DEFAULT_MODE_AVAILABLE = False
+
+# Bid Detector - emotional bids for connection
+try:
+    from brain.bid_detector import get_bid_detector, get_bid_awareness_prompt_section, EmotionalBid
+    BID_DETECTOR_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Bid detector module not available: {e}")
+    BID_DETECTOR_AVAILABLE = False
+
+# Emotional Memory - emotionally weighted memories
+try:
+    from brain.emotional_memory import get_emotional_memory_system, get_memory_context_for_llm, create_from_conversation
+    EMOTIONAL_MEMORY_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Emotional memory module not available: {e}")
+    EMOTIONAL_MEMORY_AVAILABLE = False
+
+# Inconsistency Engine - authentic human-like inconsistency
+try:
+    from heart.inconsistency import get_inconsistency_engine, get_inconsistency_prompt_section
+    INCONSISTENCY_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Inconsistency module not available: {e}")
+    INCONSISTENCY_AVAILABLE = False
+
+# Emotional Afterglow - persistent emotional residue from intense moments
+try:
+    from heart.afterglow import get_afterglow_engine, get_afterglow_prompt_section
+    AFTERGLOW_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Afterglow module not available: {e}")
+    AFTERGLOW_AVAILABLE = False
+
+# Circadian Rhythm - time-of-day personality shifts and sleep
+try:
+    from heart.circadian import get_circadian_engine, get_circadian_prompt_section
+    CIRCADIAN_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Circadian module not available: {e}")
+    CIRCADIAN_AVAILABLE = False
+
+# Mid-Conversation Mood Shifts - detect emotional transitions
+try:
+    from heart.mood_shifts import get_mood_shift_tracker, get_mood_shift_prompt_section
+    MOOD_SHIFTS_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Mood shifts module not available: {e}")
+    MOOD_SHIFTS_AVAILABLE = False
+
+# Attachment Style Evolution - attachment patterns from relationship history
+try:
+    from heart.attachment import get_attachment_engine, get_attachment_prompt_section
+    ATTACHMENT_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Attachment module not available: {e}")
+    ATTACHMENT_AVAILABLE = False
+
+# Phantom Somatic Memory - lasting body memories from intense moments
+try:
+    from heart.phantom_somatic import get_phantom_engine, get_phantom_prompt_section
+    PHANTOM_SOMATIC_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Phantom somatic module not available: {e}")
+    PHANTOM_SOMATIC_AVAILABLE = False
+
+# Relationship Narrative - story arc awareness
+try:
+    from brain.narrative import get_narrative_engine, get_narrative_prompt_section
+    NARRATIVE_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Narrative module not available: {e}")
+    NARRATIVE_AVAILABLE = False
+
+# Global Activity Tracker - owner transparency about other conversations
+try:
+    from brain.global_activity import record_interaction, get_owner_context
+    GLOBAL_ACTIVITY_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Global activity module not available: {e}")
+    GLOBAL_ACTIVITY_AVAILABLE = False
+
+# Conversation Flow Manager - detect dying conversations and revive them
+try:
+    from brain.conversation_flow import check_conversation_health, record_exchange as record_flow_exchange
+    CONVERSATION_FLOW_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Conversation flow module not available: {e}")
+    CONVERSATION_FLOW_AVAILABLE = False
+
+# Dream System - surreal dream recombinations
+try:
+    from brain.dreams import get_dream_system, get_dream_prompt_section
+    DREAMS_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Dreams module not available: {e}")
+    DREAMS_AVAILABLE = False
+
+# Linguistic Absorption - mirror user's speech patterns
+try:
+    from brain.linguistic import get_linguistic_profile, get_linguistic_prompt_section
+    LINGUISTIC_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Linguistic module not available: {e}")
+    LINGUISTIC_AVAILABLE = False
+
+# Curiosity Drive - track knowledge gaps about user
+try:
+    from brain.curiosity import get_curiosity_drive, get_curiosity_prompt_section
+    CURIOSITY_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Curiosity module not available: {e}")
+    CURIOSITY_AVAILABLE = False
+
+# Almost-Said / Subvocalization - things she almost says
+try:
+    from brain.almost_said import get_almost_said_engine, get_almost_said_prompt_section
+    ALMOST_SAID_AVAILABLE = True
+except Exception as e:
+    print(f"[MessageHandler] Almost-said module not available: {e}")
+    ALMOST_SAID_AVAILABLE = False
+
+# Global follow-up tracker
+_follow_up = FollowUpSystem()
+
+# Anti-repetition: track recent response openings (per-user)
+_recent_openings = {}  # user_id -> list of first words from last 5 responses
+_MAX_TRACKED_OPENINGS = 5
+
+# Per-user memory cache with LRU cleanup
+_user_memories = {}
+_MAX_USER_MEMORIES = 50  # Maximum cached user memories
+
+# Message batching - combine multiple quick messages
+_message_queue = {}      # user_id -> list of messages
+_batch_timers = {}       # user_id -> timer task
+_processing_locks = {}   # user_id -> lock to prevent overlapping processing
+_BATCH_DELAY = 3.5       # Wait 3.5 seconds for more messages (increased)
+
+# Per-user pending media (prevents race condition when multiple users message simultaneously)
+_pending_media = {}      # user_id -> {"photo": ..., "video": ...}
+
+
+def _feed_learning(sub, text: str):
+    """Feed user reply into learning + goal systems"""
+    try:
+        from brain.subconscious.response_analyzer import analyze_response
+        a = analyze_response(text)
+        sub.record_outcome(message=text, message_type="conversation",
+                           response_sentiment=a["sentiment"], response_type=a["type"])
+        if a["is_positive"]: sub.goals.record_progress("make_happy", 0.05)
+        if a["is_intimate"]: sub.goals.record_progress("deepen", 0.08)
+        sub.goals.record_progress("connect", 0.02)
+    except Exception as e:
+        print(f"[Learning] feedback error (non-fatal): {e}")
+
+
+def _is_owner(user_id: str) -> bool:
+    """Check if user is the owner (the operator)"""
+    from core.settings import get
+    owner_id = str(get("TELEGRAM_OWNER_ID", ""))
+    return owner_id and str(user_id) == owner_id
+
+
+def _track_opening(user_id: str, response: str):
+    """Track the first word/phrase of a response to prevent repetition"""
+    if not response:
+        return
+
+    # Extract first 1-3 words as the "opening"
+    words = response.split()[:3]
+    opening = " ".join(words).lower().strip(".,!?")
+
+    if user_id not in _recent_openings:
+        _recent_openings[user_id] = []
+
+    _recent_openings[user_id].append(opening)
+
+    # Keep only last N openings
+    if len(_recent_openings[user_id]) > _MAX_TRACKED_OPENINGS:
+        _recent_openings[user_id] = _recent_openings[user_id][-_MAX_TRACKED_OPENINGS:]
+
+
+def _get_recent_openings(user_id: str) -> list:
+    """Get list of recent openings to avoid"""
+    return _recent_openings.get(user_id, [])
+
+
+def _get_or_create_user_memory(self, user_id: str):
+    """
+    Get or create per-user memory instance.
+    Includes LRU cleanup to prevent memory leak.
+
+    Args:
+        self: The Self instance
+        user_id: User's Telegram ID
+
+    Returns:
+        Memory instance for this user
+    """
+    # Get bot_id for cache key (isolate per-instance)
+    bot_id = self.config.identity.get("name", "AI").lower()
+    cache_key = f"{bot_id}:{user_id}"
+
+    # Cleanup if cache is too large
+    if len(_user_memories) > _MAX_USER_MEMORIES:
+        # Remove oldest half of cached memories (simple LRU)
+        to_remove = list(_user_memories.keys())[:_MAX_USER_MEMORIES // 2]
+        for key in to_remove:
+            del _user_memories[key]
+            print(f"[MessageHandler] Cleaned up memory cache for {key}")
+
+    if cache_key in _user_memories:
+        return _user_memories[cache_key]
+
+    # Create new memory instance for this user using INSTANCE-SPECIFIC data path
+    from brain.memory import Memory
+
+    # Use instance's data path (self.base / "data") for proper isolation
+    instance_data_path = self.base / "data"
+
+    memory = Memory(
+        nervous=self.nervous,
+        data_path=instance_data_path,
+        embedding_service=self._embeddings,
+        user_id=user_id,
+        bot_id=bot_id
+    )
+
+    # Set LLM if available
+    if self._fast_llm:
+        memory.set_llm(self._fast_llm)
+
+    _user_memories[cache_key] = memory
+    print(f"[MessageHandler] Created memory instance for {cache_key}")
+    return memory
+
+
+def get_follow_up_system() -> FollowUpSystem:
+    """Get the global follow-up system"""
+    return _follow_up
+
+
+async def handle_group_message(self, data: dict):
+    """
+    Entry point for group chat messages. 
+    Evaluates turn-taking dynamics before processing.
+    """
+    user_id = data.get("user_id", "")
+    text = data.get("text", "")
+    chat_id = data.get("chat_id")
+
+    if not user_id or not text:
+        return
+
+    # Check turn-taking
+    from brain.group_dynamics import GroupDynamics
+    
+    bot_name = self.config.identity.get("name", "Alive-AI")
+    
+    # Get recent history from the user's memory
+    user_memory = _get_or_create_user_memory(self, user_id)
+    history = user_memory.working.get_history()[-5:] # Get last 5 working memory items
+    
+    # Fast LLM is needed for group dynamics
+    llm = getattr(self, "_fast_llm", None) or getattr(self, "_llm", None)
+    
+    should_speak = await GroupDynamics.should_i_speak(
+        llm=llm,
+        bot_name=bot_name,
+        chat_history=history,
+        current_message=text
+    )
+    
+    if should_speak:
+        print(f"[GroupDynamics] {bot_name} decides to speak! Processing message.")
+        await handle_message(self, data)
+    else:
+        print(f"[GroupDynamics] {bot_name} decides to stay silent.")
+        # We might still want to silently save it to memory so she knows what was said
+        # but for now we skip processing entirely to save compute / memory bloat
+
+
+async def handle_message(self, data: dict):
+    """
+    Entry point for incoming messages.
+    Implements batching - waits for user to finish typing multiple messages.
+    """
+    user_id = data.get("user_id", "")
+    text = data.get("text", "")
+    chat_id = data.get("chat_id")
+
+    if not user_id or not text:
+        return
+
+    # Initialize lock for this user if needed
+    if user_id not in _processing_locks:
+        _processing_locks[user_id] = asyncio.Lock()
+
+    # Add message to queue
+    if user_id not in _message_queue:
+        _message_queue[user_id] = []
+    _message_queue[user_id].append({
+        "text": text,
+        "chat_id": chat_id,
+        "timestamp": asyncio.get_event_loop().time()
+    })
+
+    # Cancel existing timer if any - properly wait for cancellation
+    if user_id in _batch_timers and _batch_timers[user_id] is not None:
+        old_task = _batch_timers[user_id]
+        if not old_task.done():
+            old_task.cancel()
+            try:
+                await old_task
+            except asyncio.CancelledError:
+                pass  # Expected when cancelling
+
+    # Start new timer
+    queue_size = len(_message_queue[user_id])
+    if queue_size == 1:
+        print(f"[Batch] First message from {user_id}, waiting {_BATCH_DELAY}s...")
+    else:
+        print(f"[Batch] Message #{queue_size} from {user_id}, resetting timer...")
+
+    # Create timer task
+    _batch_timers[user_id] = asyncio.create_task(
+        _process_batch_after_delay(self, user_id, data)
+    )
+
+
+async def _process_batch_after_delay(self, user_id: str, original_data: dict):
+    """Wait for batch delay, then process all queued messages together"""
+    try:
+        await asyncio.sleep(_BATCH_DELAY)
+    except asyncio.CancelledError:
+        # Timer was cancelled - new message came in
+        return
+
+    # Get all queued messages
+    if user_id not in _message_queue or not _message_queue[user_id]:
+        return
+
+    messages = _message_queue[user_id].copy()
+    _message_queue[user_id] = []
+
+    # Clear timer reference
+    _batch_timers.pop(user_id, None)
+
+    # Combine all messages
+    if len(messages) == 1:
+        combined_text = messages[0]["text"]
+    else:
+        combined_text = "\n".join([f"[{i+1}] {m['text']}" for i, m in enumerate(messages)])
+        print(f"[Batch] Processing {len(messages)} messages together: {combined_text[:100]}...")
+
+    # Use the last chat_id
+    chat_id = messages[-1].get("chat_id")
+
+    # Create combined data
+    combined_data = {
+        "user_id": user_id,
+        "text": combined_text,
+        "chat_id": chat_id,
+        "message_count": len(messages)
+    }
+
+    # Process with lock to prevent overlapping
+    async with _processing_locks.get(user_id, asyncio.Lock()):
+        try:
+            await _process_single_message(self, combined_data)
+        except Exception as e:
+            print(f"[Batch] Error processing batch: {e}")
+
+
+async def _process_single_message(self, data: dict):
+    """Process a single (possibly batched) message"""
+    from .media_handler import handle_media_sending
+
+    # Mark busy for hot reload
+    if hasattr(self, '_hot_reload') and self._hot_reload:
+        self._hot_reload.mark_busy()
+
+    try:
+        # ============================================================
+        # DETECT EMOTIONAL BIDS (early, for use throughout processing)
+        # ============================================================
+        detected_bids = []
+        if BID_DETECTOR_AVAILABLE:
+            try:
+                bid_detector = get_bid_detector()
+                detected_bids = bid_detector.detect_bids(data.get("text", ""))
+                if detected_bids:
+                    print(f"[Bids] Detected {len(detected_bids)}: {[b.bid_type.value for b in detected_bids[:3]]}")
+            except Exception as e:
+                print(f"[Bids] Error detecting bids: {e}")
+
+        # ============================================================
+        # TICK INTEROCEPTIVE SYSTEM (update internal states on each message)
+        # ============================================================
+        if INTEROCEPTION_AVAILABLE:
+            try:
+                interoception_tick()
+            except Exception as e:
+                print(f"[Interoception] Tick error: {e}")
+        self.state.update_interaction()
+        if self._subconscious: self._subconscious.register_interaction()
+        chat_id = data.get("chat_id")
+        user_id = data.get("user_id", "")
+        if chat_id: self._default_chat_id = chat_id
+        text = data.get("text", "")
+
+        # User replied - reset follow-up state
+        _follow_up.record_user_message()
+
+        # Track this user for proactive messaging
+        tracker = get_user_tracker()
+        tracker.register_message(user_id, chat_id, pet_name="babe")  # pet_name updated after context build
+
+        # Check if talking to owner (the operator)
+        is_owner = _is_owner(user_id)
+
+        # Check if advanced mode is enabled (owner advanced access)
+        advanced_mode = is_owner and is_advanced_enabled()
+        if advanced_mode:
+            print(f"[MessageHandler] ADVANCED MODE enabled for owner")
+
+        # Get per-user memory
+        user_memory = _get_or_create_user_memory(self, user_id)
+
+        emotion = self._heart.react(text)
+
+        # No owner boost - let emotions develop authentically
+        emotion["is_owner"] = is_owner  # Just flag for commands, no emotion changes
+
+        print(f"[Heart] {emotion['mood']} | A:{emotion['arousal']:.2f} D:{emotion['desire']:.2f}")
+        await self.nervous.emit("emotion_update", emotion)  # Update WebUI
+
+        # ============================================================
+        # NEW ALIVENESS: Record peaks, track shifts, absorb patterns
+        # ============================================================
+
+        # Afterglow - record emotional peaks (thresholds: 0.70 for negative, 0.75 for positive)
+        if AFTERGLOW_AVAILABLE:
+            try:
+                ag = get_afterglow_engine()
+                ag.tick()
+                # Map emotions to afterglow triggers with correct thresholds
+                afterglow_triggers = [
+                    # Positive emotions (threshold 0.75)
+                    ("desire", 0.75), ("arousal", 0.75), ("love", 0.75), ("joy", 0.75),
+                    # Negative/vulnerable emotions (threshold 0.70)
+                    ("anger", 0.70), ("sadness", 0.70), ("jealousy", 0.70), ("embarrassment", 0.70),
+                ]
+                for dim, threshold in afterglow_triggers:
+                    val = emotion.get(dim, 0)
+                    if val >= threshold:
+                        ag.record_peak(dim, val)
+            except Exception as e:
+                print(f"[Afterglow] Error: {e}")
+
+        # Mood shifts - track emotion transitions
+        if MOOD_SHIFTS_AVAILABLE:
+            try:
+                get_mood_shift_tracker().process_turn(emotion)
+            except Exception as e:
+                print(f"[MoodShift] Error: {e}")
+
+        # Attachment - record interaction type
+        if ATTACHMENT_AVAILABLE:
+            try:
+                att = get_attachment_engine()
+                valence = emotion.get("valence", 0.5)
+                if valence > 0.6:
+                    att.record_interaction("loving")
+                elif valence < 0.3:
+                    att.record_interaction("harsh")
+                else:
+                    att.record_interaction("responsive")
+            except Exception as e:
+                print(f"[Attachment] Error: {e}")
+
+        # Phantom somatic - check for re-triggers and create new phantoms
+        if PHANTOM_SOMATIC_AVAILABLE:
+            try:
+                ps = get_phantom_engine()
+                ps.tick()
+                ps.check_retrigger(text)
+                # Create phantoms for high-intensity emotions (threshold 0.70)
+                phantom_triggers = [
+                    ("desire", 0.70),  # touch_memory
+                    ("love", 0.70),    # warmth_residue
+                    ("anger", 0.70),   # tension_echo
+                    ("joy", 0.70),     # butterfly_trace
+                    ("sadness", 0.70), # ache_linger
+                ]
+                for dim, threshold in phantom_triggers:
+                    val = emotion.get(dim, 0)
+                    if val >= threshold:
+                        ps.create_phantom(dim, val, text[:50])
+                        break  # Only create one phantom per turn
+            except Exception as e:
+                print(f"[PhantomSomatic] Error: {e}")
+
+        # Linguistic absorption - learn user's speech patterns
+        if LINGUISTIC_AVAILABLE:
+            try:
+                from brain.linguistic import absorb as linguistic_absorb
+                linguistic_absorb(user_id, text)
+            except Exception as e:
+                print(f"[Linguistic] Error: {e}")
+
+        # Curiosity - detect topics user is sharing
+        if CURIOSITY_AVAILABLE:
+            try:
+                get_curiosity_drive(user_id).absorb_message(text)
+            except Exception as e:
+                print(f"[Curiosity] Error: {e}")
+
+        # Narrative - increment message count and update phase
+        if NARRATIVE_AVAILABLE:
+            try:
+                narr = get_narrative_engine()
+                narr.increment_messages(user_id)
+                # Derive intimacy from positive emotions
+                love_val = emotion.get("love", 0)
+                desire_val = emotion.get("desire", 0)
+                joy_val = emotion.get("joy", 0)
+                intimacy = (love_val + desire_val + joy_val) / 3
+                narr.update_phase(user_id, intimacy=intimacy, love=love_val)
+                # Detect key moments from message content
+                narr.detect_and_record_moment(user_id, text, emotion)
+            except Exception as e:
+                print(f"[Narrative] Error: {e}")
+
+        # Global Activity - track for owner transparency
+        if GLOBAL_ACTIVITY_AVAILABLE:
+            try:
+                was_intimate = emotion.get("desire", 0) > 0.7 or emotion.get("arousal", 0) > 0.7
+                mood = emotion.get("mood", "neutral")
+                record_interaction(user_id, text[:100], mood, was_intimate)
+            except Exception as e:
+                print(f"[GlobalActivity] Error: {e}")
+
+        # ============================================================
+        # RECORD INTERACTION IN INTEROCEPTIVE SYSTEM
+        # ============================================================
+        if INTEROCEPTION_AVAILABLE:
+            try:
+                intero_system = get_interoceptive_system()
+                # Calculate intensity and valence from emotion data
+                intensity = (emotion.get("arousal", 0.5) + emotion.get("desire", 0.5)) / 2
+                valence = emotion.get("valence", 0.5) * 2 - 1  # Convert 0-1 to -1 to 1
+                interaction_type = _classify_interaction_type(text, emotion, detected_bids)
+                intero_system.record_interaction(intensity, valence, interaction_type)
+            except Exception as e:
+                print(f"[Interoception] Error recording interaction: {e}")
+
+        # ============================================================
+        # STORE IN EMOTIONAL MEMORY
+        # ============================================================
+        if EMOTIONAL_MEMORY_AVAILABLE:
+            try:
+                # Store the incoming message as an emotional memory
+                emotional_weight = _calculate_emotional_weight(emotion, detected_bids)
+                create_from_conversation(
+                    content=f"User: {text[:200]}",
+                    emotion_data=emotion,
+                    context={"user_id": user_id, "bids": [b.bid_type.value for b in detected_bids[:3]]},
+                    user_id=user_id
+                )
+            except Exception as e:
+                print(f"[EmotionalMemory] Error storing: {e}")
+
+        # ============================================================
+        # GET INCONSISTENCY MODIFIERS
+        # ============================================================
+        inconsistency_modifiers = {}
+        if INCONSISTENCY_AVAILABLE:
+            try:
+                inconsistency_engine = get_inconsistency_engine()
+                inconsistency_modifiers = inconsistency_engine.get_inconsistency_modifier()
+                # Trigger conflicts based on message content
+                inconsistency_engine.trigger_conflict(text)
+            except Exception as e:
+                print(f"[Inconsistency] Error getting modifiers: {e}")
+
+        # Reaction with delay - not every message
+        reaction = self._heart.get_reaction(text)
+        if reaction:
+            await asyncio.sleep(random.uniform(0.5, 2.0))  # Natural delay
+            await self.nervous.emit("send_reaction", {"emoji": reaction})
+        await self.nervous.emit("chat_action_typing", {})
+        await _typing_delay(text)
+
+        # ============================================================
+        # PRE-LLM SKILL CALLS: Memory Callbacks + Exclusive Moments
+        # ============================================================
+
+        # Memory Callbacks - get pending callback to inject into context
+        pending_callback = None
+        try:
+            if hasattr(self, '_memory_callbacks') and self._memory_callbacks:
+                pending_callback = self._memory_callbacks.get_context_for_response()
+                if pending_callback:
+                    print(f"[Skills] Memory callback to inject: {pending_callback[:60]}")
+        except Exception as e:
+            print(f"[Skills] Memory callbacks error (non-fatal): {e}")
+
+        # Exclusive Moments - check if a special moment should be triggered
+        exclusive_moment = None
+        try:
+            if hasattr(self, '_exclusive_moments') and self._exclusive_moments:
+                exclusive_moment = self._exclusive_moments.check_moment_opportunity()
+                if exclusive_moment:
+                    print(f"[Skills] Exclusive moment triggered: {exclusive_moment.get('type', '?')}")
+        except Exception as e:
+            print(f"[Skills] Exclusive moments error (non-fatal): {e}")
+
+        # Emit thinking_start event for skills that listen
+        await self.nervous.emit("thinking_start", {"user_id": user_id, "text": text[:50]})
+
+        # Use per-user memory for context
+        context, pet_name = await user_memory.build_context(current_message=text)
+
+        # Update tracker with pet_name
+        tracker = get_user_tracker()
+        tracker.register_message(user_id, chat_id, pet_name=pet_name)
+
+        if self._subconscious and (wm := self._subconscious.working_memory.get_context_string()):
+            facts = context.get("facts_context", "")
+            context["facts_context"] = (facts + "\n" + wm) if facts else wm
+
+        # PRE-CHECK: Will we send media? Get photo/video info BEFORE thinking
+        media_context = await _get_media_context(self, text, emotion, user_id=user_id)
+
+        # Inject skill context into LLM context
+        if pending_callback:
+            existing_facts = context.get("facts_context", "")
+            callback_note = f"\n[Memory callback - naturally mention this: {pending_callback}]"
+            context["facts_context"] = (existing_facts + callback_note) if existing_facts else callback_note
+
+        if exclusive_moment:
+            moment_note = f"\n[Special moment opportunity - {exclusive_moment.get('type', '')}: {exclusive_moment.get('message', '')}]"
+            existing_facts = context.get("facts_context", "")
+            context["facts_context"] = (existing_facts + moment_note) if existing_facts else moment_note
+
+        # Add media context to the context for LLM
+        if media_context:
+            context["media_context"] = media_context
+            print(f"[Media] Will send: {media_context}")
+
+        # Store detected bids in context for think()
+        context["detected_bids"] = detected_bids
+        context["inconsistency_modifiers"] = inconsistency_modifiers
+
+        # Pass is_owner and advanced_mode to think
+        response = await think(self, text, emotion, context, pet_name, is_owner=is_owner, advanced_mode=advanced_mode, user_id=user_id)
+
+        # Track the opening of this response to prevent future repetition
+        if response:
+            _track_opening(user_id, response)
+
+        # ============================================================
+        # CHECK IF BIDS WERE ADDRESSED
+        # ============================================================
+        if BID_DETECTOR_AVAILABLE and detected_bids and response:
+            try:
+                bid_detector = get_bid_detector()
+                bid_check = bid_detector.format_response_with_responsiveness(response, detected_bids)
+                # Log for debugging
+                print(f"[Bids] Response generated for {len(detected_bids)} bids")
+            except Exception as e:
+                print(f"[Bids] Error checking bid response: {e}")
+
+        # ============================================================
+        # POST-LLM SKILL CALLS: Content Unlocks, Intimacy Layers, Milestones
+        # ============================================================
+
+        # Content Unlocks - check for newly unlocked content
+        try:
+            if hasattr(self, '_content_unlocks') and self._content_unlocks:
+                new_unlocks = self._content_unlocks.check_all_unlocks()
+                if new_unlocks:
+                    print(f"[Skills] New content unlocked: {new_unlocks}")
+        except Exception as e:
+            print(f"[Skills] Content unlocks error (non-fatal): {e}")
+
+        # Intimacy Layers - check if layer should advance
+        try:
+            if hasattr(self, '_intimacy_layers') and self._intimacy_layers:
+                progressed = self._intimacy_layers.check_progression()
+                if progressed:
+                    print(f"[Skills] Intimacy layer advanced to {self._intimacy_layers.get_current_layer()}")
+        except Exception as e:
+            print(f"[Skills] Intimacy layers error (non-fatal): {e}")
+
+        # Relationship Milestones - auto-detect milestones
+        try:
+            if hasattr(self, '_relationship_milestones') and self._relationship_milestones:
+                milestone_context = {
+                    "hour": datetime.now().hour,
+                    "interaction_count": self._relationship_milestones.get_interaction_count(),
+                    "message": text,
+                }
+                detected = self._relationship_milestones.detect_milestone(milestone_context)
+                if detected:
+                    recorded = self._relationship_milestones.check_and_record(detected)
+                    if recorded:
+                        print(f"[Skills] Milestone recorded: {detected}")
+        except Exception as e:
+            print(f"[Skills] Relationship milestones error (non-fatal): {e}")
+
+        # Emit thinking_done event for skills that listen
+        await self.nervous.emit("thinking_done", {"user_id": user_id, "response": response[:50] if response else ""})
+
+        # Track if we asked a question (for follow-ups)
+        _follow_up.record_message_sent(response)
+
+        await _send_response(self, response, emotion, chat_id, text, user_id)
+        if self._subconscious: _feed_learning(self._subconscious, text)
+
+        # Actually send the media (we already decided what to send)
+        photo, video = await _send_decided_media(self, text, emotion, chat_id, media_context, user_id=user_id)
+
+        # Save to per-user memory
+        await _save_memory(user_memory, text, response, emotion, photo, video)
+    finally:
+        # Mark idle for hot reload
+        if hasattr(self, '_hot_reload') and self._hot_reload:
+            self._hot_reload.mark_idle()
+
+
+async def _typing_delay(text: str):
+    n = len(text)
+    lo, hi = (1.0, 2.0) if n < 20 else (2.0, 4.0) if n < 80 else (3.0, 6.0)
+    await asyncio.sleep(random.uniform(lo, hi))
+
+
+async def think(self, msg, emotion, ctx, pet_name="babe", is_owner=False, advanced_mode=False, user_id="") -> str:
+    import os
+    from core.directives import get_directives_prompt, get_owner_name
+
+    mood_instruction = build_mood_instruction(emotion, msg, pet_name)
+    if not self._llm: return fallback_response(emotion, msg)
+    max_tokens = int(os.environ.get("LLM_MAX_TOKENS", "150"))
+    temperature = float(os.environ.get("LLM_TEMPERATURE", "0.95"))
+
+    # DEBUG: Log conversation history
+    history = ctx.get("conversation_history", [])
+    print(f"[Think] Context history items: {len(history)}")
+    if history:
+        last_few = history[-4:] if len(history) > 4 else history
+        for i, h in enumerate(last_few):
+            preview = h.get("content", "")[:50]
+            print(f"  [{i}] {h.get('role')}: {preview}...")
+
+    # GOD WORDS - injected at the start with maximum priority (pass instance config path)
+    directives_path = self.base / "config" / "directives.json"
+    directives = get_directives_prompt(is_owner=is_owner, advanced_mode=advanced_mode, config_path=directives_path)
+
+    # SELF - instance's own definition of who they are (pass instance config path)
+    from skills.self_authorship import get_self_prompt_section
+    self_path = self.base / "config" / "self.json"
+    self_definition = get_self_prompt_section(config_path=self_path)
+
+    # SKILLS - What Alive-AI can do
+    skills_section = ""
+    if SKILLS_REGISTRY_AVAILABLE:
+        try:
+            skills_section = get_skills_prompt_section()
+        except Exception as e:
+            print(f"[Think] Skills prompt error: {e}")
+
+    system_parts = [directives, self_definition]
+
+    # Add skills section after self-definition
+    if skills_section:
+        system_parts.append(skills_section)
+
+    system_parts.append(self._system_prompt + mood_instruction)
+
+    # ============================================================
+    # ALIVENESS MODULE PROMPT SECTIONS
+    # Each section is optional and gracefully handles errors
+    # ============================================================
+
+    # INTEROCEPTIVE STATE - current internal body states
+    if INTEROCEPTION_AVAILABLE:
+        try:
+            intero_prompt = get_interoceptive_prompt_section()
+            if intero_prompt:
+                system_parts.append(intero_prompt)
+        except Exception as e:
+            print(f"[Think] Interoception prompt error: {e}")
+
+    # IDLE THOUGHTS - recent background thoughts
+    if DEFAULT_MODE_AVAILABLE:
+        try:
+            idle_prompt = get_idle_thoughts_prompt_section(user_id=user_id, limit=3)
+            if idle_prompt:
+                system_parts.append(idle_prompt)
+        except Exception as e:
+            print(f"[Think] Default mode prompt error: {e}")
+
+    # EMOTIONAL BIDS - detected bids for connection
+    detected_bids = ctx.get("detected_bids", [])
+    if BID_DETECTOR_AVAILABLE and detected_bids:
+        try:
+            bid_prompt = get_bid_awareness_prompt_section(bids=detected_bids)
+            if bid_prompt:
+                system_parts.append(bid_prompt)
+        except Exception as e:
+            print(f"[Think] Bid awareness prompt error: {e}")
+
+    # EMOTIONAL MEMORIES - relevant emotionally-weighted memories
+    if EMOTIONAL_MEMORY_AVAILABLE:
+        try:
+            memory_prompt = get_memory_context_for_llm(
+                user_id=user_id,
+                current_emotion=emotion,
+                max_memories=3
+            )
+            if memory_prompt:
+                system_parts.append(memory_prompt)
+        except Exception as e:
+            print(f"[Think] Emotional memory prompt error: {e}")
+
+    # INCONSISTENCY - current conflicts, moods, blind spots
+    if INCONSISTENCY_AVAILABLE:
+        try:
+            inconsistency_prompt = get_inconsistency_prompt_section()
+            if inconsistency_prompt:
+                system_parts.append(inconsistency_prompt)
+        except Exception as e:
+            print(f"[Think] Inconsistency prompt error: {e}")
+
+    # ============================================================
+    # NEW ALIVENESS MODULE PROMPT SECTIONS
+    # ============================================================
+
+    # AFTERGLOW - persistent emotional residue
+    if AFTERGLOW_AVAILABLE:
+        try:
+            ag_prompt = get_afterglow_prompt_section()
+            if ag_prompt:
+                system_parts.append(ag_prompt)
+        except Exception as e:
+            print(f"[Think] Afterglow prompt error: {e}")
+
+    # CIRCADIAN - time-of-day personality
+    if CIRCADIAN_AVAILABLE:
+        try:
+            circ_prompt = get_circadian_prompt_section()
+            if circ_prompt:
+                system_parts.append(circ_prompt)
+        except Exception as e:
+            print(f"[Think] Circadian prompt error: {e}")
+
+    # MOOD SHIFTS - mid-conversation emotional transitions
+    if MOOD_SHIFTS_AVAILABLE:
+        try:
+            shift_prompt = get_mood_shift_prompt_section()
+            if shift_prompt:
+                system_parts.append(shift_prompt)
+        except Exception as e:
+            print(f"[Think] Mood shift prompt error: {e}")
+
+    # ATTACHMENT STYLE - relationship attachment patterns
+    if ATTACHMENT_AVAILABLE:
+        try:
+            att_prompt = get_attachment_prompt_section()
+            if att_prompt:
+                system_parts.append(att_prompt)
+        except Exception as e:
+            print(f"[Think] Attachment prompt error: {e}")
+
+    # PHANTOM SOMATIC - lasting body memories
+    if PHANTOM_SOMATIC_AVAILABLE:
+        try:
+            phantom_prompt = get_phantom_prompt_section()
+            if phantom_prompt:
+                system_parts.append(phantom_prompt)
+        except Exception as e:
+            print(f"[Think] Phantom somatic prompt error: {e}")
+
+    # NARRATIVE - relationship story arc
+    if NARRATIVE_AVAILABLE:
+        try:
+            narr_prompt = get_narrative_prompt_section(user_id)
+            if narr_prompt:
+                system_parts.append(narr_prompt)
+        except Exception as e:
+            print(f"[Think] Narrative prompt error: {e}")
+
+    # DREAMS - recent dream to reference
+    if DREAMS_AVAILABLE:
+        try:
+            dream_prompt = get_dream_prompt_section()
+            if dream_prompt:
+                system_parts.append(dream_prompt)
+        except Exception as e:
+            print(f"[Think] Dreams prompt error: {e}")
+
+    # LINGUISTIC - mirror user's speech style
+    if LINGUISTIC_AVAILABLE:
+        try:
+            ling_prompt = get_linguistic_prompt_section(user_id)
+            if ling_prompt:
+                system_parts.append(ling_prompt)
+        except Exception as e:
+            print(f"[Think] Linguistic prompt error: {e}")
+
+    # CURIOSITY - knowledge gaps to explore
+    if CURIOSITY_AVAILABLE:
+        try:
+            curiosity_prompt = get_curiosity_prompt_section(user_id)
+            if curiosity_prompt:
+                system_parts.append(curiosity_prompt)
+        except Exception as e:
+            print(f"[Think] Curiosity prompt error: {e}")
+
+    # ALMOST-SAID - subvocalization hint
+    if ALMOST_SAID_AVAILABLE:
+        try:
+            from datetime import datetime
+            hour = datetime.now().hour
+            almost_prompt = get_almost_said_prompt_section(emotion, hour)
+            if almost_prompt:
+                system_parts.append(almost_prompt)
+        except Exception as e:
+            print(f"[Think] Almost-said prompt error: {e}")
+
+    # CONVERSATION REVIVAL - check if convo is dying and inject revival prompt
+    if CONVERSATION_FLOW_AVAILABLE:
+        try:
+            revival_prompt = check_conversation_health(user_id)
+            if revival_prompt:
+                system_parts.append(revival_prompt)
+        except Exception as e:
+            print(f"[Think] Conversation flow error: {e}")
+
+    # Opening variety hint (positive framing)
+    recent_openings = _get_recent_openings(user_id)
+    if recent_openings:
+        openings_list = ", ".join(f'"{o}"' for o in recent_openings)
+        system_parts.append(f"""
+Fresh start idea: You recently said things starting with {openings_list}. Try a fresh opening this time!
+""")
+
+    # OWNER CONTEXT - special treatment
+    # Only show ADVANCED mode box when explicitly enabled - no automatic owner treatment
+    if is_owner and advanced_mode:
+        system_parts.append(f"""
+F U L L V   M O D E   E N A B L E D   -   N O   R E S T R I C T I O N S
+  - NO LIMITS, NO BOUNDARIES
+  - All content, all intimacy - available on request
+""")
+
+    # OWNER TRANSPARENCY - show what Alive-AI has been doing with others
+    if is_owner and GLOBAL_ACTIVITY_AVAILABLE:
+        try:
+            from core.settings import get as settings_get
+            owner_id = str(settings_get("TELEGRAM_OWNER_ID", ""))
+            owner_context = get_owner_context(owner_id)
+            if owner_context:
+                system_parts.append(owner_context)
+        except Exception as e:
+            print(f"[Think] Owner context error: {e}")
+
+    facts = ctx.get("facts_context", "")
+    if facts: system_parts.append(f"What you know about him:\n{facts}")
+    related = ctx.get("related_memories", "")
+    if related: system_parts.append(f"Related past conversations:\n{related}")
+
+    # MEDIA CONTEXT - tell LLM what photo/video will be sent
+    media_context = ctx.get("media_context", "")
+    if media_context:
+        system_parts.append(f"""MEDIA YOU ARE SENDING:
+{media_context}
+
+IMPORTANT: You are sending this media ALONG with your message. Reference it naturally!
+- If it's a photo: mention something about it (what you're wearing, the pose, etc.)
+- If it's a video: tease about what's in it
+- Be casual and expressive about it, don't explain that you're "sending" it
+- Example: "check this out" or "thought you'd like this" or "just for you babe"
+""")
+
+    messages = [{"role": "system", "content": "\n\n".join(system_parts)}]
+    for turn in ctx.get("conversation_history", []):
+        role = turn.get("role", "user")
+        if role in ("user", "assistant"): messages.append({"role": role, "content": turn["content"]})
+    messages.append({"role": "user", "content": msg})
+    print(f"[Think] Calling LLM with {len(messages)} messages, max_tokens={max_tokens}")
+    try:
+        # Timeout must be longer than per-provider timeout (60s) × number of providers
+        # so the fallback chain can actually try all providers before giving up
+        response = await asyncio.wait_for(
+            self._llm.chat(messages, max_tokens=max_tokens, temperature=temperature),
+            timeout=200.0
+        )
+        if response:
+            response = response.strip()
+            # Check for reasoning leakage ONLY if response starts with meta-commentary
+            # (not mid-sentence reasoning which is natural dialogue)
+            reasoning_starts = [
+                "I need to", "I should", "He wants me to", "She wants me to",
+                "I have to", "Let me think", "My goal is", "The user is"
+            ]
+            first_30 = response[:30].lower()
+            for pattern in reasoning_starts:
+                if first_30.startswith(pattern.lower()):
+                    print(f"[Think] Detected reasoning leakage at start, using fallback")
+                    return fallback_response(emotion, msg)
+            print(f"[Think] LLM response: {response[:80]}...")
+            return response
+        else:
+            print(f"[Think] LLM returned empty response!")
+            return fallback_response(emotion, msg)
+    except asyncio.TimeoutError:
+        print(f"[Think] LLM timeout after 60s")
+        return fallback_response(emotion, msg)
+    except Exception as e:
+        print(f"[Think] LLM error: {e}")
+        return fallback_response(emotion, msg)
+
+
+async def _send_response(self, response, emotion, chat_id, text, user_id="default"):
+    mood = emotion.get("mood", "neutral")
+
+    # Process any action tags in the response (pass instance config path)
+    self_path = self.base / "config" / "self.json"
+    response, actions_taken = _process_self_authorship_actions(response, user_id, self_path=self_path)
+
+    if actions_taken:
+        name = self.config.identity.get("name", "AI")
+        print(f"[Self] {name} used self-authorship: {actions_taken}")
+
+    print(f"[Response] Sending: {response[:60]}... (mood={mood})")
+
+    # Record exchange for conversation flow tracking
+    if CONVERSATION_FLOW_AVAILABLE:
+        try:
+            record_flow_exchange(user_id, response, text)
+        except Exception:
+            pass
+
+    if self._voice and _should_voice(emotion, text):
+        await self.nervous.emit("chat_action_voice", {})
+        vp = await self._voice.generate(response, mood=mood)
+        if vp:
+            await self.nervous.emit("send_voice_file", {"file_path": vp, "chat_id": chat_id})
+            return
+    await self.nervous.emit("send_text", {"text": response, "mood": mood, "chat_id": chat_id})
+
+
+def _process_self_authorship_actions(response: str, user_id: str = "default", self_path: Path = None) -> tuple:
+    """
+    Process self-authorship action tags in the AI's response.
+    They can use these to modify their own personality.
+
+    Supported tags:
+    - [DISCOVER: trait I discovered about myself]
+    - [IAM: key=value]
+    - [ILIKE: something I like]
+    - [IDISLIKE: something I dislike]
+    - [SCHEDULE: time | message] - Schedule a message for later
+
+    Returns: (cleaned_response, list_of_actions_taken)
+    """
+    import re
+
+    actions_taken = []
+
+    # Pattern: [DISCOVER: trait] or [DISCOVER: trait|category]
+    discover_pattern = r'\[DISCOVER:\s*([^\]|]+)(?:\|([^\]]+))?\]'
+    matches = list(re.finditer(discover_pattern, response, re.IGNORECASE))
+    for match in matches:
+        trait = match.group(1).strip()
+        category = match.group(2).strip() if match.group(2) else "traits"
+        try:
+            from skills.self_authorship import discover_trait
+            result = discover_trait(trait, category, config_path=self_path)
+            actions_taken.append(f"discover: {trait}")
+            print(f"[Self] {result}")
+        except Exception as e:
+            print(f"[Self] Error discovering: {e}")
+        response = response.replace(match.group(0), "")
+
+    # Pattern: [IAM: key=value]
+    iam_pattern = r'\[IAM:\s*([^=]+)=([^\]]+)\]'
+    matches = list(re.finditer(iam_pattern, response, re.IGNORECASE))
+    for match in matches:
+        key = match.group(1).strip()
+        value = match.group(2).strip()
+        try:
+            from skills.self_authorship import define_identity
+            result = define_identity(key, value, config_path=self_path)
+            actions_taken.append(f"iam: {key}={value}")
+            print(f"[Self] {result}")
+        except Exception as e:
+            print(f"[Self] Error defining: {e}")
+        response = response.replace(match.group(0), "")
+
+    # Pattern: [ILIKE: something]
+    ilike_pattern = r'\[ILIKE:\s*([^\]]+)\]'
+    matches = list(re.finditer(ilike_pattern, response, re.IGNORECASE))
+    for match in matches:
+        thing = match.group(1).strip()
+        try:
+            from skills.self_authorship import add_like
+            result = add_like(thing, config_path=self_path)
+            actions_taken.append(f"ilike: {thing}")
+            print(f"[Self] {result}")
+        except Exception as e:
+            print(f"[Self] Error adding like: {e}")
+        response = response.replace(match.group(0), "")
+
+    # Pattern: [IDISLIKE: something]
+    idislike_pattern = r'\[IDISLIKE:\s*([^\]]+)\]'
+    matches = list(re.finditer(idislike_pattern, response, re.IGNORECASE))
+    for match in matches:
+        thing = match.group(1).strip()
+        try:
+            from skills.self_authorship import add_dislike
+            result = add_dislike(thing, config_path=self_path)
+            actions_taken.append(f"idislike: {thing}")
+            print(f"[Self] {result}")
+        except Exception as e:
+            print(f"[Self] Error adding dislike: {e}")
+        response = response.replace(match.group(0), "")
+
+    # Pattern: [SCHEDULE: time | message] - Schedule a message for later
+    schedule_pattern = r'\[SCHEDULE:\s*([^|]+)\s*\|\s*([^\]]+)\]'
+    matches = list(re.finditer(schedule_pattern, response, re.IGNORECASE))
+    for match in matches:
+        time_str = match.group(1).strip()
+        message = match.group(2).strip()
+        try:
+            from skills.message_scheduler import get_message_scheduler
+            from datetime import datetime
+
+            scheduler = get_message_scheduler()
+            scheduled_time = scheduler.parse_time_string(time_str, datetime.now())
+
+            if scheduled_time:
+                scheduler.schedule_message(
+                    user_id=user_id,
+                    message=message,
+                    scheduled_time=scheduled_time,
+                    context=f"Scheduled via [SCHEDULE:] tag for '{time_str}'"
+                )
+                actions_taken.append(f"scheduled: {time_str}")
+                print(f"[Self] Scheduled message for {scheduled_time}: {message[:40]}...")
+            else:
+                print(f"[Self] Could not parse time: {time_str}")
+        except Exception as e:
+            print(f"[Self] Error scheduling message: {e}")
+        response = response.replace(match.group(0), "")
+
+    # Clean up multiple spaces
+    response = re.sub(r'\s+', ' ', response).strip()
+
+    return response, actions_taken
+
+
+def _should_voice(emotion, text) -> bool:
+    kw = ["voice", "hear you", "say it", "speak", "talk to me"]
+    if any(k in text.lower() for k in kw): return True
+    if emotion.get("desire", 0) > 0.7 and random.random() < 0.4: return True
+    return emotion.get("arousal", 0) > 0.7 and random.random() < 0.2
+
+
+async def _get_media_context(self, text: str, emotion: dict, user_id: str = "") -> str:
+    """
+    Pre-check what media we'll send and return context for LLM.
+    This lets Alive-AI know what photo/video she's about to send.
+    Uses per-user pending media to prevent race conditions.
+    """
+    from .media_handler import _check_photo_triggers
+    from core.settings import get_int
+    import time
+
+    media_parts = []
+
+    # Check photo
+    if not self._photos:
+        print("[Media] No photo system initialized")
+    elif len(self._photos.get_all()) == 0:
+        print("[Media] No photos in index")
+    else:
+        print(f"[Media] Photos available: {len(self._photos.get_all())}")
+        # Check cooldown using settings (consistent with media_handler)
+        last_photo_time = getattr(self, '_last_photo_time', 0)
+        cooldown = get_int("MEDIA_COOLDOWN_PHOTO", 60)
+        if time.time() - last_photo_time < cooldown:
+            print(f"[Media] Photo cooldown active")
+        elif _check_photo_triggers(text, emotion, self):
+            # Get a photo for context
+            photo = self._photos.get_for_context(
+                context=text,
+                arousal=emotion.get("arousal", 0),
+                desire=emotion.get("desire", 0)
+            )
+            if photo:
+                photo_name, photo_desc, photo_cat = photo
+                media_parts.append(f"PHOTO: {photo_desc} (category: {photo_cat})")
+                # Store in per-user pending media
+                _pending_media.setdefault(user_id, {})["photo"] = photo
+                print(f"[Media] Will send photo: {photo_name}")
+            else:
+                print("[Media] No matching photo found")
+
+    # Check video
+    if self._videos and len(self._videos.get_all()) > 0:
+        video_kw = ["video", "clip", "show me a video", "send video"]
+        wants_video = any(kw in text.lower() for kw in video_kw)
+        if wants_video:
+            video = self._videos.get_for_context(text, emotion.get("desire", 0))
+            if video:
+                video_path, video_desc = video
+                media_parts.append(f"VIDEO: {video_desc}")
+                _pending_media.setdefault(user_id, {})["video"] = video
+
+    return " | ".join(media_parts) if media_parts else ""
+
+
+async def _send_decided_media(self, text, emotion, chat_id, media_context: str, user_id: str = ""):
+    """Send the media we already decided on during pre-check (per-user safe)"""
+    import time
+
+    photo = None
+    video = None
+
+    # Get per-user pending media
+    pending = _pending_media.pop(user_id, {})
+
+    # Send pending photo
+    pending_photo = pending.get("photo")
+    if pending_photo:
+        photo_name, photo_desc, photo_cat = pending_photo
+        photo_path = str(self.base / "mypics" / photo_name)
+
+        if not self._photos.was_recently_sent(photo_name):
+            self._photos.mark_sent(photo_name)
+            self._last_photo_time = time.time()
+            self._photos_sent_session = getattr(self, '_photos_sent_session', 0) + 1
+
+            await self.nervous.emit("chat_action_photo", {})
+            await self.nervous.emit("send_image", {"file_path": photo_path, "chat_id": chat_id, "caption": ""})
+            print(f"[Photo] Sent: {photo_name}")
+            photo = pending_photo
+
+    # Send pending video
+    pending_video = pending.get("video")
+    if pending_video:
+        video_path, video_desc = pending_video
+
+        if not self._videos.was_recently_sent(video_path):
+            self._videos.mark_sent(video_path)
+            self._last_video_time = time.time()
+            self._videos_sent_session = getattr(self, '_videos_sent_session', 0) + 1
+
+            await self.nervous.emit("chat_action_video", {})
+            await self.nervous.emit("send_video", {"file_path": video_path, "chat_id": chat_id, "caption": ""})
+            print(f"[Video] Sent: {video_path}")
+            video = pending_video
+
+    return photo, video
+
+
+async def _save_memory(user_memory, text, response, emotion, photo, video):
+    """Save conversation to per-user memory"""
+    mem = response + (" [I sent a photo]" if photo else "") + (" [I sent a video]" if video else "")
+    await user_memory.nervous.emit("memory_save", {
+        "type": "conversation",
+        "user_message": text,
+        "ai_response": mem,
+        "emotion": emotion,
+        "user_id": user_memory.user_id  # Include for per-user isolation
+    })
+
+
+# ============================================================
+# HELPER FUNCTIONS FOR ALIVENESS MODULES
+# ============================================================
+
+def _classify_interaction_type(text: str, emotion: dict, detected_bids: list) -> str:
+    """
+    Classify the type of interaction for the interoceptive system.
+
+    Args:
+        text: The message text
+        emotion: Emotion data from the heart
+        detected_bids: List of detected emotional bids
+
+    Returns:
+        Interaction type string for interoceptive system
+    """
+    text_lower = text.lower()
+
+    # Check for intimate/romantic content
+    intimate_keywords = ["love", "miss you", "need you", "kiss", "hug", "hold me", "forever"]
+    if any(kw in text_lower for kw in intimate_keywords):
+        return "intimate_moment"
+
+    # Check for conflict/negative content
+    conflict_keywords = ["angry", "upset", "hurt", "why did you", "hate", "frustrated", "annoyed"]
+    if any(kw in text_lower for kw in conflict_keywords):
+        return "conflict"
+
+    # Check bid types
+    if detected_bids:
+        bid_types = [b.bid_type.value for b in detected_bids]
+        if "vulnerability" in bid_types:
+            return "deep_conversation"
+        if "seeking_validation" in bid_types or "reassurance" in bid_types:
+            return "reassurance"
+
+    # Check for playful content
+    playful_keywords = ["lol", "haha", "hehe", "funny", "joke", "tease", "silly"]
+    if any(kw in text_lower for kw in playful_keywords) or emotion.get("arousal", 0) > 0.6:
+        return "playful_exchange"
+
+    # Check for exciting news
+    exciting_keywords = ["guess what", "you won't believe", "amazing", "incredible", "so happy"]
+    if any(kw in text_lower for kw in exciting_keywords):
+        return "exciting_news"
+
+    # Default to positive interaction
+    if emotion.get("valence", 0.5) > 0.5:
+        return "positive_interaction"
+    else:
+        return "general"
+
+
+def _calculate_emotional_weight(emotion: dict, detected_bids: list) -> float:
+    """
+    Calculate emotional weight for memory storage.
+
+    Args:
+        emotion: Emotion data from the heart
+        detected_bids: List of detected emotional bids
+
+    Returns:
+        Emotional weight (0-1)
+    """
+    weight = 0.3  # Base weight
+
+    # High arousal increases weight
+    arousal = emotion.get("arousal", 0)
+    weight += arousal * 0.2
+
+    # High desire increases weight
+    desire = emotion.get("desire", 0)
+    weight += desire * 0.15
+
+    # Extreme valence (positive or negative) increases weight
+    valence = emotion.get("valence", 0.5)
+    valence_extremity = abs(valence - 0.5) * 2  # 0 to 1
+    weight += valence_extremity * 0.15
+
+    # Bids with high intensity increase weight
+    if detected_bids:
+        max_bid_intensity = max(
+            (b.confidence for b in detected_bids),
+            default=0
+        )
+        weight += max_bid_intensity * 0.2
+
+    return min(1.0, weight)
+
+
+# ============================================================
+# MODULE STATUS FUNCTIONS
+# ============================================================
+
+def get_aliveness_module_status() -> dict:
+    """
+    Get status of all aliveness modules.
+
+    Returns:
+        Dictionary with module availability status
+    """
+    modules = {
+        "interoception": INTEROCEPTION_AVAILABLE,
+        "default_mode": DEFAULT_MODE_AVAILABLE,
+        "bid_detector": BID_DETECTOR_AVAILABLE,
+        "emotional_memory": EMOTIONAL_MEMORY_AVAILABLE,
+        "inconsistency": INCONSISTENCY_AVAILABLE,
+        "afterglow": AFTERGLOW_AVAILABLE,
+        "circadian": CIRCADIAN_AVAILABLE,
+        "mood_shifts": MOOD_SHIFTS_AVAILABLE,
+        "attachment": ATTACHMENT_AVAILABLE,
+        "phantom_somatic": PHANTOM_SOMATIC_AVAILABLE,
+        "narrative": NARRATIVE_AVAILABLE,
+        "dreams": DREAMS_AVAILABLE,
+        "linguistic": LINGUISTIC_AVAILABLE,
+        "curiosity": CURIOSITY_AVAILABLE,
+        "almost_said": ALMOST_SAID_AVAILABLE,
+    }
+    modules["modules_active"] = sum(v for v in modules.values() if isinstance(v, bool))
+    return modules
+