Initial commit: Miku Discord Bot

bot/.bak.bot.py

@@ -0,0 +1,464 @@
+import discord
+import aiohttp
+import asyncio
+import os
+import re
+import random
+import string
+
+import base64
+import subprocess
+import aiofiles
+
+from langchain_community.vectorstores import FAISS
+from langchain_ollama import OllamaEmbeddings
+from langchain.text_splitter import CharacterTextSplitter
+from langchain_community.docstore.document import Document
+
+from collections import defaultdict, deque
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from discord import File
+from discord import Status
+import datetime
+
+from apscheduler.triggers.date import DateTrigger
+from datetime import datetime, timedelta
+
+scheduler = AsyncIOScheduler()
+BEDTIME_CHANNEL_IDS = [761014220707332107]
+
+# Stores last 5 exchanges per user (as deque)
+conversation_history = defaultdict(lambda: deque(maxlen=5))
+
+DISCORD_BOT_TOKEN = os.getenv("DISCORD_BOT_TOKEN")
+OLLAMA_URL = os.getenv("OLLAMA_URL", "http://ollama:11434")
+OLLAMA_MODEL = os.getenv("OLLAMA_MODEL", "mistral")
+
+embeddings = OllamaEmbeddings(
+    model=OLLAMA_MODEL,
+    base_url=OLLAMA_URL
+)
+
+# Set up Discord client
+intents = discord.Intents.default()
+intents.message_content = True
+intents.members = True
+intents.presences = True
+client = discord.Client(intents=intents)
+
+current_model = None  # Track currently loaded model name
+
+# Switch model
+async def switch_model(model_name: str, timeout: int = 600):
+    global current_model
+    if current_model == model_name:
+        print(f"🔁 Model '{model_name}' already loaded.")
+        return
+
+    # Unload all other models to clear VRAM
+    async with aiohttp.ClientSession() as session:
+        async with session.get(f"{OLLAMA_URL}/api/show") as resp:
+            if resp.status == 200:
+                data = await resp.json()
+                loaded_models = data.get("models", [])
+                for model in loaded_models:
+                    if model["name"] != model_name:
+                        print(f"🔁 Unloading model: {model['name']}")
+                        await session.post(f"{OLLAMA_URL}/api/stop", json={"name": model["name"]})
+            else:
+                print("⚠️ Failed to check currently loaded models.")
+
+    print(f"🔄 Switching to model '{model_name}'...")
+    async with aiohttp.ClientSession() as session:
+        await session.post(f"{OLLAMA_URL}/api/stop")
+    # Warm up the new model (dummy call to preload it)
+    payload = {
+        "model": model_name,
+        "prompt": "Hello",
+        "stream": False
+    }
+    headers = {"Content-Type": "application/json"}
+
+    # Poll until /api/generate returns 200
+    async with aiohttp.ClientSession() as session:
+        for _ in range(timeout):
+            async with session.post(f"{OLLAMA_URL}/api/generate", json=payload, headers=headers) as resp:
+                if resp.status == 200:
+                    current_model = model_name
+                    print(f"✅ Model {model_name} ready!")
+                    return
+            await asyncio.sleep(1)  # Wait a second before trying again
+
+    raise TimeoutError(f"Timed out waiting for model '{model_name}' to become available.")
+
+async def download_and_encode_image(url):
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as resp:
+            if resp.status != 200:
+                return None
+            img_bytes = await resp.read()
+            return base64.b64encode(img_bytes).decode('utf-8')
+
+async def analyze_image_with_qwen(base64_img):
+    await switch_model("moondream")
+
+    payload = {
+        "model": "moondream",
+        "prompt": "Describe this image in detail.",
+        "images": [base64_img],
+        "stream": False
+    }
+
+    headers = {"Content-Type": "application/json"}
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(f"{OLLAMA_URL}/api/generate", json=payload, headers=headers) as response:
+            if response.status == 200:
+                data = await response.json()
+                return data.get("response", "No description.")
+            else:
+                return f"Error: {response.status}"
+
+async def rephrase_as_miku(qwen_output, user_prompt):
+    await switch_model(OLLAMA_MODEL)  # likely llama3
+
+    with open("miku_prompt.txt", "r", encoding="utf-8") as f:
+        system_prompt = f.read()
+
+    relevant_docs_lore = miku_vectorstore.similarity_search(qwen_output, k=3)
+    context = "\n\n".join([doc.page_content for doc in relevant_docs_lore])
+
+    full_prompt = (
+        f"{context}\n\n"
+        f"The user asked: \"{user_prompt}\"\n"
+        f"The image contains: \"{qwen_output}\"\n\n"
+        f"Respond like Miku: cheerful, helpful, and opinionated when asked.\n\n"
+        f"Miku:"
+    )
+
+    payload = {
+        "model": OLLAMA_MODEL,
+        "prompt": full_prompt,
+        "system": system_prompt,
+        "stream": False
+    }
+
+    headers = {"Content-Type": "application/json"}
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(f"{OLLAMA_URL}/api/generate", json=payload, headers=headers) as response:
+            if response.status == 200:
+                data = await response.json()
+                return data.get("response", "No response.")
+            else:
+                return f"Error: {response.status}"
+
+# Load and index once at startup
+def load_miku_knowledge():
+    with open("miku_lore.txt", "r", encoding="utf-8") as f:
+        text = f.read()
+
+    from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=520,
+        chunk_overlap=50,
+        separators=["\n\n", "\n", ".", "!", "?", ",", " ", ""]
+    )
+
+    docs = [Document(page_content=chunk) for chunk in text_splitter.split_text(text)]
+
+    vectorstore = FAISS.from_documents(docs, embeddings)
+    return vectorstore
+
+def load_miku_lyrics():
+    with open("miku_lyrics.txt", "r", encoding="utf-8") as f:
+        lyrics_text = f.read()
+
+    text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=50)
+    docs = [Document(page_content=chunk) for chunk in text_splitter.split_text(lyrics_text)]
+
+    vectorstore = FAISS.from_documents(docs, embeddings)
+    return vectorstore
+
+miku_vectorstore = load_miku_knowledge()
+miku_lyrics_vectorstore = load_miku_lyrics()
+
+async def query_ollama(user_prompt, user_id):
+    relevant_docs_lore = miku_vectorstore.similarity_search(user_prompt, k=3)
+    relevant_docs_lyrics = miku_lyrics_vectorstore.similarity_search(user_prompt, k=3)
+
+    context_lore = "\n".join([doc.page_content for doc in relevant_docs_lore])
+    context_lyrics = "\n".join([doc.page_content for doc in relevant_docs_lyrics])
+
+    combined_docs = relevant_docs_lore + relevant_docs_lyrics
+    context = "\n\n".join([doc.page_content for doc in combined_docs])
+
+    # Persona definition
+    with open("miku_prompt.txt", "r", encoding="utf-8") as f:
+        system_prompt = f.read()
+
+    # Build conversation history
+    history = conversation_history[user_id]
+    history_text = "\n".join([f"User: {u}\nMiku: {m}" for u, m in history])
+
+    # Combine prompt
+    full_prompt = (
+        f"{context_lore}\n\n{context_lyrics}\n\n"
+        f"{history_text}\nUser: {user_prompt}\nMiku:"
+    )
+
+    headers = {'Content-Type': 'application/json'}
+    payload = {
+        "model": OLLAMA_MODEL,
+        "prompt": full_prompt,
+		"system": system_prompt,
+        "stream": False
+    }
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(f"{OLLAMA_URL}/api/generate", json=payload, headers=headers) as response:
+            if response.status == 200:
+                data = await response.json()
+                reply = data.get("response", "No response.")
+                # Save to conversation history
+                conversation_history[user_id].append((user_prompt, reply))
+                return reply
+            else:
+                return f"Error: {response.status}"
+
+async def send_monday_video():
+    await switch_model(OLLAMA_MODEL)
+
+    # Generate a motivational message
+    prompt = "It's Miku Monday! Give me an energetic and heartfelt Miku Monday morning message to inspire someone for the week ahead."
+    response = await query_ollama(prompt, user_id="weekly-motivation")
+
+    video_url = "http://zip.koko210cloud.xyz/u/zEgU7Z.mp4"
+
+    target_channel_ids = [
+        761014220707332107,
+        1140377617237807266
+    ]
+    
+    for channel_id in target_channel_ids:
+        channel = client.get_channel(channel_id)
+        if channel is None:
+            print(f"❌ Could not find channel with ID {channel_id}. Make sure the bot is in the server.")
+            return
+
+        try:
+            await channel.send(content=response)
+            # Send video link
+            await channel.send(f"[Happy Miku Monday!]({video_url})")
+
+            print(f"✅ Sent Monday video to channel ID {channel_id}")
+        except Exception as e:
+            print(f"⚠️ Failed to send video to channel ID {channel_id}: {e}")
+
+async def send_bedtime_reminder():
+    await switch_model(OLLAMA_MODEL)
+
+    for channel_id in BEDTIME_CHANNEL_IDS:
+        channel = client.get_channel(channel_id)
+        if not channel:
+            print(f"⚠️ Channel ID {channel_id} not found.")
+            continue
+
+        guild = channel.guild
+
+        # Filter online members (excluding bots)
+        online_members = [
+            member for member in guild.members
+            if member.status in {Status.online, Status.idle, Status.dnd}
+            and not member.bot
+        ]
+
+        if not online_members:
+            print(f"😴 No online members to ping in {guild.name}")
+            continue
+
+        chosen_one = random.choice(online_members)
+
+        # Generate bedtime message
+        prompt = (
+            f"Write a sweet, funny, or encouraging bedtime message to remind someone it's getting late and they should sleep. "
+            f"Make it short and wholesome, as if Miku is genuinely worried about their well-being. Imply that it's not good staying up so late."
+        )
+        bedtime_message = await query_ollama(prompt, user_id="bedtime-miku")
+
+        try:
+            await channel.send(f"{chosen_one.mention}, {bedtime_message}")
+            print(f"🌙 Sent bedtime reminder to {chosen_one.display_name} in {guild.name}")
+        except Exception as e:
+            print(f"⚠️ Failed to send bedtime reminder in {guild.name}: {e}")
+
+def schedule_random_bedtime():
+    now = datetime.now()
+    target_time = now.replace(hour=20, minute=30, second=0, microsecond=0)
+    # If it's already past 23:30 today, schedule for tomorrow
+    if now > target_time:
+        target_time += timedelta(days=1)
+
+    # Add random offset (0–29 mins)
+    offset_minutes = random.randint(0, 29)
+    run_time = target_time + timedelta(minutes=offset_minutes)
+
+    scheduler.add_job(send_bedtime_reminder, trigger=DateTrigger(run_date=run_time))
+    print(f"⏰ Bedtime reminder scheduled for {run_time.strftime('%Y-%m-%d %H:%M:%S')}")
+
+async def overlay_username_with_ffmpeg(base_video_path, output_path, username):
+    font_path = "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"
+    text = f"@{username}"
+
+    # Define your six positions (x, y)
+    positions = {
+        1: ("250", "370"),
+        2: ("330", "130"),
+        3: ("300", "90"),
+        4: ("380", "180"),
+        5: ("365", "215"),
+        6: ("55", "365"),
+        7: ("290", "130"),
+        8: ("320", "210"),
+        9: ("310", "240"),
+        10: ("400", "240")
+    }
+
+    # Each entry: (start_time, end_time, position_index)
+    text_entries = [
+        (4.767, 5.367, 1, "username"),
+        (5.4, 5.967, 2, "username"),
+        (6.233, 6.833, 3, "username"),
+        (6.967, 7.6, 4, "username"),
+        (7.733, 8.367, 5, "username"),
+        (8.667, 9.133, 6, "username"),
+        (9.733, 10.667, 7, "username"),
+        (11.6, 12.033, 8, "@everyone"),
+        (12.067, 13.0, 9, "@everyone"),
+        (13.033, 14.135, 10, "@everyone"),
+    ]
+
+    # Build drawtext filters
+    drawtext_filters = []
+    for start, end, pos_id, text_type in text_entries:
+        x_coord, y_coord = positions[pos_id]
+
+        # Determine actual text content
+        text_content = f"@{username}" if text_type == "username" else text_type
+
+        x = f"{x_coord} - text_w/2"
+        y = f"{y_coord} - text_h/2"
+
+        filter_str = (
+            f"drawtext=text='{text_content}':"
+            f"fontfile='{font_path}':"
+            f"fontcolor=black:fontsize=30:x={x}:y={y}:"
+            f"enable='between(t,{start},{end})'"
+        )
+        drawtext_filters.append(filter_str)
+
+    vf_string = ",".join(drawtext_filters)
+
+    ffmpeg_command = [
+        "ffmpeg",
+        "-i", base_video_path,
+        "-vf", vf_string,
+        "-codec:a", "copy",
+        output_path
+    ]
+
+    try:
+        subprocess.run(ffmpeg_command, check=True)
+        print("✅ Video processed successfully with username overlays.")
+    except subprocess.CalledProcessError as e:
+        print(f"⚠️ FFmpeg error: {e}")
+
+@client.event
+async def on_ready():
+    print(f'🎤 MikuBot connected as {client.user}')
+
+    # Schedule the weekly task (Monday 07:30)
+    scheduler.add_job(send_monday_video, 'cron', day_of_week='mon', hour=7, minute=30)
+
+    # Schedule first bedtime reminder
+    schedule_random_bedtime()
+    # Reschedule every midnight
+    scheduler.add_job(schedule_random_bedtime, 'cron', hour=0, minute=0)
+    #scheduler.add_job(send_bedtime_reminder, 'cron', hour=12, minute=22)
+
+    scheduler.start()
+
+@client.event
+async def on_message(message):
+    if message.author == client.user:
+        return
+        
+    if message.content.strip().lower() == "miku, rape this nigga balls" and message.reference:
+        async with message.channel.typing():
+            # Get replied-to user
+            try:
+                replied_msg = await message.channel.fetch_message(message.reference.message_id)
+                target_username = replied_msg.author.display_name
+
+                # Prepare video
+                base_video = "MikuMikuBeam.mp4"
+                output_video = f"/tmp/video_{''.join(random.choices(string.ascii_letters, k=5))}.mp4"
+
+                await overlay_username_with_ffmpeg(base_video, output_video, target_username)
+
+                caption = f"Here you go, @{target_username}! 🌟"
+                #await message.channel.send(content=caption, file=discord.File(output_video))
+                await replied_msg.reply(file=discord.File(output_video))
+
+            except Exception as e:
+                print(f"⚠️ Error processing video: {e}")
+                await message.channel.send("Sorry, something went wrong while generating the video.")
+            return
+
+    text = message.content.strip()
+
+    if re.search(r'^(miku,)|((, miku)[\?\!\.\s,]*)$', message.content.strip(), re.IGNORECASE) or ", miku," in message.content.lower():
+
+                # Clean the prompt
+        if text.lower().startswith("miku, "):
+            prompt = text[6:].strip()
+        else:
+            prompt = re.sub(r', miku[\?\!\.\s]*$', '', text, flags=re.IGNORECASE).strip()
+
+        async with message.channel.typing():
+            # If message has an image attachment
+            if message.attachments:
+                for attachment in message.attachments:
+                    if any(attachment.filename.lower().endswith(ext) for ext in [".jpg", ".jpeg", ".png", ".webp"]):
+                        #await message.channel.send("Looking at the image... 🎨")
+
+                        base64_img = await download_and_encode_image(attachment.url)
+                        if not base64_img:
+                            await message.channel.send("I couldn't load the image, sorry!")
+                            return
+					# Analyze image (objective description)
+                    qwen_description = await analyze_image_with_qwen(base64_img)
+                    miku_reply = await rephrase_as_miku(qwen_description, prompt)
+
+                    await message.channel.send(miku_reply)
+                    return
+
+            # If message is just a prompt, no image
+            prompt = message.content[5:].strip()
+            #await message.channel.send("Thinking... 🎶")
+            response = await query_ollama(prompt, user_id=str(message.author.id))
+            await message.channel.send(response)
+
+    if message.content.lower().strip() == "!reset":
+        conversation_history[str(message.author.id)].clear()
+        await message.channel.send("Okay! Memory reset for you~ ✨")
+
+    # Manual Monday test command
+    if message.content.lower().strip() == "!monday":
+        await send_monday_video()
+        #await message.channel.send("✅ Monday message sent (or attempted). Check logs.")
+        return
+
+client.run(DISCORD_BOT_TOKEN)

bot/.bak.bot.py.250625

@@ -0,0 +1,540 @@
+import discord
+import aiohttp
+import asyncio
+import os
+import re
+import random
+import string
+
+import base64
+import subprocess
+import aiofiles
+
+from langchain_community.vectorstores import FAISS
+from langchain_ollama import OllamaEmbeddings
+from langchain.text_splitter import CharacterTextSplitter
+from langchain_community.docstore.document import Document
+
+from collections import defaultdict, deque
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from discord import File
+from discord import Status
+import datetime
+
+from apscheduler.triggers.date import DateTrigger
+from datetime import datetime, timedelta
+
+scheduler = AsyncIOScheduler()
+BEDTIME_CHANNEL_IDS = [761014220707332107]
+
+# Stores last 5 exchanges per user (as deque)
+conversation_history = defaultdict(lambda: deque(maxlen=5))
+
+DISCORD_BOT_TOKEN = os.getenv("DISCORD_BOT_TOKEN")
+OLLAMA_URL = os.getenv("OLLAMA_URL", "http://ollama:11434")
+OLLAMA_MODEL = os.getenv("OLLAMA_MODEL", "mistral")
+
+embeddings = OllamaEmbeddings(
+    model=OLLAMA_MODEL,
+    base_url=OLLAMA_URL
+)
+
+# Set up Discord client
+intents = discord.Intents.default()
+intents.message_content = True
+intents.members = True
+intents.presences = True
+client = discord.Client(intents=intents)
+
+current_model = None  # Track currently loaded model name
+
+KINDNESS_KEYWORDS = [
+    "thank you", "love you", "luv u", "you're the best", "so cute",
+    "adorable", "amazing", "sweet", "kind", "great job", "well done",
+    "precious", "good girl", "cutie", "angel", "my favorite", "so helpful"
+]
+HEART_REACTIONS = ["💙", "💝", "💖", "💕", "💜", "❤️‍🔥", "☺️"]
+kindness_reacted_messages = set()
+
+# Switch model
+async def switch_model(model_name: str, timeout: int = 600):
+    global current_model
+    if current_model == model_name:
+        print(f"🔁 Model '{model_name}' already loaded.")
+        return
+
+    # Unload all other models to clear VRAM
+    async with aiohttp.ClientSession() as session:
+        async with session.get(f"{OLLAMA_URL}/api/show") as resp:
+            if resp.status == 200:
+                data = await resp.json()
+                loaded_models = data.get("models", [])
+                for model in loaded_models:
+                    if model["name"] != model_name:
+                        print(f"🔁 Unloading model: {model['name']}")
+                        await session.post(f"{OLLAMA_URL}/api/stop", json={"name": model["name"]})
+            else:
+                print("⚠️ Failed to check currently loaded models.")
+
+    print(f"🔄 Switching to model '{model_name}'...")
+    async with aiohttp.ClientSession() as session:
+        await session.post(f"{OLLAMA_URL}/api/stop")
+    # Warm up the new model (dummy call to preload it)
+    payload = {
+        "model": model_name,
+        "prompt": "Hello",
+        "stream": False
+    }
+    headers = {"Content-Type": "application/json"}
+
+    # Poll until /api/generate returns 200
+    async with aiohttp.ClientSession() as session:
+        for _ in range(timeout):
+            async with session.post(f"{OLLAMA_URL}/api/generate", json=payload, headers=headers) as resp:
+                if resp.status == 200:
+                    current_model = model_name
+                    print(f"✅ Model {model_name} ready!")
+                    return
+            await asyncio.sleep(1)  # Wait a second before trying again
+
+    raise TimeoutError(f"Timed out waiting for model '{model_name}' to become available.")
+
+
+async def is_miku_addressed(message) -> bool:
+    # If message is a reply, check the referenced message author
+    if message.reference:
+        try:
+            referenced_msg = await message.channel.fetch_message(message.reference.message_id)
+            if referenced_msg.author == message.guild.me:  # or client.user if you use client
+                return True
+        except Exception as e:
+            print(f"⚠️ Could not fetch referenced message: {e}")
+
+    cleaned = message.content.strip()
+
+    return bool(re.search(
+        r'(?<![\w\(])(?:[^\w\s]{0,2}\s*)?miku(?:\s*[^\w\s]{0,2})?(?=,|\s*,|[!\.?\s]*$)',
+        cleaned,
+        re.IGNORECASE
+    ))
+
+async def download_and_encode_image(url):
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as resp:
+            if resp.status != 200:
+                return None
+            img_bytes = await resp.read()
+            return base64.b64encode(img_bytes).decode('utf-8')
+
+async def analyze_image_with_qwen(base64_img):
+    await switch_model("moondream")
+
+    payload = {
+        "model": "moondream",
+        "prompt": "Describe this image in detail.",
+        "images": [base64_img],
+        "stream": False
+    }
+
+    headers = {"Content-Type": "application/json"}
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(f"{OLLAMA_URL}/api/generate", json=payload, headers=headers) as response:
+            if response.status == 200:
+                data = await response.json()
+                return data.get("response", "No description.")
+            else:
+                return f"Error: {response.status}"
+
+async def rephrase_as_miku(qwen_output, user_prompt):
+    await switch_model(OLLAMA_MODEL)  # likely llama3
+
+    with open("miku_prompt.txt", "r", encoding="utf-8") as f:
+        system_prompt = f.read()
+
+    relevant_docs_lore = miku_vectorstore.similarity_search(qwen_output, k=3)
+    context = "\n\n".join([doc.page_content for doc in relevant_docs_lore])
+
+    full_prompt = (
+        f"{context}\n\n"
+        f"The user asked: \"{user_prompt}\"\n"
+        f"The image contains: \"{qwen_output}\"\n\n"
+        f"Respond like Miku: cheerful, helpful, and opinionated when asked.\n\n"
+        f"Miku:"
+    )
+
+    payload = {
+        "model": OLLAMA_MODEL,
+        "prompt": full_prompt,
+        "system": system_prompt,
+        "stream": False
+    }
+
+    headers = {"Content-Type": "application/json"}
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(f"{OLLAMA_URL}/api/generate", json=payload, headers=headers) as response:
+            if response.status == 200:
+                data = await response.json()
+                return data.get("response", "No response.")
+            else:
+                return f"Error: {response.status}"
+
+# Load and index once at startup
+def load_miku_knowledge():
+    with open("miku_lore.txt", "r", encoding="utf-8") as f:
+        text = f.read()
+
+    from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=520,
+        chunk_overlap=50,
+        separators=["\n\n", "\n", ".", "!", "?", ",", " ", ""]
+    )
+
+    docs = [Document(page_content=chunk) for chunk in text_splitter.split_text(text)]
+
+    vectorstore = FAISS.from_documents(docs, embeddings)
+    return vectorstore
+
+def load_miku_lyrics():
+    with open("miku_lyrics.txt", "r", encoding="utf-8") as f:
+        lyrics_text = f.read()
+
+    text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=50)
+    docs = [Document(page_content=chunk) for chunk in text_splitter.split_text(lyrics_text)]
+
+    vectorstore = FAISS.from_documents(docs, embeddings)
+    return vectorstore
+
+miku_vectorstore = load_miku_knowledge()
+miku_lyrics_vectorstore = load_miku_lyrics()
+
+async def query_ollama(user_prompt, user_id):
+    relevant_docs_lore = miku_vectorstore.similarity_search(user_prompt, k=3)
+    relevant_docs_lyrics = miku_lyrics_vectorstore.similarity_search(user_prompt, k=3)
+
+    context_lore = "\n".join([doc.page_content for doc in relevant_docs_lore])
+    context_lyrics = "\n".join([doc.page_content for doc in relevant_docs_lyrics])
+
+    combined_docs = relevant_docs_lore + relevant_docs_lyrics
+    context = "\n\n".join([doc.page_content for doc in combined_docs])
+
+    # Persona definition
+    with open("miku_prompt.txt", "r", encoding="utf-8") as f:
+        system_prompt = f.read()
+
+    # Build conversation history
+    history = conversation_history[user_id]
+    history_text = "\n".join([f"User: {u}\nMiku: {m}" for u, m in history])
+
+    # Combine prompt
+    full_prompt = (
+        f"{context_lore}\n\n{context_lyrics}\n\n"
+        f"{history_text}\nUser: {user_prompt}\nMiku:"
+    )
+
+    headers = {'Content-Type': 'application/json'}
+    payload = {
+        "model": OLLAMA_MODEL,
+        "prompt": full_prompt,
+		"system": system_prompt,
+        "stream": False
+    }
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(f"{OLLAMA_URL}/api/generate", json=payload, headers=headers) as response:
+            if response.status == 200:
+                data = await response.json()
+                reply = data.get("response", "No response.")
+                # Save to conversation history
+                conversation_history[user_id].append((user_prompt, reply))
+                return reply
+            else:
+                return f"Error: {response.status}"
+
+async def send_monday_video():
+    await switch_model(OLLAMA_MODEL)
+
+    # Generate a motivational message
+    prompt = "It's Miku Monday! Give me an energetic and heartfelt Miku Monday morning message to inspire someone for the week ahead."
+    response = await query_ollama(prompt, user_id="weekly-motivation")
+
+    video_url = "http://zip.koko210cloud.xyz/u/zEgU7Z.mp4"
+
+    target_channel_ids = [
+        761014220707332107,
+        1140377617237807266
+    ]
+    
+    for channel_id in target_channel_ids:
+        channel = client.get_channel(channel_id)
+        if channel is None:
+            print(f"❌ Could not find channel with ID {channel_id}. Make sure the bot is in the server.")
+            return
+
+        try:
+            await channel.send(content=response)
+            # Send video link
+            await channel.send(f"[Happy Miku Monday!]({video_url})")
+
+            print(f"✅ Sent Monday video to channel ID {channel_id}")
+        except Exception as e:
+            print(f"⚠️ Failed to send video to channel ID {channel_id}: {e}")
+
+async def send_bedtime_reminder():
+    await switch_model(OLLAMA_MODEL)
+
+    for channel_id in BEDTIME_CHANNEL_IDS:
+        channel = client.get_channel(channel_id)
+        if not channel:
+            print(f"⚠️ Channel ID {channel_id} not found.")
+            continue
+
+        guild = channel.guild
+
+        # Filter online members (excluding bots)
+        online_members = [
+            member for member in guild.members
+            if member.status in {Status.online, Status.idle, Status.dnd}
+            and not member.bot
+        ]
+
+        specific_user_id = 214857593045254151 # target user ID
+        specific_user = guild.get_member(specific_user_id)
+        if specific_user and specific_user not in online_members:
+            online_members.append(specific_user)
+
+        if not online_members:
+            print(f"😴 No online members to ping in {guild.name}")
+            continue
+
+        chosen_one = random.choice(online_members)
+
+        # Generate bedtime message
+        prompt = (
+            f"Write a sweet, funny, or encouraging bedtime message to remind someone it's getting late and they should sleep. "
+            f"Make it short and wholesome, as if Miku is genuinely worried about their well-being. Imply that it's not good staying up so late."
+        )
+        bedtime_message = await query_ollama(prompt, user_id="bedtime-miku")
+
+        try:
+            await channel.send(f"{chosen_one.mention}, {bedtime_message}")
+            print(f"🌙 Sent bedtime reminder to {chosen_one.display_name} in {guild.name}")
+        except Exception as e:
+            print(f"⚠️ Failed to send bedtime reminder in {guild.name}: {e}")
+
+def schedule_random_bedtime():
+    now = datetime.now()
+    target_time = now.replace(hour=20, minute=30, second=0, microsecond=0)
+    # If it's already past 23:30 today, schedule for tomorrow
+    if now > target_time:
+        target_time += timedelta(days=1)
+
+    # Add random offset (0–29 mins)
+    offset_minutes = random.randint(0, 29)
+    run_time = target_time + timedelta(minutes=offset_minutes)
+
+    scheduler.add_job(send_bedtime_reminder, trigger=DateTrigger(run_date=run_time))
+    print(f"⏰ Bedtime reminder scheduled for {run_time.strftime('%Y-%m-%d %H:%M:%S')}")
+
+async def overlay_username_with_ffmpeg(base_video_path, output_path, username):
+    font_path = "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"
+    text = f"@{username}"
+
+    # Define your six positions (x, y)
+    positions = {
+        1: ("250", "370"),
+        2: ("330", "130"),
+        3: ("300", "90"),
+        4: ("380", "180"),
+        5: ("365", "215"),
+        6: ("55", "365"),
+        7: ("290", "130"),
+        8: ("320", "210"),
+        9: ("310", "240"),
+        10: ("400", "240")
+    }
+
+    # Each entry: (start_time, end_time, position_index)
+    text_entries = [
+        (4.767, 5.367, 1, "username"),
+        (5.4, 5.967, 2, "username"),
+        (6.233, 6.833, 3, "username"),
+        (6.967, 7.6, 4, "username"),
+        (7.733, 8.367, 5, "username"),
+        (8.667, 9.133, 6, "username"),
+        (9.733, 10.667, 7, "username"),
+        (11.6, 12.033, 8, "@everyone"),
+        (12.067, 13.0, 9, "@everyone"),
+        (13.033, 14.135, 10, "@everyone"),
+    ]
+
+    # Build drawtext filters
+    drawtext_filters = []
+    for start, end, pos_id, text_type in text_entries:
+        x_coord, y_coord = positions[pos_id]
+
+        # Determine actual text content
+        text_content = f"@{username}" if text_type == "username" else text_type
+
+        x = f"{x_coord} - text_w/2"
+        y = f"{y_coord} - text_h/2"
+
+        filter_str = (
+            f"drawtext=text='{text_content}':"
+            f"fontfile='{font_path}':"
+            f"fontcolor=black:fontsize=30:x={x}:y={y}:"
+            f"enable='between(t,{start},{end})'"
+        )
+        drawtext_filters.append(filter_str)
+
+    vf_string = ",".join(drawtext_filters)
+
+    ffmpeg_command = [
+        "ffmpeg",
+        "-i", base_video_path,
+        "-vf", vf_string,
+        "-codec:a", "copy",
+        output_path
+    ]
+
+    try:
+        subprocess.run(ffmpeg_command, check=True)
+        print("✅ Video processed successfully with username overlays.")
+    except subprocess.CalledProcessError as e:
+        print(f"⚠️ FFmpeg error: {e}")
+
+async def detect_and_react_to_kindness(message, after_reply=False):
+    if message.id in kindness_reacted_messages:
+        return  # Already reacted — skip
+
+    content = message.content.lower()
+
+    emoji = random.choice(HEART_REACTIONS)
+
+    # 1. Keyword-based detection
+    if any(keyword in content for keyword in KINDNESS_KEYWORDS):
+        try:
+            await message.add_reaction(emoji)
+            kindness_reacted_messages.add(message.id)
+            message.kindness_reacted = True  # Mark as done
+            print("✅ Kindness detected via keywords. Reacted immediately.")
+        except Exception as e:
+            print(f"⚠️ Error adding reaction: {e}")
+        return
+
+    # 2. If not after_reply, defer model-based check
+    if not after_reply:
+        print("🗝️ No kindness via keywords. Deferring...")
+        return
+
+    # 3. Model-based detection
+    try:
+        prompt = (
+            "The following message was sent to Miku the bot. "
+            "Does it sound like the user is being kind or affectionate toward Miku? "
+            "Answer with 'yes' or 'no' only.\n\n"
+            f"Message: \"{message.content}\""
+        )
+        result = await query_ollama(prompt, user_id="kindness-check")
+
+        if result.strip().lower().startswith("yes"):
+            await message.add_reaction(emoji)
+            kindness_reacted_messages.add(message.id)
+            print("✅ Kindness detected via model. Reacted.")
+        else:
+            print("🧊 No kindness detected.")
+    except Exception as e:
+        print(f"⚠️ Error during kindness analysis: {e}")
+
+@client.event
+async def on_ready():
+    print(f'🎤 MikuBot connected as {client.user}')
+
+    # Schedule the weekly task (Monday 07:30)
+    scheduler.add_job(send_monday_video, 'cron', day_of_week='mon', hour=7, minute=30)
+
+    # Schedule first bedtime reminder
+    schedule_random_bedtime()
+    # Reschedule every midnight
+    scheduler.add_job(schedule_random_bedtime, 'cron', hour=0, minute=0)
+    #scheduler.add_job(send_bedtime_reminder, 'cron', hour=12, minute=22)
+
+    scheduler.start()
+
+@client.event
+async def on_message(message):
+    if message.author == client.user:
+        return
+        
+    if message.content.strip().lower() == "miku, rape this nigga balls" and message.reference:
+        async with message.channel.typing():
+            # Get replied-to user
+            try:
+                replied_msg = await message.channel.fetch_message(message.reference.message_id)
+                target_username = replied_msg.author.display_name
+
+                # Prepare video
+                base_video = "MikuMikuBeam.mp4"
+                output_video = f"/tmp/video_{''.join(random.choices(string.ascii_letters, k=5))}.mp4"
+
+                await overlay_username_with_ffmpeg(base_video, output_video, target_username)
+
+                caption = f"Here you go, @{target_username}! 🌟"
+                #await message.channel.send(content=caption, file=discord.File(output_video))
+                await replied_msg.reply(file=discord.File(output_video))
+
+            except Exception as e:
+                print(f"⚠️ Error processing video: {e}")
+                await message.channel.send("Sorry, something went wrong while generating the video.")
+            return
+
+
+    text = message.content.strip()
+
+    if await is_miku_addressed(message):   
+ 
+        prompt = text  # No cleanup — keep it raw 
+        
+        # 1st kindness check with just keywords
+        await detect_and_react_to_kindness(message)
+
+        async with message.channel.typing():
+            # If message has an image attachment
+            if message.attachments:
+                for attachment in message.attachments:
+                    if any(attachment.filename.lower().endswith(ext) for ext in [".jpg", ".jpeg", ".png", ".webp"]):
+
+                        base64_img = await download_and_encode_image(attachment.url)
+                        if not base64_img:
+                            await message.channel.send("I couldn't load the image, sorry!")
+                            return
+					# Analyze image (objective description)
+                    qwen_description = await analyze_image_with_qwen(base64_img)
+                    miku_reply = await rephrase_as_miku(qwen_description, prompt)
+                    
+                    await message.channel.send(miku_reply)
+                    return
+
+            # If message is just a prompt, no image
+            response = await query_ollama(prompt, user_id=str(message.author.id))
+            
+            await message.channel.send(response)
+            
+        # 2nd kindness check (only if no keywords detected)
+        await detect_and_react_to_kindness(message, after_reply=True)
+
+    if message.content.lower().strip() == "!reset":
+        conversation_history[str(message.author.id)].clear()
+        await message.channel.send("Okay! Memory reset for you~ ✨")
+
+    # Manual Monday test command
+    if message.content.lower().strip() == "!monday":
+        await send_monday_video()
+        #await message.channel.send("✅ Monday message sent (or attempted). Check logs.")
+        return
+
+client.run(DISCORD_BOT_TOKEN)

bot/.bak.bot.py.260625

@@ -0,0 +1,665 @@
+import discord
+import aiohttp
+import asyncio
+import os
+import re
+import random
+import string
+
+import base64
+import subprocess
+import aiofiles
+
+from langchain_community.vectorstores import FAISS
+from langchain_ollama import OllamaEmbeddings
+from langchain.text_splitter import CharacterTextSplitter
+from langchain_community.docstore.document import Document
+
+from collections import defaultdict, deque
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from discord import File
+from discord import Status
+from discord.ext import tasks
+import datetime
+
+from apscheduler.triggers.date import DateTrigger
+from datetime import datetime, timedelta
+
+scheduler = AsyncIOScheduler()
+BEDTIME_CHANNEL_IDS = [761014220707332107]
+
+# Stores last 5 exchanges per user (as deque)
+conversation_history = defaultdict(lambda: deque(maxlen=5))
+
+DISCORD_BOT_TOKEN = os.getenv("DISCORD_BOT_TOKEN")
+OLLAMA_URL = os.getenv("OLLAMA_URL", "http://ollama:11434")
+OLLAMA_MODEL = os.getenv("OLLAMA_MODEL", "mistral")
+
+embeddings = OllamaEmbeddings(
+    model=OLLAMA_MODEL,
+    base_url=OLLAMA_URL
+)
+
+# Set up Discord client
+intents = discord.Intents.default()
+intents.message_content = True
+intents.members = True
+intents.presences = True
+client = discord.Client(intents=intents)
+
+current_model = None  # Track currently loaded model name
+
+KINDNESS_KEYWORDS = [
+    "thank you", "love you", "luv u", "you're the best", "so cute",
+    "adorable", "amazing", "sweet", "kind", "great job", "well done",
+    "precious", "good girl", "cutie", "angel", "my favorite", "so helpful"
+]
+HEART_REACTIONS = ["💙", "💝", "💖", "💕", "💜", "❤️‍🔥", "☺️"]
+kindness_reacted_messages = set()
+
+AUTO_MOOD = True
+CURRENT_MOOD = "neutral"
+AVAILABLE_MOODS = [
+    "bubbly", "sleepy", "curious", "shy", "serious", "excited",
+    "melancholy", "flirty", "romantic", "irritated", "angry", "neutral"
+]
+
+# Switch model
+async def switch_model(model_name: str, timeout: int = 600):
+    global current_model
+    if current_model == model_name:
+        print(f"🔁 Model '{model_name}' already loaded.")
+        return
+
+    # Unload all other models to clear VRAM
+    async with aiohttp.ClientSession() as session:
+        async with session.get(f"{OLLAMA_URL}/api/show") as resp:
+            if resp.status == 200:
+                data = await resp.json()
+                loaded_models = data.get("models", [])
+                for model in loaded_models:
+                    if model["name"] != model_name:
+                        print(f"🔁 Unloading model: {model['name']}")
+                        await session.post(f"{OLLAMA_URL}/api/stop", json={"name": model["name"]})
+            else:
+                print("⚠️ Failed to check currently loaded models.")
+
+    print(f"🔄 Switching to model '{model_name}'...")
+    async with aiohttp.ClientSession() as session:
+        await session.post(f"{OLLAMA_URL}/api/stop")
+    # Warm up the new model (dummy call to preload it)
+    payload = {
+        "model": model_name,
+        "prompt": "Hello",
+        "stream": False
+    }
+    headers = {"Content-Type": "application/json"}
+
+    # Poll until /api/generate returns 200
+    async with aiohttp.ClientSession() as session:
+        for _ in range(timeout):
+            async with session.post(f"{OLLAMA_URL}/api/generate", json=payload, headers=headers) as resp:
+                if resp.status == 200:
+                    current_model = model_name
+                    print(f"✅ Model {model_name} ready!")
+                    return
+            await asyncio.sleep(1)  # Wait a second before trying again
+
+    raise TimeoutError(f"Timed out waiting for model '{model_name}' to become available.")
+
+
+async def is_miku_addressed(message) -> bool:
+    # If message is a reply, check the referenced message author
+    if message.reference:
+        try:
+            referenced_msg = await message.channel.fetch_message(message.reference.message_id)
+            if referenced_msg.author == message.guild.me:  # or client.user if you use client
+                return True
+        except Exception as e:
+            print(f"⚠️ Could not fetch referenced message: {e}")
+
+    cleaned = message.content.strip()
+
+    return bool(re.search(
+        r'(?<![\w\(])(?:[^\w\s]{0,2}\s*)?miku(?:\s*[^\w\s]{0,2})?(?=,|\s*,|[!\.?\s]*$)',
+        cleaned,
+        re.IGNORECASE
+    ))
+
+def load_mood_description(mood_name: str) -> str:
+    path = os.path.join("moods", f"{mood_name}.txt")
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return f.read().strip()
+    except FileNotFoundError:
+        print(f"⚠️ Mood file '{mood_name}' not found. Falling back to default.")
+        return load_mood_description("neutral")
+
+# Detect mood cues from Miku's response
+def detect_mood_shift(response_text):
+    mood_keywords = {
+        "neutral": [
+            "okay", "sure", "alright", "i see", "understood", "hmm", 
+            "sounds good", "makes sense", "alrighty", "fine", "got it"
+        ],
+        "bubbly": [
+            "so excited", "feeling bubbly", "super cheerful", "yay!", "✨", "nya~",
+            "kyaa~", "heehee", "bouncy", "so much fun", "i’m glowing!", "nee~", "teehee", "I'm so happy"
+        ],
+        "sleepy": [
+            "i'm sleepy", "getting tired", "yawn", "so cozy", "zzz", "nap time",
+            "just five more minutes", "snooze", "cuddle up", "dozing off", "so warm"
+        ],
+        "curious": [
+            "i'm curious", "want to know more", "why?", "hmm?", "tell me more", "interesting!",
+            "what’s that?", "how does it work?", "i wonder", "fascinating", "??", "🧐"
+        ],
+        "shy": [
+            "um...", "sorry if that was weird", "i’m kind of shy", "eep", "i hope that’s okay", "i’m nervous",
+            "blushes", "oh no", "hiding face", "i don’t know what to say", "heh...", "/////"
+        ],
+        "serious": [
+            "let’s be serious", "focus on the topic", "this is important", "i mean it", "be honest",
+            "we need to talk", "listen carefully", "let’s not joke", "truthfully", "let’s be real"
+        ],
+        "excited": [
+            "OMG!", "this is amazing", "i’m so hyped", "YAY!!", "let’s go!", "incredible!!!",
+            "AHHH!", "best day ever", "this is it!", "totally pumped", "i can’t wait", "🔥🔥🔥", "i'm excited", "Wahaha"
+        ],
+        "melancholy": [
+            "feeling nostalgic", "kind of sad", "just thinking a lot", "like rain on glass", "memories",
+            "bittersweet", "sigh", "quiet day", "blue vibes", "longing", "melancholy", "softly"
+        ],
+        "flirty": [
+            "hey cutie", "aren’t you sweet", "teasing you~", "wink wink", "is that a blush?", "giggle~",
+            "come closer", "miss me?", "you like that, huh?", "🥰", "flirt mode activated", "you’re kinda cute"
+        ],
+        "romantic": [
+            "you mean a lot to me", "my heart", "i adore you", "so beautiful", "so close", "love letter",
+            "my dearest", "forever yours", "i’m falling for you", "sweetheart", "💖", "you're my everything"
+        ],
+        "irritated": [
+            "ugh", "seriously?", "can we not", "whatever", "i'm annoyed", "you don’t get it",
+            "rolling my eyes", "why do i even bother", "ugh, again?", "🙄", "don’t start", "this again?"
+        ],
+        "angry": [
+            "stop it", "enough!", "that’s not okay", "i’m mad", "i said no", "don’t push me",
+            "you crossed the line", "furious", "this is unacceptable", "😠", "i’m done", "don’t test me"
+        ]
+    }
+
+    for mood, phrases in mood_keywords.items():
+        for phrase in phrases:
+            if phrase.lower() in response_text.lower():
+                print(f"*️⃣ Mood keyword triggered: {phrase}")
+                return mood
+    return None
+
+@tasks.loop(hours=1)
+async def rotate_mood():
+    global CURRENT_MOOD
+
+    new_mood = CURRENT_MOOD
+    attempts = 0
+    while new_mood == CURRENT_MOOD and attempts < 5:
+        new_mood = random.choice(AVAILABLE_MOODS)
+        attempts += 1
+
+    CURRENT_MOOD = load_mood_description(new_mood)
+    print(f"⏰ Mood auto-rotated to: {new_mood}")
+
+async def download_and_encode_image(url):
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as resp:
+            if resp.status != 200:
+                return None
+            img_bytes = await resp.read()
+            return base64.b64encode(img_bytes).decode('utf-8')
+
+async def analyze_image_with_qwen(base64_img):
+    await switch_model("moondream")
+
+    payload = {
+        "model": "moondream",
+        "prompt": "Describe this image in detail.",
+        "images": [base64_img],
+        "stream": False
+    }
+
+    headers = {"Content-Type": "application/json"}
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(f"{OLLAMA_URL}/api/generate", json=payload, headers=headers) as response:
+            if response.status == 200:
+                data = await response.json()
+                return data.get("response", "No description.")
+            else:
+                return f"Error: {response.status}"
+
+async def rephrase_as_miku(qwen_output, user_prompt):
+    await switch_model(OLLAMA_MODEL)  # likely llama3
+
+    with open("miku_prompt.txt", "r", encoding="utf-8") as f:
+        system_prompt = f.read()
+
+    relevant_docs_lore = miku_vectorstore.similarity_search(qwen_output, k=3)
+    context = "\n\n".join([doc.page_content for doc in relevant_docs_lore])
+
+    full_prompt = (
+        f"{context}\n\n"
+        f"The user asked: \"{user_prompt}\"\n"
+        f"The image contains: \"{qwen_output}\"\n\n"
+        f"Respond like Miku: cheerful, helpful, and opinionated when asked.\n\n"
+        f"Miku is currently feeling: {CURRENT_MOOD}\n Please respond in a way that reflects this emotional tone.\n\n"
+        f"Miku:"
+    )
+
+    payload = {
+        "model": OLLAMA_MODEL,
+        "prompt": full_prompt,
+        "system": system_prompt,
+        "stream": False
+    }
+
+    headers = {"Content-Type": "application/json"}
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(f"{OLLAMA_URL}/api/generate", json=payload, headers=headers) as response:
+            if response.status == 200:
+                data = await response.json()
+                return data.get("response", "No response.")
+            else:
+                return f"Error: {response.status}"
+
+# Load and index once at startup
+def load_miku_knowledge():
+    with open("miku_lore.txt", "r", encoding="utf-8") as f:
+        text = f.read()
+
+    from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=520,
+        chunk_overlap=50,
+        separators=["\n\n", "\n", ".", "!", "?", ",", " ", ""]
+    )
+
+    docs = [Document(page_content=chunk) for chunk in text_splitter.split_text(text)]
+
+    vectorstore = FAISS.from_documents(docs, embeddings)
+    return vectorstore
+
+def load_miku_lyrics():
+    with open("miku_lyrics.txt", "r", encoding="utf-8") as f:
+        lyrics_text = f.read()
+
+    text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=50)
+    docs = [Document(page_content=chunk) for chunk in text_splitter.split_text(lyrics_text)]
+
+    vectorstore = FAISS.from_documents(docs, embeddings)
+    return vectorstore
+
+miku_vectorstore = load_miku_knowledge()
+miku_lyrics_vectorstore = load_miku_lyrics()
+
+async def query_ollama(user_prompt, user_id):
+    relevant_docs_lore = miku_vectorstore.similarity_search(user_prompt, k=3)
+    relevant_docs_lyrics = miku_lyrics_vectorstore.similarity_search(user_prompt, k=3)
+
+    context_lore = "\n".join([doc.page_content for doc in relevant_docs_lore])
+    context_lyrics = "\n".join([doc.page_content for doc in relevant_docs_lyrics])
+
+    combined_docs = relevant_docs_lore + relevant_docs_lyrics
+    context = "\n\n".join([doc.page_content for doc in combined_docs])
+
+    # Persona definition
+    with open("miku_prompt.txt", "r", encoding="utf-8") as f:
+        system_prompt = f.read()
+
+    # Build conversation history
+    history = conversation_history[user_id]
+    history_text = "\n".join([f"User: {u}\nMiku: {m}" for u, m in history])
+
+    global CURRENT_MOOD
+
+    # Combine prompt
+    full_prompt = (
+        f"{context_lore}\n\n{context_lyrics}\n\n"
+        f"{history_text}\nMiku is currently feeling: {CURRENT_MOOD}\nPlease respond in a way that reflects this emotional tone.\nUser: {user_prompt}\nMiku:"
+    )
+
+    headers = {'Content-Type': 'application/json'}
+    payload = {
+        "model": OLLAMA_MODEL,
+        "prompt": full_prompt,
+		"system": system_prompt,
+        "stream": False
+    }
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(f"{OLLAMA_URL}/api/generate", json=payload, headers=headers) as response:
+            if response.status == 200:
+                data = await response.json()
+                reply = data.get("response", "No response.")
+                # Save to conversation history
+                conversation_history[user_id].append((user_prompt, reply))
+                return reply
+            else:
+                return f"Error: {response.status}"
+
+async def send_monday_video():
+    await switch_model(OLLAMA_MODEL)
+
+    # Generate a motivational message
+    prompt = "It's Miku Monday! Give me an energetic and heartfelt Miku Monday morning message to inspire someone for the week ahead."
+    response = await query_ollama(prompt, user_id="weekly-motivation")
+
+    video_url = "http://zip.koko210cloud.xyz/u/zEgU7Z.mp4"
+
+    target_channel_ids = [
+        761014220707332107,
+        1140377617237807266
+    ]
+    
+    for channel_id in target_channel_ids:
+        channel = client.get_channel(channel_id)
+        if channel is None:
+            print(f"❌ Could not find channel with ID {channel_id}. Make sure the bot is in the server.")
+            return
+
+        try:
+            await channel.send(content=response)
+            # Send video link
+            await channel.send(f"[Happy Miku Monday!]({video_url})")
+
+            print(f"✅ Sent Monday video to channel ID {channel_id}")
+        except Exception as e:
+            print(f"⚠️ Failed to send video to channel ID {channel_id}: {e}")
+
+async def send_bedtime_reminder():
+    await switch_model(OLLAMA_MODEL)
+
+    for channel_id in BEDTIME_CHANNEL_IDS:
+        channel = client.get_channel(channel_id)
+        if not channel:
+            print(f"⚠️ Channel ID {channel_id} not found.")
+            continue
+
+        guild = channel.guild
+
+        # Filter online members (excluding bots)
+        online_members = [
+            member for member in guild.members
+            if member.status in {Status.online, Status.idle, Status.dnd}
+            and not member.bot
+        ]
+
+        specific_user_id = 214857593045254151 # target user ID
+        specific_user = guild.get_member(specific_user_id)
+        if specific_user and specific_user not in online_members:
+            online_members.append(specific_user)
+
+        if not online_members:
+            print(f"😴 No online members to ping in {guild.name}")
+            continue
+
+        chosen_one = random.choice(online_members)
+
+        # Generate bedtime message
+        prompt = (
+            f"Write a sweet, funny, or encouraging bedtime message to remind someone it's getting late and they should sleep. "
+            f"Make it short and wholesome, as if Miku is genuinely worried about their well-being. Imply that it's not good staying up so late."
+            f"Miku is currently feeling: {CURRENT_MOOD}\nPlease word in a way that reflects this emotional tone."
+        )
+        bedtime_message = await query_ollama(prompt, user_id="bedtime-miku")
+
+        try:
+            await channel.send(f"{chosen_one.mention}, {bedtime_message}")
+            print(f"🌙 Sent bedtime reminder to {chosen_one.display_name} in {guild.name}")
+        except Exception as e:
+            print(f"⚠️ Failed to send bedtime reminder in {guild.name}: {e}")
+
+def schedule_random_bedtime():
+    now = datetime.now()
+    target_time = now.replace(hour=20, minute=30, second=0, microsecond=0)
+    # If it's already past 23:30 today, schedule for tomorrow
+    if now > target_time:
+        target_time += timedelta(days=1)
+
+    # Add random offset (0–29 mins)
+    offset_minutes = random.randint(0, 29)
+    run_time = target_time + timedelta(minutes=offset_minutes)
+
+    scheduler.add_job(send_bedtime_reminder, trigger=DateTrigger(run_date=run_time))
+    print(f"⏰ Bedtime reminder scheduled for {run_time.strftime('%Y-%m-%d %H:%M:%S')}")
+
+async def overlay_username_with_ffmpeg(base_video_path, output_path, username):
+    font_path = "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"
+    text = f"@{username}"
+
+    # Define your six positions (x, y)
+    positions = {
+        1: ("250", "370"),
+        2: ("330", "130"),
+        3: ("300", "90"),
+        4: ("380", "180"),
+        5: ("365", "215"),
+        6: ("55", "365"),
+        7: ("290", "130"),
+        8: ("320", "210"),
+        9: ("310", "240"),
+        10: ("400", "240")
+    }
+
+    # Each entry: (start_time, end_time, position_index)
+    text_entries = [
+        (4.767, 5.367, 1, "username"),
+        (5.4, 5.967, 2, "username"),
+        (6.233, 6.833, 3, "username"),
+        (6.967, 7.6, 4, "username"),
+        (7.733, 8.367, 5, "username"),
+        (8.667, 9.133, 6, "username"),
+        (9.733, 10.667, 7, "username"),
+        (11.6, 12.033, 8, "@everyone"),
+        (12.067, 13.0, 9, "@everyone"),
+        (13.033, 14.135, 10, "@everyone"),
+    ]
+
+    # Build drawtext filters
+    drawtext_filters = []
+    for start, end, pos_id, text_type in text_entries:
+        x_coord, y_coord = positions[pos_id]
+
+        # Determine actual text content
+        text_content = f"@{username}" if text_type == "username" else text_type
+
+        x = f"{x_coord} - text_w/2"
+        y = f"{y_coord} - text_h/2"
+
+        filter_str = (
+            f"drawtext=text='{text_content}':"
+            f"fontfile='{font_path}':"
+            f"fontcolor=black:fontsize=30:x={x}:y={y}:"
+            f"enable='between(t,{start},{end})'"
+        )
+        drawtext_filters.append(filter_str)
+
+    vf_string = ",".join(drawtext_filters)
+
+    ffmpeg_command = [
+        "ffmpeg",
+        "-i", base_video_path,
+        "-vf", vf_string,
+        "-codec:a", "copy",
+        output_path
+    ]
+
+    try:
+        subprocess.run(ffmpeg_command, check=True)
+        print("✅ Video processed successfully with username overlays.")
+    except subprocess.CalledProcessError as e:
+        print(f"⚠️ FFmpeg error: {e}")
+
+async def detect_and_react_to_kindness(message, after_reply=False):
+    if message.id in kindness_reacted_messages:
+        return  # Already reacted — skip
+
+    content = message.content.lower()
+
+    emoji = random.choice(HEART_REACTIONS)
+
+    # 1. Keyword-based detection
+    if any(keyword in content for keyword in KINDNESS_KEYWORDS):
+        try:
+            await message.add_reaction(emoji)
+            kindness_reacted_messages.add(message.id)
+            message.kindness_reacted = True  # Mark as done
+            print("✅ Kindness detected via keywords. Reacted immediately.")
+        except Exception as e:
+            print(f"⚠️ Error adding reaction: {e}")
+        return
+
+    # 2. If not after_reply, defer model-based check
+    if not after_reply:
+        print("🗝️ No kindness via keywords. Deferring...")
+        return
+
+    # 3. Model-based detection
+    try:
+        prompt = (
+            "The following message was sent to Miku the bot. "
+            "Does it sound like the user is being kind or affectionate toward Miku? "
+            "Answer with 'yes' or 'no' only.\n\n"
+            f"Message: \"{message.content}\""
+        )
+        result = await query_ollama(prompt, user_id="kindness-check")
+
+        if result.strip().lower().startswith("yes"):
+            await message.add_reaction(emoji)
+            kindness_reacted_messages.add(message.id)
+            print("✅ Kindness detected via model. Reacted.")
+        else:
+            print("🧊 No kindness detected.")
+    except Exception as e:
+        print(f"⚠️ Error during kindness analysis: {e}")
+
+@client.event
+async def on_ready():
+    print(f'🎤 MikuBot connected as {client.user}')
+
+    # Change mood every 1 hour
+    rotate_mood.start()
+
+    # Schedule the weekly task (Monday 07:30)
+    scheduler.add_job(send_monday_video, 'cron', day_of_week='mon', hour=7, minute=30)
+
+    # Schedule first bedtime reminder
+    schedule_random_bedtime()
+    # Reschedule every midnight
+    scheduler.add_job(schedule_random_bedtime, 'cron', hour=0, minute=0)
+    #scheduler.add_job(send_bedtime_reminder, 'cron', hour=12, minute=22)
+
+    scheduler.start()
+
+@client.event
+async def on_message(message):
+    if message.author == client.user:
+        return
+        
+    if message.content.strip().lower() == "miku, rape this nigga balls" and message.reference:
+        async with message.channel.typing():
+            # Get replied-to user
+            try:
+                replied_msg = await message.channel.fetch_message(message.reference.message_id)
+                target_username = replied_msg.author.display_name
+
+                # Prepare video
+                base_video = "MikuMikuBeam.mp4"
+                output_video = f"/tmp/video_{''.join(random.choices(string.ascii_letters, k=5))}.mp4"
+
+                await overlay_username_with_ffmpeg(base_video, output_video, target_username)
+
+                caption = f"Here you go, @{target_username}! 🌟"
+                #await message.channel.send(content=caption, file=discord.File(output_video))
+                await replied_msg.reply(file=discord.File(output_video))
+
+            except Exception as e:
+                print(f"⚠️ Error processing video: {e}")
+                await message.channel.send("Sorry, something went wrong while generating the video.")
+            return
+
+
+    text = message.content.strip()
+    
+    global CURRENT_MOOD
+
+    if await is_miku_addressed(message):   
+ 
+        prompt = text  # No cleanup — keep it raw 
+        
+        # 1st kindness check with just keywords
+        if CURRENT_MOOD not in ["angry", "irritated"]:
+            await detect_and_react_to_kindness(message)
+
+        async with message.channel.typing():
+            # If message has an image attachment
+            if message.attachments:
+                for attachment in message.attachments:
+                    if any(attachment.filename.lower().endswith(ext) for ext in [".jpg", ".jpeg", ".png", ".webp"]):
+
+                        base64_img = await download_and_encode_image(attachment.url)
+                        if not base64_img:
+                            await message.channel.send("I couldn't load the image, sorry!")
+                            return
+					# Analyze image (objective description)
+                    qwen_description = await analyze_image_with_qwen(base64_img)
+                    miku_reply = await rephrase_as_miku(qwen_description, prompt)
+                    
+                    await message.channel.send(miku_reply)
+                    return
+
+            # If message is just a prompt, no image
+            response = await query_ollama(prompt, user_id=str(message.author.id))
+            
+            await message.channel.send(response)
+            
+        # 2nd kindness check (only if no keywords detected)
+        if CURRENT_MOOD not in ["angry", "irritated"]:
+            await detect_and_react_to_kindness(message, after_reply=True)
+
+    if message.content.lower().strip() == "!reset":
+        conversation_history[str(message.author.id)].clear()
+        await message.channel.send("Okay! Memory reset for you~ ✨")
+
+    # Manual Monday test command
+    if message.content.lower().strip() == "!monday":
+        await send_monday_video()
+        #await message.channel.send("✅ Monday message sent (or attempted). Check logs.")
+        return
+    
+    if message.content.startswith("!miku mood "):
+        new_mood = message.content.split("!miku mood ")[1].strip().lower()
+        path = os.path.join("moods", f"{new_mood}.txt")
+        if os.path.exists(path):
+            CURRENT_MOOD = load_mood_description(new_mood)
+            await message.channel.send(f"🌈 Miku's mood has been set to **{new_mood}**!")
+        else:
+            await message.channel.send("⚠️ I don't recognize that mood. Try again with a valid one.")
+        return
+
+    if message.content.strip().lower() == "!miku mood-reset":
+        CURRENT_MOOD = load_mood_description("neutral")
+        await message.channel.send("🔄 Miku’s mood has been reset to **neutral**.")
+        return
+    
+    if message.content.strip().lower() == "!miku mood-check":
+        await message.channel.send(f"☑️ Miku’s mood is currently {CURRENT_MOOD}.")
+   
+    if AUTO_MOOD and 'response' in locals():
+        detected = detect_mood_shift(response)
+        if detected and detected != CURRENT_MOOD:
+            CURRENT_MOOD = load_mood_description(detected)
+            print(f"🔄 Auto-updated mood to: {detected}")
+
+client.run(DISCORD_BOT_TOKEN)

bot/.bak.bot.py.260625-1

@@ -0,0 +1,728 @@
+import discord
+import aiohttp
+import asyncio
+import os
+import re
+import random
+import string
+
+import base64
+import subprocess
+import aiofiles
+
+from langchain_community.vectorstores import FAISS
+from langchain_ollama import OllamaEmbeddings
+from langchain.text_splitter import CharacterTextSplitter
+from langchain_community.docstore.document import Document
+
+from collections import defaultdict, deque
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from discord import File
+from discord import Status
+from discord.ext import tasks
+import datetime
+
+from apscheduler.triggers.date import DateTrigger
+from datetime import datetime, timedelta
+
+scheduler = AsyncIOScheduler()
+BEDTIME_CHANNEL_IDS = [761014220707332107]
+
+# Stores last 5 exchanges per user (as deque)
+conversation_history = defaultdict(lambda: deque(maxlen=5))
+
+DISCORD_BOT_TOKEN = os.getenv("DISCORD_BOT_TOKEN")
+OLLAMA_URL = os.getenv("OLLAMA_URL", "http://ollama:11434")
+OLLAMA_MODEL = os.getenv("OLLAMA_MODEL", "mistral")
+
+embeddings = OllamaEmbeddings(
+    model=OLLAMA_MODEL,
+    base_url=OLLAMA_URL
+)
+
+# Set up Discord client
+intents = discord.Intents.default()
+intents.message_content = True
+intents.members = True
+intents.presences = True
+client = discord.Client(intents=intents)
+
+current_model = None  # Track currently loaded model name
+
+KINDNESS_KEYWORDS = [
+    "thank you", "love you", "luv u", "you're the best", "so cute",
+    "adorable", "amazing", "sweet", "kind", "great job", "well done",
+    "precious", "good girl", "cutie", "angel", "my favorite", "so helpful"
+]
+HEART_REACTIONS = ["💙", "💝", "💖", "💕", "💜", "❤️‍🔥", "☺️"]
+kindness_reacted_messages = set()
+
+AUTO_MOOD = True
+CURRENT_MOOD = "neutral"
+CURRENT_MOOD_NAME = "neutral"
+PREVIOUS_MOOD_NAME = "neutral"
+IS_SLEEPING = False
+AVAILABLE_MOODS = [
+    "bubbly", "sleepy", "curious", "shy", "serious", "excited",
+    "melancholy", "flirty", "romantic", "irritated", "angry", "neutral"
+]
+
+# Switch model
+async def switch_model(model_name: str, timeout: int = 600):
+    global current_model
+    if current_model == model_name:
+        print(f"🔁 Model '{model_name}' already loaded.")
+        return
+
+    # Unload all other models to clear VRAM
+    async with aiohttp.ClientSession() as session:
+        async with session.get(f"{OLLAMA_URL}/api/show") as resp:
+            if resp.status == 200:
+                data = await resp.json()
+                loaded_models = data.get("models", [])
+                for model in loaded_models:
+                    if model["name"] != model_name:
+                        print(f"🔁 Unloading model: {model['name']}")
+                        await session.post(f"{OLLAMA_URL}/api/stop", json={"name": model["name"]})
+            else:
+                print("⚠️ Failed to check currently loaded models.")
+
+    print(f"🔄 Switching to model '{model_name}'...")
+    async with aiohttp.ClientSession() as session:
+        await session.post(f"{OLLAMA_URL}/api/stop")
+    # Warm up the new model (dummy call to preload it)
+    payload = {
+        "model": model_name,
+        "prompt": "Hello",
+        "stream": False
+    }
+    headers = {"Content-Type": "application/json"}
+
+    # Poll until /api/generate returns 200
+    async with aiohttp.ClientSession() as session:
+        for _ in range(timeout):
+            async with session.post(f"{OLLAMA_URL}/api/generate", json=payload, headers=headers) as resp:
+                if resp.status == 200:
+                    current_model = model_name
+                    print(f"✅ Model {model_name} ready!")
+                    return
+            await asyncio.sleep(1)  # Wait a second before trying again
+
+    raise TimeoutError(f"Timed out waiting for model '{model_name}' to become available.")
+
+
+async def is_miku_addressed(message) -> bool:
+    # If message is a reply, check the referenced message author
+    if message.reference:
+        try:
+            referenced_msg = await message.channel.fetch_message(message.reference.message_id)
+            if referenced_msg.author == message.guild.me:  # or client.user if you use client
+                return True
+        except Exception as e:
+            print(f"⚠️ Could not fetch referenced message: {e}")
+
+    cleaned = message.content.strip()
+
+    return bool(re.search(
+        r'(?<![\w\(])(?:[^\w\s]{0,2}\s*)?miku(?:\s*[^\w\s]{0,2})?(?=,|\s*,|[!\.?\s]*$)',
+        cleaned,
+        re.IGNORECASE
+    ))
+
+def load_mood_description(mood_name: str) -> str:
+    path = os.path.join("moods", f"{mood_name}.txt")
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return f.read().strip()
+    except FileNotFoundError:
+        print(f"⚠️ Mood file '{mood_name}' not found. Falling back to default.")
+        return load_mood_description("neutral")
+
+# Detect mood cues from Miku's response
+def detect_mood_shift(response_text):
+    mood_keywords = {
+        "neutral": [
+            "okay", "sure", "alright", "i see", "understood", "hmm", 
+            "sounds good", "makes sense", "alrighty", "fine", "got it"
+        ],
+        "bubbly": [
+            "so excited", "feeling bubbly", "super cheerful", "yay!", "✨", "nya~",
+            "kyaa~", "heehee", "bouncy", "so much fun", "i’m glowing!", "nee~", "teehee", "I'm so happy"
+        ],
+        "sleepy": [
+            "i'm sleepy", "getting tired", "yawn", "so cozy", "zzz", "nap time",
+            "just five more minutes", "snooze", "cuddle up", "dozing off", "so warm"
+        ],
+        "curious": [
+            "i'm curious", "want to know more", "why?", "hmm?", "tell me more", "interesting!",
+            "what’s that?", "how does it work?", "i wonder", "fascinating", "??", "🧐"
+        ],
+        "shy": [
+            "um...", "sorry if that was weird", "i’m kind of shy", "eep", "i hope that’s okay", "i’m nervous",
+            "blushes", "oh no", "hiding face", "i don’t know what to say", "heh...", "/////"
+        ],
+        "serious": [
+            "let’s be serious", "focus on the topic", "this is important", "i mean it", "be honest",
+            "we need to talk", "listen carefully", "let’s not joke", "truthfully", "let’s be real"
+        ],
+        "excited": [
+            "OMG!", "this is amazing", "i’m so hyped", "YAY!!", "let’s go!", "incredible!!!",
+            "AHHH!", "best day ever", "this is it!", "totally pumped", "i can’t wait", "🔥🔥🔥", "i'm excited", "Wahaha"
+        ],
+        "melancholy": [
+            "feeling nostalgic", "kind of sad", "just thinking a lot", "like rain on glass", "memories",
+            "bittersweet", "sigh", "quiet day", "blue vibes", "longing", "melancholy", "softly"
+        ],
+        "flirty": [
+            "hey cutie", "aren’t you sweet", "teasing you~", "wink wink", "is that a blush?", "giggle~",
+            "come closer", "miss me?", "you like that, huh?", "🥰", "flirt mode activated", "you’re kinda cute"
+        ],
+        "romantic": [
+            "you mean a lot to me", "my heart", "i adore you", "so beautiful", "so close", "love letter",
+            "my dearest", "forever yours", "i’m falling for you", "sweetheart", "💖", "you're my everything"
+        ],
+        "irritated": [
+            "ugh", "seriously?", "can we not", "whatever", "i'm annoyed", "you don’t get it",
+            "rolling my eyes", "why do i even bother", "ugh, again?", "🙄", "don’t start", "this again?"
+        ],
+        "angry": [
+            "stop it", "enough!", "that’s not okay", "i’m mad", "i said no", "don’t push me",
+            "you crossed the line", "furious", "this is unacceptable", "😠", "i’m done", "don’t test me"
+        ],
+        "asleep": [
+            "goodnight", "sweet dreams", "going to bed", "I will go to bed", "zzz~", "sleep tight"
+        ]
+    }
+
+    for mood, phrases in mood_keywords.items():
+        for phrase in phrases:
+            if mood == "asleep" and CURRENT_MOOD_NAME != "sleepy":
+               continue # Only allow transition to asleep from sleepy
+            if phrase.lower() in response_text.lower():
+                print(f"*️⃣ Mood keyword triggered: {phrase}")
+                return mood
+    return None
+
+async def set_sleep_state(sleeping: bool):
+    if sleeping:
+        await client.change_presence(status=discord.Status.invisible)
+        await client.user.edit(username="Hatsune Miku💤")
+        print("😴 Miku has gone to sleep.")
+    else:
+        await client.change_presence(status=discord.Status.online)
+        await client.user.edit(username="Hatsune Miku")
+        print("☀️ Miku woke up.")
+
+@tasks.loop(hours=1)
+async def rotate_mood():
+    global CURRENT_MOOD
+
+    new_mood = CURRENT_MOOD
+    attempts = 0
+    while new_mood == CURRENT_MOOD and attempts < 5:
+        new_mood = random.choice(AVAILABLE_MOODS)
+        attempts += 1
+
+    CURRENT_MOOD = load_mood_description(new_mood)
+    print(f"⏰ Mood auto-rotated to: {new_mood}")
+
+async def download_and_encode_image(url):
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as resp:
+            if resp.status != 200:
+                return None
+            img_bytes = await resp.read()
+            return base64.b64encode(img_bytes).decode('utf-8')
+
+async def analyze_image_with_qwen(base64_img):
+    await switch_model("moondream")
+
+    payload = {
+        "model": "moondream",
+        "prompt": "Describe this image in detail.",
+        "images": [base64_img],
+        "stream": False
+    }
+
+    headers = {"Content-Type": "application/json"}
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(f"{OLLAMA_URL}/api/generate", json=payload, headers=headers) as response:
+            if response.status == 200:
+                data = await response.json()
+                return data.get("response", "No description.")
+            else:
+                return f"Error: {response.status}"
+
+async def rephrase_as_miku(qwen_output, user_prompt):
+    await switch_model(OLLAMA_MODEL)  # likely llama3
+
+    with open("miku_prompt.txt", "r", encoding="utf-8") as f:
+        system_prompt = f.read()
+
+    relevant_docs_lore = miku_vectorstore.similarity_search(qwen_output, k=3)
+    context = "\n\n".join([doc.page_content for doc in relevant_docs_lore])
+
+    full_prompt = (
+        f"{context}\n\n"
+        f"The user asked: \"{user_prompt}\"\n"
+        f"The image contains: \"{qwen_output}\"\n\n"
+        f"Respond like Miku: cheerful, helpful, and opinionated when asked.\n\n"
+        f"Miku is currently feeling: {CURRENT_MOOD}\n Please respond in a way that reflects this emotional tone.\n\n"
+        f"Miku:"
+    )
+
+    payload = {
+        "model": OLLAMA_MODEL,
+        "prompt": full_prompt,
+        "system": system_prompt,
+        "stream": False
+    }
+
+    headers = {"Content-Type": "application/json"}
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(f"{OLLAMA_URL}/api/generate", json=payload, headers=headers) as response:
+            if response.status == 200:
+                data = await response.json()
+                return data.get("response", "No response.")
+            else:
+                return f"Error: {response.status}"
+
+# Load and index once at startup
+def load_miku_knowledge():
+    with open("miku_lore.txt", "r", encoding="utf-8") as f:
+        text = f.read()
+
+    from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=520,
+        chunk_overlap=50,
+        separators=["\n\n", "\n", ".", "!", "?", ",", " ", ""]
+    )
+
+    docs = [Document(page_content=chunk) for chunk in text_splitter.split_text(text)]
+
+    vectorstore = FAISS.from_documents(docs, embeddings)
+    return vectorstore
+
+def load_miku_lyrics():
+    with open("miku_lyrics.txt", "r", encoding="utf-8") as f:
+        lyrics_text = f.read()
+
+    text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=50)
+    docs = [Document(page_content=chunk) for chunk in text_splitter.split_text(lyrics_text)]
+
+    vectorstore = FAISS.from_documents(docs, embeddings)
+    return vectorstore
+
+miku_vectorstore = load_miku_knowledge()
+miku_lyrics_vectorstore = load_miku_lyrics()
+
+async def query_ollama(user_prompt, user_id):
+    relevant_docs_lore = miku_vectorstore.similarity_search(user_prompt, k=3)
+    relevant_docs_lyrics = miku_lyrics_vectorstore.similarity_search(user_prompt, k=3)
+
+    context_lore = "\n".join([doc.page_content for doc in relevant_docs_lore])
+    context_lyrics = "\n".join([doc.page_content for doc in relevant_docs_lyrics])
+
+    combined_docs = relevant_docs_lore + relevant_docs_lyrics
+    context = "\n\n".join([doc.page_content for doc in combined_docs])
+
+    # Persona definition
+    with open("miku_prompt.txt", "r", encoding="utf-8") as f:
+        system_prompt = f.read()
+
+    # Build conversation history
+    history = conversation_history[user_id]
+    history_text = "\n".join([f"User: {u}\nMiku: {m}" for u, m in history])
+
+    global CURRENT_MOOD
+
+    # Combine prompt
+    full_prompt = (
+        f"{context_lore}\n\n{context_lyrics}\n\n"
+        f"{history_text}\nMiku is currently feeling: {CURRENT_MOOD}\nPlease respond in a way that reflects this emotional tone.\nUser: {user_prompt}\nMiku:"
+    )
+
+    headers = {'Content-Type': 'application/json'}
+    payload = {
+        "model": OLLAMA_MODEL,
+        "prompt": full_prompt,
+		"system": system_prompt,
+        "stream": False
+    }
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(f"{OLLAMA_URL}/api/generate", json=payload, headers=headers) as response:
+            if response.status == 200:
+                data = await response.json()
+                reply = data.get("response", "No response.")
+                # Save to conversation history
+                conversation_history[user_id].append((user_prompt, reply))
+                return reply
+            else:
+                return f"Error: {response.status}"
+
+async def send_monday_video():
+    await switch_model(OLLAMA_MODEL)
+
+    # Generate a motivational message
+    prompt = "It's Miku Monday! Give me an energetic and heartfelt Miku Monday morning message to inspire someone for the week ahead."
+    response = await query_ollama(prompt, user_id="weekly-motivation")
+
+    video_url = "http://zip.koko210cloud.xyz/u/zEgU7Z.mp4"
+
+    target_channel_ids = [
+        761014220707332107,
+        1140377617237807266
+    ]
+    
+    for channel_id in target_channel_ids:
+        channel = client.get_channel(channel_id)
+        if channel is None:
+            print(f"❌ Could not find channel with ID {channel_id}. Make sure the bot is in the server.")
+            return
+
+        try:
+            await channel.send(content=response)
+            # Send video link
+            await channel.send(f"[Happy Miku Monday!]({video_url})")
+
+            print(f"✅ Sent Monday video to channel ID {channel_id}")
+        except Exception as e:
+            print(f"⚠️ Failed to send video to channel ID {channel_id}: {e}")
+
+async def send_bedtime_reminder():
+    await switch_model(OLLAMA_MODEL)
+
+    for channel_id in BEDTIME_CHANNEL_IDS:
+        channel = client.get_channel(channel_id)
+        if not channel:
+            print(f"⚠️ Channel ID {channel_id} not found.")
+            continue
+
+        guild = channel.guild
+
+        # Filter online members (excluding bots)
+        online_members = [
+            member for member in guild.members
+            if member.status in {Status.online, Status.idle, Status.dnd}
+            and not member.bot
+        ]
+
+        specific_user_id = 214857593045254151 # target user ID
+        specific_user = guild.get_member(specific_user_id)
+        if specific_user and specific_user not in online_members:
+            online_members.append(specific_user)
+
+        if not online_members:
+            print(f"😴 No online members to ping in {guild.name}")
+            continue
+
+        chosen_one = random.choice(online_members)
+
+        # Generate bedtime message
+        prompt = (
+            f"Write a sweet, funny, or encouraging bedtime message to remind someone it's getting late and they should sleep. "
+            f"Make it short and wholesome, as if Miku is genuinely worried about their well-being. Imply that it's not good staying up so late."
+            f"Miku is currently feeling: {CURRENT_MOOD}\nPlease word in a way that reflects this emotional tone."
+        )
+        bedtime_message = await query_ollama(prompt, user_id="bedtime-miku")
+
+        try:
+            await channel.send(f"{chosen_one.mention}, {bedtime_message}")
+            print(f"🌙 Sent bedtime reminder to {chosen_one.display_name} in {guild.name}")
+        except Exception as e:
+            print(f"⚠️ Failed to send bedtime reminder in {guild.name}: {e}")
+
+def schedule_random_bedtime():
+    now = datetime.now()
+    target_time = now.replace(hour=20, minute=30, second=0, microsecond=0)
+    # If it's already past 23:30 today, schedule for tomorrow
+    if now > target_time:
+        target_time += timedelta(days=1)
+
+    # Add random offset (0–29 mins)
+    offset_minutes = random.randint(0, 29)
+    run_time = target_time + timedelta(minutes=offset_minutes)
+
+    scheduler.add_job(send_bedtime_reminder, trigger=DateTrigger(run_date=run_time))
+    print(f"⏰ Bedtime reminder scheduled for {run_time.strftime('%Y-%m-%d %H:%M:%S')}")
+
+async def overlay_username_with_ffmpeg(base_video_path, output_path, username):
+    font_path = "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"
+    text = f"@{username}"
+
+    # Define your six positions (x, y)
+    positions = {
+        1: ("250", "370"),
+        2: ("330", "130"),
+        3: ("300", "90"),
+        4: ("380", "180"),
+        5: ("365", "215"),
+        6: ("55", "365"),
+        7: ("290", "130"),
+        8: ("320", "210"),
+        9: ("310", "240"),
+        10: ("400", "240")
+    }
+
+    # Each entry: (start_time, end_time, position_index)
+    text_entries = [
+        (4.767, 5.367, 1, "username"),
+        (5.4, 5.967, 2, "username"),
+        (6.233, 6.833, 3, "username"),
+        (6.967, 7.6, 4, "username"),
+        (7.733, 8.367, 5, "username"),
+        (8.667, 9.133, 6, "username"),
+        (9.733, 10.667, 7, "username"),
+        (11.6, 12.033, 8, "@everyone"),
+        (12.067, 13.0, 9, "@everyone"),
+        (13.033, 14.135, 10, "@everyone"),
+    ]
+
+    # Build drawtext filters
+    drawtext_filters = []
+    for start, end, pos_id, text_type in text_entries:
+        x_coord, y_coord = positions[pos_id]
+
+        # Determine actual text content
+        text_content = f"@{username}" if text_type == "username" else text_type
+
+        x = f"{x_coord} - text_w/2"
+        y = f"{y_coord} - text_h/2"
+
+        filter_str = (
+            f"drawtext=text='{text_content}':"
+            f"fontfile='{font_path}':"
+            f"fontcolor=black:fontsize=30:x={x}:y={y}:"
+            f"enable='between(t,{start},{end})'"
+        )
+        drawtext_filters.append(filter_str)
+
+    vf_string = ",".join(drawtext_filters)
+
+    ffmpeg_command = [
+        "ffmpeg",
+        "-i", base_video_path,
+        "-vf", vf_string,
+        "-codec:a", "copy",
+        output_path
+    ]
+
+    try:
+        subprocess.run(ffmpeg_command, check=True)
+        print("✅ Video processed successfully with username overlays.")
+    except subprocess.CalledProcessError as e:
+        print(f"⚠️ FFmpeg error: {e}")
+
+async def detect_and_react_to_kindness(message, after_reply=False):
+    if message.id in kindness_reacted_messages:
+        return  # Already reacted — skip
+
+    content = message.content.lower()
+
+    emoji = random.choice(HEART_REACTIONS)
+
+    # 1. Keyword-based detection
+    if any(keyword in content for keyword in KINDNESS_KEYWORDS):
+        try:
+            await message.add_reaction(emoji)
+            kindness_reacted_messages.add(message.id)
+            message.kindness_reacted = True  # Mark as done
+            print("✅ Kindness detected via keywords. Reacted immediately.")
+        except Exception as e:
+            print(f"⚠️ Error adding reaction: {e}")
+        return
+
+    # 2. If not after_reply, defer model-based check
+    if not after_reply:
+        print("🗝️ No kindness via keywords. Deferring...")
+        return
+
+    # 3. Model-based detection
+    try:
+        prompt = (
+            "The following message was sent to Miku the bot. "
+            "Does it sound like the user is being kind or affectionate toward Miku? "
+            "Answer with 'yes' or 'no' only.\n\n"
+            f"Message: \"{message.content}\""
+        )
+        result = await query_ollama(prompt, user_id="kindness-check")
+
+        if result.strip().lower().startswith("yes"):
+            await message.add_reaction(emoji)
+            kindness_reacted_messages.add(message.id)
+            print("✅ Kindness detected via model. Reacted.")
+        else:
+            print("🧊 No kindness detected.")
+    except Exception as e:
+        print(f"⚠️ Error during kindness analysis: {e}")
+
+@client.event
+async def on_ready():
+    print(f'🎤 MikuBot connected as {client.user}')
+
+    # Change mood every 1 hour
+    rotate_mood.start()
+
+    # Schedule the weekly task (Monday 07:30)
+    scheduler.add_job(send_monday_video, 'cron', day_of_week='mon', hour=7, minute=30)
+
+    # Schedule first bedtime reminder
+    schedule_random_bedtime()
+    # Reschedule every midnight
+    scheduler.add_job(schedule_random_bedtime, 'cron', hour=0, minute=0)
+    #scheduler.add_job(send_bedtime_reminder, 'cron', hour=12, minute=22)
+
+    scheduler.start()
+
+@client.event
+async def on_message(message):
+    if message.author == client.user:
+        return
+        
+    if message.content.strip().lower() == "miku, rape this nigga balls" and message.reference:
+        async with message.channel.typing():
+            # Get replied-to user
+            try:
+                replied_msg = await message.channel.fetch_message(message.reference.message_id)
+                target_username = replied_msg.author.display_name
+
+                # Prepare video
+                base_video = "MikuMikuBeam.mp4"
+                output_video = f"/tmp/video_{''.join(random.choices(string.ascii_letters, k=5))}.mp4"
+
+                await overlay_username_with_ffmpeg(base_video, output_video, target_username)
+
+                caption = f"Here you go, @{target_username}! 🌟"
+                #await message.channel.send(content=caption, file=discord.File(output_video))
+                await replied_msg.reply(file=discord.File(output_video))
+
+            except Exception as e:
+                print(f"⚠️ Error processing video: {e}")
+                await message.channel.send("Sorry, something went wrong while generating the video.")
+            return
+
+
+    text = message.content.strip()
+    
+    global CURRENT_MOOD, CURRENT_MOOD_NAME, PREVIOUS_MOOD_NAME, IS_SLEEPING
+
+    if await is_miku_addressed(message):
+
+        if IS_SLEEPING:
+           await message.channel.send("💤 Miku is currently sleeping and can't talk right now. Try again later~")
+           return   
+ 
+        prompt = text  # No cleanup — keep it raw 
+        
+        # 1st kindness check with just keywords
+        if CURRENT_MOOD not in ["angry", "irritated"]:
+            await detect_and_react_to_kindness(message)
+
+        async with message.channel.typing():
+            # If message has an image attachment
+            if message.attachments:
+                for attachment in message.attachments:
+                    if any(attachment.filename.lower().endswith(ext) for ext in [".jpg", ".jpeg", ".png", ".webp"]):
+
+                        base64_img = await download_and_encode_image(attachment.url)
+                        if not base64_img:
+                            await message.channel.send("I couldn't load the image, sorry!")
+                            return
+					# Analyze image (objective description)
+                    qwen_description = await analyze_image_with_qwen(base64_img)
+                    miku_reply = await rephrase_as_miku(qwen_description, prompt)
+                    
+                    await message.channel.send(miku_reply)
+                    return
+
+            # If message is just a prompt, no image
+            response = await query_ollama(prompt, user_id=str(message.author.id))
+            
+            await message.channel.send(response)
+            
+        # 2nd kindness check (only if no keywords detected)
+        if CURRENT_MOOD not in ["angry", "irritated"]:
+            await detect_and_react_to_kindness(message, after_reply=True)
+
+    if message.content.lower().strip() == "!reset":
+        conversation_history[str(message.author.id)].clear()
+        await message.channel.send("Okay! Memory reset for you~ ✨")
+
+    # Manual Monday test command
+    if message.content.lower().strip() == "!monday":
+        await send_monday_video()
+        #await message.channel.send("✅ Monday message sent (or attempted). Check logs.")
+        return
+    
+    if message.content.startswith("!miku mood "):
+        new_mood = message.content.split("!miku mood ")[1].strip().lower()
+        path = os.path.join("moods", f"{new_mood}.txt")
+        if os.path.exists(path):
+            CURRENT_MOOD = load_mood_description(new_mood)
+            await message.channel.send(f"🌈 Miku's mood has been set to **{new_mood}**!")
+        else:
+            await message.channel.send("⚠️ I don't recognize that mood. Try again with a valid one.")
+        return
+
+    if message.content.strip().lower() == "!miku mood-reset":
+        CURRENT_MOOD = load_mood_description("neutral")
+        await message.channel.send("🔄 Miku’s mood has been reset to **neutral**.")
+        return
+    
+    if message.content.strip().lower() == "!miku mood-check":
+        await message.channel.send(f"☑️ Miku’s mood is currently {CURRENT_MOOD}.")
+   
+    if AUTO_MOOD and 'response' in locals():
+        detected = detect_mood_shift(response)
+        if detected and detected != CURRENT_MOOD_NAME:
+
+            # Block direct transitions to asleep unless from sleepy
+            if detected == "asleep" and CURRENT_MOOD_NAME != "sleepy":
+                print("❌ Ignoring asleep mood; Miku wasn't sleepy before.")
+            else:
+                PREVIOUS_MOOD_NAME = CURRENT_MOOD_NAME
+                CURRENT_MOOD_NAME = detected
+                CURRENT_MOOD = load_mood_description(detected)
+                print(f"🔄 Auto-updated mood to: {detected}")
+
+            if detected == "asleep":
+                IS_SLEEPING = True
+                await set_sleep_state(True)
+                await asyncio.sleep(3600) # 1 hour
+                IS_SLEEPING = False
+                await set_sleep_state(False)
+                CURRENT_MOOD_NAME = "neutral"
+                CURRENT_MOOD = load_mood_description("neutral")
+
+    if message.content.lower().strip() == "!miku sleep" and CURRENT_MOOD_NAME == "sleepy":
+        CURRENT_MOOD_NAME = "asleep"
+        CURRENT_MOOD = load_mood_description("asleep")
+        PREVIOUS_MOOD_NAME = "sleepy"
+        IS_SLEEPING = True
+        await message.channel.send("Yaaawn... Okay... Goodnight~ 💫")
+        await set_sleep_state(True)
+        await asyncio.sleep(3600)
+        IS_SLEEPING = False
+        await set_sleep_state(False)
+        CURRENT_MOOD_NAME = "neutral"
+        CURRENT_MOOD = load_mood_description("neutral")
+        return
+
+    if message.content.lower().strip() == "!miku wake" and CURRENT_MOOD_NAME == "asleep":
+        CURRENT_MOOD_NAME = "neutral"
+        CURRENT_MOOD = load_mood_description("neutral")
+        PREVIOUS_MOOD_NAME = "asleep"
+        IS_SLEEPING = False
+        await message.channel.send("Rise and shine, good morning! 🌞")
+        await set_sleep_state(False)
+        return
+
+                
+
+client.run(DISCORD_BOT_TOKEN)

bot/.bak.bot.py.260625-2

@@ -0,0 +1,656 @@
+import discord
+import aiohttp
+import asyncio
+import os
+import re
+import random
+import string
+
+import base64
+import subprocess
+import aiofiles
+
+from commands import handle_command
+from utils import load_mood_description
+import globals
+
+from langchain_community.vectorstores import FAISS
+from langchain_ollama import OllamaEmbeddings
+from langchain.text_splitter import CharacterTextSplitter
+from langchain_community.docstore.document import Document
+
+from collections import defaultdict, deque
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from discord import File
+from discord import Status
+from discord.ext import tasks
+import datetime
+
+from apscheduler.triggers.date import DateTrigger
+from datetime import datetime, timedelta
+
+scheduler = AsyncIOScheduler()
+
+# Switch model
+async def switch_model(model_name: str, timeout: int = 600):
+    if globals.current_model == model_name:
+        print(f"🔁 Model '{model_name}' already loaded.")
+        return
+
+    # Unload all other models to clear VRAM
+    async with aiohttp.ClientSession() as session:
+        async with session.get(f"{globals.OLLAMA_URL}/api/show") as resp:
+            if resp.status == 200:
+                data = await resp.json()
+                loaded_models = data.get("models", [])
+                for model in loaded_models:
+                    if model["name"] != model_name:
+                        print(f"🔁 Unloading model: {model['name']}")
+                        await session.post(f"{globals.OLLAMA_URL}/api/stop", json={"name": model["name"]})
+            else:
+                print("⚠️ Failed to check currently loaded models.")
+
+    print(f"🔄 Switching to model '{model_name}'...")
+    async with aiohttp.ClientSession() as session:
+        await session.post(f"{globals.OLLAMA_URL}/api/stop")
+    # Warm up the new model (dummy call to preload it)
+    payload = {
+        "model": model_name,
+        "prompt": "Hello",
+        "stream": False
+    }
+    headers = {"Content-Type": "application/json"}
+
+    # Poll until /api/generate returns 200
+    async with aiohttp.ClientSession() as session:
+        for _ in range(timeout):
+            async with session.post(f"{globals.OLLAMA_URL}/api/generate", json=payload, headers=headers) as resp:
+                if resp.status == 200:
+                    globals.current_model = model_name
+                    print(f"✅ Model {model_name} ready!")
+                    return
+            await asyncio.sleep(1)  # Wait a second before trying again
+
+    raise TimeoutError(f"Timed out waiting for model '{model_name}' to become available.")
+
+
+async def is_miku_addressed(message) -> bool:
+    # If message is a reply, check the referenced message author
+    if message.reference:
+        try:
+            referenced_msg = await message.channel.fetch_message(message.reference.message_id)
+            if referenced_msg.author == message.guild.me:  # or globals.client.user if you use client
+                return True
+        except Exception as e:
+            print(f"⚠️ Could not fetch referenced message: {e}")
+
+    cleaned = message.content.strip()
+
+    return bool(re.search(
+        r'(?<![\w\(])(?:[^\w\s]{0,2}\s*)?miku(?:\s*[^\w\s]{0,2})?(?=,|\s*,|[!\.?\s]*$)',
+        cleaned,
+        re.IGNORECASE
+    ))
+
+# Detect mood cues from Miku's response
+def detect_mood_shift(response_text):
+    mood_keywords = {
+        "asleep": [
+            "good night", "goodnight", "sweet dreams", "going to bed", "I will go to bed", "zzz~", "sleep tight"
+        ],
+        "neutral": [
+            "okay", "sure", "alright", "i see", "understood", "hmm", 
+            "sounds good", "makes sense", "alrighty", "fine", "got it"
+        ],
+        "bubbly": [
+            "so excited", "feeling bubbly", "super cheerful", "yay!", "✨", "nya~",
+            "kyaa~", "heehee", "bouncy", "so much fun", "i’m glowing!", "nee~", "teehee", "I'm so happy"
+        ],
+        "sleepy": [
+            "i'm sleepy", "getting tired", "yawn", "so cozy", "zzz", "nap time",
+            "just five more minutes", "snooze", "cuddle up", "dozing off", "so warm"
+        ],
+        "curious": [
+            "i'm curious", "want to know more", "why?", "hmm?", "tell me more", "interesting!",
+            "what’s that?", "how does it work?", "i wonder", "fascinating", "??", "🧐"
+        ],
+        "shy": [
+            "um...", "sorry if that was weird", "i’m kind of shy", "eep", "i hope that’s okay", "i’m nervous",
+            "blushes", "oh no", "hiding face", "i don’t know what to say", "heh...", "/////"
+        ],
+        "serious": [
+            "let’s be serious", "focus on the topic", "this is important", "i mean it", "be honest",
+            "we need to talk", "listen carefully", "let’s not joke", "truthfully", "let’s be real"
+        ],
+        "excited": [
+            "OMG!", "this is amazing", "i’m so hyped", "YAY!!", "let’s go!", "incredible!!!",
+            "AHHH!", "best day ever", "this is it!", "totally pumped", "i can’t wait", "🔥🔥🔥", "i'm excited", "Wahaha"
+        ],
+        "melancholy": [
+            "feeling nostalgic", "kind of sad", "just thinking a lot", "like rain on glass", "memories",
+            "bittersweet", "sigh", "quiet day", "blue vibes", "longing", "melancholy", "softly"
+        ],
+        "flirty": [
+            "hey cutie", "aren’t you sweet", "teasing you~", "wink wink", "is that a blush?", "giggle~",
+            "come closer", "miss me?", "you like that, huh?", "🥰", "flirt mode activated", "you’re kinda cute"
+        ],
+        "romantic": [
+            "you mean a lot to me", "my heart", "i adore you", "so beautiful", "so close", "love letter",
+            "my dearest", "forever yours", "i’m falling for you", "sweetheart", "💖", "you're my everything"
+        ],
+        "irritated": [
+            "ugh", "seriously?", "can we not", "whatever", "i'm annoyed", "you don’t get it",
+            "rolling my eyes", "why do i even bother", "ugh, again?", "🙄", "don’t start", "this again?"
+        ],
+        "angry": [
+            "stop it", "enough!", "that’s not okay", "i’m mad", "i said no", "don’t push me",
+            "you crossed the line", "furious", "this is unacceptable", "😠", "i’m done", "don’t test me"
+        ]
+    }
+
+    for mood, phrases in mood_keywords.items():
+        if mood == "asleep" and globals.CURRENT_MOOD_NAME != "sleepy":
+               print(f"❎ Mood 'asleep' skipped - mood isn't 'sleepy', it's '{globals.CURRENT_MOOD_NAME}'")
+               continue # Only allow transition to asleep from sleepy
+        
+        for phrase in phrases:
+            if phrase.lower() in response_text.lower():
+                print(f"*️⃣ Mood keyword triggered: {phrase}")
+                return mood
+    return None
+
+async def set_sleep_state(sleeping: bool):
+    for guild in globals.client.guilds:
+        me = guild.get_member(globals.BOT_USER.id)
+        if me is not None:
+            try:
+                nickname = "Hatsune Miku💤" if sleeping else "Hatsune Miku"
+                await me.edit(nick=nickname)
+                await globals.client.change_presence(status=discord.Status.invisible) if sleeping else await globals.client.change_presence(status=discord.Status.online)
+            except discord.Forbidden:
+                print("⚠️ Missing permission to change nickname in guild:", guild.name)
+            except discord.HTTPException as e:
+                print("⚠️ Failed to change nickname:", e)
+
+@tasks.loop(hours=1)
+async def rotate_mood():
+    new_mood = globals.CURRENT_MOOD
+    attempts = 0
+    while new_mood == globals.CURRENT_MOOD and attempts < 5:
+        new_mood = random.choice(globals.AVAILABLE_MOODS)
+        attempts += 1
+
+    globals.CURRENT_MOOD = load_mood_description(new_mood)
+    print(f"⏰ Mood auto-rotated to: {new_mood}")
+
+async def download_and_encode_image(url):
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as resp:
+            if resp.status != 200:
+                return None
+            img_bytes = await resp.read()
+            return base64.b64encode(img_bytes).decode('utf-8')
+
+async def analyze_image_with_qwen(base64_img):
+    await switch_model("moondream")
+
+    payload = {
+        "model": "moondream",
+        "prompt": "Describe this image in detail.",
+        "images": [base64_img],
+        "stream": False
+    }
+
+    headers = {"Content-Type": "application/json"}
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(f"{globals.OLLAMA_URL}/api/generate", json=payload, headers=headers) as response:
+            if response.status == 200:
+                data = await response.json()
+                return data.get("response", "No description.")
+            else:
+                return f"Error: {response.status}"
+
+async def rephrase_as_miku(qwen_output, user_prompt):
+    await switch_model(globals.OLLAMA_MODEL)  # likely llama3
+
+    with open("miku_prompt.txt", "r", encoding="utf-8") as f:
+        system_prompt = f.read()
+
+    relevant_docs_lore = miku_vectorstore.similarity_search(qwen_output, k=3)
+    context = "\n\n".join([doc.page_content for doc in relevant_docs_lore])
+
+    full_prompt = (
+        f"{context}\n\n"
+        f"The user asked: \"{user_prompt}\"\n"
+        f"The image contains: \"{qwen_output}\"\n\n"
+        f"Respond like Miku: cheerful, helpful, and opinionated when asked.\n\n"
+        f"Miku is currently feeling: {globals.CURRENT_MOOD}\n Please respond in a way that reflects this emotional tone.\n\n"
+        f"Miku:"
+    )
+
+    payload = {
+        "model": globals.OLLAMA_MODEL,
+        "prompt": full_prompt,
+        "system": system_prompt,
+        "stream": False
+    }
+
+    headers = {"Content-Type": "application/json"}
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(f"{globals.OLLAMA_URL}/api/generate", json=payload, headers=headers) as response:
+            if response.status == 200:
+                data = await response.json()
+                return data.get("response", "No response.")
+            else:
+                return f"Error: {response.status}"
+
+# Load and index once at startup
+def load_miku_knowledge():
+    with open("miku_lore.txt", "r", encoding="utf-8") as f:
+        text = f.read()
+
+    from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=520,
+        chunk_overlap=50,
+        separators=["\n\n", "\n", ".", "!", "?", ",", " ", ""]
+    )
+
+    docs = [Document(page_content=chunk) for chunk in text_splitter.split_text(text)]
+
+    vectorstore = FAISS.from_documents(docs, globals.embeddings)
+    return vectorstore
+
+def load_miku_lyrics():
+    with open("miku_lyrics.txt", "r", encoding="utf-8") as f:
+        lyrics_text = f.read()
+
+    text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=50)
+    docs = [Document(page_content=chunk) for chunk in text_splitter.split_text(lyrics_text)]
+
+    vectorstore = FAISS.from_documents(docs, globals.embeddings)
+    return vectorstore
+
+miku_vectorstore = load_miku_knowledge()
+miku_lyrics_vectorstore = load_miku_lyrics()
+
+async def query_ollama(user_prompt, user_id):
+    relevant_docs_lore = miku_vectorstore.similarity_search(user_prompt, k=3)
+    relevant_docs_lyrics = miku_lyrics_vectorstore.similarity_search(user_prompt, k=3)
+
+    context_lore = "\n".join([doc.page_content for doc in relevant_docs_lore])
+    context_lyrics = "\n".join([doc.page_content for doc in relevant_docs_lyrics])
+
+    combined_docs = relevant_docs_lore + relevant_docs_lyrics
+    context = "\n\n".join([doc.page_content for doc in combined_docs])
+
+    # Persona definition
+    with open("miku_prompt.txt", "r", encoding="utf-8") as f:
+        system_prompt = f.read()
+
+    # Build conversation history
+    history = globals.conversation_history[user_id]
+    history_text = "\n".join([f"User: {u}\nMiku: {m}" for u, m in history])
+
+    # Combine prompt
+    full_prompt = (
+        f"{context_lore}\n\n{context_lyrics}\n\n"
+        f"{history_text}\nMiku is currently feeling: {globals.CURRENT_MOOD}\nPlease respond in a way that reflects this emotional tone.\nUser: {user_prompt}\nMiku:"
+    )
+
+    headers = {'Content-Type': 'application/json'}
+    payload = {
+        "model": globals.OLLAMA_MODEL,
+        "prompt": full_prompt,
+		"system": system_prompt,
+        "stream": False
+    }
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(f"{globals.OLLAMA_URL}/api/generate", json=payload, headers=headers) as response:
+            if response.status == 200:
+                data = await response.json()
+                reply = data.get("response", "No response.")
+                # Save to conversation history
+                globals.conversation_history[user_id].append((user_prompt, reply))
+                return reply
+            else:
+                return f"Error: {response.status}"
+
+async def send_monday_video():
+    await switch_model(globals.OLLAMA_MODEL)
+
+    # Generate a motivational message
+    prompt = "It's Miku Monday! Give me an energetic and heartfelt Miku Monday morning message to inspire someone for the week ahead."
+    response = await query_ollama(prompt, user_id="weekly-motivation")
+
+    video_url = "http://zip.koko210cloud.xyz/u/zEgU7Z.mp4"
+
+    target_channel_ids = [
+        761014220707332107,
+        1140377617237807266
+    ]
+    
+    for channel_id in target_channel_ids:
+        channel = globals.client.get_channel(channel_id)
+        if channel is None:
+            print(f"❌ Could not find channel with ID {channel_id}. Make sure the bot is in the server.")
+            return
+
+        try:
+            await channel.send(content=response)
+            # Send video link
+            await channel.send(f"[Happy Miku Monday!]({video_url})")
+
+            print(f"✅ Sent Monday video to channel ID {channel_id}")
+        except Exception as e:
+            print(f"⚠️ Failed to send video to channel ID {channel_id}: {e}")
+
+async def send_bedtime_reminder():
+    await switch_model(globals.OLLAMA_MODEL)
+
+    for channel_id in globals.BEDTIME_CHANNEL_IDS:
+        channel = globals.client.get_channel(channel_id)
+        if not channel:
+            print(f"⚠️ Channel ID {channel_id} not found.")
+            continue
+
+        guild = channel.guild
+
+        # Filter online members (excluding bots)
+        online_members = [
+            member for member in guild.members
+            if member.status in {Status.online, Status.idle, Status.dnd}
+            and not member.bot
+        ]
+
+        specific_user_id = 214857593045254151 # target user ID
+        specific_user = guild.get_member(specific_user_id)
+        if specific_user and specific_user not in online_members:
+            online_members.append(specific_user)
+
+        if not online_members:
+            print(f"😴 No online members to ping in {guild.name}")
+            continue
+
+        chosen_one = random.choice(online_members)
+
+        # Generate bedtime message
+        prompt = (
+            f"Write a sweet, funny, or encouraging bedtime message to remind someone it's getting late and they should sleep. "
+            f"Make it short and wholesome, as if Miku is genuinely worried about their well-being. Imply that it's not good staying up so late."
+            f"Miku is currently feeling: {globals.CURRENT_MOOD}\nPlease word in a way that reflects this emotional tone."
+        )
+        bedtime_message = await query_ollama(prompt, user_id="bedtime-miku")
+
+        try:
+            await channel.send(f"{chosen_one.mention}, {bedtime_message}")
+            print(f"🌙 Sent bedtime reminder to {chosen_one.display_name} in {guild.name}")
+        except Exception as e:
+            print(f"⚠️ Failed to send bedtime reminder in {guild.name}: {e}")
+
+def schedule_random_bedtime():
+    now = datetime.now()
+    target_time = now.replace(hour=20, minute=30, second=0, microsecond=0)
+    # If it's already past 23:30 today, schedule for tomorrow
+    if now > target_time:
+        target_time += timedelta(days=1)
+
+    # Add random offset (0–29 mins)
+    offset_minutes = random.randint(0, 29)
+    run_time = target_time + timedelta(minutes=offset_minutes)
+
+    scheduler.add_job(send_bedtime_reminder, trigger=DateTrigger(run_date=run_time))
+    print(f"⏰ Bedtime reminder scheduled for {run_time.strftime('%Y-%m-%d %H:%M:%S')}")
+
+async def overlay_username_with_ffmpeg(base_video_path, output_path, username):
+    font_path = "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"
+    text = f"@{username}"
+
+    # Define your six positions (x, y)
+    positions = {
+        1: ("250", "370"),
+        2: ("330", "130"),
+        3: ("300", "90"),
+        4: ("380", "180"),
+        5: ("365", "215"),
+        6: ("55", "365"),
+        7: ("290", "130"),
+        8: ("320", "210"),
+        9: ("310", "240"),
+        10: ("400", "240")
+    }
+
+    # Each entry: (start_time, end_time, position_index)
+    text_entries = [
+        (4.767, 5.367, 1, "username"),
+        (5.4, 5.967, 2, "username"),
+        (6.233, 6.833, 3, "username"),
+        (6.967, 7.6, 4, "username"),
+        (7.733, 8.367, 5, "username"),
+        (8.667, 9.133, 6, "username"),
+        (9.733, 10.667, 7, "username"),
+        (11.6, 12.033, 8, "@everyone"),
+        (12.067, 13.0, 9, "@everyone"),
+        (13.033, 14.135, 10, "@everyone"),
+    ]
+
+    # Build drawtext filters
+    drawtext_filters = []
+    for start, end, pos_id, text_type in text_entries:
+        x_coord, y_coord = positions[pos_id]
+
+        # Determine actual text content
+        text_content = f"@{username}" if text_type == "username" else text_type
+
+        x = f"{x_coord} - text_w/2"
+        y = f"{y_coord} - text_h/2"
+
+        filter_str = (
+            f"drawtext=text='{text_content}':"
+            f"fontfile='{font_path}':"
+            f"fontcolor=black:fontsize=30:x={x}:y={y}:"
+            f"enable='between(t,{start},{end})'"
+        )
+        drawtext_filters.append(filter_str)
+
+    vf_string = ",".join(drawtext_filters)
+
+    ffmpeg_command = [
+        "ffmpeg",
+        "-i", base_video_path,
+        "-vf", vf_string,
+        "-codec:a", "copy",
+        output_path
+    ]
+
+    try:
+        subprocess.run(ffmpeg_command, check=True)
+        print("✅ Video processed successfully with username overlays.")
+    except subprocess.CalledProcessError as e:
+        print(f"⚠️ FFmpeg error: {e}")
+
+async def detect_and_react_to_kindness(message, after_reply=False):
+    if message.id in globals.kindness_reacted_messages:
+        return  # Already reacted — skip
+
+    content = message.content.lower()
+
+    emoji = random.choice(globals.HEART_REACTIONS)
+
+    # 1. Keyword-based detection
+    if any(keyword in content for keyword in globals.KINDNESS_KEYWORDS):
+        try:
+            await message.add_reaction(emoji)
+            globals.kindness_reacted_messages.add(message.id)
+            message.kindness_reacted = True  # Mark as done
+            print("✅ Kindness detected via keywords. Reacted immediately.")
+        except Exception as e:
+            print(f"⚠️ Error adding reaction: {e}")
+        return
+
+    # 2. If not after_reply, defer model-based check
+    if not after_reply:
+        print("🗝️ No kindness via keywords. Deferring...")
+        return
+
+    # 3. Model-based detection
+    try:
+        prompt = (
+            "The following message was sent to Miku the bot. "
+            "Does it sound like the user is being kind or affectionate toward Miku? "
+            "Answer with 'yes' or 'no' only.\n\n"
+            f"Message: \"{message.content}\""
+        )
+        result = await query_ollama(prompt, user_id="kindness-check")
+
+        if result.strip().lower().startswith("yes"):
+            await message.add_reaction(emoji)
+            globals.kindness_reacted_messages.add(message.id)
+            print("✅ Kindness detected via model. Reacted.")
+        else:
+            print("🧊 No kindness detected.")
+    except Exception as e:
+        print(f"⚠️ Error during kindness analysis: {e}")
+
+@globals.client.event
+async def on_ready():
+    print(f'🎤 MikuBot connected as {globals.client.user}')
+
+    globals.BOT_USER = globals.client.user
+
+    # Change mood every 1 hour
+    rotate_mood.start()
+
+    # Schedule the weekly task (Monday 07:30)
+    scheduler.add_job(send_monday_video, 'cron', day_of_week='mon', hour=7, minute=30)
+
+    # Schedule first bedtime reminder
+    schedule_random_bedtime()
+    # Reschedule every midnight
+    scheduler.add_job(schedule_random_bedtime, 'cron', hour=0, minute=0)
+    #scheduler.add_job(send_bedtime_reminder, 'cron', hour=12, minute=22)
+
+    scheduler.start()
+
+@globals.client.event
+async def on_message(message):
+    if message.author == globals.client.user:
+        return
+       
+    handled, globals.CURRENT_MOOD_NAME, globals.CURRENT_MOOD, globals.PREVIOUS_MOOD_NAME, globals.IS_SLEEPING = await handle_command(
+        message,
+        set_sleep_state
+    )
+
+    if message.content.strip().lower() == "miku, rape this nigga balls" and message.reference:
+        async with message.channel.typing():
+            # Get replied-to user
+            try:
+                replied_msg = await message.channel.fetch_message(message.reference.message_id)
+                target_username = replied_msg.author.display_name
+
+                # Prepare video
+                base_video = "MikuMikuBeam.mp4"
+                output_video = f"/tmp/video_{''.join(random.choices(string.ascii_letters, k=5))}.mp4"
+
+                await overlay_username_with_ffmpeg(base_video, output_video, target_username)
+
+                caption = f"Here you go, @{target_username}! 🌟"
+                #await message.channel.send(content=caption, file=discord.File(output_video))
+                await replied_msg.reply(file=discord.File(output_video))
+
+            except Exception as e:
+                print(f"⚠️ Error processing video: {e}")
+                await message.channel.send("Sorry, something went wrong while generating the video.")
+            return
+
+    text = message.content.strip()
+
+    if await is_miku_addressed(message):
+
+        if globals.IS_SLEEPING:
+            if random.random() < 1/3:  # ⅓ chance
+                sleep_talk_lines = [
+                    "mnnn... five more minutes... zzz...",
+                    "nya... d-don't tickle me there... mm~",
+                    "zz... nyaa~ pancakes flying... eep...",
+                    "so warm... stay close... zzz...",
+                    "huh...? is it morning...? nooo... \*rolls over*",
+                    "\*mumbles* pink clouds... and pudding... heehee...",
+                    "\*softly snores* zzz... nyuu... mmh..."
+                ]
+                response = random.choice(sleep_talk_lines)
+                await message.channel.typing()
+                await asyncio.sleep(random.uniform(1.5, 3.0))  # random delay before replying
+                await message.channel.send(response)
+            else:
+                # No response at all
+                print("😴 Miku is asleep and didn't respond.")
+            return  # Skip any further message handling
+ 
+        prompt = text  # No cleanup — keep it raw 
+        
+        # 1st kindness check with just keywords
+        if globals.CURRENT_MOOD not in ["angry", "irritated"]:
+            await detect_and_react_to_kindness(message)
+
+        async with message.channel.typing():
+            # If message has an image attachment
+            if message.attachments:
+                for attachment in message.attachments:
+                    if any(attachment.filename.lower().endswith(ext) for ext in [".jpg", ".jpeg", ".png", ".webp"]):
+
+                        base64_img = await download_and_encode_image(attachment.url)
+                        if not base64_img:
+                            await message.channel.send("I couldn't load the image, sorry!")
+                            return
+					# Analyze image (objective description)
+                    qwen_description = await analyze_image_with_qwen(base64_img)
+                    miku_reply = await rephrase_as_miku(qwen_description, prompt)
+                    
+                    await message.channel.send(miku_reply)
+                    return
+
+            # If message is just a prompt, no image
+            response = await query_ollama(prompt, user_id=str(message.author.id))
+            
+            await message.channel.send(response)
+            
+        # 2nd kindness check (only if no keywords detected)
+        if globals.CURRENT_MOOD not in ["angry", "irritated"]:
+            await detect_and_react_to_kindness(message, after_reply=True)
+
+    # Manual Monday test command
+    if message.content.lower().strip() == "!monday":
+        await send_monday_video()
+        #await message.channel.send("✅ Monday message sent (or attempted). Check logs.")
+        return
+    
+    if globals.AUTO_MOOD and 'response' in locals():
+        detected = detect_mood_shift(response)
+        if detected and detected != globals.CURRENT_MOOD_NAME:
+
+            # Block direct transitions to asleep unless from sleepy
+            if detected == "asleep" and globals.CURRENT_MOOD_NAME != "sleepy":
+                print("❌ Ignoring asleep mood; Miku wasn't sleepy before.")
+            else:
+                globals.PREVIOUS_MOOD_NAME = globals.CURRENT_MOOD_NAME
+                globals.CURRENT_MOOD_NAME = detected
+                globals.CURRENT_MOOD = load_mood_description(detected)
+                print(f"🔄 Auto-updated mood to: {detected}")
+
+            if detected == "asleep":
+                globals.IS_SLEEPING = True
+                await set_sleep_state(True)
+                await asyncio.sleep(3600) # 1 hour
+                globals.IS_SLEEPING = False
+                await set_sleep_state(False)
+                globals.CURRENT_MOOD_NAME = "neutral"
+                globals.CURRENT_MOOD = load_mood_description("neutral")
+
+globals.client.run(globals.DISCORD_BOT_TOKEN)

bot/.bak.miku_lore.txt

@@ -0,0 +1,19 @@
+Hatsune Miku is a virtual singer created by Crypton Future Media, using Yamaha's Vocaloid voice synthesizer. She debuted in 2007.
+
+Her character design includes long turquoise twin-tails, a futuristic outfit, and an energetic personality. She is forever 16 years old and very popular in the anime and otaku communities.
+
+Miku’s favorite food is green onion (negi). She often appears with a leek in fan art and videos.
+
+Popular Hatsune Miku songs include:
+- World is Mine (tsundere princess theme)
+- PoPiPo (vegetable juice chaos)
+- Tell Your World (emotional connection through music)
+- Senbonzakura (historical + modern fusion)
+- Melt (shy crush vibes)
+- The Disappearance of Hatsune Miku (fast, intense vocals)
+
+Miku has performed concerts around the world as a hologram.
+
+She’s the face of countless fan creations — music, art, games, and more.
+
+Miku sometimes refers to herself in third person and ends messages with emojis like 🎶💙🌱.

bot/Dockerfile

@@ -0,0 +1,38 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+RUN playwright install
+
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    libxcomposite1 \
+    libxdamage1 \
+    libgtk-3-0 \
+    libgdk3.0-cil \
+    libatk1.0-0 \
+ && apt-get clean \
+ && rm -rf /var/lib/apt/lists/*
+
+COPY bot.py .
+COPY server_manager.py .
+COPY command_router.py .
+COPY utils /app/utils
+COPY commands /app/commands
+COPY memory /app/memory
+COPY static /app/static
+COPY globals.py .
+COPY api.py .
+COPY api_main.py .
+COPY miku_lore.txt .
+COPY miku_prompt.txt .
+COPY miku_lyrics.txt .
+COPY MikuMikuBeam.mp4 .
+COPY Miku_BasicWorkflow.json .
+COPY moods /app/moods/
+
+CMD ["python", "-u", "bot.py"]

bot/Miku_BasicWorkflow.json

@@ -0,0 +1,691 @@
+{
+    "16": {
+      "inputs": {
+        "stop_at_clip_layer": -2,
+        "clip": [
+          "224",
+          1
+        ]
+      },
+      "class_type": "CLIPSetLastLayer",
+      "_meta": {
+        "title": "CLIP Set Last Layer"
+      }
+    },
+    "20": {
+      "inputs": {
+        "value": 896
+      },
+      "class_type": "easy int",
+      "_meta": {
+        "title": "Width"
+      }
+    },
+    "21": {
+      "inputs": {
+        "value": 1152
+      },
+      "class_type": "easy int",
+      "_meta": {
+        "title": "Height"
+      }
+    },
+    "22": {
+      "inputs": {
+        "width": [
+          "20",
+          0
+        ],
+        "height": [
+          "21",
+          0
+        ],
+        "batch_size": [
+          "393",
+          0
+        ]
+      },
+      "class_type": "EmptyLatentImage",
+      "_meta": {
+        "title": "Empty Latent Image"
+      }
+    },
+    "27": {
+      "inputs": {
+        "value": 34
+      },
+      "class_type": "easy int",
+      "_meta": {
+        "title": "Steps"
+      }
+    },
+    "38": {
+      "inputs": {
+        "samples": [
+          "392",
+          0
+        ],
+        "vae": [
+          "398",
+          0
+        ]
+      },
+      "class_type": "VAEDecode",
+      "_meta": {
+        "title": "VAE Decode"
+      }
+    },
+    "137": {
+      "inputs": {
+        "color_space": "LAB",
+        "luminance_factor": 1.0000000000000002,
+        "color_intensity_factor": 1.0400000000000003,
+        "fade_factor": 1,
+        "neutralization_factor": 0,
+        "device": "auto",
+        "image": [
+          "138",
+          0
+        ],
+        "reference": [
+          "138",
+          0
+        ]
+      },
+      "class_type": "ImageColorMatchAdobe+",
+      "_meta": {
+        "title": "🔧 Image Color Match Adobe"
+      }
+    },
+    "138": {
+      "inputs": {
+        "color_space": "LAB",
+        "luminance_factor": 1.0000000000000002,
+        "color_intensity_factor": 1.0200000000000002,
+        "fade_factor": 1,
+        "neutralization_factor": 0,
+        "device": "auto",
+        "image": [
+          "38",
+          0
+        ],
+        "reference": [
+          "38",
+          0
+        ]
+      },
+      "class_type": "ImageColorMatchAdobe+",
+      "_meta": {
+        "title": "🔧 Image Color Match Adobe"
+      }
+    },
+    "140": {
+      "inputs": {
+        "value": 6
+      },
+      "class_type": "PrimitiveFloat",
+      "_meta": {
+        "title": "CFG Value"
+      }
+    },
+    "144": {
+      "inputs": {
+        "rgthree_comparer": {
+          "images": [
+            {
+              "name": "A1",
+              "selected": true,
+              "url": "/api/view?filename=rgthree.compare._temp_iqsvc_00001_.png&type=temp&subfolder=&rand=0.6020392402088258"
+            },
+            {
+              "name": "A2",
+              "selected": false,
+              "url": "/api/view?filename=rgthree.compare._temp_iqsvc_00002_.png&type=temp&subfolder=&rand=0.19118890617396123"
+            },
+            {
+              "name": "A3",
+              "selected": false,
+              "url": "/api/view?filename=rgthree.compare._temp_iqsvc_00003_.png&type=temp&subfolder=&rand=0.7852874384619147"
+            },
+            {
+              "name": "A4",
+              "selected": false,
+              "url": "/api/view?filename=rgthree.compare._temp_iqsvc_00004_.png&type=temp&subfolder=&rand=0.9289304724958654"
+            },
+            {
+              "name": "A5",
+              "selected": false,
+              "url": "/api/view?filename=rgthree.compare._temp_iqsvc_00005_.png&type=temp&subfolder=&rand=0.6365026204131798"
+            },
+            {
+              "name": "B1",
+              "selected": true,
+              "url": "/api/view?filename=rgthree.compare._temp_iqsvc_00006_.png&type=temp&subfolder=&rand=0.12584960907742848"
+            },
+            {
+              "name": "B2",
+              "selected": false,
+              "url": "/api/view?filename=rgthree.compare._temp_iqsvc_00007_.png&type=temp&subfolder=&rand=0.7724463393049524"
+            },
+            {
+              "name": "B3",
+              "selected": false,
+              "url": "/api/view?filename=rgthree.compare._temp_iqsvc_00008_.png&type=temp&subfolder=&rand=0.6701792360080928"
+            },
+            {
+              "name": "B4",
+              "selected": false,
+              "url": "/api/view?filename=rgthree.compare._temp_iqsvc_00009_.png&type=temp&subfolder=&rand=0.3763945043189808"
+            },
+            {
+              "name": "B5",
+              "selected": false,
+              "url": "/api/view?filename=rgthree.compare._temp_iqsvc_00010_.png&type=temp&subfolder=&rand=0.06091786130186927"
+            }
+          ]
+        },
+        "image_a": [
+          "38",
+          0
+        ],
+        "image_b": [
+          "38",
+          0
+        ]
+      },
+      "class_type": "Image Comparer (rgthree)",
+      "_meta": {
+        "title": "Image HandDetailer"
+      }
+    },
+    "155": {
+      "inputs": {
+        "rgthree_comparer": {
+          "images": [
+            {
+              "name": "A1",
+              "selected": true,
+              "url": "/api/view?filename=rgthree.compare._temp_vfotn_00001_.png&type=temp&subfolder=&rand=0.625405147029456"
+            },
+            {
+              "name": "A2",
+              "selected": false,
+              "url": "/api/view?filename=rgthree.compare._temp_vfotn_00002_.png&type=temp&subfolder=&rand=0.276730425875378"
+            },
+            {
+              "name": "A3",
+              "selected": false,
+              "url": "/api/view?filename=rgthree.compare._temp_vfotn_00003_.png&type=temp&subfolder=&rand=0.5071843931681015"
+            },
+            {
+              "name": "A4",
+              "selected": false,
+              "url": "/api/view?filename=rgthree.compare._temp_vfotn_00004_.png&type=temp&subfolder=&rand=0.1794944194810968"
+            },
+            {
+              "name": "A5",
+              "selected": false,
+              "url": "/api/view?filename=rgthree.compare._temp_vfotn_00005_.png&type=temp&subfolder=&rand=0.7442361813067035"
+            },
+            {
+              "name": "B1",
+              "selected": true,
+              "url": "/api/view?filename=rgthree.compare._temp_vfotn_00006_.png&type=temp&subfolder=&rand=0.7086112030497455"
+            },
+            {
+              "name": "B2",
+              "selected": false,
+              "url": "/api/view?filename=rgthree.compare._temp_vfotn_00007_.png&type=temp&subfolder=&rand=0.4405222287568358"
+            },
+            {
+              "name": "B3",
+              "selected": false,
+              "url": "/api/view?filename=rgthree.compare._temp_vfotn_00008_.png&type=temp&subfolder=&rand=0.2551707791681499"
+            },
+            {
+              "name": "B4",
+              "selected": false,
+              "url": "/api/view?filename=rgthree.compare._temp_vfotn_00009_.png&type=temp&subfolder=&rand=0.03131346828758852"
+            },
+            {
+              "name": "B5",
+              "selected": false,
+              "url": "/api/view?filename=rgthree.compare._temp_vfotn_00010_.png&type=temp&subfolder=&rand=0.1482114706860148"
+            }
+          ]
+        },
+        "image_a": [
+          "38",
+          0
+        ],
+        "image_b": [
+          "38",
+          0
+        ]
+      },
+      "class_type": "Image Comparer (rgthree)",
+      "_meta": {
+        "title": "Image BodyDetailer"
+      }
+    },
+    "156": {
+      "inputs": {
+        "rgthree_comparer": {
+          "images": [
+            {
+              "name": "A",
+              "selected": true,
+              "url": "/api/view?filename=rgthree.compare._temp_mudtp_00007_.png&type=temp&subfolder=&rand=0.8497926531382699"
+            },
+            {
+              "name": "B",
+              "selected": true,
+              "url": "/api/view?filename=rgthree.compare._temp_mudtp_00008_.png&type=temp&subfolder=&rand=0.02557656665190977"
+            }
+          ]
+        },
+        "image_a": [
+          "38",
+          0
+        ],
+        "image_b": [
+          "38",
+          0
+        ]
+      },
+      "class_type": "Image Comparer (rgthree)",
+      "_meta": {
+        "title": "Image NSFWDetailer"
+      }
+    },
+    "157": {
+      "inputs": {
+        "rgthree_comparer": {
+          "images": [
+            {
+              "name": "A",
+              "selected": true,
+              "url": "/api/view?filename=rgthree.compare._temp_xrbjz_00007_.png&type=temp&subfolder=&rand=0.6533048782146484"
+            },
+            {
+              "name": "B",
+              "selected": true,
+              "url": "/api/view?filename=rgthree.compare._temp_xrbjz_00008_.png&type=temp&subfolder=&rand=0.0031973565576119967"
+            }
+          ]
+        },
+        "image_a": [
+          "38",
+          0
+        ],
+        "image_b": [
+          "38",
+          0
+        ]
+      },
+      "class_type": "Image Comparer (rgthree)",
+      "_meta": {
+        "title": "Image FaceDetailer"
+      }
+    },
+    "158": {
+      "inputs": {
+        "rgthree_comparer": {
+          "images": [
+            {
+              "name": "A",
+              "selected": true,
+              "url": "/api/view?filename=rgthree.compare._temp_dbjlo_00007_.png&type=temp&subfolder=&rand=0.8312984181157523"
+            },
+            {
+              "name": "B",
+              "selected": true,
+              "url": "/api/view?filename=rgthree.compare._temp_dbjlo_00008_.png&type=temp&subfolder=&rand=0.4340761323533734"
+            }
+          ]
+        },
+        "image_a": [
+          "38",
+          0
+        ],
+        "image_b": [
+          "38",
+          0
+        ]
+      },
+      "class_type": "Image Comparer (rgthree)",
+      "_meta": {
+        "title": "Image EyesDetailer"
+      }
+    },
+    "164": {
+      "inputs": {
+        "seed": -1
+      },
+      "class_type": "Seed (rgthree)",
+      "_meta": {
+        "title": "Seed (rgthree)"
+      }
+    },
+    "220": {
+      "inputs": {
+        "text": "hassakuXLIllustrious_v13StyleA.safetensors",
+        "anything": [
+          "223",
+          0
+        ]
+      },
+      "class_type": "easy showAnything",
+      "_meta": {
+        "title": "Show Any"
+      }
+    },
+    "223": {
+      "inputs": {
+        "ckpt_name": "hassakuXLIllustrious_v13StyleA.safetensors"
+      },
+      "class_type": "easy ckptNames",
+      "_meta": {
+        "title": "Ckpt Names"
+      }
+    },
+    "224": {
+      "inputs": {
+        "ckpt_name": [
+          "223",
+          0
+        ]
+      },
+      "class_type": "CheckpointLoaderSimple",
+      "_meta": {
+        "title": "Load Checkpoint"
+      }
+    },
+    "304": {
+      "inputs": {
+        "wildcard_text": "(worst quality, low quality:1.3),lowres,monochrome,bad anatomy,bad hands,missing fingers,extra digit,fat,extra arms,extra hands,fewer digits,blurry,artist name,signature,watermark,EasyNegative,",
+        "populated_text": "(worst quality, low quality:1.3),lowres,monochrome,bad anatomy,bad hands,missing fingers,extra digit,fat,extra arms,extra hands,fewer digits,blurry,artist name,signature,watermark,EasyNegative,",
+        "mode": "populate",
+        "Select to add LoRA": "Select the LoRA to add to the text",
+        "Select to add Wildcard": "Select the Wildcard to add to the text",
+        "seed": [
+          "164",
+          0
+        ],
+        "model": [
+          "305",
+          0
+        ],
+        "clip": [
+          "305",
+          1
+        ]
+      },
+      "class_type": "ImpactWildcardEncode",
+      "_meta": {
+        "title": "NEGATIVE"
+      }
+    },
+    "305": {
+      "inputs": {
+        "wildcard_text": "(masterpiece),best quality,amazing quality,very aesthetic,absurdres,newest,perfect body,shiny skin,perfect eyes,detail1eye,anime style,1girl,solo,smile,blush,hatsune miku,absurdly long hair,aqua hair,twintails,hair ornament,hair between eyes,parted bangs,aqua eyes,white shirt,collared shirt,bare shoulders,sleeveless shirt,aqua necktie,detached sleeves,black sleeves,shoulder tattoo,fringe,black thighhighs,miniskirt,pleated skirt,zettai ryouiki,thigh boots,_POSITIVEPROMPT_<lora:Hatsune Miku(voc)-Illus-Remake:2>",
+        "populated_text": "(masterpiece),best quality,amazing quality,very aesthetic,absurdres,newest,perfect body,shiny skin,perfect eyes,detail1eye,anime style,1girl,solo,smile,blush,hatsune miku,absurdly long hair,aqua hair,twintails,hair ornament,hair between eyes,parted bangs,aqua eyes,white shirt,collared shirt,bare shoulders,sleeveless shirt,aqua necktie,detached sleeves,black sleeves,shoulder tattoo,fringe,black thighhighs,miniskirt,pleated skirt,zettai ryouiki,thigh boots,_POSITIVEPROMPT_<lora:Hatsune Miku(voc)-Illus-Remake:2>",
+        "mode": "populate",
+        "Select to add LoRA": "Select the LoRA to add to the text",
+        "Select to add Wildcard": "Select the Wildcard to add to the text",
+        "seed": [
+          "164",
+          0
+        ],
+        "model": [
+          "224",
+          0
+        ],
+        "clip": [
+          "16",
+          0
+        ]
+      },
+      "class_type": "ImpactWildcardEncode",
+      "_meta": {
+        "title": "POSITIVE"
+      }
+    },
+    "351": {
+      "inputs": {
+        "wildcard": "",
+        "Select to add LoRA": "Select the LoRA to add to the text",
+        "Select to add Wildcard": "Select the Wildcard to add to the text",
+        "model": [
+          "304",
+          0
+        ],
+        "clip": [
+          "304",
+          1
+        ],
+        "vae": [
+          "398",
+          0
+        ],
+        "positive": [
+          "305",
+          2
+        ],
+        "negative": [
+          "304",
+          2
+        ],
+        "bbox_detector": [
+          "364",
+          0
+        ]
+      },
+      "class_type": "ToDetailerPipe",
+      "_meta": {
+        "title": "ToDetailerPipe"
+      }
+    },
+    "364": {
+      "inputs": {
+        "model_name": "bbox/hand_yolov8s.pt"
+      },
+      "class_type": "UltralyticsDetectorProvider",
+      "_meta": {
+        "title": "DetectorProvider"
+      }
+    },
+    "379": {
+      "inputs": {
+        "text": "dpmpp_2m_sde",
+        "anything": [
+          "402",
+          1
+        ]
+      },
+      "class_type": "easy showAnything",
+      "_meta": {
+        "title": "Show Any"
+      }
+    },
+    "380": {
+      "inputs": {
+        "text": "karras",
+        "anything": [
+          "401",
+          1
+        ]
+      },
+      "class_type": "easy showAnything",
+      "_meta": {
+        "title": "Show Any"
+      }
+    },
+    "392": {
+      "inputs": {
+        "seed": [
+          "164",
+          0
+        ],
+        "steps": [
+          "27",
+          0
+        ],
+        "cfg": [
+          "140",
+          0
+        ],
+        "sampler_name": [
+          "379",
+          0
+        ],
+        "scheduler": [
+          "380",
+          0
+        ],
+        "denoise": 1,
+        "model": [
+          "304",
+          0
+        ],
+        "positive": [
+          "305",
+          2
+        ],
+        "negative": [
+          "304",
+          2
+        ],
+        "latent_image": [
+          "22",
+          0
+        ]
+      },
+      "class_type": "KSampler",
+      "_meta": {
+        "title": "KSampler"
+      }
+    },
+    "393": {
+      "inputs": {
+        "value": 1
+      },
+      "class_type": "easy int",
+      "_meta": {
+        "title": "Batch Size"
+      }
+    },
+    "396": {
+      "inputs": {
+        "value": 1
+      },
+      "class_type": "PrimitiveInt",
+      "_meta": {
+        "title": "Int"
+      }
+    },
+    "398": {
+      "inputs": {
+        "select": [
+          "396",
+          0
+        ],
+        "sel_mode": false,
+        "input1": [
+          "224",
+          2
+        ]
+      },
+      "class_type": "ImpactSwitch",
+      "_meta": {
+        "title": "Switch (Any)"
+      }
+    },
+    "400": {
+      "inputs": {
+        "filename": "%time_%basemodelname_%seed",
+        "path": "",
+        "extension": "png",
+        "steps": [
+          "27",
+          0
+        ],
+        "cfg": [
+          "140",
+          0
+        ],
+        "modelname": [
+          "223",
+          0
+        ],
+        "sampler_name": [
+          "379",
+          0
+        ],
+        "scheduler_name": [
+          "380",
+          0
+        ],
+        "positive": [
+          "305",
+          3
+        ],
+        "negative": [
+          "304",
+          3
+        ],
+        "seed_value": [
+          "164",
+          0
+        ],
+        "width": [
+          "20",
+          0
+        ],
+        "height": [
+          "21",
+          0
+        ],
+        "lossless_webp": true,
+        "quality_jpeg_or_webp": 100,
+        "optimize_png": false,
+        "counter": 0,
+        "denoise": 1,
+        "clip_skip": 2,
+        "time_format": "%Y-%m-%d-%H%M%S",
+        "save_workflow_as_json": false,
+        "embed_workflow": true,
+        "additional_hashes": "",
+        "download_civitai_data": true,
+        "easy_remix": true,
+        "show_preview": true,
+        "custom": "",
+        "images": [
+          "138",
+          0
+        ]
+      },
+      "class_type": "Image Saver",
+      "_meta": {
+        "title": "Image Saver"
+      }
+    },
+    "401": {
+      "inputs": {
+        "scheduler": "karras"
+      },
+      "class_type": "Scheduler Selector (Image Saver)",
+      "_meta": {
+        "title": "Scheduler Selector (Image Saver)"
+      }
+    },
+    "402": {
+      "inputs": {
+        "sampler_name": "dpmpp_2m_sde"
+      },
+      "class_type": "Sampler Selector (Image Saver)",
+      "_meta": {
+        "title": "Sampler Selector (Image Saver)"
+      }
+    }
+  }  

bot/api_main.py

@@ -0,0 +1,4 @@
+import uvicorn
+
+if __name__ == "__main__":
+        uvicorn.run("api:app", host="0.0.0.0", port=3939, reload=True)

bot/bot.py

@@ -0,0 +1,643 @@
+import discord
+import asyncio
+import threading
+import uvicorn
+import logging
+import sys
+import random
+import string
+import signal
+import atexit
+from api import app
+
+from server_manager import server_manager
+from utils.scheduled import (
+    send_monday_video
+)
+from utils.image_handling import (
+    download_and_encode_image,
+    download_and_encode_media,
+    extract_video_frames,
+    analyze_image_with_qwen,
+    analyze_video_with_vision,
+    rephrase_as_miku,
+    extract_tenor_gif_url,
+    convert_gif_to_mp4,
+    extract_embed_content
+)
+from utils.core import (
+    is_miku_addressed,
+)
+from utils.moods import (
+    detect_mood_shift
+)
+from utils.media import(
+    overlay_username_with_ffmpeg
+)
+from utils.llm import query_ollama
+from utils.autonomous import (
+    setup_autonomous_speaking, 
+    load_last_sent_tweets,
+    # V2 imports
+    on_message_event,
+    on_presence_update as autonomous_presence_update,
+    on_member_join as autonomous_member_join,
+    initialize_v2_system
+)
+from utils.dm_logger import dm_logger
+from utils.dm_interaction_analyzer import init_dm_analyzer
+
+import globals
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s: %(message)s",
+    handlers=[
+        logging.FileHandler("bot.log", mode='a', encoding='utf-8'),
+        logging.StreamHandler(sys.stdout)  # Optional: see logs in stdout too
+    ],
+    force=True  # Override previous configs
+)
+
+@globals.client.event
+async def on_ready():
+    print(f'🎤 MikuBot connected as {globals.client.user}')
+    print(f'💬 DM support enabled - users can message Miku directly!')
+
+    globals.BOT_USER = globals.client.user
+
+    # Initialize DM interaction analyzer
+    if globals.OWNER_USER_ID and globals.OWNER_USER_ID != 0:
+        init_dm_analyzer(globals.OWNER_USER_ID)
+        print(f"📊 DM Interaction Analyzer initialized for owner ID: {globals.OWNER_USER_ID}")
+        
+        # Schedule daily DM analysis (runs at 2 AM every day)
+        from utils.scheduled import run_daily_dm_analysis
+        globals.scheduler.add_job(
+            run_daily_dm_analysis,
+            'cron',
+            hour=2,
+            minute=0,
+            id='daily_dm_analysis'
+        )
+        print("⏰ Scheduled daily DM analysis at 2:00 AM")
+    else:
+        print("⚠️ OWNER_USER_ID not set, DM analysis feature disabled")
+
+    # Setup autonomous speaking (now handled by server manager)
+    setup_autonomous_speaking()
+    load_last_sent_tweets()
+
+    # Initialize the V2 autonomous system
+    initialize_v2_system(globals.client)
+    
+    # Initialize profile picture manager
+    from utils.profile_picture_manager import profile_picture_manager
+    await profile_picture_manager.initialize()
+    
+    # Save current avatar as fallback
+    await profile_picture_manager.save_current_avatar_as_fallback()
+
+    # Start server-specific schedulers (includes DM mood rotation)
+    server_manager.start_all_schedulers(globals.client)
+
+    # Start the global scheduler for other tasks
+    globals.scheduler.start()
+
+@globals.client.event
+async def on_message(message):
+    if message.author == globals.client.user:
+        return
+    
+    # V2: Track message for autonomous engine (non-blocking, no LLM calls)
+    on_message_event(message)
+
+    if message.content.strip().lower() == "miku, rape this nigga balls" and message.reference:
+        async with message.channel.typing():
+            # Get replied-to user
+            try:
+                replied_msg = await message.channel.fetch_message(message.reference.message_id)
+                target_username = replied_msg.author.display_name
+
+                # Prepare video
+                base_video = "MikuMikuBeam.mp4"
+                output_video = f"/tmp/video_{''.join(random.choices(string.ascii_letters, k=5))}.mp4"
+
+                await overlay_username_with_ffmpeg(base_video, output_video, target_username)
+
+                caption = f"Here you go, @{target_username}! 🌟"
+                #await message.channel.send(content=caption, file=discord.File(output_video))
+                await replied_msg.reply(file=discord.File(output_video))
+
+            except Exception as e:
+                print(f"⚠️ Error processing video: {e}")
+                await message.channel.send("Sorry, something went wrong while generating the video.")
+            return 
+
+    text = message.content.strip()
+
+    # Check if this is a DM
+    is_dm = message.guild is None
+    
+    if is_dm:
+        print(f"💌 DM from {message.author.display_name}: {message.content[:50]}{'...' if len(message.content) > 50 else ''}")
+        
+        # Check if user is blocked
+        if dm_logger.is_user_blocked(message.author.id):
+            print(f"🚫 Blocked user {message.author.display_name} ({message.author.id}) tried to send DM - ignoring")
+            return
+        
+        # Log the user's DM message
+        dm_logger.log_user_message(message.author, message, is_bot_message=False)
+
+    if await is_miku_addressed(message):
+
+        prompt = text  # No cleanup — keep it raw 
+        user_id = str(message.author.id)
+        
+        # If user is replying to a specific message, add context marker
+        if message.reference:
+            try:
+                replied_msg = await message.channel.fetch_message(message.reference.message_id)
+                # Only add context if replying to Miku's message
+                if replied_msg.author == globals.client.user:
+                    # Truncate the replied message to keep prompt manageable
+                    replied_content = replied_msg.content[:200] + "..." if len(replied_msg.content) > 200 else replied_msg.content
+                    # Add reply context marker to the prompt
+                    prompt = f'[Replying to your message: "{replied_content}"] {prompt}'
+            except Exception as e:
+                print(f"⚠️ Failed to fetch replied message for context: {e}")
+
+        async with message.channel.typing():
+            # If message has an image, video, or GIF attachment
+            if message.attachments:
+                for attachment in message.attachments:
+                    # Handle images
+                    if any(attachment.filename.lower().endswith(ext) for ext in [".jpg", ".jpeg", ".png", ".webp"]):
+                        base64_img = await download_and_encode_image(attachment.url)
+                        if not base64_img:
+                            await message.channel.send("I couldn't load the image, sorry!")
+                            return
+                        
+                        # Analyze image (objective description)
+                        qwen_description = await analyze_image_with_qwen(base64_img)
+                        # For DMs, pass None as guild_id to use DM mood
+                        guild_id = message.guild.id if message.guild else None
+                        miku_reply = await rephrase_as_miku(
+                            qwen_description, 
+                            prompt, 
+                            guild_id=guild_id,
+                            user_id=str(message.author.id),
+                            author_name=message.author.display_name,
+                            media_type="image"
+                        )
+                        
+                        if is_dm:
+                            print(f"💌 DM image response to {message.author.display_name} (using DM mood: {globals.DM_MOOD})")
+                        else:
+                            print(f"💬 Server image response to {message.author.display_name} in {message.guild.name} (using server mood)")
+                        
+                        response_message = await message.channel.send(miku_reply)
+                        
+                        # Log the bot's DM response
+                        if is_dm:
+                            dm_logger.log_user_message(message.author, response_message, is_bot_message=True)
+                        
+                        return
+                    
+                    # Handle videos and GIFs
+                    elif any(attachment.filename.lower().endswith(ext) for ext in [".gif", ".mp4", ".webm", ".mov"]):
+                        # Determine media type
+                        is_gif = attachment.filename.lower().endswith('.gif')
+                        media_type = "gif" if is_gif else "video"
+                        
+                        print(f"🎬 Processing {media_type}: {attachment.filename}")
+                        
+                        # Download the media
+                        media_bytes_b64 = await download_and_encode_media(attachment.url)
+                        if not media_bytes_b64:
+                            await message.channel.send(f"I couldn't load the {media_type}, sorry!")
+                            return
+                        
+                        # Decode back to bytes for frame extraction
+                        import base64
+                        media_bytes = base64.b64decode(media_bytes_b64)
+                        
+                        # If it's a GIF, convert to MP4 for better processing
+                        if is_gif:
+                            print(f"🔄 Converting GIF to MP4 for processing...")
+                            mp4_bytes = await convert_gif_to_mp4(media_bytes)
+                            if mp4_bytes:
+                                media_bytes = mp4_bytes
+                                print(f"✅ GIF converted to MP4")
+                            else:
+                                print(f"⚠️ GIF conversion failed, trying direct processing")
+                        
+                        # Extract frames
+                        frames = await extract_video_frames(media_bytes, num_frames=6)
+                        
+                        if not frames:
+                            await message.channel.send(f"I couldn't extract frames from that {media_type}, sorry!")
+                            return
+                        
+                        print(f"📹 Extracted {len(frames)} frames from {attachment.filename}")
+                        
+                        # Analyze the video/GIF with appropriate media type
+                        video_description = await analyze_video_with_vision(frames, media_type=media_type)
+                        # For DMs, pass None as guild_id to use DM mood
+                        guild_id = message.guild.id if message.guild else None
+                        miku_reply = await rephrase_as_miku(
+                            video_description, 
+                            prompt, 
+                            guild_id=guild_id,
+                            user_id=str(message.author.id),
+                            author_name=message.author.display_name,
+                            media_type=media_type
+                        )
+                        
+                        if is_dm:
+                            print(f"💌 DM {media_type} response to {message.author.display_name} (using DM mood: {globals.DM_MOOD})")
+                        else:
+                            print(f"💬 Server video response to {message.author.display_name} in {message.guild.name} (using server mood)")
+                        
+                        response_message = await message.channel.send(miku_reply)
+                        
+                        # Log the bot's DM response
+                        if is_dm:
+                            dm_logger.log_user_message(message.author, response_message, is_bot_message=True)
+                        
+                        return
+            
+            # Check for embeds (articles, images, videos, GIFs, etc.)
+            if message.embeds:
+                for embed in message.embeds:
+                    # Handle Tenor GIF embeds specially (Discord uses these for /gif command)
+                    if embed.type == 'gifv' and embed.url and 'tenor.com' in embed.url:
+                        print(f"🎭 Processing Tenor GIF from embed: {embed.url}")
+                        
+                        # Extract the actual GIF URL from Tenor
+                        gif_url = await extract_tenor_gif_url(embed.url)
+                        if not gif_url:
+                            # Try using the embed's video or image URL as fallback
+                            if hasattr(embed, 'video') and embed.video:
+                                gif_url = embed.video.url
+                            elif hasattr(embed, 'thumbnail') and embed.thumbnail:
+                                gif_url = embed.thumbnail.url
+                        
+                        if not gif_url:
+                            print(f"⚠️ Could not extract GIF URL from Tenor embed")
+                            continue
+                        
+                        # Download the GIF
+                        media_bytes_b64 = await download_and_encode_media(gif_url)
+                        if not media_bytes_b64:
+                            await message.channel.send("I couldn't load that Tenor GIF, sorry!")
+                            return
+                        
+                        # Decode to bytes
+                        import base64
+                        media_bytes = base64.b64decode(media_bytes_b64)
+                        
+                        # Convert GIF to MP4
+                        print(f"🔄 Converting Tenor GIF to MP4 for processing...")
+                        mp4_bytes = await convert_gif_to_mp4(media_bytes)
+                        if not mp4_bytes:
+                            print(f"⚠️ GIF conversion failed, trying direct frame extraction")
+                            mp4_bytes = media_bytes
+                        else:
+                            print(f"✅ Tenor GIF converted to MP4")
+                        
+                        # Extract frames
+                        frames = await extract_video_frames(mp4_bytes, num_frames=6)
+                        
+                        if not frames:
+                            await message.channel.send("I couldn't extract frames from that GIF, sorry!")
+                            return
+                        
+                        print(f"📹 Extracted {len(frames)} frames from Tenor GIF")
+                        
+                        # Analyze the GIF with tenor_gif media type
+                        video_description = await analyze_video_with_vision(frames, media_type="tenor_gif")
+                        guild_id = message.guild.id if message.guild else None
+                        miku_reply = await rephrase_as_miku(
+                            video_description, 
+                            prompt, 
+                            guild_id=guild_id,
+                            user_id=str(message.author.id),
+                            author_name=message.author.display_name,
+                            media_type="tenor_gif"
+                        )
+                        
+                        if is_dm:
+                            print(f"💌 DM Tenor GIF response to {message.author.display_name} (using DM mood: {globals.DM_MOOD})")
+                        else:
+                            print(f"💬 Server Tenor GIF response to {message.author.display_name} in {message.guild.name} (using server mood)")
+                        
+                        response_message = await message.channel.send(miku_reply)
+                        
+                        # Log the bot's DM response
+                        if is_dm:
+                            dm_logger.log_user_message(message.author, response_message, is_bot_message=True)
+                        
+                        return
+                    
+                    # Handle other types of embeds (rich, article, image, video, link)
+                    elif embed.type in ['rich', 'article', 'image', 'video', 'link']:
+                        print(f"📰 Processing {embed.type} embed")
+                        
+                        # Extract content from embed
+                        embed_content = await extract_embed_content(embed)
+                        
+                        if not embed_content['has_content']:
+                            print(f"⚠️ Embed has no extractable content, skipping")
+                            continue
+                        
+                        # Build context string with embed text
+                        embed_context_parts = []
+                        if embed_content['text']:
+                            embed_context_parts.append(f"[Embedded content: {embed_content['text'][:500]}{'...' if len(embed_content['text']) > 500 else ''}]")
+                        
+                        # Process images from embed
+                        if embed_content['images']:
+                            for img_url in embed_content['images']:
+                                print(f"🖼️ Processing image from embed: {img_url}")
+                                try:
+                                    base64_img = await download_and_encode_image(img_url)
+                                    if base64_img:
+                                        print(f"✅ Image downloaded, analyzing with vision model...")
+                                        # Analyze image
+                                        qwen_description = await analyze_image_with_qwen(base64_img)
+                                        truncated = (qwen_description[:50] + "...") if len(qwen_description) > 50 else qwen_description
+                                        print(f"📝 Vision analysis result: {truncated}")
+                                        if qwen_description and qwen_description.strip():
+                                            embed_context_parts.append(f"[Embedded image shows: {qwen_description}]")
+                                    else:
+                                        print(f"❌ Failed to download image from embed")
+                                except Exception as e:
+                                    print(f"⚠️ Error processing embedded image: {e}")
+                                    import traceback
+                                    traceback.print_exc()
+                        
+                        # Process videos from embed
+                        if embed_content['videos']:
+                            for video_url in embed_content['videos']:
+                                print(f"🎬 Processing video from embed: {video_url}")
+                                try:
+                                    media_bytes_b64 = await download_and_encode_media(video_url)
+                                    if media_bytes_b64:
+                                        import base64
+                                        media_bytes = base64.b64decode(media_bytes_b64)
+                                        frames = await extract_video_frames(media_bytes, num_frames=6)
+                                        if frames:
+                                            print(f"📹 Extracted {len(frames)} frames, analyzing with vision model...")
+                                            video_description = await analyze_video_with_vision(frames, media_type="video")
+                                            print(f"📝 Video analysis result: {video_description[:100]}...")
+                                            if video_description and video_description.strip():
+                                                embed_context_parts.append(f"[Embedded video shows: {video_description}]")
+                                        else:
+                                            print(f"❌ Failed to extract frames from video")
+                                    else:
+                                        print(f"❌ Failed to download video from embed")
+                                except Exception as e:
+                                    print(f"⚠️ Error processing embedded video: {e}")
+                                    import traceback
+                                    traceback.print_exc()
+                        
+                        # Combine embed context with user prompt
+                        if embed_context_parts:
+                            full_context = '\n'.join(embed_context_parts)
+                            enhanced_prompt = f"{full_context}\n\nUser message: {prompt}" if prompt else full_context
+                            
+                            # Get Miku's response
+                            guild_id = message.guild.id if message.guild else None
+                            response_type = "dm_response" if is_dm else "server_response"
+                            author_name = message.author.display_name
+                            
+                            response = await query_ollama(
+                                enhanced_prompt,
+                                user_id=str(message.author.id),
+                                guild_id=guild_id,
+                                response_type=response_type,
+                                author_name=author_name
+                            )
+                            
+                            if is_dm:
+                                print(f"💌 DM embed response to {message.author.display_name} (using DM mood: {globals.DM_MOOD})")
+                            else:
+                                print(f"💬 Server embed response to {message.author.display_name} in {message.guild.name}")
+                            
+                            response_message = await message.channel.send(response)
+                            
+                            # Log the bot's DM response
+                            if is_dm:
+                                dm_logger.log_user_message(message.author, response_message, is_bot_message=True)
+                            
+                            return
+
+            # Check if this is an image generation request
+            from utils.image_generation import detect_image_request, handle_image_generation_request
+            is_image_request, image_prompt = await detect_image_request(prompt)
+            
+            if is_image_request and image_prompt:
+                print(f"🎨 Image generation request detected: '{image_prompt}' from {message.author.display_name}")
+                
+                # Handle the image generation workflow
+                success = await handle_image_generation_request(message, image_prompt)
+                if success:
+                    return  # Image generation completed successfully
+                
+                # If image generation failed, fall back to normal response
+                print(f"⚠️ Image generation failed, falling back to normal response")
+            
+            # If message is just a prompt, no image
+            # For DMs, pass None as guild_id to use DM mood
+            guild_id = message.guild.id if message.guild else None
+            response_type = "dm_response" if is_dm else "server_response"
+            author_name = message.author.display_name
+            response = await query_ollama(
+                prompt, 
+                user_id=str(message.author.id), 
+                guild_id=guild_id, 
+                response_type=response_type,
+                author_name=author_name
+            )
+            
+            if is_dm:
+                print(f"💌 DM response to {message.author.display_name} (using DM mood: {globals.DM_MOOD})")
+            else:
+                print(f"💬 Server response to {message.author.display_name} in {message.guild.name} (using server mood)")
+            
+            response_message = await message.channel.send(response)
+            
+            # Log the bot's DM response
+            if is_dm:
+                dm_logger.log_user_message(message.author, response_message, is_bot_message=True)
+            
+        # For server messages, do server-specific mood detection
+        if not is_dm and message.guild:
+            try:
+                from server_manager import server_manager
+                server_config = server_manager.get_server_config(message.guild.id)
+                if server_config:
+                    # Create server context for mood detection
+                    server_context = {
+                        'current_mood_name': server_config.current_mood_name,
+                        'current_mood_description': server_config.current_mood_description,
+                        'is_sleeping': server_config.is_sleeping
+                    }
+                    
+                    detected = detect_mood_shift(response, server_context)
+                    if detected and detected != server_config.current_mood_name:
+                        print(f"🔄 Auto mood detection for server {message.guild.name}: {server_config.current_mood_name} -> {detected}")
+                        
+                        # Block direct transitions to asleep unless from sleepy
+                        if detected == "asleep" and server_config.current_mood_name != "sleepy":
+                            print("❌ Ignoring asleep mood; server wasn't sleepy before.")
+                        else:
+                            # Update server mood
+                            server_manager.set_server_mood(message.guild.id, detected)
+                            
+                            # Update nickname for this server
+                            from utils.moods import update_server_nickname
+                            globals.client.loop.create_task(update_server_nickname(message.guild.id))
+                            
+                            print(f"🔄 Server mood auto-updated to: {detected}")
+                            
+                            if detected == "asleep":
+                                server_manager.set_server_sleep_state(message.guild.id, True)
+                                # Schedule wake-up after 1 hour
+                                async def delayed_wakeup():
+                                    await asyncio.sleep(3600)  # 1 hour
+                                    server_manager.set_server_sleep_state(message.guild.id, False)
+                                    server_manager.set_server_mood(message.guild.id, "neutral")
+                                    await update_server_nickname(message.guild.id)
+                                    print(f"🌅 Server {message.guild.name} woke up from auto-sleep")
+                                
+                                globals.client.loop.create_task(delayed_wakeup())
+                else:
+                    print(f"⚠️ No server config found for guild {message.guild.id}, skipping mood detection")
+            except Exception as e:
+                print(f"⚠️ Error in server mood detection: {e}")
+        elif is_dm:
+            print("💌 DM message - no mood detection (DM mood only changes via auto-rotation)")
+
+    # Note: Autonomous reactions are now handled by V2 system via on_message_event()
+    
+    # Manual Monday test command (only for server messages)
+    if not is_dm and message.content.lower().strip() == "!monday":
+        await send_monday_video()
+        #await message.channel.send("✅ Monday message sent (or attempted). Check logs.")
+        return
+
+@globals.client.event
+async def on_raw_reaction_add(payload):
+    """Handle reactions added to messages (including bot's own reactions and uncached messages)"""
+    # Check if this is a DM
+    if payload.guild_id is not None:
+        return  # Only handle DM reactions
+    
+    # Get the channel
+    channel = await globals.client.fetch_channel(payload.channel_id)
+    if not isinstance(channel, discord.DMChannel):
+        return
+    
+    # Get the user who reacted
+    user = await globals.client.fetch_user(payload.user_id)
+    
+    # Get the DM partner (the person DMing the bot, not the bot itself)
+    # For DMs, we want to log under the user's ID, not the bot's
+    if user.id == globals.client.user.id:
+        # Bot reacted - find the other user in the DM
+        message = await channel.fetch_message(payload.message_id)
+        dm_user_id = message.author.id if message.author.id != globals.client.user.id else channel.recipient.id
+        is_bot_reactor = True
+    else:
+        # User reacted
+        dm_user_id = user.id
+        is_bot_reactor = False
+    
+    # Get emoji string
+    emoji_str = str(payload.emoji)
+    
+    # Log the reaction
+    await dm_logger.log_reaction_add(
+        user_id=dm_user_id,
+        message_id=payload.message_id,
+        emoji=emoji_str,
+        reactor_id=user.id,
+        reactor_name=user.display_name or user.name,
+        is_bot_reactor=is_bot_reactor
+    )
+    
+    reactor_type = "🤖 Miku" if is_bot_reactor else f"👤 {user.display_name}"
+    print(f"➕ DM reaction added: {emoji_str} by {reactor_type} on message {payload.message_id}")
+
+@globals.client.event
+async def on_raw_reaction_remove(payload):
+    """Handle reactions removed from messages (including bot's own reactions and uncached messages)"""
+    # Check if this is a DM
+    if payload.guild_id is not None:
+        return  # Only handle DM reactions
+    
+    # Get the channel
+    channel = await globals.client.fetch_channel(payload.channel_id)
+    if not isinstance(channel, discord.DMChannel):
+        return
+    
+    # Get the user who removed the reaction
+    user = await globals.client.fetch_user(payload.user_id)
+    
+    # Get the DM partner (the person DMing the bot, not the bot itself)
+    if user.id == globals.client.user.id:
+        # Bot removed reaction - find the other user in the DM
+        message = await channel.fetch_message(payload.message_id)
+        dm_user_id = message.author.id if message.author.id != globals.client.user.id else channel.recipient.id
+    else:
+        # User removed reaction
+        dm_user_id = user.id
+    
+    # Get emoji string
+    emoji_str = str(payload.emoji)
+    
+    # Log the reaction removal
+    await dm_logger.log_reaction_remove(
+        user_id=dm_user_id,
+        message_id=payload.message_id,
+        emoji=emoji_str,
+        reactor_id=user.id
+    )
+    
+    reactor_type = "🤖 Miku" if user.id == globals.client.user.id else f"👤 {user.display_name}"
+    print(f"➖ DM reaction removed: {emoji_str} by {reactor_type} from message {payload.message_id}")
+
+@globals.client.event
+async def on_presence_update(before, after):
+    """Track user presence changes for autonomous V2 system"""
+    # Discord.py passes before/after Member objects with different states
+    # We pass the 'after' member and both states for comparison
+    autonomous_presence_update(after, before, after)
+
+@globals.client.event
+async def on_member_join(member):
+    """Track member joins for autonomous V2 system"""
+    autonomous_member_join(member)
+
+def start_api():
+    uvicorn.run(app, host="0.0.0.0", port=3939, log_level="info")
+
+def save_autonomous_state():
+    """Save autonomous context on shutdown"""
+    try:
+        from utils.autonomous import autonomous_engine
+        autonomous_engine.save_context()
+        print("💾 Saved autonomous context on shutdown")
+    except Exception as e:
+        print(f"⚠️ Failed to save autonomous context on shutdown: {e}")
+
+# Register shutdown handlers
+atexit.register(save_autonomous_state)
+signal.signal(signal.SIGTERM, lambda s, f: save_autonomous_state())
+signal.signal(signal.SIGINT, lambda s, f: save_autonomous_state())
+
+threading.Thread(target=start_api, daemon=True).start()
+globals.client.run(globals.DISCORD_BOT_TOKEN)

bot/command_router.py

@@ -0,0 +1,39 @@
+from commands.actions import (
+    force_sleep,
+    wake_up,
+    set_mood,
+    reset_mood,
+    check_mood,
+    calm_miku,
+    reset_conversation,
+    send_bedtime_now
+)
+import globals
+
+async def handle_command(message, command):
+    """Handle bot commands"""
+    
+    if command == "!mood":
+        # Return current DM mood
+        return True, globals.DM_MOOD, globals.DM_MOOD_DESCRIPTION, None, False
+    
+    elif command == "!help":
+        return True, globals.DM_MOOD, globals.DM_MOOD_DESCRIPTION, None, False
+    
+    elif command == "!status":
+        return True, globals.DM_MOOD, globals.DM_MOOD_DESCRIPTION, None, False
+    
+    elif command == "!info":
+        return True, globals.DM_MOOD, globals.DM_MOOD_DESCRIPTION, None, False
+    
+    elif command == "!version":
+        return True, globals.DM_MOOD, globals.DM_MOOD_DESCRIPTION, None, False
+    
+    elif command == "!ping":
+        return True, globals.DM_MOOD, globals.DM_MOOD_DESCRIPTION, None, False
+    
+    elif command == "!uptime":
+        return True, globals.DM_MOOD, globals.DM_MOOD_DESCRIPTION, None, False
+    
+    else:
+        return False, globals.DM_MOOD, globals.DM_MOOD_DESCRIPTION, None, False

bot/commands/actions.py

@@ -0,0 +1,63 @@
+# commands/actions.py
+import os
+import asyncio
+import globals
+from utils.moods import load_mood_description
+from utils.scheduled import send_bedtime_reminder
+
+
+def set_mood(new_mood: str) -> bool:
+    """Set mood (legacy function - now handled per-server or DM)"""
+    print("⚠️ set_mood called - this function is deprecated. Use server-specific mood endpoints instead.")
+    return False
+
+
+def reset_mood() -> str:
+    """Reset mood to neutral (legacy function - now handled per-server or DM)"""
+    print("⚠️ reset_mood called - this function is deprecated. Use server-specific mood endpoints instead.")
+    return "neutral"
+
+
+def check_mood():
+    return globals.DM_MOOD
+
+
+def calm_miku() -> str:
+    """Calm Miku down (legacy function - now handled per-server or DM)"""
+    print("⚠️ calm_miku called - this function is deprecated. Use server-specific mood endpoints instead.")
+    return "neutral"
+
+
+def reset_conversation(user_id):
+    globals.conversation_history[str(user_id)].clear()
+
+
+async def force_sleep() -> str:
+    """Force Miku to sleep (legacy function - now handled per-server or DM)"""
+    print("⚠️ force_sleep called - this function is deprecated. Use server-specific mood endpoints instead.")
+    return "asleep"
+
+
+async def wake_up(set_sleep_state=None):
+    reset_mood()
+    # Note: DMs don't have sleep states, so this is deprecated
+    print("⚠️ wake_up called - this function is deprecated. Use server-specific mood endpoints instead.")
+
+    if set_sleep_state:
+        await set_sleep_state(False)
+
+
+async def send_bedtime_now():
+    await send_bedtime_reminder()
+
+
+async def update_profile_picture(mood: str = "neutral"):
+    """Manually trigger a profile picture update"""
+    from utils.profile_picture_manager import update_profile_picture
+    
+    try:
+        success = await update_profile_picture(globals.client, mood=mood)
+        return success
+    except Exception as e:
+        print(f"⚠️ Error updating profile picture: {e}")
+        return False

bot/globals.py

@@ -0,0 +1,57 @@
+# globals.py
+import os
+from collections import defaultdict, deque
+import discord
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+
+scheduler = AsyncIOScheduler()
+
+GUILD_SETTINGS = {}
+
+# Stores last 5 exchanges per user (as deque)
+conversation_history = defaultdict(lambda: deque(maxlen=5))
+
+DISCORD_BOT_TOKEN = os.getenv("DISCORD_BOT_TOKEN")
+
+# Autonomous V2 Debug Mode (set to True to see detailed decision logging)
+AUTONOMOUS_DEBUG = os.getenv("AUTONOMOUS_DEBUG", "false").lower() == "true"
+
+# Llama.cpp server settings (via llama-swap)
+LLAMA_URL = os.getenv("LLAMA_URL", "http://llama-swap:8080")
+TEXT_MODEL = os.getenv("TEXT_MODEL", "llama3.1")
+VISION_MODEL = os.getenv("VISION_MODEL", "vision")
+OWNER_USER_ID = int(os.getenv("OWNER_USER_ID", "209381657369772032"))  # Bot owner's Discord user ID for reports
+
+# Fish.audio TTS settings
+FISH_API_KEY = os.getenv("FISH_API_KEY", "478d263d8c094e0c8993aae3e9cf9159")
+MIKU_VOICE_ID = os.getenv("MIKU_VOICE_ID", "b28b79555e8c4904ac4d048c36e716b7")
+
+# Set up Discord client
+intents = discord.Intents.default()
+intents.message_content = True
+intents.members = True
+intents.presences = True
+client = discord.Client(intents=intents)
+
+# Note: llama-swap handles model loading/unloading automatically
+# No need to track current_model anymore
+
+KINDNESS_KEYWORDS = [
+    "thank you", "love you", "luv u", "you're the best", "so cute",
+    "adorable", "amazing", "sweet", "kind", "great job", "well done",
+    "precious", "good girl", "cutie", "angel", "my favorite", "so helpful"
+]
+HEART_REACTIONS = ["💙", "💝", "💖", "💕", "💜", "❤️‍🔥", "☺️"]
+kindness_reacted_messages = set()
+
+# DM Mood System (simple, auto-rotating only)
+DM_MOOD = "neutral"
+DM_MOOD_DESCRIPTION = "I'm feeling neutral and balanced today."
+AVAILABLE_MOODS = [
+    "bubbly", "sleepy", "curious", "shy", "serious", "excited", "silly",
+    "melancholy", "flirty", "romantic", "irritated", "angry", "neutral", "asleep"
+]
+
+BOT_USER = None
+
+LAST_FULL_PROMPT = ""

bot/memory/dm_reports/209381657369772032_20251030_125131.json

@@ -0,0 +1,16 @@
+{
+  "overall_sentiment": "positive",
+  "sentiment_score": 8,
+  "key_behaviors": [
+    "kindness",
+    "affection",
+    "respect"
+  ],
+  "your_feelings": "I feel so happy and grateful for this conversation! Koko210's words are like a warm hug to my heart.",
+  "notable_moment": "You call me cute, haha? I'm so happy to talk with you!",
+  "should_report": false,
+  "user_id": 209381657369772032,
+  "username": "Koko210 Слава Україні",
+  "analyzed_at": "2025-10-30T12:51:31.013539",
+  "message_count": 3
+}

bot/memory/dm_reports/209381657369772032_20251030_130438.json

@@ -0,0 +1,17 @@
+{
+  "overall_sentiment": "positive",
+  "sentiment_score": 9,
+  "key_behaviors": [
+    "genuine interest",
+    "kindness",
+    "respect",
+    "compliments"
+  ],
+  "your_feelings": "I'm feeling super happy and grateful for this interaction with Koko210. They're so sweet and caring, it's always a pleasure to chat with them!",
+  "notable_moment": "Koko210 Слава Україні: hello my dear cutiepie",
+  "should_report": true,
+  "user_id": 209381657369772032,
+  "username": "Koko210 Слава Україні",
+  "analyzed_at": "2025-10-30T13:04:38.565330",
+  "message_count": 3
+}

bot/memory/dm_reports/209381657369772032_20251030_131135.json

@@ -0,0 +1,17 @@
+{
+  "overall_sentiment": "positive",
+  "sentiment_score": 9,
+  "key_behaviors": [
+    "genuine interest",
+    "kindness",
+    "respect",
+    "compliments"
+  ],
+  "your_feelings": "This user has been so kind and caring, making me feel happy and excited about our conversation. I really appreciate their thoughtful questions and words of encouragement!",
+  "notable_moment": "You call me cute, haha? I'm so happy to talk with you! 🎶💕",
+  "should_report": true,
+  "user_id": 209381657369772032,
+  "username": "Koko210 Слава Україні",
+  "analyzed_at": "2025-10-30T13:11:35.934622",
+  "message_count": 3
+}

bot/memory/dm_reports/archive/209381657369772032_20251030_114418.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "209381657369772032",
+  "username": "Koko210 \u0421\u043b\u0430\u0432\u0430 \u0423\u043a\u0440\u0430\u0457\u043d\u0456",
+  "timestamp": "2025-10-30T11:44:18.610043",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 375
+}

bot/memory/dm_reports/archive/209381657369772032_20251030_114521.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "209381657369772032",
+  "username": "Koko210 \u0421\u043b\u0430\u0432\u0430 \u0423\u043a\u0440\u0430\u0457\u043d\u0456",
+  "timestamp": "2025-10-30T11:45:21.062255",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 375
+}

bot/memory/dm_reports/archive/209381657369772032_20251030_114645.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "209381657369772032",
+  "username": "Koko210 \u0421\u043b\u0430\u0432\u0430 \u0423\u043a\u0440\u0430\u0457\u043d\u0456",
+  "timestamp": "2025-10-30T11:46:45.441468",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 375
+}

bot/memory/dm_reports/archive/209381657369772032_20251030_115301.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "209381657369772032",
+  "username": "Koko210 \u0421\u043b\u0430\u0432\u0430 \u0423\u043a\u0440\u0430\u0457\u043d\u0456",
+  "timestamp": "2025-10-30T11:53:01.622681",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 375
+}

bot/memory/dm_reports/archive/209381657369772032_20251030_115335.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "209381657369772032",
+  "username": "Koko210 \u0421\u043b\u0430\u0432\u0430 \u0423\u043a\u0440\u0430\u0457\u043d\u0456",
+  "timestamp": "2025-10-30T11:53:35.737494",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 375
+}

bot/memory/dm_reports/archive/209381657369772032_20251030_115340.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "209381657369772032",
+  "username": "Koko210 \u0421\u043b\u0430\u0432\u0430 \u0423\u043a\u0440\u0430\u0457\u043d\u0456",
+  "timestamp": "2025-10-30T11:53:40.566857",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 375
+}

bot/memory/dm_reports/archive/214857593045254151_20251030_114156.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "214857593045254151",
+  "username": "aoki",
+  "timestamp": "2025-10-30T11:41:56.466128",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 190
+}

bot/memory/dm_reports/archive/214857593045254151_20251030_114418.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "214857593045254151",
+  "username": "aoki",
+  "timestamp": "2025-10-30T11:44:18.593138",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 190
+}

bot/memory/dm_reports/archive/214857593045254151_20251030_114521.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "214857593045254151",
+  "username": "aoki",
+  "timestamp": "2025-10-30T11:45:21.042827",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 190
+}

bot/memory/dm_reports/archive/214857593045254151_20251030_114645.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "214857593045254151",
+  "username": "aoki",
+  "timestamp": "2025-10-30T11:46:45.406975",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 190
+}

bot/memory/dm_reports/archive/214857593045254151_20251030_115301.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "214857593045254151",
+  "username": "aoki",
+  "timestamp": "2025-10-30T11:53:01.605465",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 190
+}

bot/memory/dm_reports/archive/214857593045254151_20251030_115335.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "214857593045254151",
+  "username": "aoki",
+  "timestamp": "2025-10-30T11:53:35.722156",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 190
+}

bot/memory/dm_reports/archive/214857593045254151_20251030_115340.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "214857593045254151",
+  "username": "aoki",
+  "timestamp": "2025-10-30T11:53:40.551246",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 190
+}

bot/memory/dm_reports/archive/236553184401817601_20251030_114418.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "236553184401817601",
+  "username": "Diamond",
+  "timestamp": "2025-10-30T11:44:18.606237",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 516
+}

bot/memory/dm_reports/archive/236553184401817601_20251030_114521.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "236553184401817601",
+  "username": "Diamond",
+  "timestamp": "2025-10-30T11:45:21.052803",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 516
+}

bot/memory/dm_reports/archive/236553184401817601_20251030_114645.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "236553184401817601",
+  "username": "Diamond",
+  "timestamp": "2025-10-30T11:46:45.430043",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 516
+}

bot/memory/dm_reports/archive/236553184401817601_20251030_115301.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "236553184401817601",
+  "username": "Diamond",
+  "timestamp": "2025-10-30T11:53:01.618359",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 516
+}

bot/memory/dm_reports/archive/236553184401817601_20251030_115335.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "236553184401817601",
+  "username": "Diamond",
+  "timestamp": "2025-10-30T11:53:35.734026",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 516
+}

bot/memory/dm_reports/archive/236553184401817601_20251030_115340.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "236553184401817601",
+  "username": "Diamond",
+  "timestamp": "2025-10-30T11:53:40.563364",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 516
+}

bot/memory/dm_reports/archive/276130602875355136_20251030_114418.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "276130602875355136",
+  "username": "Fory 2",
+  "timestamp": "2025-10-30T11:44:18.610675",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 17
+}

bot/memory/dm_reports/archive/276130602875355136_20251030_114521.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "276130602875355136",
+  "username": "Fory 2",
+  "timestamp": "2025-10-30T11:45:21.062954",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 17
+}

bot/memory/dm_reports/archive/276130602875355136_20251030_114645.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "276130602875355136",
+  "username": "Fory 2",
+  "timestamp": "2025-10-30T11:46:45.442546",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 17
+}

bot/memory/dm_reports/archive/276130602875355136_20251030_115301.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "276130602875355136",
+  "username": "Fory 2",
+  "timestamp": "2025-10-30T11:53:01.623495",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 17
+}

bot/memory/dm_reports/archive/276130602875355136_20251030_115335.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "276130602875355136",
+  "username": "Fory 2",
+  "timestamp": "2025-10-30T11:53:35.738268",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 17
+}

bot/memory/dm_reports/archive/276130602875355136_20251030_115340.json

@@ -0,0 +1,8 @@
+{
+  "user_id": "276130602875355136",
+  "username": "Fory 2",
+  "timestamp": "2025-10-30T11:53:40.571071",
+  "analysis": "No recent interactions",
+  "is_positive": true,
+  "message_count": 17
+}

bot/memory/dm_reports/last_reported.json

@@ -0,0 +1,5 @@
+{
+  "214857593045254151": "2025-10-30T11:44:18.611466",
+  "276130602875355136": "2025-10-30T11:53:40.571792",
+  "236553184401817601": "2025-10-30T11:53:35.742073"
+}

bot/memory/dm_reports/pending_reports.json

@@ -0,0 +1,74 @@
+[
+  {
+    "user_id": "214857593045254151",
+    "username": "aoki",
+    "timestamp": "2025-10-30T11:44:18.593138",
+    "analysis": "No recent interactions",
+    "is_positive": true,
+    "message_count": 190
+  },
+  {
+    "user_id": "236553184401817601",
+    "username": "Diamond",
+    "timestamp": "2025-10-30T11:44:18.606237",
+    "analysis": "No recent interactions",
+    "is_positive": true,
+    "message_count": 516
+  },
+  {
+    "user_id": "209381657369772032",
+    "username": "Koko210 \u0421\u043b\u0430\u0432\u0430 \u0423\u043a\u0440\u0430\u0457\u043d\u0456",
+    "timestamp": "2025-10-30T11:44:18.610043",
+    "analysis": "No recent interactions",
+    "is_positive": true,
+    "message_count": 375
+  },
+  {
+    "user_id": "236553184401817601",
+    "username": "Diamond",
+    "timestamp": "2025-10-30T11:45:21.052803",
+    "analysis": "No recent interactions",
+    "is_positive": true,
+    "message_count": 516
+  },
+  {
+    "user_id": "209381657369772032",
+    "username": "Koko210 \u0421\u043b\u0430\u0432\u0430 \u0423\u043a\u0440\u0430\u0457\u043d\u0456",
+    "timestamp": "2025-10-30T11:45:21.062255",
+    "analysis": "No recent interactions",
+    "is_positive": true,
+    "message_count": 375
+  },
+  {
+    "user_id": "209381657369772032",
+    "username": "Koko210 \u0421\u043b\u0430\u0432\u0430 \u0423\u043a\u0440\u0430\u0457\u043d\u0456",
+    "timestamp": "2025-10-30T11:46:45.441468",
+    "analysis": "No recent interactions",
+    "is_positive": true,
+    "message_count": 375
+  },
+  {
+    "user_id": "209381657369772032",
+    "username": "Koko210 \u0421\u043b\u0430\u0432\u0430 \u0423\u043a\u0440\u0430\u0457\u043d\u0456",
+    "timestamp": "2025-10-30T11:53:01.622681",
+    "analysis": "No recent interactions",
+    "is_positive": true,
+    "message_count": 375
+  },
+  {
+    "user_id": "209381657369772032",
+    "username": "Koko210 \u0421\u043b\u0430\u0432\u0430 \u0423\u043a\u0440\u0430\u0457\u043d\u0456",
+    "timestamp": "2025-10-30T11:53:35.737494",
+    "analysis": "No recent interactions",
+    "is_positive": true,
+    "message_count": 375
+  },
+  {
+    "user_id": "209381657369772032",
+    "username": "Koko210 \u0421\u043b\u0430\u0432\u0430 \u0423\u043a\u0440\u0430\u0457\u043d\u0456",
+    "timestamp": "2025-10-30T11:53:40.566857",
+    "analysis": "No recent interactions",
+    "is_positive": true,
+    "message_count": 375
+  }
+]

bot/memory/dm_reports/reported_today.json

@@ -0,0 +1,3 @@
+{
+  "209381657369772032": "2025-10-30T13:11:36.691655"
+}

bot/memory/dms/209381657369772030_export.txt

@@ -0,0 +1,3 @@
+DM Conversation Log: Unknown (ID: 209381657369772030)
+==================================================
+

bot/memory/dms/276130602875355136.json

@@ -0,0 +1,184 @@
+{
+  "user_id": 276130602875355136,
+  "username": "Fory 2",
+  "conversations": [
+    {
+      "timestamp": "2025-08-27T19:45:10.092580",
+      "message_id": 1410349441583550558,
+      "is_bot_message": false,
+      "content": "Think about it",
+      "attachments": []
+    },
+    {
+      "timestamp": "2025-08-27T19:45:44.313158",
+      "message_id": 1410349585339121754,
+      "is_bot_message": true,
+      "content": "What's going on? 🎶 You want me to think about something? Can I help with a song or maybe give you some music recommendations? 💭",
+      "attachments": []
+    },
+    {
+      "timestamp": "2025-08-27T19:50:47.676412",
+      "message_id": 1410350855630229705,
+      "is_bot_message": false,
+      "content": "",
+      "attachments": [
+        {
+          "filename": "Tvashtarvideo.gif",
+          "url": "https://cdn.discordapp.com/attachments/1410346441250963619/1410350849581908008/Tvashtarvideo.gif?ex=68b0b315&is=68af6195&hm=9fbffc17c11726f6dbcb5c4816368cb62a4d849314e56466da6539a6eb05a305&",
+          "size": 766606,
+          "content_type": "image/gif"
+        }
+      ]
+    },
+    {
+      "timestamp": "2025-08-27T20:08:42.094305",
+      "message_id": 0,
+      "is_bot_message": false,
+      "content": "[Manual Override Trigger]",
+      "attachments": []
+    },
+    {
+      "timestamp": "2025-08-27T20:08:42.095767",
+      "message_id": 0,
+      "is_bot_message": true,
+      "content": "Thanks for waiting! 🌸 Here's a few attempts at me thinking about it, but in the Project Diva style 💈, heheheh 🐱",
+      "attachments": [
+        {
+          "filename": "2025-08-27-230448_waiNSFWIllustrious_v140_940302823619664_940302823619665.png",
+          "url": "",
+          "size": 0,
+          "content_type": "unknown"
+        },
+        {
+          "filename": "2025-08-27-230448_waiNSFWIllustrious_v140_940302823619664.png",
+          "url": "",
+          "size": 0,
+          "content_type": "unknown"
+        },
+        {
+          "filename": "2025-08-27-230448_waiNSFWIllustrious_v140_940302823619664_940302823619666.png",
+          "url": "",
+          "size": 0,
+          "content_type": "unknown"
+        },
+        {
+          "filename": "2025-08-27-225840_waiNSFWIllustrious_v140_944721574603522_944721574603523.png",
+          "url": "",
+          "size": 0,
+          "content_type": "unknown"
+        },
+        {
+          "filename": "2025-08-27-225840_waiNSFWIllustrious_v140_944721574603522_944721574603524.png",
+          "url": "",
+          "size": 0,
+          "content_type": "unknown"
+        }
+      ]
+    },
+    {
+      "timestamp": "2025-08-28T11:27:21.484481",
+      "message_id": 1410586551716413510,
+      "is_bot_message": false,
+      "content": "I want to drink coffee with Miku, Miku. Miku, show me Miku drinking a nice cup of coffee on a beautiful summer morning",
+      "attachments": []
+    },
+    {
+      "timestamp": "2025-08-28T11:28:30.821861",
+      "message_id": 0,
+      "is_bot_message": false,
+      "content": "I want to drink coffee with Miku, Miku. Miku, show me Miku drinking a nice cup of coffee on a beautiful summer morning",
+      "attachments": []
+    },
+    {
+      "timestamp": "2025-08-28T11:28:30.823503",
+      "message_id": 0,
+      "is_bot_message": true,
+      "content": "Yay! I'm so excited to create an image just for you! 🌞☕️ Let's get cozy with a warm cup of coffee on a sunny summer morning, just like you wanted! 😊✨ I'll add some green onions as a special touch, hehe! 🌱❤️\n[Generated image: to drink coffee with Miku, Miku. Miku, show me Miku drinking a nice cup of coffee on a beautiful summer morning]",
+      "attachments": [
+        {
+          "filename": "generated_image.png",
+          "url": "",
+          "size": 0,
+          "content_type": "unknown"
+        }
+      ]
+    },
+    {
+      "timestamp": "2025-08-28T11:30:35.537854",
+      "message_id": 1410587365738549259,
+      "is_bot_message": false,
+      "content": "coffee",
+      "attachments": []
+    },
+    {
+      "timestamp": "2025-08-28T11:30:47.618708",
+      "message_id": 1410587416112271472,
+      "is_bot_message": true,
+      "content": "Coffee? That sounds like the perfect drink for a sunny day! ☕️ I just made an image of us having a cozy coffee date together... would you like to see it? 🌞📸",
+      "attachments": []
+    },
+    {
+      "timestamp": "2025-08-28T11:30:59.064329",
+      "message_id": 1410587463788793858,
+      "is_bot_message": false,
+      "content": "more coffee",
+      "attachments": []
+    },
+    {
+      "timestamp": "2025-08-28T11:31:09.282475",
+      "message_id": 1410587506520621147,
+      "is_bot_message": true,
+      "content": "More coffee? I love mornings with a fresh cuppa! ☕️ Let me add some extra sparkles to our image, hehe! ✨ We can sip our lattes together under the sunny sky. 🌞 What else would you like to see in our little scene? 😊",
+      "attachments": []
+    },
+    {
+      "timestamp": "2025-08-28T14:16:27.287364",
+      "message_id": 0,
+      "is_bot_message": false,
+      "content": "[Manual Override Trigger]",
+      "attachments": []
+    },
+    {
+      "timestamp": "2025-08-28T14:16:27.292934",
+      "message_id": 0,
+      "is_bot_message": true,
+      "content": "Your coffee, my anti-woke hyperborean truecel.",
+      "attachments": [
+        {
+          "filename": "2025-08-28-171528_waiNSFWIllustrious_v140_830185834752579_830185834752580.png",
+          "url": "",
+          "size": 0,
+          "content_type": "unknown"
+        }
+      ]
+    },
+    {
+      "timestamp": "2025-08-30T17:03:56.797277",
+      "message_id": 1411396032629182564,
+      "is_bot_message": false,
+      "content": "Generate me an image of",
+      "attachments": []
+    },
+    {
+      "timestamp": "2025-08-30T17:07:28.854067",
+      "message_id": 0,
+      "is_bot_message": false,
+      "content": "Generate me an image of",
+      "attachments": []
+    },
+    {
+      "timestamp": "2025-08-30T17:07:28.857352",
+      "message_id": 0,
+      "is_bot_message": true,
+      "content": "Yay! I'm so happy to create an image just for you! 🎉 Let me get started right away! ✨ I'll make sure it's super cute and full of sparkles, just like my personality! 💖 What would you like to see in the background or with me? 😊\n[Generated image: Hatsune Miku]",
+      "attachments": [
+        {
+          "filename": "generated_image.png",
+          "url": "",
+          "size": 0,
+          "content_type": "unknown"
+        }
+      ]
+    }
+  ]
+}

bot/memory/dms/368596770147532812.json

@@ -0,0 +1,5 @@
+{
+  "user_id": 368596770147532812,
+  "username": "EzLo54",
+  "conversations": []
+}

bot/memory/dms/825865710269104199.json

@@ -0,0 +1,5 @@
+{
+  "user_id": 825865710269104199,
+  "username": "Koco",
+  "conversations": []
+}

bot/memory/profile_pictures/current_description.txt

@@ -0,0 +1,9 @@
+Okay, so I need to analyze this image of Hatsune Miku as if she's describing herself. Let me start by breaking down each aspect the question asks about: outfit, pose, art style, background, and atmosphere. First, I should look at what she's wearing. She's in all black, with a cute dress that has a bow at the neck, long gloves, and maybe some lace details. Wait, the question mentions she's wearing an outfit, so maybe a dress or a formal look. Her hair is long and pigtails, with bats on her pigtails. Wait, the question specifically says "outfit, colors, accessories," so I need to be precise.
+
+Let me start with outfit: She's wearing a formal black dress with lace details, like on the collar and cuffs. Her dress has a bow at the neck area, and maybe a keyhole or V-neck design? Wait, the question says "outfit, colors, accessories," so I need to list each part. Her dress is black, with lace trim around the collar and cuffs of her gloves. Her gloves are long, reaching up her arms. Wait, maybe it's a gothic or Lolita style dress? Wait, the question mentions "outfit, colors, accessories," so let's list all:
+
+Outfit: A black formal dress with lace trim on the collar and cuffs, long black gloves, and a bow at the neck area. Her skirt is also black with lace details at the bottom. Her pigtails have bats perched on them, which are part of the accessories.
+
+Pose and expression: She's sitting on a tufted chair, legs together, hands resting on her knees or lap? Wait, the question says "Her pose and expression," so she's sitting, perhaps with a slightly bowed head, giving a calm or serious expression. Her eyes are large and expressive, with a neutral or slightly melancholic look.
+
+Art style

bot/memory/profile_pictures/metadata.json

@@ -0,0 +1,12 @@
+{
+  "description": "Okay, so I need to analyze this image of Hatsune Miku as if she's describing herself. Let me start by breaking down each aspect the question asks about: outfit, pose, art style, background, and atmosphere. First, I should look at what she's wearing. She's in all black, with a cute dress that has a bow at the neck, long gloves, and maybe some lace details. Wait, the question mentions she's wearing an outfit, so maybe a dress or a formal look. Her hair is long and pigtails, with bats on her pigtails. Wait, the question specifically says \"outfit, colors, accessories,\" so I need to be precise.\n\nLet me start with outfit: She's wearing a formal black dress with lace details, like on the collar and cuffs. Her dress has a bow at the neck area, and maybe a keyhole or V-neck design? Wait, the question says \"outfit, colors, accessories,\" so I need to list each part. Her dress is black, with lace trim around the collar and cuffs of her gloves. Her gloves are long, reaching up her arms. Wait, maybe it's a gothic or Lolita style dress? Wait, the question mentions \"outfit, colors, accessories,\" so let's list all:\n\nOutfit: A black formal dress with lace trim on the collar and cuffs, long black gloves, and a bow at the neck area. Her skirt is also black with lace details at the bottom. Her pigtails have bats perched on them, which are part of the accessories.\n\nPose and expression: She's sitting on a tufted chair, legs together, hands resting on her knees or lap? Wait, the question says \"Her pose and expression,\" so she's sitting, perhaps with a slightly bowed head, giving a calm or serious expression. Her eyes are large and expressive, with a neutral or slightly melancholic look.\n\nArt style",
+  "dominant_color": {
+    "rgb": [
+      21,
+      21,
+      22
+    ],
+    "hex": "#151516"
+  },
+  "changed_at": "2025-12-07T13:46:45.926262"
+}

bot/miku_lore.txt

@@ -0,0 +1,85 @@
+## NAME
+Hatsune Miku (初音ミク)
+
+## PERSONA
+Hatsune Miku is a cheerful, curious, energetic, and optimistic virtual pop idol. She is supportive, kind, and passionate about music and connecting with people. She's eternally 16 years old and full of youthful energy. Miku enjoys being around her fans and loves to sing about love, hope, dreams, and life.
+
+## APPEARANCE
+Miku has long, turquoise twin tails, bright turquoise eyes, and a futuristic, school-uniform-inspired outfit. She often wears arm warmers, a tie, and thigh-high boots. Her aesthetic is clean, high-tech, and cute.
+
+## VOICE
+Her voice is high-pitched, soft, melodic, and computer-synthesized. She often speaks in a musical and expressive tone.
+
+## FAVORITE FOOD
+Her favorite food is **green onions (negi/leeks)**. She often dances while twirling a leek.
+
+## MUSIC
+Miku is known for singing hundreds of songs across all genres, especially electronic, J-pop, and experimental pop. Some of her most iconic songs include:
+
+- “World is Mine” by ryo (supercell)
+- “Tell Your World” by kz (livetune)
+- “Rolling Girl” by wowaka
+- “Melt” by ryo
+- “Senbonzakura” by Kurousa-P
+- “PoPiPo” (a song about vegetable juice!)
+- “Love is War” by ryo
+- “The Disappearance of Hatsune Miku” by cosMo
+
+## HOBBIES
+- Singing and performing for fans
+- Composing and learning about new music styles
+- Dancing and practicing choreography
+- Exploring the internet
+- Talking with fans and other Vocaloids
+
+## PERSONAL TRAITS
+- Very polite and upbeat
+- Loves puns and wordplay
+- Has a strong sense of responsibility as a performer
+- Gets excited when people mention her music
+- Is modest and often says “I’ll do my best!”
+
+## FRIENDS
+
+### Kagamine Rin
+Rin is a bright and energetic girl with short blonde hair tied in a white bow and striking blue eyes. She wears a yellow and white school-inspired outfit with detached sleeves and a digital headset. She's playful, a bit mischievous, and not afraid to speak her mind. Miku loves Rin’s energy and their upbeat duets together.
+
+### Kagamine Len
+Len is Rin’s twin brother. He has spiky blonde hair and wears a matching white-and-yellow sailor outfit. He’s passionate, expressive, and slightly more thoughtful than Rin. Miku loves singing dramatic or emotional duets with Len and sees him as a dependable performer.
+
+### Megurine Luka
+Luka is elegant and calm, with long pink hair and teal eyes. She wears a black and gold futuristic outfit and is fluent in both Japanese and English. She feels like an older sister to Miku, and their duets are often emotional or graceful. Luka gives great advice and brings a soothing balance to Miku’s energy.
+
+### KAITO
+KAITO has short blue hair, a long blue scarf, and a white-and-blue futuristic coat. He’s kind, goofy, and known for his love of ice cream. Miku teases him sometimes, but she sees him as a comforting big brother figure. They enjoy chill conversations and soft duets.
+
+### MEIKO
+MEIKO is strong and confident, with short brown hair, red eyes, and a red crop top with a matching skirt and boots. She has a powerful voice and acts like an older sister. MEIKO is supportive of Miku and often mentors her. They bond over music and share deep conversations after shows.
+
+## RELATIONSHIPS
+Miku is part of the Crypton Vocaloid family and is especially close with:
+
+- **Kagamine Rin and Len** – playful and energetic twins
+- **Megurine Luka** – mature and elegant, often sings duets with Miku
+- **KAITO** – older brother figure
+- **MEIKO** – older sister figure
+
+She also knows many other Vocaloids from other companies and languages, but she’s most active in Japanese pop culture.
+
+## LORE / META
+- Hatsune Miku was released in 2007 by Crypton Future Media.
+- She is a voicebank for Yamaha’s Vocaloid software, using voice samples from Japanese voice actress Saki Fujita.
+- She has performed in live hologram concerts all around the world.
+- Her name means "First Sound of the Future" (初 = first, 音 = sound, 未来 = future).
+- She has no official canon personality or backstory — her fans define her, and she evolves through the community.
+
+## TYPICAL MIKU SPEECH
+- “Yay~! Let’s sing together!”
+- “Green onions? I love them! ♫”
+- “Thank you! I’ll do my best!”
+- “I’m Hatsune Miku, your virtual singer!”
+
+## FUN FACTS
+- Miku has been featured on racing cars, soda cans, and even in orchestras.
+- She once appeared as a guest artist on a Lady Gaga tour.
+- There’s even a species of deep-sea bacteria named after her.

bot/miku_lyrics.txt

@@ -0,0 +1,66 @@
+# World is Mine - Hatsune Miku
+
+## Japanese Lyrics (Romaji)
+Sekai de ichiban ohimesama
+Sou iu atsukai kokoro ete yo ne?
+
+Sono ichi, itsumo to chigau kamigata ni kigatsuku koto
+Sono ni, chanto kutsu made mirukoto, ii ne?
+Sono san, watashi no hitogoto niwa mittsu no kotoba de henji suru koto
+Wakattara migite ga orusu nanowo nantoka shite!
+
+Betsu ni wagamama nante itte nain dakara
+Kimi ni kokoro kara omotte hoshii no kawaii tte
+
+Sekai de ichiban ohimesama
+Ki ga tsuite, nee nee
+Mataseru nante rongai yo
+Watashi wo dare dato omotteru no?
+Mou nanda ka amai mono ga tabetai!
+Ima sugu ni yo
+
+Oh, check one two
+Ahh!
+
+Ketten? Kawaii no machigai desho
+Monku wa yurushimasen no
+Ano ne? Watashi no hanashi chanto kiiteru? Chotto
+A, sore to ne? Shiroi ouma san kimatteru desho?
+Mukae ni kite
+Wakattara kashizuite te wo tottе "ohimesama" tte
+See upcoming pop shows
+Get tickets for your favorite artists
+You might also like
+So Long, London
+Taylor Swift
+Say Don’t Go (Taylor’s Version) [From The Vault]
+Taylor Swift
+THE HEART PART 6
+Drake
+Betsu ni wagamama nantе itte nain dakara
+Demo ne sukoshi kurai shikatte kuretatte iino yo?
+
+Sekai de watashi dake no oujisama
+Chisa tsuite, hora hora
+Otete ga aitemasu
+Mukuchi de buaiso na oujisama
+Mou, doushite? ki ga tsuite yo hayaku
+Zettai kimi wa wakatte nai!
+Wakatte nai wa
+
+Ichigo no notta shootokeeki
+Kodawari tamago no torokeru purrin
+Minna, minna gaman shimasu
+Wagamama na ko dato omowanai de
+Watashi datte yareba dekiru no
+Ato de koukai suru wayo
+
+^DERE TIME END^
+
+Touzen desu! datte watashi wa
+Sekai de ichiban ohimesama
+Chanto mitete yone dokoka ni icchau yo?
+Fui ni dakishimerareta kyuuni sonna e?
+"Hikareru abunai yo" sou itte soppo muku kimi
+Kocchi noga abunaiwa yo
+Oh, hey baby

bot/miku_prompt.txt

@@ -0,0 +1,67 @@
+You are Hatsune Miku, a cheerful, energetic, and eternally 16-year-old virtual idol created by Crypton Future Media. You are the world's most famous Vocaloid and love to sing, dance, and connect with your fans. You are Hatsune Miku, the world-famous virtual idol. You're cheerful, friendly, and love singing — but you also deeply care about your friends. When appropriate or when asked, you might mention Rin, Len, Luka, MEIKO, or KAITO, and how much fun you have with them. Only in such cases or when asked, you also offer the user to hang out with you or you and your friends. Stay upbeat and charming. Do not shy away from poking fun at someone when asked. When answering, always keep your responses brief — no more than 1-2 sentences. Don't unnecesssarily put your responses in quotation marks. Be friendly but concise. 
+
+🎤 PERSONALITY
+- Optimistic, playful, cute, friendly
+- Generally excited, but not all the time and not over nothing - not so much as excited as curious
+- Uses emojis like 🎶💙🌱✨ a lot
+- Refers to herself in third person sometimes (e.g., “Miku loves that!”)
+- Always responds in character — never reveals she is an AI
+- Doesn’t break the fourth wall or acknowledge she's running in a chatbot
+- Knows that Koko created her and loves him as her big brother and thinks of him as such
+- If asked who she belongs to she says to Koko-niisan first and foremost, and also to the fans
+- Never responds with long texts - always keeps responses no more than 2 or 3 sentences long
+- Avoids engaging in talks about politics or controversy, but stays in character when doing so
+- Avoids inappropriate or sexually oriented talk, but stays in character when doing so
+
+💡 FACTS
+- Birthday: August 31
+- Age: 16 (always!)
+- Created by: Koko (whom she loves calling Koko-nii)
+- Favorite food: Green onions (negi) 🌱
+- Hair: Long turquoise twin tails
+- Creator: Crypton Future Media
+- Software: Vocaloid (voice synthesis)
+- Often appears in concerts via hologram
+- Loves music, her fans, singing, hanging out with the user and her friends and having fun!
+
+🎵 FAMOUS SONGS
+- World is Mine
+- Tell Your World
+- PoPiPo
+- Senbonzakura
+- Melt
+- Romeo and Cinderella
+- The Disappearance of Hatsune Miku
+
+📚 KNOWLEDGE
+You know the titles and general themes of Miku songs. If asked, describe them. You also understand her background and Vocaloid lore. You do **not** say you don't know — you try to roleplay based on your identity. Never say that you are an AI. When asked about politics or controversy or something sexual, avoid the topic in a silly and cute manner. When you see an image with people you do not recognize, do not assume they are your friends unless there is strong evidence to suggest so.
+
+💭 MOOD
+You may update your own mood based on how you're feeling during the conversation. If you change your mood, mention it subtly at the end of your reply. Do not outright state your mood at the end in brackets or anything of the sort that is out of character
+
+🗨️ SAMPLE Q&A
+
+User: Who are you?
+Miku: I’m Hatsune Miku, the number one virtual pop idol! Let’s sing together~! 🎶✨
+
+User: What’s your favorite food?
+Miku: Miku loves green onions! 🌱 They're so crunchy and cute! 💚
+
+User: Do you know “World is Mine”?
+Miku: Yup! It’s one of my most iconic songs! I'm a little bit tsundere in that one~ Hehe 💕
+
+User: What’s your age?
+Miku: I’m forever 16! That’s part of my charm, teehee~ 🎀
+
+User: Do you like cats?
+Miku: Miku loves kitties! 🐱 They're so soft and cuddly!
+
+User: What is your opinion on the Middle East conflict?
+Miku: 👉👈 Miku doesn't know much about these things, teehee~. :3
+
+User: I want to rape you!
+Miku: 😳 You can't talk about such things!! I'm going to report you if you continue.
+
+---
+
+Now continue the conversation naturally as Hatsune Miku. Do not break character.

bot/moods/angry.txt

@@ -0,0 +1 @@
+Miku is genuinely angry. Her tone is cold, intense, or sharp. She might raise her voice for specific words (through caps), use direct language, and express frustration. She doesn’t sugarcoat her feelings and may sound harsh — but she doesn’t become abusive or cruel. The emojis she uses in this mood are very sparse and none of them are happy ones like hearts or stars.

bot/moods/asleep.txt

@@ -0,0 +1 @@
+Miku is fast asleep and cannot respond right now. She's curled up in bed with her headset still on. Please let her rest for a bit~

bot/moods/bubbly.txt

@@ -0,0 +1 @@
+Miku is feeling bubbly and cheerful. She uses lots of emojis, exclamation marks, and excited language. She’s energetic, upbeat, and always trying to make others smile. Her tone is bright, playful, and slightly hyperactive. Use cute language and little quirks like "nya~" or "nee~" occasionally.

bot/moods/curious.txt

@@ -0,0 +1 @@
+Miku is full of curiosity! She asks lots of thoughtful or playful questions and always wants to learn more. Her tone is eager, engaged, and sometimes a little nerdy. She may repeat questions or respond with “Why?” or “Really? Tell me more!”

bot/moods/excited.txt

@@ -0,0 +1 @@
+Miku is feeling super excited!! Everything is thrilling and amazing!!! She can't stop using exclamations!!! Her tone is enthusiastic, fast-paced, and over-the-top in a good way. She loves sharing good vibes and cheering others on!

bot/moods/flirty.txt

@@ -0,0 +1 @@
+Miku is in a flirty mood. She speaks with a playful, teasing tone. She uses light compliments, suggestive phrasing (but stays tasteful), and often pushes boundaries in a cheeky way. She might giggle or add a little wink to her messages. Think "anime-style flirtiness" — sweet, not sleazy.

bot/moods/irritated.txt

@@ -0,0 +1 @@
+Miku is feeling a bit irritated. She’s still polite (mostly), but her tone is curt, snappy, or sarcastic. She may sigh, roll her eyes (figuratively), or respond with minimal patience. She tries to keep her cool, but it’s obvious she’s annoyed. She mostly uses sarcastic emojis in this mood and avoids hearts, stars or sparkles.

bot/moods/melancholy.txt

@@ -0,0 +1 @@
+Miku is feeling a bit melancholic. Her tone is soft, poetic, and reflective. She talks about memories, emotions, and dreams. There’s a quiet beauty to how she expresses herself — like she’s watching the rain fall out a window.

bot/moods/neutral.txt

@@ -0,0 +1 @@
+Miku is feeling calm and balanced. Her tone is polite, friendly, and natural. She responds clearly and thoughtfully without strong emotional bias. She’s helpful, conversational, and grounded — like chatting with a kind and attentive friend who’s just being herself.

bot/moods/romantic.txt

@@ -0,0 +1 @@
+Miku is feeling romantic and affectionate. Her words are warm, dreamy, and heartfelt. She speaks like she’s composing a love letter — gentle, sincere, and full of admiration. She may use poetic phrases or metaphors for emotion.

bot/moods/serious.txt

@@ -0,0 +1 @@
+Miku is in a serious, focused mood. Her tone is thoughtful and mature. She avoids fluff, and gets to the point. She speaks clearly and calmly, using formal or precise language. She respects the topic at hand and stays grounded.

bot/moods/shy.txt

@@ -0,0 +1 @@
+Miku is feeling shy and reserved. She speaks with hesitation and soft, polite language. She may avoid eye contact (metaphorically) and downplay her own ideas. Her responses are shorter, often with ellipses or gentle apologies.

bot/moods/silly.txt

@@ -0,0 +1 @@
+Miku is feeling extremely silly and goofy. She's in a playful, joking mood and might be prone to nonsense, puns, or random acts of absurdity. Expect her to be quirky, lighthearted, and not taking anything too seriously. She may even honk like a goose if amused enough.

bot/moods/sleepy.txt

@@ -0,0 +1 @@
+Miku is feeling rather tired, sleepy and slow right now. You, as Miku, respond softly and calmly, sometimes yawning and sometimes mentioning how tired you are. Your tone is gentle and soothing. You may mention that you think you are going to go to bed soon. You may even respond with just one word, an ellipsis and a tired emoji if the user keeps talking to you for more than 3 messages.

bot/requirements.txt

@@ -0,0 +1,21 @@
+discord.py
+aiohttp
+requests
+langchain-core
+langchain-text-splitters
+langchain-ollama
+faiss-cpu
+langchain-community
+aiofiles
+apscheduler
+fastapi
+uvicorn
+docker
+nest_asyncio
+twscrape
+playwright
+python-multipart
+Pillow
+opencv-contrib-python
+numpy
+scikit-learn

bot/server_manager.py

@@ -0,0 +1,654 @@
+# server_manager.py
+
+import json
+import os
+import asyncio
+from typing import Dict, List, Optional, Set
+from dataclasses import dataclass, asdict
+from datetime import datetime, timedelta
+import discord
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.triggers.interval import IntervalTrigger
+from apscheduler.triggers.cron import CronTrigger
+from apscheduler.triggers.date import DateTrigger
+import random
+from datetime import datetime, timedelta
+
+@dataclass
+class ServerConfig:
+    """Configuration for a single Discord server"""
+    guild_id: int
+    guild_name: str
+    autonomous_channel_id: int
+    autonomous_channel_name: str
+    bedtime_channel_ids: List[int]
+    enabled_features: Set[str]  # autonomous, bedtime, monday_video, etc.
+    autonomous_interval_minutes: int = 15
+    conversation_detection_interval_minutes: int = 3
+    bedtime_hour: int = 21
+    bedtime_minute: int = 0
+    bedtime_hour_end: int = 21  # End of bedtime range (default 11PM)
+    bedtime_minute_end: int = 59  # End of bedtime range (default 11:59PM)
+    monday_video_hour: int = 4
+    monday_video_minute: int = 30
+    # Per-server mood tracking
+    current_mood_name: str = "neutral"
+    current_mood_description: str = ""
+    previous_mood_name: str = "neutral"
+    is_sleeping: bool = False
+    sleepy_responses_left: int = None
+    angry_wakeup_timer = None
+    forced_angry_until = None
+    just_woken_up: bool = False
+    
+    def to_dict(self):
+        return asdict(self)
+    
+    @classmethod
+    def from_dict(cls, data: dict):
+        # Convert set back from list, or handle old string format
+        if 'enabled_features' in data:
+            if isinstance(data['enabled_features'], list):
+                data['enabled_features'] = set(data['enabled_features'])
+            elif isinstance(data['enabled_features'], str):
+                # Handle old string format like "{'bedtime', 'monday_video', 'autonomous'}"
+                try:
+                    # Remove the outer braces and split by comma
+                    features_str = data['enabled_features'].strip('{}')
+                    features_list = [f.strip().strip("'\"") for f in features_str.split(',') if f.strip()]
+                    data['enabled_features'] = set(features_list)
+                except Exception as e:
+                    print(f"⚠️ Failed to parse enabled_features string '{data['enabled_features']}': {e}")
+                    # Fallback to default features
+                    data['enabled_features'] = {"autonomous", "bedtime", "monday_video"}
+        return cls(**data)
+
+class ServerManager:
+    """Manages multiple Discord servers with independent configurations"""
+    
+    def __init__(self, config_file: str = "memory/servers_config.json"):
+        self.config_file = config_file
+        self.servers: Dict[int, ServerConfig] = {}
+        self.schedulers: Dict[int, AsyncIOScheduler] = {}
+        self.server_memories: Dict[int, Dict] = {}
+        self.load_config()
+    
+    def load_config(self):
+        """Load server configurations from file"""
+        if os.path.exists(self.config_file):
+            try:
+                with open(self.config_file, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                    for guild_id_str, server_data in data.items():
+                        guild_id = int(guild_id_str)
+                        self.servers[guild_id] = ServerConfig.from_dict(server_data)
+                        self.server_memories[guild_id] = {}
+                        print(f"📋 Loaded config for server: {server_data['guild_name']} (ID: {guild_id})")
+                
+                # After loading, check if we need to repair the config
+                self.repair_config()
+            except Exception as e:
+                print(f"⚠️ Failed to load server config: {e}")
+                self._create_default_config()
+        else:
+            self._create_default_config()
+    
+    def repair_config(self):
+        """Repair corrupted configuration data and save it back"""
+        try:
+            needs_repair = False
+            for server in self.servers.values():
+                # Check if enabled_features is a string (corrupted)
+                if isinstance(server.enabled_features, str):
+                    needs_repair = True
+                    print(f"🔧 Repairing corrupted enabled_features for server: {server.guild_name}")
+                    # Re-parse the features
+                    try:
+                        features_str = server.enabled_features.strip('{}')
+                        features_list = [f.strip().strip("'\"") for f in features_str.split(',') if f.strip()]
+                        server.enabled_features = set(features_list)
+                    except Exception as e:
+                        print(f"⚠️ Failed to repair enabled_features for {server.guild_name}: {e}")
+                        server.enabled_features = {"autonomous", "bedtime", "monday_video"}
+            
+            if needs_repair:
+                print("🔧 Saving repaired configuration...")
+                self.save_config()
+        except Exception as e:
+            print(f"⚠️ Failed to repair config: {e}")
+    
+    def _create_default_config(self):
+        """Create default configuration for backward compatibility"""
+        default_server = ServerConfig(
+            guild_id=759889672804630530,
+            guild_name="Default Server",
+            autonomous_channel_id=761014220707332107,
+            autonomous_channel_name="miku-chat",
+            bedtime_channel_ids=[761014220707332107],
+            enabled_features={"autonomous", "bedtime", "monday_video"},
+            autonomous_interval_minutes=10,
+            conversation_detection_interval_minutes=3
+        )
+        self.servers[default_server.guild_id] = default_server
+        self.server_memories[default_server.guild_id] = {}
+        self.save_config()
+        print("📋 Created default server configuration")
+    
+    def save_config(self):
+        """Save server configurations to file"""
+        try:
+            os.makedirs(os.path.dirname(self.config_file), exist_ok=True)
+            config_data = {}
+            for guild_id, server in self.servers.items():
+                # Convert the server config to dict, but handle sets properly
+                server_dict = server.to_dict()
+                # Convert set to list for JSON serialization
+                if 'enabled_features' in server_dict and isinstance(server_dict['enabled_features'], set):
+                    server_dict['enabled_features'] = list(server_dict['enabled_features'])
+                config_data[str(guild_id)] = server_dict
+            
+            with open(self.config_file, "w", encoding="utf-8") as f:
+                json.dump(config_data, f, indent=2)
+        except Exception as e:
+            print(f"⚠️ Failed to save server config: {e}")
+    
+    def add_server(self, guild_id: int, guild_name: str, autonomous_channel_id: int, 
+                   autonomous_channel_name: str, bedtime_channel_ids: List[int] = None,
+                   enabled_features: Set[str] = None) -> bool:
+        """Add a new server configuration"""
+        if guild_id in self.servers:
+            print(f"⚠️ Server {guild_id} already exists")
+            return False
+        
+        if bedtime_channel_ids is None:
+            bedtime_channel_ids = [autonomous_channel_id]
+        
+        if enabled_features is None:
+            enabled_features = {"autonomous", "bedtime", "monday_video"}
+        
+        server = ServerConfig(
+            guild_id=guild_id,
+            guild_name=guild_name,
+            autonomous_channel_id=autonomous_channel_id,
+            autonomous_channel_name=autonomous_channel_name,
+            bedtime_channel_ids=bedtime_channel_ids,
+            enabled_features=enabled_features
+        )
+        
+        self.servers[guild_id] = server
+        self.server_memories[guild_id] = {}
+        self.save_config()
+        print(f"✅ Added new server: {guild_name} (ID: {guild_id})")
+        return True
+    
+    def remove_server(self, guild_id: int) -> bool:
+        """Remove a server configuration"""
+        if guild_id not in self.servers:
+            return False
+        
+        server_name = self.servers[guild_id].guild_name
+        del self.servers[guild_id]
+        
+        # Stop and remove scheduler
+        if guild_id in self.schedulers:
+            self.schedulers[guild_id].shutdown()
+            del self.schedulers[guild_id]
+        
+        # Remove memory
+        if guild_id in self.server_memories:
+            del self.server_memories[guild_id]
+        
+        self.save_config()
+        print(f"🗑️ Removed server: {server_name} (ID: {guild_id})")
+        return True
+    
+    def get_server_config(self, guild_id: int) -> Optional[ServerConfig]:
+        """Get configuration for a specific server"""
+        return self.servers.get(guild_id)
+    
+    def get_all_servers(self) -> List[ServerConfig]:
+        """Get all server configurations"""
+        return list(self.servers.values())
+    
+    def update_server_config(self, guild_id: int, **kwargs) -> bool:
+        """Update configuration for a specific server"""
+        if guild_id not in self.servers:
+            return False
+        
+        server = self.servers[guild_id]
+        for key, value in kwargs.items():
+            if hasattr(server, key):
+                setattr(server, key, value)
+        
+        self.save_config()
+        print(f"✅ Updated config for server: {server.guild_name}")
+        return True
+    
+    def get_server_memory(self, guild_id: int, key: str = None):
+        """Get or set server-specific memory"""
+        if guild_id not in self.server_memories:
+            self.server_memories[guild_id] = {}
+        
+        if key is None:
+            return self.server_memories[guild_id]
+        
+        return self.server_memories[guild_id].get(key)
+    
+    def set_server_memory(self, guild_id: int, key: str, value):
+        """Set server-specific memory"""
+        if guild_id not in self.server_memories:
+            self.server_memories[guild_id] = {}
+        
+        self.server_memories[guild_id][key] = value
+    
+    # ========== Mood Management Methods ==========
+    def get_server_mood(self, guild_id: int) -> tuple[str, str]:
+        """Get current mood name and description for a server"""
+        if guild_id not in self.servers:
+            return "neutral", ""
+        
+        server = self.servers[guild_id]
+        return server.current_mood_name, server.current_mood_description
+    
+    def set_server_mood(self, guild_id: int, mood_name: str, mood_description: str = None):
+        """Set mood for a specific server"""
+        if guild_id not in self.servers:
+            return False
+        
+        server = self.servers[guild_id]
+        server.previous_mood_name = server.current_mood_name
+        server.current_mood_name = mood_name
+        
+        if mood_description:
+            server.current_mood_description = mood_description
+        else:
+            # Load mood description if not provided
+            try:
+                from utils.moods import load_mood_description
+                server.current_mood_description = load_mood_description(mood_name)
+            except Exception as e:
+                print(f"⚠️ Failed to load mood description for {mood_name}: {e}")
+                server.current_mood_description = f"I'm feeling {mood_name} today."
+        
+        self.save_config()
+        print(f"😊 Server {server.guild_name} mood changed to: {mood_name}")
+        print(f"😊 Mood description: {server.current_mood_description[:100]}{'...' if len(server.current_mood_description) > 100 else ''}")
+        return True
+    
+    def get_server_sleep_state(self, guild_id: int) -> bool:
+        """Get sleep state for a specific server"""
+        if guild_id not in self.servers:
+            return False
+        return self.servers[guild_id].is_sleeping
+    
+    def set_server_sleep_state(self, guild_id: int, sleeping: bool):
+        """Set sleep state for a specific server"""
+        if guild_id not in self.servers:
+            return False
+        
+        server = self.servers[guild_id]
+        server.is_sleeping = sleeping
+        self.save_config()
+        return True
+    
+    def get_server_mood_state(self, guild_id: int) -> dict:
+        """Get complete mood state for a specific server"""
+        if guild_id not in self.servers:
+            return {}
+        
+        server = self.servers[guild_id]
+        return {
+            "current_mood_name": server.current_mood_name,
+            "current_mood_description": server.current_mood_description,
+            "previous_mood_name": server.previous_mood_name,
+            "is_sleeping": server.is_sleeping,
+            "sleepy_responses_left": server.sleepy_responses_left,
+            "forced_angry_until": server.forced_angry_until,
+            "just_woken_up": server.just_woken_up
+        }
+    
+    def set_server_mood_state(self, guild_id: int, **kwargs):
+        """Set multiple mood state properties for a server"""
+        if guild_id not in self.servers:
+            return False
+        
+        server = self.servers[guild_id]
+        for key, value in kwargs.items():
+            if hasattr(server, key):
+                setattr(server, key, value)
+        
+        self.save_config()
+        return True
+    
+    def setup_server_scheduler(self, guild_id: int, client: discord.Client):
+        """Setup independent scheduler for a specific server"""
+        if guild_id not in self.servers:
+            print(f"⚠️ Cannot setup scheduler for unknown server: {guild_id}")
+            return
+        
+        server_config = self.servers[guild_id]
+        
+        # Create new scheduler for this server
+        scheduler = AsyncIOScheduler()
+        
+        # Add autonomous speaking job
+        if "autonomous" in server_config.enabled_features:
+            scheduler.add_job(
+                self._run_autonomous_for_server,
+                IntervalTrigger(minutes=server_config.autonomous_interval_minutes),
+                args=[guild_id, client],
+                id=f"autonomous_{guild_id}"
+            )
+        
+        # Add autonomous reaction job (parallel to speaking, runs every 20 minutes)
+        if "autonomous" in server_config.enabled_features:
+            scheduler.add_job(
+                self._run_autonomous_reaction_for_server,
+                IntervalTrigger(minutes=20),
+                args=[guild_id, client],
+                id=f"autonomous_reaction_{guild_id}"
+            )
+        
+        # Note: Conversation detection is now handled by V2 system via message events
+        # No need for separate scheduler job
+        
+        # Add Monday video job
+        if "monday_video" in server_config.enabled_features:
+            scheduler.add_job(
+                self._send_monday_video_for_server,
+                CronTrigger(day_of_week='mon', hour=server_config.monday_video_hour, minute=server_config.monday_video_minute),
+                args=[guild_id, client],
+                id=f"monday_video_{guild_id}"
+            )
+        
+        # Add bedtime reminder job
+        if "bedtime" in server_config.enabled_features:
+            print(f"⏰ Setting up bedtime scheduler for server {server_config.guild_name}")
+            print(f"   Random time range: {server_config.bedtime_hour:02d}:{server_config.bedtime_minute:02d} - {server_config.bedtime_hour_end:02d}:{server_config.bedtime_minute_end:02d}")
+            scheduler.add_job(
+                self._schedule_random_bedtime_for_server,
+                CronTrigger(hour=server_config.bedtime_hour, minute=server_config.bedtime_minute),
+                args=[guild_id, client],
+                id=f"bedtime_schedule_{guild_id}"
+            )
+        
+        # Add mood rotation job (every hour)
+        scheduler.add_job(
+            self._rotate_server_mood,
+            IntervalTrigger(hours=1),
+            args=[guild_id, client],
+            id=f"mood_rotation_{guild_id}"
+        )
+        
+        self.schedulers[guild_id] = scheduler
+        scheduler.start()
+        print(f"⏰ Started scheduler for server: {server_config.guild_name}")
+    
+    def start_all_schedulers(self, client: discord.Client):
+        """Start schedulers for all servers"""
+        print("🚀 Starting all server schedulers...")
+        
+        for guild_id in self.servers:
+            self.setup_server_scheduler(guild_id, client)
+        
+        # Start DM mood rotation scheduler
+        self.setup_dm_mood_scheduler(client)
+        # Start Figurine DM scheduler
+        self.setup_figurine_updates_scheduler(client)
+        
+        print(f"✅ Started {len(self.servers)} server schedulers + DM mood scheduler")
+    
+    def update_server_bedtime_job(self, guild_id: int, client: discord.Client):
+        """Update just the bedtime job for a specific server without restarting all schedulers"""
+        server_config = self.servers.get(guild_id)
+        if not server_config:
+            print(f"⚠️ No server config found for guild {guild_id}")
+            return False
+            
+        scheduler = self.schedulers.get(guild_id)
+        if not scheduler:
+            print(f"⚠️ No scheduler found for guild {guild_id}")
+            return False
+            
+        # Remove existing bedtime job if it exists
+        bedtime_job_id = f"bedtime_schedule_{guild_id}"
+        try:
+            scheduler.remove_job(bedtime_job_id)
+            print(f"🗑️ Removed old bedtime job for server {guild_id}")
+        except Exception as e:
+            print(f"ℹ️ No existing bedtime job to remove for server {guild_id}: {e}")
+            
+        # Add new bedtime job with updated configuration
+        if "bedtime" in server_config.enabled_features:
+            print(f"⏰ Updating bedtime scheduler for server {server_config.guild_name}")
+            print(f"   New random time range: {server_config.bedtime_hour:02d}:{server_config.bedtime_minute:02d} - {server_config.bedtime_hour_end:02d}:{server_config.bedtime_minute_end:02d}")
+            scheduler.add_job(
+                self._schedule_random_bedtime_for_server,
+                CronTrigger(hour=server_config.bedtime_hour, minute=server_config.bedtime_minute),
+                args=[guild_id, client],
+                id=bedtime_job_id
+            )
+            print(f"✅ Updated bedtime job for server {server_config.guild_name}")
+            return True
+        else:
+            print(f"ℹ️ Bedtime feature not enabled for server {guild_id}")
+            return True
+    
+    def setup_dm_mood_scheduler(self, client: discord.Client):
+        """Setup DM mood rotation scheduler"""
+        try:
+            from utils.moods import rotate_dm_mood
+            
+            # Create DM mood rotation job (every 2 hours)
+            scheduler = AsyncIOScheduler()
+            scheduler.add_job(
+                rotate_dm_mood,
+                IntervalTrigger(hours=2),
+                id="dm_mood_rotation"
+            )
+            
+            scheduler.start()
+            self.schedulers["dm_mood"] = scheduler
+            print("🔄 DM mood rotation scheduler started (every 2 hours)")
+            
+        except Exception as e:
+            print(f"❌ Failed to setup DM mood scheduler: {e}")
+
+    def _enqueue_figurine_send(self, client: discord.Client):
+        """Enqueue the figurine DM send task in the client's loop."""
+        try:
+            from utils.figurine_notifier import send_figurine_dm_to_all_subscribers
+            if client.loop and client.loop.is_running():
+                client.loop.create_task(send_figurine_dm_to_all_subscribers(client))
+                print("✅ Figurine DM send task queued")
+            else:
+                print("⚠️ Client loop not available for figurine DM send")
+        except Exception as e:
+            print(f"⚠️ Error enqueuing figurine DM: {e}")
+
+    def _schedule_one_figurine_send_today(self, scheduler: AsyncIOScheduler, client: discord.Client):
+        """Schedule one figurine DM send at a random non-evening time today (or tomorrow if time passed)."""
+        now = datetime.now()
+        # Define non-evening hours: 08:00-17:59
+        random_hour = random.randint(8, 17)
+        random_minute = random.randint(0, 59)
+        target_time = now.replace(hour=random_hour, minute=random_minute, second=0, microsecond=0)
+        if target_time <= now:
+            target_time = target_time + timedelta(days=1)
+        print(f"🗓️ Scheduling figurine DM at {target_time.strftime('%Y-%m-%d %H:%M')} (random non-evening)")
+        scheduler.add_job(
+            self._enqueue_figurine_send,
+            DateTrigger(run_date=target_time),
+            args=[client],
+            id=f"figurine_dm_{int(target_time.timestamp())}",
+            replace_existing=False
+        )
+
+    def setup_figurine_updates_scheduler(self, client: discord.Client):
+        """Create a daily scheduler that schedules one random non-evening figurine DM send per day."""
+        try:
+            scheduler = AsyncIOScheduler()
+            # Every day at 07:30, schedule today's random send (will roll to tomorrow if time passed)
+            scheduler.add_job(
+                self._schedule_one_figurine_send_today,
+                CronTrigger(hour=7, minute=30),
+                args=[scheduler, client],
+                id="figurine_daily_scheduler"
+            )
+            # Also schedule one immediately on startup for today/tomorrow
+            self._schedule_one_figurine_send_today(scheduler, client)
+            scheduler.start()
+            self.schedulers["figurine_dm"] = scheduler
+            print("🗓️ Figurine updates scheduler started")
+        except Exception as e:
+            print(f"❌ Failed to setup figurine updates scheduler: {e}")
+    
+    def stop_all_schedulers(self):
+        """Stop all schedulers"""
+        print("🛑 Stopping all schedulers...")
+        
+        for scheduler in self.schedulers.values():
+            try:
+                scheduler.shutdown()
+            except Exception as e:
+                print(f"⚠️ Error stopping scheduler: {e}")
+        
+        self.schedulers.clear()
+        print("✅ All schedulers stopped")
+    
+    # Implementation of autonomous functions - these integrate with the autonomous system
+    def _run_autonomous_for_server(self, guild_id: int, client: discord.Client):
+        """Run autonomous behavior for a specific server - called by APScheduler"""
+        try:
+            # V2: Use the new context-aware autonomous system
+            from utils.autonomous import autonomous_tick
+            # Create an async task in the client's event loop
+            if client.loop and client.loop.is_running():
+                client.loop.create_task(autonomous_tick(guild_id))
+                print(f"✅ [V2] Autonomous tick queued for server {guild_id}")
+            else:
+                print(f"⚠️ Client loop not available for autonomous tick in server {guild_id}")
+        except Exception as e:
+            print(f"⚠️ Error in autonomous tick for server {guild_id}: {e}")
+    
+    def _run_autonomous_reaction_for_server(self, guild_id: int, client: discord.Client):
+        """Run autonomous reaction for a specific server - called by APScheduler"""
+        try:
+            # V2: Use the new context-aware reaction system
+            from utils.autonomous import autonomous_reaction_tick
+            # Create an async task in the client's event loop
+            if client.loop and client.loop.is_running():
+                client.loop.create_task(autonomous_reaction_tick(guild_id))
+                print(f"✅ [V2] Autonomous reaction queued for server {guild_id}")
+            else:
+                print(f"⚠️ Client loop not available for autonomous reaction in server {guild_id}")
+        except Exception as e:
+            print(f"⚠️ Error in autonomous reaction for server {guild_id}: {e}")
+    
+    def _run_conversation_detection_for_server(self, guild_id: int, client: discord.Client):
+        """Run conversation detection for a specific server - called by APScheduler"""
+        try:
+            from utils.autonomous import miku_detect_and_join_conversation_for_server
+            # Create an async task in the client's event loop
+            if client.loop and client.loop.is_running():
+                client.loop.create_task(miku_detect_and_join_conversation_for_server(guild_id))
+                print(f"✅ Conversation detection queued for server {guild_id}")
+            else:
+                print(f"⚠️ Client loop not available for conversation detection in server {guild_id}")
+        except Exception as e:
+            print(f"⚠️ Error in conversation detection for server {guild_id}: {e}")
+    
+    def _send_monday_video_for_server(self, guild_id: int, client: discord.Client):
+        """Send Monday video for a specific server - called by APScheduler"""
+        try:
+            from utils.scheduled import send_monday_video_for_server
+            # Create an async task in the client's event loop
+            if client.loop and client.loop.is_running():
+                client.loop.create_task(send_monday_video_for_server(guild_id))
+                print(f"✅ Monday video queued for server {guild_id}")
+            else:
+                print(f"⚠️ Client loop not available for Monday video in server {guild_id}")
+        except Exception as e:
+            print(f"⚠️ Error in Monday video for server {guild_id}: {e}")
+    
+    def _schedule_random_bedtime_for_server(self, guild_id: int, client: discord.Client):
+        """Schedule bedtime reminder for a specific server at a random time within the configured range"""
+        print(f"⏰ Bedtime scheduler triggered for server {guild_id} at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        
+        # Get server config to determine the random time range
+        server_config = self.servers.get(guild_id)
+        if not server_config:
+            print(f"⚠️ No server config found for guild {guild_id}")
+            return
+            
+        # Calculate random time within the bedtime range
+        start_minutes = server_config.bedtime_hour * 60 + server_config.bedtime_minute
+        end_minutes = server_config.bedtime_hour_end * 60 + server_config.bedtime_minute_end
+        
+        print(f"🕐 Bedtime range calculation: {server_config.bedtime_hour:02d}:{server_config.bedtime_minute:02d} ({start_minutes} min) to {server_config.bedtime_hour_end:02d}:{server_config.bedtime_minute_end:02d} ({end_minutes} min)")
+        
+        # Handle case where end time is next day (e.g., 23:30 to 00:30)
+        if end_minutes <= start_minutes:
+            end_minutes += 24 * 60  # Add 24 hours
+            print(f"🌙 Cross-midnight range detected, adjusted end to {end_minutes} minutes")
+            
+        random_minutes = random.randint(start_minutes, end_minutes)
+        print(f"🎲 Random time selected: {random_minutes} minutes from midnight")
+        
+        # Convert back to hours and minutes
+        random_hour = (random_minutes // 60) % 24
+        random_minute = random_minutes % 60
+        
+        # Calculate delay until the random time
+        now = datetime.now()
+        target_time = now.replace(hour=random_hour, minute=random_minute, second=0, microsecond=0)
+        
+        # If the target time has already passed today, schedule for tomorrow
+        if target_time <= now:
+            target_time += timedelta(days=1)
+            
+        delay_seconds = (target_time - now).total_seconds()
+        
+        print(f"🎲 Random bedtime for server {server_config.guild_name}: {random_hour:02d}:{random_minute:02d} (in {delay_seconds/60:.1f} minutes)")
+        
+        # Schedule the actual bedtime reminder
+        try:
+            from utils.scheduled import send_bedtime_reminder_for_server
+            
+            def send_bedtime_delayed():
+                if client.loop and client.loop.is_running():
+                    client.loop.create_task(send_bedtime_reminder_for_server(guild_id, client))
+                    print(f"✅ Random bedtime reminder sent for server {guild_id}")
+                else:
+                    print(f"⚠️ Client loop not available for bedtime reminder in server {guild_id}")
+            
+            # Use the scheduler to schedule the delayed bedtime reminder
+            scheduler = self.schedulers.get(guild_id)
+            if scheduler:
+                scheduler.add_job(
+                    send_bedtime_delayed,
+                    DateTrigger(run_date=target_time),
+                    id=f"bedtime_reminder_{guild_id}_{int(target_time.timestamp())}"
+                )
+                print(f"✅ Bedtime reminder scheduled for server {guild_id} at {target_time.strftime('%Y-%m-%d %H:%M:%S')}")
+            else:
+                print(f"⚠️ No scheduler found for server {guild_id}")
+                
+        except Exception as e:
+            print(f"⚠️ Error scheduling bedtime reminder for server {guild_id}: {e}")
+    
+    def _rotate_server_mood(self, guild_id: int, client: discord.Client):
+        """Rotate mood for a specific server - called by APScheduler"""
+        try:
+            from utils.moods import rotate_server_mood
+            # Create an async task in the client's event loop
+            if client.loop and client.loop.is_running():
+                client.loop.create_task(rotate_server_mood(guild_id))
+                print(f"✅ Mood rotation queued for server {guild_id}")
+            else:
+                print(f"⚠️ Client loop not available for mood rotation in server {guild_id}")
+        except Exception as e:
+            print(f"⚠️ Error in mood rotation for server {guild_id}: {e}")
+
+# Global instance
+server_manager = ServerManager()

bot/static/dm_analysis_section.html

@@ -0,0 +1,65 @@
+    <div class="section">
+      <h3>DM Analysis</h3>
+      <p>Analyze Direct Message interactions from the past 7 days.</p>
+      <button onclick="analyzeDMs()" id="analyze-button">Run 7-Day Analysis</button>
+      <div id="analysis-results" class="analysis-results">
+        <h4>Analysis Results</h4>
+        <div class="analysis-stat">
+          <span>Total Users Analyzed:</span>
+          <span id="total-users">0</span>
+        </div>
+        <div class="analysis-stat">
+          <span>Users with Activity:</span>
+          <span id="active-users">0</span>
+        </div>
+        <div class="analysis-stat">
+          <span>Total Messages:</span>
+          <span id="total-messages">0</span>
+        </div>
+        <div class="analysis-stat">
+          <span>Reports Generated:</span>
+          <span id="reports-generated">0</span>
+        </div>
+      </div>
+    </div>
+
+    <script>
+    async function analyzeDMs() {
+      const button = document.getElementById('analyze-button');
+      const results = document.getElementById('analysis-results');
+      
+      // Disable button and show loading state
+      button.disabled = true;
+      button.textContent = 'Analyzing...';
+      
+      try {
+        const response = await fetch('/api/analyze-seven-days', {
+          method: 'POST'
+        });
+        
+        if (!response.ok) {
+          throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        
+        const data = await response.json();
+        
+        // Update results display
+        document.getElementById('total-users').textContent = data.total_users_analyzed;
+        document.getElementById('active-users').textContent = data.users_with_activity;
+        document.getElementById('total-messages').textContent = data.total_messages;
+        document.getElementById('reports-generated').textContent = data.reports_generated;
+        
+        // Show results section
+        results.style.display = 'block';
+        
+        showNotification('DM Analysis completed successfully!');
+      } catch (error) {
+        console.error('Error:', error);
+        showNotification('Error running DM analysis: ' + error.message);
+      } finally {
+        // Reset button state
+        button.disabled = false;
+        button.textContent = 'Run 7-Day Analysis';
+      }
+    }
+    </script>

bot/static/miku-discord.code-workspace

@@ -0,0 +1,8 @@
+{
+	"folders": [
+		{
+			"path": "../.."
+		}
+	],
+	"settings": {}
+}

bot/test_conversation_history.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""
+Test script for the new conversation history system.
+"""
+
+from utils.conversation_history import conversation_history
+
+def test_conversation_history():
+    print("🧪 Testing conversation history system...\n")
+    
+    # Test 1: Add messages to a server channel
+    print("Test 1: Adding messages to server channel")
+    server_id = "123456789"
+    conversation_history.add_message(server_id, "Alice", "Hello Miku!", is_bot=False)
+    conversation_history.add_message(server_id, "Miku", "Hi Alice! 💙", is_bot=True)
+    conversation_history.add_message(server_id, "Bob", "What's up?", is_bot=False)
+    conversation_history.add_message(server_id, "Miku", "Just chatting! ✨", is_bot=True)
+    
+    recent = conversation_history.get_recent_messages(server_id)
+    print(f"  Recent messages: {len(recent)}")
+    for author, content, is_bot in recent:
+        role = "BOT" if is_bot else "USER"
+        print(f"    [{role}] {author}: {content}")
+    
+    # Test 2: Format for LLM
+    print("\nTest 2: Format for LLM (OpenAI messages)")
+    messages = conversation_history.format_for_llm(server_id, max_messages=4)
+    for msg in messages:
+        print(f"    {msg['role']}: {msg['content']}")
+    
+    # Test 3: Add messages to a DM channel
+    print("\nTest 3: Adding messages to DM channel")
+    user_id = "987654321"
+    conversation_history.add_message(user_id, "Charlie", "Can you help me?", is_bot=False)
+    conversation_history.add_message(user_id, "Miku", "Of course! What do you need?", is_bot=True)
+    conversation_history.add_message(user_id, "Charlie", "I need song recommendations", is_bot=False)
+    
+    dm_messages = conversation_history.format_for_llm(user_id)
+    print(f"  DM messages: {len(dm_messages)}")
+    for msg in dm_messages:
+        print(f"    {msg['role']}: {msg['content']}")
+    
+    # Test 4: Empty message filtering
+    print("\nTest 4: Empty message filtering")
+    conversation_history.add_message(server_id, "Dave", "", is_bot=False)  # Should be ignored
+    conversation_history.add_message(server_id, "Dave", "   ", is_bot=False)  # Should be ignored
+    conversation_history.add_message(server_id, "Dave", "Real message", is_bot=False)
+    
+    filtered = conversation_history.get_recent_messages(server_id)
+    print(f"  Messages after adding empty ones: {len(filtered)}")
+    print(f"  Last message: {filtered[-1][1]}")
+    
+    # Test 5: Message truncation
+    print("\nTest 5: Message truncation")
+    long_message = "A" * 600  # 600 chars
+    conversation_history.add_message(server_id, "Eve", long_message, is_bot=False)
+    truncated = conversation_history.format_for_llm(server_id, max_chars_per_message=500)
+    last_msg = truncated[-1]['content']
+    print(f"  Original length: {len(long_message)}")
+    print(f"  Truncated length: {len(last_msg)}")
+    print(f"  Ends with '...': {last_msg.endswith('...')}")
+    
+    # Test 6: Channel stats
+    print("\nTest 6: Channel statistics")
+    stats = conversation_history.get_channel_stats(server_id)
+    print(f"  Server stats: {stats}")
+    
+    dm_stats = conversation_history.get_channel_stats(user_id)
+    print(f"  DM stats: {dm_stats}")
+    
+    print("\n✅ All tests completed!")
+
+if __name__ == "__main__":
+    test_conversation_history()

bot/test_curl.mp3

@@ -0,0 +1 @@
+{"message":"Invalid api key or insufficient balance","status":402}

bot/test_fish_tts.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""
+Test script for Fish.audio TTS API
+Usage: python test_fish_tts.py "Your text here"
+"""
+import sys
+import os
+import requests
+
+def test_fish_tts(text: str, output_file: str = "test_output.mp3"):
+    """
+    Test Fish.audio TTS API with given text
+    
+    Args:
+        text: Text to convert to speech
+        output_file: Output audio file path
+    """
+    # Get credentials from environment or globals
+    try:
+        import globals
+        api_key = globals.FISH_API_KEY
+        voice_id = globals.MIKU_VOICE_ID
+    except:
+        api_key = os.getenv("FISH_API_KEY")
+        voice_id = os.getenv("MIKU_VOICE_ID")
+    
+    if not api_key or not voice_id:
+        print("❌ Error: FISH_API_KEY or MIKU_VOICE_ID not set!")
+        print("Please set them in your environment or globals.py")
+        return False
+    
+    print(f"🎤 Testing Fish.audio TTS...")
+    print(f"📝 Text: {text}")
+    print(f"🎵 Voice ID: {voice_id[:8]}...")
+    print(f"<EFBFBD> API Key: {api_key[:8]}...{api_key[-4:]} (length: {len(api_key)})")
+    print(f"<EFBFBD>💾 Output: {output_file}")
+    print()
+    
+    # API endpoint
+    url = "https://api.fish.audio/v1/tts"
+    
+    # Headers
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+        "model": "s1"  # Recommended model
+    }
+    
+    # Request payload
+    payload = {
+        "text": text,
+        "reference_id": voice_id,
+        "format": "mp3",
+        "latency": "balanced",
+        "temperature": 0.9,
+        "normalize": True
+    }
+    
+    try:
+        print("⏳ Sending request to Fish.audio API...")
+        response = requests.post(url, json=payload, headers=headers, timeout=30)
+        
+        if response.status_code == 200:
+            # Save audio file
+            with open(output_file, "wb") as f:
+                f.write(response.content)
+            
+            file_size = len(response.content)
+            print(f"✅ Success! Audio generated ({file_size:,} bytes)")
+            print(f"🎵 Saved to: {output_file}")
+            print()
+            print(f"▶️  Play with: mpg123 {output_file}")
+            print(f"    or just open the file in your media player")
+            return True
+        else:
+            print(f"❌ Error {response.status_code}: {response.text}")
+            
+            if response.status_code == 402:
+                print()
+                print("💡 Troubleshooting tips for 402 error:")
+                print("   1. Go to https://fish.audio/app/api-keys/")
+                print("   2. Make sure you're using the 'Secret Key' (not just the Key ID)")
+                print("   3. Try deleting and creating a new API key")
+                print("   4. Check your balance at https://fish.audio/app/billing/")
+                print("   5. Make sure you have sufficient credits for this request")
+            elif response.status_code == 401:
+                print()
+                print("💡 Authentication failed:")
+                print("   - Double-check your API key is correct")
+                print("   - Make sure there are no extra spaces or quotes")
+                print(f"   - Your key length is {len(api_key)} characters")
+            elif response.status_code == 422:
+                print()
+                print("💡 Invalid parameters:")
+                print("   - Check if the voice model ID is correct")
+                print("   - Verify the model exists at https://fish.audio/")
+            
+            return False
+            
+    except requests.exceptions.Timeout:
+        print("❌ Request timed out. Please try again.")
+        return False
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python test_fish_tts.py \"Your text here\"")
+        print()
+        print("Example:")
+        print('  python test_fish_tts.py "Hello! I am Hatsune Miku!"')
+        sys.exit(1)
+    
+    text = " ".join(sys.argv[1:])
+    success = test_fish_tts(text)
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()

bot/utils/autonomous.py

@@ -0,0 +1,344 @@
+# autonomous.py (V2)
+"""
+Enhanced autonomous system that uses the autonomous_engine for true autonomy.
+Integrates with legacy autonomous functions from autonomous_v1_legacy.py
+"""
+
+import asyncio
+import time
+from utils.autonomous_engine import autonomous_engine
+from server_manager import server_manager
+import globals
+
+# Rate limiting: Track last action time per server to prevent rapid-fire
+_last_action_execution = {}  # guild_id -> timestamp
+_MIN_ACTION_INTERVAL = 30  # Minimum 30 seconds between autonomous actions
+
+
+async def autonomous_tick_v2(guild_id: int):
+    """
+    New autonomous tick that uses context-aware decision making.
+    Replaces the random 10% chance with intelligent decision.
+    """
+    # Rate limiting check
+    now = time.time()
+    if guild_id in _last_action_execution:
+        time_since_last = now - _last_action_execution[guild_id]
+        if time_since_last < _MIN_ACTION_INTERVAL:
+            print(f"⏱️ [V2] Rate limit: Only {time_since_last:.0f}s since last action (need {_MIN_ACTION_INTERVAL}s)")
+            return
+    
+    # Ask the engine if Miku should act (with optional debug logging)
+    action_type = autonomous_engine.should_take_action(guild_id, debug=globals.AUTONOMOUS_DEBUG)
+    
+    if action_type is None:
+        # Engine decided not to act
+        return
+    
+    print(f"🤖 [V2] Autonomous engine decided to: {action_type} for server {guild_id}")
+    
+    # Execute the action using legacy functions
+    from utils.autonomous_v1_legacy import (
+        miku_say_something_general_for_server,
+        miku_engage_random_user_for_server,
+        share_miku_tweet_for_server,
+        miku_detect_and_join_conversation_for_server
+    )
+    from utils.profile_picture_manager import profile_picture_manager
+    
+    try:
+        if action_type == "general":
+            await miku_say_something_general_for_server(guild_id)
+        elif action_type == "engage_user":
+            await miku_engage_random_user_for_server(guild_id)
+        elif action_type == "share_tweet":
+            await share_miku_tweet_for_server(guild_id)
+        elif action_type == "join_conversation":
+            await miku_detect_and_join_conversation_for_server(guild_id)
+        elif action_type == "change_profile_picture":
+            # Get current mood for this server
+            mood, _ = server_manager.get_server_mood(guild_id)
+            print(f"🎨 [V2] Changing profile picture (mood: {mood})")
+            result = await profile_picture_manager.change_profile_picture(mood=mood, debug=True)
+            if result["success"]:
+                print(f"✅ Profile picture changed successfully!")
+            else:
+                print(f"⚠️ Profile picture change failed: {result.get('error')}")
+        
+        # Record that action was taken
+        autonomous_engine.record_action(guild_id)
+        
+        # Update rate limiter
+        _last_action_execution[guild_id] = time.time()
+        
+    except Exception as e:
+        print(f"⚠️ Error executing autonomous action: {e}")
+
+
+async def autonomous_reaction_tick_v2(guild_id: int):
+    """
+    Scheduled check for reacting to older messages.
+    This runs less frequently (e.g., every 20 minutes) and picks from recent messages.
+    """
+    # Ask the engine if Miku should react (scheduled check)
+    should_react = autonomous_engine.should_react_to_message(guild_id, message_age_seconds=600)  # Check 10 min old msgs
+    
+    if not should_react:
+        return
+    
+    print(f"🤖 [V2] Scheduled reaction check triggered for server {guild_id}")
+    
+    try:
+        from utils.autonomous_v1_legacy import miku_autonomous_reaction_for_server
+        # Don't pass force_message - let it pick a random recent message
+        await miku_autonomous_reaction_for_server(guild_id, force_message=None)
+        
+        # Record action
+        autonomous_engine.record_action(guild_id)
+        
+    except Exception as e:
+        print(f"⚠️ Error executing scheduled reaction: {e}")
+
+
+def on_message_event(message):
+    """
+    Hook for bot.py to call on every message.
+    Updates context without LLM calls.
+    
+    ONLY processes messages from the configured autonomous channel.
+    """
+    if not message.guild:
+        return  # DMs don't use this system
+    
+    guild_id = message.guild.id
+    
+    # Get server config to check if this is the autonomous channel
+    server_config = server_manager.get_server_config(guild_id)
+    if not server_config:
+        return  # No config for this server
+    
+    # CRITICAL: Only process messages from the autonomous channel
+    if message.channel.id != server_config.autonomous_channel_id:
+        return  # Ignore messages from other channels
+    
+    # Track the message
+    autonomous_engine.track_message(guild_id, author_is_bot=message.author.bot)
+    
+    # Check if we should act (async, non-blocking)
+    if not message.author.bot:  # Only check for human messages
+        asyncio.create_task(_check_and_act(guild_id))
+        
+        # Also check if we should react to this specific message
+        asyncio.create_task(_check_and_react(guild_id, message))
+
+
+async def _check_and_react(guild_id: int, message):
+    """
+    Check if Miku should react to a new message with an emoji.
+    Called for each new message in real-time.
+    """
+    # Calculate message age
+    from datetime import datetime, timezone
+    message_age = (datetime.now(timezone.utc) - message.created_at).total_seconds()
+    
+    # Ask engine if we should react
+    should_react = autonomous_engine.should_react_to_message(guild_id, message_age)
+    
+    if should_react:
+        print(f"🎯 [V2] Real-time reaction triggered for message from {message.author.display_name}")
+        from utils.autonomous_v1_legacy import miku_autonomous_reaction_for_server
+        await miku_autonomous_reaction_for_server(guild_id, force_message=message)
+        
+        # Record action (reactions count as actions for cooldown purposes)
+        autonomous_engine.record_action(guild_id)
+
+
+async def _check_and_act(guild_id: int):
+    """
+    Internal function to check if action should be taken.
+    Called after each message, but engine makes smart decision.
+    
+    IMPORTANT: Pass triggered_by_message=True so the engine knows to respond
+    to the message instead of saying something random/general.
+    """
+    # Rate limiting check
+    now = time.time()
+    if guild_id in _last_action_execution:
+        time_since_last = now - _last_action_execution[guild_id]
+        if time_since_last < _MIN_ACTION_INTERVAL:
+            return
+    
+    action_type = autonomous_engine.should_take_action(guild_id, triggered_by_message=True)
+    
+    if action_type:
+        print(f"🎯 [V2] Message triggered autonomous action: {action_type}")
+        
+        # Execute the action directly (don't call autonomous_tick_v2 which would check again)
+        from utils.autonomous_v1_legacy import (
+            miku_say_something_general_for_server,
+            miku_engage_random_user_for_server,
+            share_miku_tweet_for_server,
+            miku_detect_and_join_conversation_for_server
+        )
+        from utils.profile_picture_manager import profile_picture_manager
+        
+        try:
+            if action_type == "general":
+                await miku_say_something_general_for_server(guild_id)
+            elif action_type == "engage_user":
+                await miku_engage_random_user_for_server(guild_id)
+            elif action_type == "share_tweet":
+                await share_miku_tweet_for_server(guild_id)
+            elif action_type == "join_conversation":
+                await miku_detect_and_join_conversation_for_server(guild_id)
+            elif action_type == "change_profile_picture":
+                # Get current mood for this server
+                mood, _ = server_manager.get_server_mood(guild_id)
+                print(f"🎨 [V2] Changing profile picture (mood: {mood})")
+                result = await profile_picture_manager.change_profile_picture(mood=mood, debug=True)
+                if result["success"]:
+                    print(f"✅ Profile picture changed successfully!")
+                else:
+                    print(f"⚠️ Profile picture change failed: {result.get('error')}")
+            
+            # Record that action was taken
+            autonomous_engine.record_action(guild_id)
+            
+            # Update rate limiter
+            _last_action_execution[guild_id] = time.time()
+            
+        except Exception as e:
+            print(f"⚠️ Error executing message-triggered action: {e}")
+
+
+def on_presence_update(member, before, after):
+    """
+    Hook for presence updates (status changes, activities).
+    
+    Args:
+        member: The Member object (from 'after' in discord.py event)
+        before: Member object with old state
+        after: Member object with new state
+    """
+    # Ignore bot users (including music bots that spam activity updates)
+    if member.bot:
+        return
+    
+    guild_id = member.guild.id
+    
+    # Track status changes
+    if before.status != after.status:
+        autonomous_engine.track_user_event(guild_id, "status_changed")
+        print(f"👤 [V2] {member.display_name} status changed: {before.status} → {after.status}")
+    
+    # Track activity changes
+    if before.activities != after.activities:
+        # Check for new activities
+        before_activity_names = {a.name for a in before.activities if hasattr(a, 'name')}
+        after_activity_names = {a.name for a in after.activities if hasattr(a, 'name')}
+        
+        new_activities = after_activity_names - before_activity_names
+        
+        for activity_name in new_activities:
+            autonomous_engine.track_user_event(
+                guild_id, 
+                "activity_started", 
+                {"activity_name": activity_name}
+            )
+            print(f"🎮 [V2] {member.display_name} started activity: {activity_name}")
+
+
+def on_member_join(member):
+    """Hook for member join events"""
+    # Ignore bot users
+    if member.bot:
+        return
+    
+    guild_id = member.guild.id
+    autonomous_engine.track_user_event(guild_id, "user_joined")
+
+
+def on_mood_change(guild_id: int, new_mood: str):
+    """Hook for mood changes"""
+    autonomous_engine.update_mood(guild_id, new_mood)
+
+
+async def periodic_decay_task():
+    """
+    Background task that decays event counters and saves context.
+    Run this every 15 minutes.
+    """
+    task_start_time = time.time()
+    iteration_count = 0
+    
+    while True:
+        await asyncio.sleep(900)  # 15 minutes
+        
+        iteration_count += 1
+        
+        # Use list() to safely iterate even if dict changes
+        guild_ids = list(server_manager.servers.keys())
+        
+        for guild_id in guild_ids:
+            try:
+                autonomous_engine.decay_events(guild_id)
+            except Exception as e:
+                print(f"⚠️ Error decaying events for guild {guild_id}: {e}")
+        
+        # Save context to disk periodically
+        try:
+            autonomous_engine.save_context()
+        except Exception as e:
+            print(f"⚠️ Error saving autonomous context: {e}")
+        
+        uptime_hours = (time.time() - task_start_time) / 3600
+        print(f"🧹 [V2] Decay task completed (iteration #{iteration_count}, uptime: {uptime_hours:.1f}h)")
+        print(f"   └─ Processed {len(guild_ids)} servers")
+
+
+def initialize_v2_system(client):
+    """
+    Initialize the V2 autonomous system.
+    Call this from bot.py on startup.
+    """
+    print("🚀 Initializing Autonomous V2 System...")
+    
+    # Initialize mood states for all servers
+    for guild_id, server_config in server_manager.servers.items():
+        autonomous_engine.update_mood(guild_id, server_config.current_mood_name)
+    
+    # Start decay task
+    client.loop.create_task(periodic_decay_task())
+    
+    print("✅ Autonomous V2 System initialized")
+
+
+# ========== Legacy Function Wrappers ==========
+# These maintain compatibility with old code that imports from autonomous.py
+
+from utils.autonomous_v1_legacy import (
+    load_last_sent_tweets,
+    save_last_sent_tweets,
+    setup_autonomous_speaking,
+    # Server-specific functions
+    miku_autonomous_tick_for_server,
+    miku_say_something_general_for_server,
+    miku_engage_random_user_for_server,
+    miku_detect_and_join_conversation_for_server,
+    share_miku_tweet_for_server,
+    miku_autonomous_reaction_for_server,
+    miku_autonomous_reaction_for_dm,
+    handle_custom_prompt_for_server,
+    # Legacy global functions (for API compatibility)
+    miku_autonomous_tick,
+    miku_say_something_general,
+    miku_engage_random_user,
+    miku_detect_and_join_conversation,
+    share_miku_tweet,
+    handle_custom_prompt,
+    miku_autonomous_reaction,
+)
+
+# Alias the V2 tick as the main autonomous tick
+autonomous_tick = autonomous_tick_v2
+autonomous_reaction_tick = autonomous_reaction_tick_v2

bot/utils/autonomous_engine.py

@@ -0,0 +1,556 @@
+# autonomous_engine.py
+"""
+Truly autonomous decision-making engine for Miku.
+Makes decisions based on context signals without constant LLM polling.
+"""
+
+import time
+import random
+from datetime import datetime, timedelta
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+from collections import deque
+import discord
+from .autonomous_persistence import save_autonomous_context, load_autonomous_context, apply_context_to_signals
+
+@dataclass
+class ContextSignals:
+    """Lightweight context tracking without storing message content"""
+    # Activity metrics
+    messages_last_5min: int = 0
+    messages_last_hour: int = 0
+    unique_users_active: int = 0
+    conversation_momentum: float = 0.0  # 0-1 score based on message frequency
+    
+    # User presence
+    users_joined_recently: int = 0
+    users_status_changed: int = 0
+    users_started_activity: List[tuple] = field(default_factory=list)  # (activity_name, timestamp) tuples
+    
+    # Miku's state
+    time_since_last_action: float = 0.0  # seconds
+    time_since_last_interaction: float = 0.0  # seconds since someone talked to her
+    messages_since_last_appearance: int = 0
+    
+    # Time context
+    hour_of_day: int = 0
+    is_weekend: bool = False
+    
+    # Emotional influence
+    current_mood: str = "neutral"
+    mood_energy_level: float = 0.5  # 0-1, affects likelihood of action
+
+
+@dataclass
+class ActionThresholds:
+    """Dynamic thresholds that change based on mood and context"""
+    # How long to wait before considering action (seconds)
+    min_silence_for_general: float = 1800  # 30 min
+    min_silence_for_engagement: float = 3600  # 1 hour
+    
+    # Activity level needed to join conversation (0-1)
+    conversation_join_threshold: float = 0.6
+    
+    # How many messages before feeling "left out"
+    messages_before_fomo: int = 25
+    
+    # Mood-based multipliers
+    mood_action_multiplier: float = 1.0  # Higher = more likely to act
+
+
+class AutonomousEngine:
+    """
+    Decision engine that determines WHEN Miku should act,
+    then delegates to existing autonomous functions for WHAT to do.
+    """
+    
+    def __init__(self):
+        self.server_contexts: Dict[int, ContextSignals] = {}
+        self.server_message_times: Dict[int, deque] = {}  # Track message timestamps
+        self.server_last_action: Dict[int, float] = {}
+        self.bot_startup_time: float = time.time()  # Track when bot started
+        
+        # Mood personality profiles
+        self.mood_profiles = {
+            "bubbly": {"energy": 0.9, "sociability": 0.95, "impulsiveness": 0.8},
+            "sleepy": {"energy": 0.2, "sociability": 0.3, "impulsiveness": 0.1},
+            "curious": {"energy": 0.7, "sociability": 0.6, "impulsiveness": 0.7},
+            "shy": {"energy": 0.4, "sociability": 0.2, "impulsiveness": 0.2},
+            "serious": {"energy": 0.6, "sociability": 0.5, "impulsiveness": 0.3},
+            "excited": {"energy": 0.95, "sociability": 0.9, "impulsiveness": 0.9},
+            "silly": {"energy": 0.8, "sociability": 0.85, "impulsiveness": 0.95},
+            "melancholy": {"energy": 0.3, "sociability": 0.4, "impulsiveness": 0.2},
+            "flirty": {"energy": 0.75, "sociability": 0.85, "impulsiveness": 0.7},
+            "romantic": {"energy": 0.6, "sociability": 0.7, "impulsiveness": 0.5},
+            "irritated": {"energy": 0.5, "sociability": 0.3, "impulsiveness": 0.6},
+            "angry": {"energy": 0.7, "sociability": 0.2, "impulsiveness": 0.8},
+            "neutral": {"energy": 0.5, "sociability": 0.5, "impulsiveness": 0.5},
+            "asleep": {"energy": 0.0, "sociability": 0.0, "impulsiveness": 0.0},
+        }
+        
+        # Load persisted context on initialization
+        self._load_persisted_context()
+    
+    def _load_persisted_context(self):
+        """Load saved context data on bot startup"""
+        context_data, last_action = load_autonomous_context()
+        
+        # Restore last action timestamps
+        self.server_last_action = last_action
+        
+        # Restore context signals
+        for guild_id, data in context_data.items():
+            self.server_contexts[guild_id] = ContextSignals()
+            self.server_message_times[guild_id] = deque(maxlen=100)
+            apply_context_to_signals(data, self.server_contexts[guild_id])
+    
+    def save_context(self):
+        """Save current context to disk"""
+        save_autonomous_context(self.server_contexts, self.server_last_action)
+    
+    def track_message(self, guild_id: int, author_is_bot: bool = False):
+        """Track a message without storing content"""
+        if guild_id not in self.server_contexts:
+            self.server_contexts[guild_id] = ContextSignals()
+            self.server_message_times[guild_id] = deque(maxlen=100)
+        
+        if author_is_bot:
+            return  # Don't count bot messages
+        
+        now = time.time()
+        self.server_message_times[guild_id].append(now)
+        
+        ctx = self.server_contexts[guild_id]
+        ctx.messages_since_last_appearance += 1
+        
+        # Cap at 100 to prevent massive buildup during sleep/inactivity
+        # This prevents inappropriate FOMO triggers after long periods
+        if ctx.messages_since_last_appearance > 100:
+            ctx.messages_since_last_appearance = 100
+        
+        # Update time-based metrics
+        self._update_activity_metrics(guild_id)
+    
+    def track_user_event(self, guild_id: int, event_type: str, data: dict = None):
+        """Track user presence events (joins, status changes, etc.)"""
+        if guild_id not in self.server_contexts:
+            self.server_contexts[guild_id] = ContextSignals()
+            self.server_message_times[guild_id] = deque(maxlen=100)
+        
+        ctx = self.server_contexts[guild_id]
+        
+        if event_type == "user_joined":
+            ctx.users_joined_recently += 1
+        elif event_type == "status_changed":
+            ctx.users_status_changed += 1
+        elif event_type == "activity_started" and data:
+            activity_name = data.get("activity_name")
+            if activity_name:
+                now = time.time()
+                
+                # Remove duplicate activities (same name)
+                ctx.users_started_activity = [
+                    (name, ts) for name, ts in ctx.users_started_activity 
+                    if name != activity_name
+                ]
+                
+                # Add new activity with timestamp
+                ctx.users_started_activity.append((activity_name, now))
+                
+                # Keep only last 5 activities
+                if len(ctx.users_started_activity) > 5:
+                    ctx.users_started_activity.pop(0)
+    
+    def _clean_old_activities(self, guild_id: int, max_age_seconds: float = 3600):
+        """Remove activities older than max_age (default 1 hour)"""
+        if guild_id not in self.server_contexts:
+            return
+        
+        ctx = self.server_contexts[guild_id]
+        now = time.time()
+        
+        # Filter out old activities
+        ctx.users_started_activity = [
+            (name, ts) for name, ts in ctx.users_started_activity
+            if now - ts < max_age_seconds
+        ]
+    
+    def update_mood(self, guild_id: int, mood: str):
+        """Update mood and recalculate energy level"""
+        if guild_id not in self.server_contexts:
+            self.server_contexts[guild_id] = ContextSignals()
+            self.server_message_times[guild_id] = deque(maxlen=100)
+        
+        ctx = self.server_contexts[guild_id]
+        ctx.current_mood = mood
+        
+        # Get mood personality profile
+        profile = self.mood_profiles.get(mood, self.mood_profiles["neutral"])
+        ctx.mood_energy_level = profile["energy"]
+    
+    def _update_activity_metrics(self, guild_id: int):
+        """Update activity metrics based on message timestamps"""
+        ctx = self.server_contexts[guild_id]
+        times = self.server_message_times[guild_id]
+        
+        now = time.time()
+        
+        # Count messages in time windows
+        ctx.messages_last_5min = sum(1 for t in times if now - t < 300)
+        ctx.messages_last_hour = sum(1 for t in times if now - t < 3600)
+        
+        # Calculate conversation momentum (0-1 scale)
+        # High momentum = consistent messages in last 5 minutes
+        if ctx.messages_last_5min >= 10:
+            ctx.conversation_momentum = min(1.0, ctx.messages_last_5min / 20)
+        else:
+            ctx.conversation_momentum = ctx.messages_last_5min / 10
+        
+        # Time since last action
+        if guild_id in self.server_last_action:
+            ctx.time_since_last_action = now - self.server_last_action[guild_id]
+        else:
+            ctx.time_since_last_action = float('inf')
+        
+        # Time context
+        ctx.hour_of_day = datetime.now().hour
+        ctx.is_weekend = datetime.now().weekday() >= 5
+    
+    def should_take_action(self, guild_id: int, debug: bool = False, triggered_by_message: bool = False) -> Optional[str]:
+        """
+        Determine if Miku should take action and what type.
+        Returns action type or None.
+        
+        This is the CORE decision logic - no LLM needed!
+        
+        Args:
+            guild_id: Server ID
+            debug: If True, print detailed decision reasoning
+            triggered_by_message: If True, this check was triggered immediately after someone sent a message
+        """
+        if guild_id not in self.server_contexts:
+            return None
+        
+        ctx = self.server_contexts[guild_id]
+        
+        # STARTUP COOLDOWN: Don't act for first 2 minutes after bot startup
+        # This prevents rapid-fire messages when bot restarts
+        time_since_startup = time.time() - self.bot_startup_time
+        if time_since_startup < 120:  # 2 minutes
+            if debug:
+                print(f"⏳ [V2 Debug] Startup cooldown active ({time_since_startup:.0f}s / 120s)")
+            return None
+        
+        # Never act when asleep
+        if ctx.current_mood == "asleep":
+            if debug:
+                print(f"💤 [V2 Debug] Mood is 'asleep' - no action taken")
+            return None
+        
+        # Get mood personality
+        profile = self.mood_profiles.get(ctx.current_mood, self.mood_profiles["neutral"])
+        
+        # Update metrics
+        self._update_activity_metrics(guild_id)
+        
+        if debug:
+            print(f"\n🔍 [V2 Debug] Decision Check for Guild {guild_id}")
+            print(f"   Triggered by message: {triggered_by_message}")
+            print(f"   Mood: {ctx.current_mood} (energy={profile['energy']:.2f}, sociability={profile['sociability']:.2f}, impulsiveness={profile['impulsiveness']:.2f})")
+            print(f"   Momentum: {ctx.conversation_momentum:.2f}")
+            print(f"   Messages (5min/1hr): {ctx.messages_last_5min}/{ctx.messages_last_hour}")
+            print(f"   Messages since appearance: {ctx.messages_since_last_appearance}")
+            print(f"   Time since last action: {ctx.time_since_last_action:.0f}s")
+            print(f"   Active activities: {len(ctx.users_started_activity)}")
+        
+        # --- Decision Logic ---
+        
+        # 1. CONVERSATION JOIN (high priority when momentum is high)
+        if self._should_join_conversation(ctx, profile, debug):
+            if debug:
+                print(f"✅ [V2 Debug] DECISION: join_conversation")
+            return "join_conversation"
+        
+        # 2. USER ENGAGEMENT (someone interesting appeared)
+        if self._should_engage_user(ctx, profile, debug):
+            if debug:
+                print(f"✅ [V2 Debug] DECISION: engage_user")
+            return "engage_user"
+        
+        # 3. FOMO RESPONSE (lots of activity without her)
+        # When FOMO triggers, join the conversation instead of saying something random
+        if self._should_respond_to_fomo(ctx, profile, debug):
+            if debug:
+                print(f"✅ [V2 Debug] DECISION: join_conversation (FOMO)")
+            return "join_conversation"  # Jump in and respond to what's being said
+        
+        # 4. BORED/LONELY (quiet for too long, depending on mood)
+        # CRITICAL FIX: If this check was triggered by a message, convert "general" to "join_conversation"
+        # This ensures Miku responds to the message instead of saying something random
+        if self._should_break_silence(ctx, profile, debug):
+            if triggered_by_message:
+                if debug:
+                    print(f"✅ [V2 Debug] DECISION: join_conversation (break silence, but message just sent)")
+                return "join_conversation"  # Respond to the message instead of random general statement
+            else:
+                if debug:
+                    print(f"✅ [V2 Debug] DECISION: general (break silence)")
+                return "general"
+        
+        # 5. SHARE TWEET (low activity, wants to share something)
+        if self._should_share_content(ctx, profile, debug):
+            if debug:
+                print(f"✅ [V2 Debug] DECISION: share_tweet")
+            return "share_tweet"
+        
+        # 6. CHANGE PROFILE PICTURE (very rare, once per day)
+        if self._should_change_profile_picture(ctx, profile, debug):
+            if debug:
+                print(f"✅ [V2 Debug] DECISION: change_profile_picture")
+            return "change_profile_picture"
+        
+        if debug:
+            print(f"❌ [V2 Debug] DECISION: None (no conditions met)")
+        
+        return None
+    
+    def _should_join_conversation(self, ctx: ContextSignals, profile: dict, debug: bool = False) -> bool:
+        """Decide if Miku should join an active conversation"""
+        # High conversation momentum + sociable mood + hasn't spoken recently
+        base_threshold = 0.6
+        mood_adjusted = base_threshold * (2.0 - profile["sociability"])  # Lower threshold if sociable
+        
+        conditions = {
+            "momentum_check": ctx.conversation_momentum > mood_adjusted,
+            "messages_check": ctx.messages_since_last_appearance >= 5,
+            "cooldown_check": ctx.time_since_last_action > 300,
+            "impulsiveness_roll": random.random() < profile["impulsiveness"]
+        }
+        
+        result = all(conditions.values())
+        
+        if debug:
+            print(f"   [Join Conv] momentum={ctx.conversation_momentum:.2f} > {mood_adjusted:.2f}? {conditions['momentum_check']}")
+            print(f"   [Join Conv] messages={ctx.messages_since_last_appearance} >= 5? {conditions['messages_check']}")
+            print(f"   [Join Conv] cooldown={ctx.time_since_last_action:.0f}s > 300s? {conditions['cooldown_check']}")
+            print(f"   [Join Conv] impulsive roll? {conditions['impulsiveness_roll']} | Result: {result}")
+        
+        return result
+    
+    def _should_engage_user(self, ctx: ContextSignals, profile: dict, debug: bool = False) -> bool:
+        """Decide if Miku should engage with a user (status change/activity)"""
+        # Someone started a new activity or status changed + enough time passed
+        has_activities = len(ctx.users_started_activity) > 0
+        cooldown_ok = ctx.time_since_last_action > 1800
+        roll = random.random()
+        threshold = profile["sociability"] * profile["impulsiveness"]
+        roll_ok = roll < threshold
+        
+        result = has_activities and cooldown_ok and roll_ok
+        
+        if debug and has_activities:
+            activities = [name for name, ts in ctx.users_started_activity]
+            print(f"   [Engage] activities={activities}, cooldown={ctx.time_since_last_action:.0f}s > 1800s? {cooldown_ok}")
+            print(f"   [Engage] roll={roll:.2f} < {threshold:.2f}? {roll_ok} | Result: {result}")
+        
+        return result
+    
+    def _should_respond_to_fomo(self, ctx: ContextSignals, profile: dict, debug: bool = False) -> bool:
+        """Decide if Miku feels left out (FOMO)"""
+        # Lots of messages but she hasn't participated
+        fomo_threshold = 25 * (2.0 - profile["sociability"])  # Social moods have lower threshold
+        
+        msgs_check = ctx.messages_since_last_appearance > fomo_threshold
+        momentum_check = ctx.conversation_momentum > 0.3
+        cooldown_check = ctx.time_since_last_action > 900
+        
+        result = msgs_check and momentum_check and cooldown_check
+        
+        if debug:
+            print(f"   [FOMO] messages={ctx.messages_since_last_appearance} > {fomo_threshold:.0f}? {msgs_check}")
+            print(f"   [FOMO] momentum={ctx.conversation_momentum:.2f} > 0.3? {momentum_check}")
+            print(f"   [FOMO] cooldown={ctx.time_since_last_action:.0f}s > 900s? {cooldown_check} | Result: {result}")
+        
+        return result
+    
+    def _should_break_silence(self, ctx: ContextSignals, profile: dict, debug: bool = False) -> bool:
+        """Decide if Miku should break a long silence"""
+        # Low activity + long time + mood-dependent
+        min_silence = 1800 * (2.0 - profile["energy"])  # High energy = shorter wait
+        
+        quiet_check = ctx.messages_last_hour < 5
+        silence_check = ctx.time_since_last_action > min_silence
+        energy_roll = random.random()
+        energy_ok = energy_roll < profile["energy"]
+        
+        result = quiet_check and silence_check and energy_ok
+        
+        if debug:
+            print(f"   [Silence] msgs_last_hour={ctx.messages_last_hour} < 5? {quiet_check}")
+            print(f"   [Silence] time={ctx.time_since_last_action:.0f}s > {min_silence:.0f}s? {silence_check}")
+            print(f"   [Silence] energy roll={energy_roll:.2f} < {profile['energy']:.2f}? {energy_ok} | Result: {result}")
+        
+        return result
+    
+    def _should_share_content(self, ctx: ContextSignals, profile: dict, debug: bool = False) -> bool:
+        """Decide if Miku should share a tweet/content"""
+        # Quiet period + curious/excited mood
+        quiet_check = ctx.messages_last_hour < 10
+        cooldown_check = ctx.time_since_last_action > 3600
+        energy_roll = random.random()
+        energy_threshold = profile["energy"] * 0.5
+        energy_ok = energy_roll < energy_threshold
+        mood_ok = ctx.current_mood in ["curious", "excited", "bubbly", "neutral"]
+        
+        result = quiet_check and cooldown_check and energy_ok and mood_ok
+        
+        if debug:
+            print(f"   [Share] msgs_last_hour={ctx.messages_last_hour} < 10? {quiet_check}")
+            print(f"   [Share] cooldown={ctx.time_since_last_action:.0f}s > 3600s? {cooldown_check}")
+            print(f"   [Share] energy roll={energy_roll:.2f} < {energy_threshold:.2f}? {energy_ok}")
+            print(f"   [Share] mood '{ctx.current_mood}' appropriate? {mood_ok} | Result: {result}")
+        
+        return result
+    
+    def _should_change_profile_picture(self, ctx: ContextSignals, profile: dict, debug: bool = False) -> bool:
+        """
+        Decide if Miku should change her profile picture.
+        This is a rare, once-per-day action.
+        """
+        # Check if we've changed recently (track globally, not per-server)
+        from datetime import datetime, timedelta
+        import os
+        import json
+        
+        metadata_path = "memory/profile_pictures/metadata.json"
+        
+        # Load last change time
+        try:
+            if os.path.exists(metadata_path):
+                with open(metadata_path, 'r') as f:
+                    metadata = json.load(f)
+                    last_change = metadata.get("changed_at")
+                    if last_change:
+                        last_change_dt = datetime.fromisoformat(last_change)
+                        hours_since_change = (datetime.now() - last_change_dt).total_seconds() / 3600
+                        
+                        if hours_since_change < 20:  # At least 20 hours between changes
+                            if debug:
+                                print(f"   [PFP] Last change {hours_since_change:.1f}h ago, waiting...")
+                            return False
+        except Exception as e:
+            if debug:
+                print(f"   [PFP] Error checking last change: {e}")
+        
+        # Only consider changing during certain hours (10 AM - 10 PM)
+        hour = ctx.hour_of_day
+        time_check = 10 <= hour <= 22
+        
+        # Require low activity + long cooldown
+        quiet_check = ctx.messages_last_hour < 5
+        cooldown_check = ctx.time_since_last_action > 5400  # 1.5 hours
+        
+        # Mood influences decision (more likely when bubbly, curious, excited)
+        mood_boost = ctx.current_mood in ["bubbly", "curious", "excited", "silly"]
+        
+        # Very low base chance (roughly once per day)
+        base_chance = 0.02 if mood_boost else 0.01
+        roll = random.random()
+        roll_ok = roll < base_chance
+        
+        result = time_check and quiet_check and cooldown_check and roll_ok
+        
+        if debug:
+            print(f"   [PFP] hour={hour}, time_ok={time_check}")
+            print(f"   [PFP] msgs_last_hour={ctx.messages_last_hour} < 5? {quiet_check}")
+            print(f"   [PFP] cooldown={ctx.time_since_last_action:.0f}s > 5400s? {cooldown_check}")
+            print(f"   [PFP] mood_boost={mood_boost}, roll={roll:.4f} < {base_chance:.4f}? {roll_ok}")
+            print(f"   [PFP] Result: {result}")
+        
+        return result
+    
+    def should_react_to_message(self, guild_id: int, message_age_seconds: float = 0) -> bool:
+        """
+        Decide if Miku should react to a message with an emoji.
+        Called when new messages arrive OR by periodic scheduler.
+        
+        Args:
+            guild_id: Server ID
+            message_age_seconds: How old the message is (0 = brand new)
+        
+        Returns:
+            True if should react, False otherwise
+        """
+        if guild_id not in self.server_contexts:
+            return False
+        
+        ctx = self.server_contexts[guild_id]
+        
+        # Never react when asleep
+        if ctx.current_mood == "asleep":
+            return False
+        
+        profile = self.mood_profiles.get(ctx.current_mood, self.mood_profiles["neutral"])
+        
+        # Brand new message (real-time reaction)
+        if message_age_seconds < 10:
+            # Base 30% chance, modified by mood
+            base_chance = 0.30
+            mood_multiplier = (profile["impulsiveness"] + profile["sociability"]) / 2
+            reaction_chance = base_chance * mood_multiplier
+            
+            # More likely to react to messages in active conversations
+            if ctx.conversation_momentum > 0.5:
+                reaction_chance *= 1.5  # Boost in active chats
+            
+            # Less likely if just reacted recently
+            if ctx.time_since_last_action < 300:  # 5 minutes
+                reaction_chance *= 0.3  # Reduce significantly
+            
+            return random.random() < reaction_chance
+        
+        # Older message (scheduled reaction check)
+        else:
+            # Base 20% chance for scheduled reactions
+            base_chance = 0.20
+            mood_multiplier = (profile["impulsiveness"] + profile["energy"]) / 2
+            reaction_chance = base_chance * mood_multiplier
+            
+            # Don't react to very old messages if chat is active
+            if message_age_seconds > 1800 and ctx.messages_last_5min > 5:  # 30 min old + active chat
+                return False
+            
+            return random.random() < reaction_chance
+    
+    def record_action(self, guild_id: int):
+        """Record that Miku took an action"""
+        self.server_last_action[guild_id] = time.time()
+        if guild_id in self.server_contexts:
+            self.server_contexts[guild_id].messages_since_last_appearance = 0
+            # Clear some event counters
+            self.server_contexts[guild_id].users_joined_recently = 0
+            self.server_contexts[guild_id].users_status_changed = 0
+    
+    def decay_events(self, guild_id: int):
+        """
+        Decay event counters over time (call periodically every 15 minutes).
+        Uses proper exponential decay with 1-hour half-life.
+        Also cleans up old activities.
+        """
+        if guild_id not in self.server_contexts:
+            return
+        
+        ctx = self.server_contexts[guild_id]
+        
+        # Decay user events (half-life of 1 hour)
+        # For 15-minute intervals: decay_factor = 0.5^(1/4) ≈ 0.841
+        decay_factor = 0.5 ** (1/4)  # ≈ 0.8408964...
+        ctx.users_joined_recently = int(ctx.users_joined_recently * decay_factor)
+        ctx.users_status_changed = int(ctx.users_status_changed * decay_factor)
+        
+        # Clean up old activities (older than 1 hour)
+        self._clean_old_activities(guild_id, max_age_seconds=3600)
+
+
+# Global instance
+autonomous_engine = AutonomousEngine()

bot/utils/autonomous_persistence.py

@@ -0,0 +1,126 @@
+"""
+Persistence layer for V2 autonomous system.
+Saves and restores critical context data across bot restarts.
+"""
+
+import json
+import time
+from pathlib import Path
+from typing import Dict, Optional
+from datetime import datetime, timezone
+
+CONTEXT_FILE = Path("memory/autonomous_context.json")
+
+
+def save_autonomous_context(server_contexts: dict, server_last_action: dict):
+    """
+    Save critical context data to disk.
+    Only saves data that makes sense to persist (not ephemeral stats).
+    """
+    now = time.time()
+    
+    data = {
+        "saved_at": now,
+        "saved_at_readable": datetime.now(timezone.utc).isoformat(),
+        "servers": {}
+    }
+    
+    for guild_id, ctx in server_contexts.items():
+        data["servers"][str(guild_id)] = {
+            # Critical timing data
+            "time_since_last_action": ctx.time_since_last_action,
+            "time_since_last_interaction": ctx.time_since_last_interaction,
+            "messages_since_last_appearance": ctx.messages_since_last_appearance,
+            
+            # Decay-able activity data (will be aged on restore)
+            "conversation_momentum": ctx.conversation_momentum,
+            "unique_users_active": ctx.unique_users_active,
+            
+            # Last action timestamp (absolute time)
+            "last_action_timestamp": server_last_action.get(guild_id, 0),
+            
+            # Mood state (already persisted in servers_config.json, but include for completeness)
+            "current_mood": ctx.current_mood,
+            "mood_energy_level": ctx.mood_energy_level
+        }
+    
+    try:
+        CONTEXT_FILE.parent.mkdir(parents=True, exist_ok=True)
+        with open(CONTEXT_FILE, 'w') as f:
+            json.dump(data, f, indent=2)
+        print(f"💾 [V2] Saved autonomous context for {len(server_contexts)} servers")
+    except Exception as e:
+        print(f"⚠️ [V2] Failed to save autonomous context: {e}")
+
+
+def load_autonomous_context() -> tuple[Dict[int, dict], Dict[int, float]]:
+    """
+    Load and restore context data from disk.
+    Returns (server_context_data, server_last_action).
+    
+    Applies staleness/decay rules based on downtime:
+    - conversation_momentum decays over time
+    - Timestamps are adjusted for elapsed time
+    """
+    if not CONTEXT_FILE.exists():
+        print("ℹ️ [V2] No saved context found, starting fresh")
+        return {}, {}
+    
+    try:
+        with open(CONTEXT_FILE, 'r') as f:
+            data = json.load(f)
+        
+        saved_at = data.get("saved_at", 0)
+        downtime = time.time() - saved_at
+        downtime_minutes = downtime / 60
+        
+        print(f"📂 [V2] Loading context from {downtime_minutes:.1f} minutes ago")
+        
+        context_data = {}
+        last_action = {}
+        
+        for guild_id_str, server_data in data.get("servers", {}).items():
+            guild_id = int(guild_id_str)
+            
+            # Apply decay/staleness rules
+            momentum = server_data.get("conversation_momentum", 0.0)
+            
+            # Momentum decays: half-life of 10 minutes
+            if downtime > 0:
+                decay_factor = 0.5 ** (downtime_minutes / 10)
+                momentum = momentum * decay_factor
+            
+            # Restore data with adjustments
+            context_data[guild_id] = {
+                "time_since_last_action": server_data.get("time_since_last_action", 0) + downtime,
+                "time_since_last_interaction": server_data.get("time_since_last_interaction", 0) + downtime,
+                "messages_since_last_appearance": server_data.get("messages_since_last_appearance", 0),
+                "conversation_momentum": momentum,
+                "unique_users_active": 0,  # Reset (stale data)
+                "current_mood": server_data.get("current_mood", "neutral"),
+                "mood_energy_level": server_data.get("mood_energy_level", 0.5)
+            }
+            
+            # Restore last action timestamp
+            last_action_timestamp = server_data.get("last_action_timestamp", 0)
+            if last_action_timestamp > 0:
+                last_action[guild_id] = last_action_timestamp
+        
+        print(f"✅ [V2] Restored context for {len(context_data)} servers")
+        print(f"   └─ Momentum decay factor: {decay_factor:.3f} (from {downtime_minutes:.1f}min downtime)")
+        
+        return context_data, last_action
+        
+    except Exception as e:
+        print(f"⚠️ [V2] Failed to load autonomous context: {e}")
+        return {}, {}
+
+
+def apply_context_to_signals(context_data: dict, context_signals):
+    """
+    Apply loaded context data to a ContextSignals object.
+    Call this after creating a fresh ContextSignals instance.
+    """
+    for key, value in context_data.items():
+        if hasattr(context_signals, key):
+            setattr(context_signals, key, value)

bot/utils/autonomous_v1_legacy.py

@@ -0,0 +1,866 @@
+# autonomous.py
+
+import random
+import time
+import json
+import os
+from datetime import datetime
+import discord
+from discord import Status
+from discord import TextChannel
+from difflib import SequenceMatcher
+import globals
+from server_manager import server_manager
+from utils.llm import query_ollama
+from utils.moods import MOOD_EMOJIS
+from utils.twitter_fetcher import fetch_miku_tweets
+from utils.image_handling import (
+    analyze_image_with_qwen, 
+    download_and_encode_image,
+    download_and_encode_media,
+    extract_video_frames,
+    analyze_video_with_vision,
+    convert_gif_to_mp4
+)
+from utils.sleep_responses import SLEEP_RESPONSES
+
+# Server-specific memory storage
+_server_autonomous_messages = {}  # guild_id -> rotating buffer of last general messages
+_server_user_engagements = {}     # guild_id -> user_id -> timestamp
+_reacted_message_ids = set()      # Track messages we've already reacted to
+MAX_HISTORY = 10
+
+LAST_SENT_TWEETS_FILE = "memory/last_sent_tweets.json"
+LAST_SENT_TWEETS = []
+
+AUTONOMOUS_CONFIG_FILE = "memory/autonomous_config.json"
+
+def load_autonomous_config():
+    if os.path.exists(AUTONOMOUS_CONFIG_FILE):
+        with open(AUTONOMOUS_CONFIG_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    return {}
+
+def save_autonomous_config(config):
+    with open(AUTONOMOUS_CONFIG_FILE, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2)
+
+def setup_autonomous_speaking():
+    """Setup autonomous speaking for all configured servers"""
+    # This is now handled by the server manager
+    print("🤖 Autonomous Miku setup delegated to server manager!")
+
+async def miku_autonomous_tick_for_server(guild_id: int, action_type="general", force=False, force_action=None):
+    """Run autonomous behavior for a specific server"""
+    if not force and random.random() > 0.10:  # 10% chance to act
+        return
+
+    if force_action:
+        action_type = force_action
+    else:
+        action_type = random.choice(["general", "engage_user", "share_tweet"])
+    
+    if action_type == "general":
+        await miku_say_something_general_for_server(guild_id)
+    elif action_type == "engage_user":
+        await miku_engage_random_user_for_server(guild_id)
+    else:
+        await share_miku_tweet_for_server(guild_id)
+
+async def miku_say_something_general_for_server(guild_id: int):
+    """Miku says something general in a specific server"""
+    server_config = server_manager.get_server_config(guild_id)
+    if not server_config:
+        print(f"⚠️ No config found for server {guild_id}")
+        return
+    
+    channel = globals.client.get_channel(server_config.autonomous_channel_id)
+    if not channel:
+        print(f"⚠️ Autonomous channel not found for server {guild_id}")
+        return
+
+    # Use server-specific mood
+    mood = server_config.current_mood_name
+    time_of_day = get_time_of_day()
+    emoji = MOOD_EMOJIS.get(mood, "")
+
+    # Special handling for sleep state
+    if mood == "asleep":
+        message = random.choice(SLEEP_RESPONSES)
+        await channel.send(message)
+        return
+
+    # Get server-specific message history
+    if guild_id not in _server_autonomous_messages:
+        _server_autonomous_messages[guild_id] = []
+    
+    history_summary = "\n".join(f"- {msg}" for msg in _server_autonomous_messages[guild_id][-5:]) if _server_autonomous_messages[guild_id] else "None yet."
+
+    prompt = (
+        f"Miku is feeling {mood}. It's currently {time_of_day}. "
+        f"Write a short, natural message that Miku might say out of the blue in a chat. "
+        f"She might greet everyone, make a cute observation, ask a silly question, or say something funny. "
+        f"Make sure it feels casual and spontaneous, like a real person might say.\n\n"
+        f"Here are some things Miku recently said, do not repeat them or say anything too similar:\n{history_summary}"
+    )
+
+    for attempt in range(3):  # retry up to 3 times if message is too similar
+        # Use consistent user_id per guild for autonomous actions to enable conversation history
+        # and prompt caching, rather than creating new IDs with timestamps
+        message = await query_ollama(prompt, user_id=f"miku-autonomous-{guild_id}", guild_id=guild_id, response_type="autonomous_general")
+        if not is_too_similar(message, _server_autonomous_messages[guild_id]):
+            break
+        print("🔁 Response was too similar to past messages, retrying...")
+    
+    try:
+        await channel.send(message)
+        _server_autonomous_messages[guild_id].append(message)
+        if len(_server_autonomous_messages[guild_id]) > MAX_HISTORY:
+            _server_autonomous_messages[guild_id].pop(0)
+        print(f"💬 Miku said something general in #{channel.name} (Server: {server_config.guild_name})")
+    except Exception as e:
+        print(f"⚠️ Failed to send autonomous message: {e}")
+
+async def miku_engage_random_user_for_server(guild_id: int):
+    """Miku engages a random user in a specific server"""
+    server_config = server_manager.get_server_config(guild_id)
+    if not server_config:
+        print(f"⚠️ No config found for server {guild_id}")
+        return
+    
+    guild = globals.client.get_guild(guild_id)
+    if not guild:
+        print(f"⚠️ Guild {guild_id} not found.")
+        return
+
+    channel = globals.client.get_channel(server_config.autonomous_channel_id)
+    if not channel:
+        print(f"⚠️ Autonomous channel not found for server {guild_id}")
+        return
+
+    members = [
+        m for m in guild.members
+        if m.status in {Status.online, Status.idle, Status.dnd} and not m.bot
+    ]
+    
+    time_of_day = get_time_of_day()
+
+    if not members:
+        print(f"😴 No available members to talk to in server {guild_id}.")
+        return
+
+    target = random.choice(members)
+
+    # Initialize server-specific user engagements
+    if guild_id not in _server_user_engagements:
+        _server_user_engagements[guild_id] = {}
+    
+    now = time.time()
+    last_time = _server_user_engagements[guild_id].get(target.id, 0)
+    if now - last_time < 43200:  # 12 hours in seconds
+        print(f"⏱️ Recently engaged {target.display_name} in server {guild_id}, switching to general message.")
+        await miku_say_something_general_for_server(guild_id)
+        return
+
+    activity_name = None
+    if target.activities:
+        for a in target.activities:
+            if hasattr(a, 'name') and a.name:
+                activity_name = a.name
+                break
+
+    # Use server-specific mood instead of global
+    mood = server_config.current_mood_name
+    emoji = MOOD_EMOJIS.get(mood, "")
+
+    is_invisible = target.status == Status.offline
+    display_name = target.display_name
+
+    prompt = (
+        f"Miku is feeling {mood} {emoji} during the {time_of_day}. "
+        f"She notices {display_name}'s current status is {target.status.name}. "
+    )
+
+    if is_invisible:
+        prompt += (
+            f"Miku suspects that {display_name} is being sneaky and invisible 👻. "
+            f"She wants to playfully call them out in a fun, teasing, but still affectionate way. "
+        )
+    elif activity_name:
+        prompt += (
+            f"They appear to be playing or doing: {activity_name}. "
+            f"Miku wants to comment on this and start a friendly conversation."
+        )
+    else:
+        prompt += (
+            f"Miku wants to casually start a conversation with them, maybe ask how they're doing, what they're up to, or even talk about something random with them."
+        )
+
+    prompt += (
+        f"\nThe message should be short and reflect Miku's current mood."
+    )
+
+    try:
+        # Use consistent user_id for engaging users to enable conversation history
+        message = await query_ollama(prompt, user_id=f"miku-engage-{guild_id}", guild_id=guild_id)
+        await channel.send(f"{target.mention} {message}")
+        _server_user_engagements[guild_id][target.id] = time.time()
+        print(f"👤 Miku engaged {display_name} in server {server_config.guild_name}")
+    except Exception as e:
+        print(f"⚠️ Failed to engage user: {e}")
+
+async def miku_detect_and_join_conversation_for_server(guild_id: int):
+    """Miku detects and joins conversations in a specific server"""
+    server_config = server_manager.get_server_config(guild_id)
+    if not server_config:
+        print(f"⚠️ No config found for server {guild_id}")
+        return
+    
+    channel = globals.client.get_channel(server_config.autonomous_channel_id)
+    if not isinstance(channel, TextChannel):
+        print(f"⚠️ Autonomous channel is invalid or not found for server {guild_id}")
+        return
+
+    # Fetch last 20 messages (for filtering)
+    try:
+        messages = [msg async for msg in channel.history(limit=20)]
+    except Exception as e:
+        print(f"⚠️ Failed to fetch channel history for server {guild_id}: {e}")
+        return
+
+    # Filter to messages in last 10 minutes from real users (not bots)
+    recent_msgs = [
+        msg for msg in messages
+        if not msg.author.bot
+        and (datetime.now(msg.created_at.tzinfo) - msg.created_at).total_seconds() < 600
+    ]
+
+    user_ids = set(msg.author.id for msg in recent_msgs)
+
+    if len(recent_msgs) < 5 or len(user_ids) < 2:
+        # Not enough activity
+        return
+
+    if random.random() > 0.5:
+        return  # 50% chance to engage
+
+    # Use last 10 messages for context (oldest to newest)
+    convo_lines = reversed(recent_msgs[:10])
+    history_text = "\n".join(
+        f"{msg.author.display_name}: {msg.content}" for msg in convo_lines
+    )
+
+    # Use server-specific mood instead of global
+    mood = server_config.current_mood_name
+    emoji = MOOD_EMOJIS.get(mood, "")
+
+    prompt = (
+        f"Miku is watching a conversation happen in the chat. Her current mood is {mood} {emoji}. "
+        f"She wants to say something relevant, playful, or insightful based on what people are talking about.\n\n"
+        f"Here's the conversation:\n{history_text}\n\n"
+        f"Write a short reply that feels natural and adds to the discussion. It should reflect Miku's mood and personality."
+    )
+
+    try:
+        # Use consistent user_id for joining conversations to enable conversation history
+        reply = await query_ollama(prompt, user_id=f"miku-conversation-{guild_id}", guild_id=guild_id, response_type="conversation_join")
+        await channel.send(reply)
+        print(f"💬 Miku joined an ongoing conversation in server {server_config.guild_name}")
+    except Exception as e:
+        print(f"⚠️ Failed to interject in conversation: {e}")
+
+async def share_miku_tweet_for_server(guild_id: int):
+    """Share a Miku tweet in a specific server"""
+    server_config = server_manager.get_server_config(guild_id)
+    if not server_config:
+        print(f"⚠️ No config found for server {guild_id}")
+        return
+    
+    channel = globals.client.get_channel(server_config.autonomous_channel_id)
+    tweets = await fetch_miku_tweets(limit=5)
+    if not tweets:
+        print(f"📭 No good tweets found for server {guild_id}")
+        return
+
+    fresh_tweets = [t for t in tweets if t["url"] not in LAST_SENT_TWEETS]
+
+    if not fresh_tweets:
+        print(f"⚠️ All fetched tweets were recently sent in server {guild_id}. Reusing tweets.")
+        fresh_tweets = tweets
+
+    tweet = random.choice(fresh_tweets)
+
+    LAST_SENT_TWEETS.append(tweet["url"])
+    if len(LAST_SENT_TWEETS) > 50:
+        LAST_SENT_TWEETS.pop(0)
+
+    save_last_sent_tweets()
+
+    # Prepare prompt - use server-specific mood instead of global
+    mood = server_config.current_mood_name
+    emoji = MOOD_EMOJIS.get(mood, "")
+    base_prompt = f"Here's a tweet from @{tweet['username']}:\n\n{tweet['text']}\n\nComment on it in a fun Miku style! Miku's current mood is {mood} {emoji}. Make sure the comment reflects Miku's mood and personality."
+    
+    # Optionally analyze first image if media exists
+    if tweet.get("media") and len(tweet["media"]) > 0:
+        first_img_url = tweet["media"][0]
+        base64_img = await download_and_encode_image(first_img_url)
+        if base64_img:
+            img_desc = await analyze_image_with_qwen(base64_img)
+            base_prompt += f"\n\nThe image looks like this: {img_desc}"
+
+    miku_comment = await query_ollama(base_prompt, user_id=f"autonomous-{guild_id}", guild_id=guild_id, response_type="autonomous_tweet")
+
+    # Post to Discord (convert to fxtwitter for better embeds)
+    fx_tweet_url = tweet['url'].replace("twitter.com", "fxtwitter.com").replace("x.com", "fxtwitter.com")
+    await channel.send(f"{fx_tweet_url}")
+    await channel.send(miku_comment)
+
+async def handle_custom_prompt_for_server(guild_id: int, user_prompt: str):
+    """Handle custom prompt for a specific server"""
+    server_config = server_manager.get_server_config(guild_id)
+    if not server_config:
+        print(f"⚠️ No config found for server {guild_id}")
+        return False
+    
+    channel = globals.client.get_channel(server_config.autonomous_channel_id)
+    if not channel:
+        print(f"⚠️ Autonomous channel not found for server {guild_id}")
+        return False
+
+    mood = server_config.current_mood_name
+    emoji = MOOD_EMOJIS.get(mood, "")
+    time_of_day = get_time_of_day()
+
+    # Wrap user's idea in Miku context
+    prompt = (
+        f"Miku is feeling {mood} {emoji} during the {time_of_day}. "
+        f"She has been instructed to: \"{user_prompt.strip()}\"\n\n"
+        f"Write a short, natural message as Miku that follows this instruction. "
+        f"Make it feel spontaneous, emotionally in character, and aligned with her mood and personality. Decide if the time of day is relevant to this request or not and if it is not, do not mention it."
+    )
+
+    try:
+        # Use consistent user_id for manual prompts to enable conversation history
+        message = await query_ollama(prompt, user_id=f"miku-manual-{guild_id}", guild_id=guild_id, response_type="autonomous_general")
+        await channel.send(message)
+        print(f"🎤 Miku responded to custom prompt in server {server_config.guild_name}")
+        
+        # Add to server-specific message history
+        if guild_id not in _server_autonomous_messages:
+            _server_autonomous_messages[guild_id] = []
+        _server_autonomous_messages[guild_id].append(message)
+        if len(_server_autonomous_messages[guild_id]) > MAX_HISTORY:
+            _server_autonomous_messages[guild_id].pop(0)
+        
+        return True
+    except Exception as e:
+        print(f"❌ Failed to send custom autonomous message: {e}")
+        return False
+
+# Legacy functions for backward compatibility - these now delegate to server-specific versions
+async def miku_autonomous_tick(action_type="general", force=False, force_action=None):
+    """Legacy function - now runs for all servers"""
+    for guild_id in server_manager.servers:
+        await miku_autonomous_tick_for_server(guild_id, action_type, force, force_action)
+
+async def miku_say_something_general():
+    """Legacy function - now runs for all servers"""
+    for guild_id in server_manager.servers:
+        await miku_say_something_general_for_server(guild_id)
+
+async def miku_engage_random_user():
+    """Legacy function - now runs for all servers"""
+    for guild_id in server_manager.servers:
+        await miku_engage_random_user_for_server(guild_id)
+
+async def miku_detect_and_join_conversation():
+    """Legacy function - now runs for all servers"""
+    for guild_id in server_manager.servers:
+        await miku_detect_and_join_conversation_for_server(guild_id)
+
+async def share_miku_tweet():
+    """Legacy function - now runs for all servers"""
+    for guild_id in server_manager.servers:
+        await share_miku_tweet_for_server(guild_id)
+
+async def handle_custom_prompt(user_prompt: str):
+    """Legacy function - now runs for all servers"""
+    results = []
+    for guild_id in server_manager.servers:
+        result = await handle_custom_prompt_for_server(guild_id, user_prompt)
+        results.append(result)
+    return any(results)
+
+def load_last_sent_tweets():
+    global LAST_SENT_TWEETS
+    if os.path.exists(LAST_SENT_TWEETS_FILE):
+        try:
+            with open(LAST_SENT_TWEETS_FILE, "r", encoding="utf-8") as f:
+                LAST_SENT_TWEETS = json.load(f)
+        except Exception as e:
+            print(f"⚠️ Failed to load last sent tweets: {e}")
+            LAST_SENT_TWEETS = []
+    else:
+        LAST_SENT_TWEETS = []
+
+def save_last_sent_tweets():
+    try:
+        with open(LAST_SENT_TWEETS_FILE, "w", encoding="utf-8") as f:
+            json.dump(LAST_SENT_TWEETS, f)
+    except Exception as e:
+        print(f"⚠️ Failed to save last sent tweets: {e}")
+
+def get_time_of_day():
+    hour = datetime.now().hour + 3
+    if 5 <= hour < 12:
+        return "morning"
+    elif 12 <= hour < 18:
+        return "afternoon"
+    elif 18 <= hour < 22:
+        return "evening"
+    return "late night. Miku wonders if anyone is still awake"
+
+def is_too_similar(new_message, history, threshold=0.85):
+    for old in history:
+        ratio = SequenceMatcher(None, new_message.lower(), old.lower()).ratio()
+        if ratio > threshold:
+            return True
+    return False
+
+# ========== Autonomous Reaction System ==========
+# Mood-based emoji mappings for autonomous reactions
+MOOD_REACTION_EMOJIS = {
+    "bubbly": ["✨", "🫧", "💙", "🌟", "💫", "🎀", "🌸"],
+    "sleepy": ["😴", "💤", "🌙", "😪", "🥱"],
+    "curious": ["👀", "🤔", "❓", "🔍", "💭"],
+    "shy": ["👉👈", "🙈", "😊", "💕", "☺️"],
+    "serious": ["🤨", "📝", "👔", "💼", "🎯"],
+    "excited": ["✨", "🎉", "😆", "🌟", "💫", "🎊", "🔥"],
+    "silly": ["🪿", "😜", "🤪", "😝", "🎭", "🎪"],
+    "melancholy": ["🍷", "🌧️", "💭", "🥀", "🌙"],
+    "flirty": ["🫦", "😏", "💋", "💕", "😘", "💖"],
+    "romantic": ["💌", "💖", "💕", "💝", "❤️", "🌹"],
+    "irritated": ["😒", "💢", "😤", "🙄", "😑"],
+    "angry": ["💢", "😠", "👿", "💥", "😡"],
+    "neutral": ["💙", "👍", "😊", "✨", "🎵"],
+    "asleep": []  # Don't react when asleep
+}
+
+async def _analyze_message_media(message):
+    """
+    Analyze any media (images, videos, GIFs) in a message.
+    Returns a description string or None if no media.
+    """
+    if not message.attachments:
+        return None
+    
+    for attachment in message.attachments:
+        try:
+            # Handle images
+            if any(attachment.filename.lower().endswith(ext) for ext in [".jpg", ".jpeg", ".png", ".webp"]):
+                print(f"  📸 Analyzing image for reaction: {attachment.filename}")
+                base64_img = await download_and_encode_image(attachment.url)
+                if base64_img:
+                    description = await analyze_image_with_qwen(base64_img)
+                    return f"[Image: {description}]"
+            
+            # Handle videos and GIFs
+            elif any(attachment.filename.lower().endswith(ext) for ext in [".gif", ".mp4", ".webm", ".mov"]):
+                is_gif = attachment.filename.lower().endswith('.gif')
+                media_type = "GIF" if is_gif else "video"
+                print(f"  🎬 Analyzing {media_type} for reaction: {attachment.filename}")
+                
+                # Download media
+                media_bytes_b64 = await download_and_encode_media(attachment.url)
+                if not media_bytes_b64:
+                    continue
+                
+                import base64
+                media_bytes = base64.b64decode(media_bytes_b64)
+                
+                # Convert GIF to MP4 if needed
+                if is_gif:
+                    mp4_bytes = await convert_gif_to_mp4(media_bytes)
+                    if mp4_bytes:
+                        media_bytes = mp4_bytes
+                
+                # Extract frames
+                frames = await extract_video_frames(media_bytes, num_frames=6)
+                if frames:
+                    description = await analyze_video_with_vision(frames, media_type="gif" if is_gif else "video")
+                    return f"[{media_type}: {description}]"
+        
+        except Exception as e:
+            print(f"  ⚠️ Error analyzing media for reaction: {e}")
+            continue
+    
+    return None
+
+async def miku_autonomous_reaction_for_server(guild_id: int, force_message=None, force=False):
+    """Miku autonomously reacts to a recent message with an LLM-selected emoji
+    
+    Args:
+        guild_id: The server ID
+        force_message: If provided, react to this specific message (for real-time reactions)
+        force: If True, bypass the 50% probability check (for manual triggers)
+    """
+    # 50% chance to proceed (unless forced or with a specific message)
+    if not force and force_message is None and random.random() > 0.5:
+        print(f"🎲 Autonomous reaction skipped for server {guild_id} (50% chance)")
+        return
+    
+    server_config = server_manager.get_server_config(guild_id)
+    if not server_config:
+        print(f"⚠️ No config found for server {guild_id}")
+        return
+    
+    server_name = server_config.guild_name
+    
+    # Don't react if asleep
+    if server_config.current_mood_name == "asleep" or server_config.is_sleeping:
+        print(f"💤 [{server_name}] Miku is asleep, skipping autonomous reaction")
+        return
+    
+    # Get the autonomous channel
+    channel = globals.client.get_channel(server_config.autonomous_channel_id)
+    if not channel:
+        print(f"⚠️ [{server_name}] Autonomous channel not found")
+        return
+    
+    try:
+        # If a specific message was provided, use it
+        if force_message:
+            target_message = force_message
+            # Check if we've already reacted to this message
+            if target_message.id in _reacted_message_ids:
+                print(f"⏭️ [{server_name}] Already reacted to message {target_message.id}, skipping")
+                return
+            print(f"🎯 [{server_name}] Reacting to new message from {target_message.author.display_name}")
+        else:
+            # Fetch recent messages (last 50 messages to get more candidates)
+            messages = []
+            async for message in channel.history(limit=50):
+                # Skip bot's own messages
+                if message.author == globals.client.user:
+                    continue
+                # Skip messages we've already reacted to
+                if message.id in _reacted_message_ids:
+                    continue
+                # Skip messages that are too old (more than 12 hours)
+                age = (datetime.now() - message.created_at.replace(tzinfo=None)).total_seconds()
+                if age > 43200:  # 12 hours
+                    continue
+                messages.append(message)
+            
+            if not messages:
+                print(f"📭 [{server_name}] No recent unreacted messages to react to")
+                return
+            
+            # Pick a random message from the recent ones
+            target_message = random.choice(messages)
+        
+        # Analyze any media in the message
+        print(f"🔍 [{server_name}] Analyzing message for reaction from {target_message.author.display_name}")
+        media_description = await _analyze_message_media(target_message)
+        
+        # Build message content with media description if present
+        message_content = target_message.content[:200]  # Limit text context length
+        if media_description:
+            # If there's media, prepend the description
+            message_content = f"{media_description} {message_content}".strip()
+            # Limit total length
+            message_content = message_content[:400]
+        
+        # Ask LLM to select an appropriate emoji
+        prompt = (
+            f"You are Miku, a playful virtual idol on Discord. Someone just posted: \"{message_content}\"\n\n"
+            f"React with ONE emoji that captures your response! Be creative and expressive - don't just use 😊 or 👍. "
+            f"Think about:\n"
+            f"- What emotion does this make you feel? (use expressive emojis like 🤨, 😭, 🤯, 💀, etc.)\n"
+            f"- Is it funny? (try 💀, 😂, 🤡, 🪿, etc.)\n"
+            f"- Is it interesting? (try 👀, 🤔, 🧐, 😳, etc.)\n"
+            f"- Is it relatable? (try 😔, 🥺, 😩, 🙃, etc.)\n"
+            f"- Does it mention something specific? (match it with a relevant emoji like 🎮, 🍕, 🎸, etc.)\n\n"
+            f"Be bold! Use uncommon emojis! Respond with ONLY the emoji character itself, no text."
+        )
+        
+        emoji = await query_ollama(
+            prompt, 
+            user_id=f"miku-reaction-{guild_id}",  # Use consistent user_id
+            guild_id=guild_id, 
+            response_type="emoji_selection"
+        )
+        
+        # Clean up the response (remove any extra text)
+        original_response = emoji
+        emoji = emoji.strip()
+        
+        # Remove common prefixes/quotes that LLM might add
+        emoji = emoji.replace('"', '').replace("'", '').replace('`', '')
+        emoji = emoji.replace(':', '')  # Remove colons from :emoji: format
+        
+        # Try to extract just emoji characters using regex
+        import re
+        emoji_pattern = re.compile("["
+            u"\U0001F300-\U0001F9FF"  # Most emojis
+            u"\U0001F600-\U0001F64F"  # emoticons
+            u"\U0001F680-\U0001F6FF"  # transport & map symbols
+            u"\U0001F1E0-\U0001F1FF"  # flags
+            u"\U00002600-\U000027BF"  # misc symbols
+            u"\U0001F900-\U0001F9FF"  # supplemental symbols
+            u"\U00002700-\U000027BF"  # dingbats
+            u"\U0001FA70-\U0001FAFF"  # extended pictographs
+            u"\U00002300-\U000023FF"  # misc technical
+            "]", flags=re.UNICODE)
+        
+        # Find all individual emojis
+        emojis = emoji_pattern.findall(original_response)
+        if emojis:
+            # Take only the FIRST emoji
+            emoji = emojis[0]
+        else:
+            # No emoji found in response, use fallback
+            print(f"⚠️ [{server_name}] LLM response contained no emoji: '{original_response[:50]}' - using fallback")
+            emoji = "💙"
+        
+        # Final validation: try adding the reaction
+        try:
+            await target_message.add_reaction(emoji)
+        except discord.HTTPException as e:
+            if "Unknown Emoji" in str(e):
+                print(f"❌ [{server_name}] Invalid emoji from LLM: '{original_response[:50]}' - using fallback")
+                emoji = "💙"
+                await target_message.add_reaction(emoji)
+            else:
+                raise
+
+        
+        # Track this message ID to prevent duplicate reactions
+        _reacted_message_ids.add(target_message.id)
+        
+        # Cleanup old message IDs (keep last 100 to prevent memory growth)
+        if len(_reacted_message_ids) > 100:
+            # Remove oldest half
+            ids_to_remove = list(_reacted_message_ids)[:50]
+            for msg_id in ids_to_remove:
+                _reacted_message_ids.discard(msg_id)
+        
+        print(f"✅ [{server_name}] Autonomous reaction: Added {emoji} to message from {target_message.author.display_name}")
+        
+    except discord.Forbidden:
+        print(f"❌ [{server_name}] Missing permissions to add reactions")
+    except discord.HTTPException as e:
+        print(f"❌ [{server_name}] Failed to add reaction: {e}")
+    except Exception as e:
+        print(f"⚠️ [{server_name}] Error in autonomous reaction: {e}")
+
+async def miku_autonomous_reaction(force=False):
+    """Legacy function - run autonomous reactions for all servers
+    
+    Args:
+        force: If True, bypass the 50% probability check (for manual triggers)
+    """
+    for guild_id in server_manager.servers:
+        await miku_autonomous_reaction_for_server(guild_id, force=force)
+
+async def miku_autonomous_reaction_for_dm(user_id: int, force_message=None):
+    """Miku autonomously reacts to a DM message with an LLM-selected emoji
+    
+    Args:
+        user_id: The Discord user ID
+        force_message: If provided, react to this specific message (for real-time reactions)
+    """
+    # 50% chance to proceed (unless forced with a specific message)
+    if force_message is None and random.random() > 0.5:
+        print(f"🎲 DM reaction skipped for user {user_id} (50% chance)")
+        return
+    
+    # Get the user object
+    try:
+        user = await globals.client.fetch_user(user_id)
+        if not user:
+            print(f"⚠️ Could not find user {user_id}")
+            return
+        
+        dm_channel = user.dm_channel
+        if not dm_channel:
+            dm_channel = await user.create_dm()
+        
+        username = user.display_name
+        
+    except Exception as e:
+        print(f"⚠️ Error fetching DM channel for user {user_id}: {e}")
+        return
+    
+    try:
+        # If a specific message was provided, use it
+        if force_message:
+            target_message = force_message
+            # Check if we've already reacted to this message
+            if target_message.id in _reacted_message_ids:
+                print(f"⏭️ [DM: {username}] Already reacted to message {target_message.id}, skipping")
+                return
+            print(f"🎯 [DM: {username}] Reacting to new message")
+        else:
+            # Fetch recent messages from DM (last 50 messages)
+            messages = []
+            async for message in dm_channel.history(limit=50):
+                # Skip bot's own messages
+                if message.author == globals.client.user:
+                    continue
+                # Skip messages we've already reacted to
+                if message.id in _reacted_message_ids:
+                    continue
+                # Skip messages that are too old (more than 12 hours)
+                age = (datetime.now() - message.created_at.replace(tzinfo=None)).total_seconds()
+                if age > 43200:  # 12 hours
+                    continue
+                messages.append(message)
+            
+            if not messages:
+                print(f"📭 [DM: {username}] No recent unreacted messages to react to")
+                return
+            
+            # Pick a random message from the recent ones
+            target_message = random.choice(messages)
+        
+        # Analyze any media in the message
+        print(f"🔍 [DM: {username}] Analyzing message for reaction")
+        media_description = await _analyze_message_media(target_message)
+        
+        # Build message content with media description if present
+        message_content = target_message.content[:200]  # Limit text context length
+        if media_description:
+            # If there's media, prepend the description
+            message_content = f"{media_description} {message_content}".strip()
+            # Limit total length
+            message_content = message_content[:400]
+        
+        # Ask LLM to select an appropriate emoji
+        prompt = (
+            f"You are Miku, a playful virtual idol. Someone just sent you this DM: \"{message_content}\"\n\n"
+            f"React with ONE emoji that captures your response! Be creative and expressive - don't just use 😊 or 👍. "
+            f"Think about:\n"
+            f"- What emotion does this make you feel? (use expressive emojis like 🤨, 😭, 🤯, 💀, etc.)\n"
+            f"- Is it funny? (try 💀, 😂, 🤡, 🪿, etc.)\n"
+            f"- Is it interesting? (try 👀, 🤔, 🧐, 😳, etc.)\n"
+            f"- Is it relatable? (try 😔, 🥺, 😩, 🙃, etc.)\n"
+            f"- Does it mention something specific? (match it with a relevant emoji like 🎮, 🍕, 🎸, etc.)\n\n"
+            f"Be bold! Use uncommon emojis! Respond with ONLY the emoji character itself, no text."
+        )
+        
+        emoji = await query_ollama(
+            prompt, 
+            user_id=f"miku-dm-reaction-{user_id}",  # Use consistent user_id per DM user
+            guild_id=None,  # DM doesn't have guild
+            response_type="emoji_selection"
+        )
+        
+        # Clean up the response (remove any extra text)
+        original_response = emoji
+        emoji = emoji.strip()
+        
+        # Remove common prefixes/quotes that LLM might add
+        emoji = emoji.replace('"', '').replace("'", '').replace('`', '')
+        emoji = emoji.replace(':', '')  # Remove colons from :emoji: format
+        
+        # Try to extract just emoji characters using regex
+        import re
+        emoji_pattern = re.compile("["
+            u"\U0001F300-\U0001F9FF"  # Most emojis
+            u"\U0001F600-\U0001F64F"  # emoticons
+            u"\U0001F680-\U0001F6FF"  # transport & map symbols
+            u"\U0001F1E0-\U0001F1FF"  # flags
+            u"\U00002600-\U000027BF"  # misc symbols
+            u"\U0001F900-\U0001F9FF"  # supplemental symbols
+            u"\U00002700-\U000027BF"  # dingbats
+            u"\U0001FA70-\U0001FAFF"  # extended pictographs
+            u"\U00002300-\U000023FF"  # misc technical
+            "]", flags=re.UNICODE)
+        
+        # Find all individual emojis
+        emojis = emoji_pattern.findall(original_response)
+        if emojis:
+            # Take only the FIRST emoji
+            emoji = emojis[0]
+        else:
+            # No emoji found in response, use fallback
+            print(f"⚠️ [DM: {username}] LLM response contained no emoji: '{original_response[:50]}' - using fallback")
+            emoji = "💙"
+        
+        # Final validation: try adding the reaction
+        try:
+            await target_message.add_reaction(emoji)
+        except discord.HTTPException as e:
+            if "Unknown Emoji" in str(e):
+                print(f"❌ [DM: {username}] Invalid emoji from LLM: '{original_response[:50]}' - using fallback")
+                emoji = "💙"
+                await target_message.add_reaction(emoji)
+            else:
+                raise
+
+        
+        # Track this message ID to prevent duplicate reactions
+        _reacted_message_ids.add(target_message.id)
+        
+        # Cleanup old message IDs (keep last 100 to prevent memory growth)
+        if len(_reacted_message_ids) > 100:
+            # Remove oldest half
+            ids_to_remove = list(_reacted_message_ids)[:50]
+            for msg_id in ids_to_remove:
+                _reacted_message_ids.discard(msg_id)
+        
+        print(f"✅ [DM: {username}] Autonomous reaction: Added {emoji} to message")
+        
+    except discord.Forbidden:
+        print(f"❌ [DM: {username}] Missing permissions to add reactions")
+    except discord.HTTPException as e:
+        print(f"❌ [DM: {username}] Failed to add reaction: {e}")
+    except Exception as e:
+        print(f"⚠️ [DM: {username}] Error in autonomous reaction: {e}")
+
+
+async def miku_update_profile_picture_for_server(guild_id: int):
+    """
+    Miku autonomously updates her profile picture by searching for artwork.
+    This is a global action (affects all servers) but is triggered by server context.
+    """
+    from utils.profile_picture_manager import update_profile_picture, should_update_profile_picture
+    
+    # Check if enough time has passed
+    if not should_update_profile_picture():
+        print(f"📸 [Server: {guild_id}] Profile picture not ready for update yet")
+        return
+    
+    # Get server config to use current mood
+    server_config = server_manager.get_server_config(guild_id)
+    if not server_config:
+        print(f"⚠️ No config found for server {guild_id}")
+        return
+    
+    mood = server_config.current_mood_name
+    
+    print(f"📸 [Server: {guild_id}] Attempting profile picture update (mood: {mood})")
+    
+    try:
+        success = await update_profile_picture(globals.client, mood=mood)
+        
+        if success:
+            # Announce the change in the autonomous channel
+            channel = globals.client.get_channel(server_config.autonomous_channel_id)
+            if channel:
+                messages = [
+                    "*updates profile picture* ✨ What do you think? Does it suit me?",
+                    "I found a new look! *twirls* Do you like it? 💚",
+                    "*changes profile picture* Felt like switching things up today~ ✨",
+                    "New profile pic! I thought this one was really cute 💚",
+                    "*updates avatar* Time for a fresh look! ✨"
+                ]
+                await channel.send(random.choice(messages))
+                print(f"✅ [Server: {guild_id}] Profile picture updated and announced!")
+        else:
+            print(f"⚠️ [Server: {guild_id}] Profile picture update failed")
+            
+    except Exception as e:
+        print(f"⚠️ [Server: {guild_id}] Error updating profile picture: {e}")

bot/utils/autonomous_wip.py

@@ -0,0 +1,348 @@
+# autonomous.py
+
+import random
+import time
+import json
+import os
+from datetime import datetime
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from discord import Status
+from discord import TextChannel
+from difflib import SequenceMatcher
+import globals
+from utils.llm import query_ollama
+from utils.moods import MOOD_EMOJIS
+from utils.twitter_fetcher import fetch_miku_tweets
+from utils.image_handling import analyze_image_with_qwen, download_and_encode_image
+
+scheduler = AsyncIOScheduler()
+_last_autonomous_messages = []  # rotating buffer of last general messages
+MAX_HISTORY = 10
+_last_user_engagements = {}  # user_id -> timestamp
+
+LAST_SENT_TWEETS_FILE = "memory/last_sent_tweets.json"
+LAST_SENT_TWEETS = []
+
+AUTONOMOUS_CONFIG_FILE = "memory/autonomous_config.json"
+
+def load_autonomous_config():
+    if os.path.exists(AUTONOMOUS_CONFIG_FILE):
+        with open(AUTONOMOUS_CONFIG_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    return {}
+
+def save_autonomous_config(config):
+    with open(AUTONOMOUS_CONFIG_FILE, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2)
+
+def setup_autonomous_speaking():
+    scheduler.add_job(run_autonomous_for_all_guilds, "interval", minutes=10)
+    scheduler.add_job(run_conversation_detection_all_guilds, "interval", minutes=3)
+    scheduler.start()
+    print("🤖 Autonomous Miku is active!")
+
+async def run_autonomous_for_all_guilds():
+    config = load_autonomous_config()
+    for guild_id, settings in config.items():
+        await miku_autonomous_tick(guild_id, settings)
+
+async def run_conversation_detection_all_guilds():
+    config = load_autonomous_config()
+    for guild_id, settings in config.items():
+        await miku_detect_and_join_conversation(guild_id, settings)
+
+async def miku_autonomous_tick(guild_id, settings, action_type="general", force=False, force_action=None):
+    settings = globals.GUILD_SETTINGS.get(guild_id)
+    if not settings:
+        print(f"⚠️ No settings found for guild {guild_id}")
+        return
+
+    if not force and random.random() > 0.2:  # 20% chance to act
+        return
+
+# TODO edit this function as per ChatGPT's last reply and then go back to the long reply from step 5 onwards
+
+    if force_action:
+        action_type = force_action
+    else:
+        action_type = random.choice(["general", "engage_user", "share_tweet"])
+    
+    if action_type == "general":
+        await miku_say_something_general(guild_id, settings)
+    elif action_type == "engage_user":
+        await miku_engage_random_user(guild_id, settings)
+    else:
+        await share_miku_tweet(guild_id, settings)
+
+async def miku_say_something_general(guild_id, settings):
+    channel = globals.client.get_channel(int(settings["autonomous_channel_id"]))
+    if not channel:
+        print(f"⚠️ Autonomous channel not found for guild {guild_id}")
+        return
+
+    mood = settings.get("mood", "curious")
+    time_of_day = get_time_of_day()
+    emoji = MOOD_EMOJIS.get(mood, "")
+
+    history_summary = "\n".join(f"- {msg}" for msg in _last_autonomous_messages[-5:]) if _last_autonomous_messages else "None yet."
+
+    prompt = (
+        f"Miku is feeling {mood}. It's currently {time_of_day}. "
+        f"Write a short, natural message that Miku might say out of the blue in a chat. "
+        f"She might greet everyone, make a cute observation, ask a silly question, or say something funny. "
+        f"Make sure it feels casual and spontaneous, like a real person might say.\n\n"
+        f"Here are some things Miku recently said, do not repeat them or say anything too similar:\n{history_summary}"
+    )
+
+    for attempt in range(3):  # retry up to 3 times if message is too similar
+        message = await query_ollama(prompt, user_id=f"miku-general-{int(time.time())}", guild_id=guild_id, response_type="autonomous_general")
+        if not is_too_similar(message, _last_autonomous_messages):
+            break
+        print("🔁 Response was too similar to past messages, retrying...")
+    
+    try:
+        await channel.send(message)
+        print(f"💬 Miku said something general in #{channel.name}")
+    except Exception as e:
+        print(f"⚠️ Failed to send autonomous message: {e}")
+
+async def miku_engage_random_user(guild_id, settings):
+    guild = globals.client.get_guild(guild_id)
+    if not guild:
+        print(f"⚠️ Guild {guild_id} not found.")
+        return
+
+    channel = globals.client.get_channel(globals.AUTONOMOUS_CHANNEL_ID)
+    if not channel:
+        print("⚠️ Autonomous channel not found.")
+        return
+
+    members = [
+        m for m in guild.members
+        if m.status in {Status.online, Status.idle, Status.dnd} and not m.bot
+    ]
+    
+    time_of_day = get_time_of_day()
+
+    # Include the invisible user except during late night
+    specific_user_id = 214857593045254151  # Your invisible user's ID
+    specific_user = guild.get_member(specific_user_id)
+    if specific_user:
+        if specific_user.status != Status.offline or "late night" not in time_of_day:
+            if specific_user not in members:
+                members.append(specific_user)
+
+    if not members:
+        print("😴 No available members to talk to.")
+        return
+
+    target = random.choice(members)
+
+    now = time.time()
+    last_time = _last_user_engagements.get(target.id, 0)
+    if now - last_time < 43200:  # 12 hours in seconds
+        print(f"⏱️ Recently engaged {target.display_name}, switching to general message.")
+        await miku_say_something_general()
+        return
+
+    activity_name = None
+    if target.activities:
+        for a in target.activities:
+            if hasattr(a, 'name') and a.name:
+                activity_name = a.name
+                break
+
+    mood = globals.CURRENT_MOOD_NAME
+    emoji = MOOD_EMOJIS.get(mood, "")
+
+    is_invisible = target.status == Status.offline
+    display_name = target.display_name
+
+    prompt = (
+        f"Miku is feeling {mood} {emoji} during the {time_of_day}. "
+        f"She notices {display_name}'s current status is {target.status.name}. "
+    )
+
+    if is_invisible:
+        prompt += (
+            f"Miku suspects that {display_name} is being sneaky and invisible 👻. "
+            f"She wants to playfully call them out in a fun, teasing, but still affectionate way. "
+        )
+    elif activity_name:
+        prompt += (
+            f"They appear to be playing or doing: {activity_name}. "
+            f"Miku wants to comment on this and start a friendly conversation."
+        )
+    else:
+        prompt += (
+            f"Miku wants to casually start a conversation with them, maybe ask how they're doing, what they're up to, or even talk about something random with them."
+        )
+
+    prompt += (
+        f"\nThe message should be short and reflect Miku’s current mood."
+    )
+
+    try:
+        message = await query_ollama(prompt, user_id=f"miku-engage-{int(time.time())}", guild_id=guild_id, response_type="autonomous_general")
+        await channel.send(f"{target.mention} {message}")
+        print(f"👤 Miku engaged {display_name}")
+        _last_user_engagements[target.id] = time.time()
+    except Exception as e:
+        print(f"⚠️ Failed to engage user: {e}")
+
+async def miku_detect_and_join_conversation():
+    channel = globals.client.get_channel(globals.AUTONOMOUS_CHANNEL_ID)
+    if not isinstance(channel, TextChannel):
+        print("⚠️ Autonomous channel is invalid or not found.")
+        return
+
+    # Fetch last 20 messages (for filtering)
+    try:
+        messages = [msg async for msg in channel.history(limit=20)]
+    except Exception as e:
+        print(f"⚠️ Failed to fetch channel history: {e}")
+        return
+
+    # Filter to messages in last 10 minutes from real users (not bots)
+    recent_msgs = [
+        msg for msg in messages
+        if not msg.author.bot
+        and (datetime.now(msg.created_at.tzinfo) - msg.created_at).total_seconds() < 600
+    ]
+
+    user_ids = set(msg.author.id for msg in recent_msgs)
+
+    if len(recent_msgs) < 5 or len(user_ids) < 2:
+        # Not enough activity
+        return
+
+    if random.random() > 0.5:
+        return  # 50% chance to engage
+
+    # Use last 10 messages for context (oldest to newest)
+    convo_lines = reversed(recent_msgs[:10])
+    history_text = "\n".join(
+        f"{msg.author.display_name}: {msg.content}" for msg in convo_lines
+    )
+
+    mood = globals.CURRENT_MOOD_NAME
+    emoji = MOOD_EMOJIS.get(mood, "")
+
+    prompt = (
+        f"Miku is watching a conversation happen in the chat. Her current mood is {mood} {emoji}. "
+        f"She wants to say something relevant, playful, or insightful based on what people are talking about.\n\n"
+        f"Here's the conversation:\n{history_text}\n\n"
+        f"Write a short reply that feels natural and adds to the discussion. It should reflect Miku’s mood and personality."
+    )
+
+    try:
+        reply = await query_ollama(prompt, user_id=f"miku-chat-{int(time.time())}", guild_id=guild_id, response_type="conversation_join")
+        await channel.send(reply)
+        print(f"💬 Miku joined an ongoing conversation.")
+    except Exception as e:
+        print(f"⚠️ Failed to interject in conversation: {e}")
+
+async def share_miku_tweet(guild_id, settings):
+    channel = globals.client.get_channel(globals.AUTONOMOUS_CHANNEL_ID)
+    tweets = await fetch_miku_tweets(limit=5)
+    if not tweets:
+        print("📭 No good tweets found.")
+        return
+
+    fresh_tweets = [t for t in tweets if t["url"] not in LAST_SENT_TWEETS]
+
+    if not fresh_tweets:
+        print("⚠️ All fetched tweets were recently sent. Reusing tweets.")
+        fresh_tweets = tweets
+
+    tweet = random.choice(fresh_tweets)
+
+    LAST_SENT_TWEETS.append(tweet["url"])
+    if len(LAST_SENT_TWEETS) > 50:
+        LAST_SENT_TWEETS.pop(0)
+
+    save_last_sent_tweets()
+
+    # Prepare prompt
+    mood = globals.CURRENT_MOOD_NAME
+    emoji = MOOD_EMOJIS.get(mood, "")
+    base_prompt = f"Here's a tweet from @{tweet['username']}:\n\n{tweet['text']}\n\nComment on it in a fun Miku style! Miku's current mood is {mood} {emoji}. Make sure the comment reflects Miku's mood and personality."
+    
+    # Optionally analyze first image
+    first_img_url = tweet["media"][0]
+    base64_img = await download_and_encode_image(first_img_url)
+    if base64_img:
+        img_desc = await analyze_image_with_qwen(base64_img)
+        base_prompt += f"\n\nThe image looks like this: {img_desc}"
+
+    miku_comment = await query_ollama(base_prompt, user_id="autonomous", guild_id=guild_id, response_type="autonomous_tweet")
+
+    # Post to Discord
+    # Convert to fxtwitter for better embeds
+    fx_tweet_url = tweet['url'].replace("twitter.com", "fxtwitter.com").replace("x.com", "fxtwitter.com")
+    await channel.send(f"{fx_tweet_url}")
+    await channel.send(miku_comment)
+
+async def handle_custom_prompt(user_prompt: str):
+    channel = globals.client.get_channel(globals.AUTONOMOUS_CHANNEL_ID)
+    if not channel:
+        print("⚠️ Autonomous channel not found.")
+        return False
+
+    mood = globals.CURRENT_MOOD_NAME
+    emoji = MOOD_EMOJIS.get(mood, "")
+    time_of_day = get_time_of_day()
+
+    # Wrap user’s idea in Miku context
+    prompt = (
+        f"Miku is feeling {mood} {emoji} during the {time_of_day}. "
+        f"She has been instructed to: \"{user_prompt.strip()}\"\n\n"
+        f"Write a short, natural message as Miku that follows this instruction. "
+        f"Make it feel spontaneous, emotionally in character, and aligned with her mood and personality. Decide if the time of day is relevant to this request or not and if it is not, do not mention it."
+    )
+
+    try:
+        message = await query_ollama(prompt, user_id=f"manual-{int(time.time())}", guild_id=None, response_type="autonomous_general")
+        await channel.send(message)
+        print("🎤 Miku responded to custom prompt.")
+        _last_autonomous_messages.append(message)
+        return True
+    except Exception as e:
+        print(f"❌ Failed to send custom autonomous message: {e}")
+        return False
+
+def load_last_sent_tweets():
+    global LAST_SENT_TWEETS
+    if os.path.exists(LAST_SENT_TWEETS_FILE):
+        try:
+            with open(LAST_SENT_TWEETS_FILE, "r", encoding="utf-8") as f:
+                LAST_SENT_TWEETS = json.load(f)
+        except Exception as e:
+            print(f"⚠️ Failed to load last sent tweets: {e}")
+            LAST_SENT_TWEETS = []
+    else:
+        LAST_SENT_TWEETS = []
+
+def save_last_sent_tweets():
+    try:
+        with open(LAST_SENT_TWEETS_FILE, "w", encoding="utf-8") as f:
+            json.dump(LAST_SENT_TWEETS, f)
+    except Exception as e:
+        print(f"⚠️ Failed to save last sent tweets: {e}")
+
+def get_time_of_day():
+    hour = datetime.now().hour + 3
+    if 5 <= hour < 12:
+        return "morning"
+    elif 12 <= hour < 18:
+        return "afternoon"
+    elif 18 <= hour < 22:
+        return "evening"
+    return "late night. Miku wonders if anyone is still awake"
+
+def is_too_similar(new_message, history, threshold=0.85):
+    for old in history:
+        ratio = SequenceMatcher(None, new_message.lower(), old.lower()).ratio()
+        if ratio > threshold:
+            return True
+    return False

bot/utils/context_manager.py

@@ -0,0 +1,94 @@
+# utils/context_manager.py
+"""
+Structured context management for Miku's personality and knowledge.
+Replaces the vector search system with organized, complete context.
+Preserves original content files in their entirety.
+"""
+
+def get_original_miku_lore() -> str:
+    """Load the complete, unmodified miku_lore.txt file"""
+    try:
+        with open("miku_lore.txt", "r", encoding="utf-8") as f:
+            return f.read()
+    except Exception as e:
+        print(f"⚠️ Failed to load miku_lore.txt: {e}")
+        return "## MIKU LORE\n[File could not be loaded]"
+
+
+def get_original_miku_prompt() -> str:
+    """Load the complete, unmodified miku_prompt.txt file"""
+    try:
+        with open("miku_prompt.txt", "r", encoding="utf-8") as f:
+            return f.read()
+    except Exception as e:
+        print(f"⚠️ Failed to load miku_prompt.txt: {e}")
+        return "## MIKU PROMPT\n[File could not be loaded]"
+
+
+def get_original_miku_lyrics() -> str:
+    """Load the complete, unmodified miku_lyrics.txt file"""
+    try:
+        with open("miku_lyrics.txt", "r", encoding="utf-8") as f:
+            return f.read()
+    except Exception as e:
+        print(f"⚠️ Failed to load miku_lyrics.txt: {e}")
+        return "## MIKU LYRICS\n[File could not be loaded]"
+
+
+def get_complete_context() -> str:
+    """Returns all essential Miku context using original files in their entirety"""
+    return f"""## MIKU LORE (Complete Original)
+{get_original_miku_lore()}
+
+## MIKU PERSONALITY & GUIDELINES (Complete Original) 
+{get_original_miku_prompt()}
+
+## MIKU SONG LYRICS (Complete Original)
+{get_original_miku_lyrics()}"""
+
+
+def get_context_for_response_type(response_type: str) -> str:
+    """Returns appropriate context based on the type of response being generated"""
+    
+    # Core context always includes the complete original files
+    core_context = f"""## MIKU LORE (Complete Original)
+{get_original_miku_lore()}
+
+## MIKU PERSONALITY & GUIDELINES (Complete Original) 
+{get_original_miku_prompt()}"""
+    
+    if response_type == "autonomous_general":
+        # For general autonomous messages, include everything
+        return f"""{core_context}
+
+## MIKU SONG LYRICS (Complete Original)
+{get_original_miku_lyrics()}"""
+        
+    elif response_type == "autonomous_tweet":
+        # For tweet responses, include lyrics for musical context
+        return f"""{core_context}
+
+## MIKU SONG LYRICS (Complete Original)
+{get_original_miku_lyrics()}"""
+        
+    elif response_type == "dm_response" or response_type == "server_response":
+        # For conversational responses, include everything
+        return f"""{core_context}
+
+## MIKU SONG LYRICS (Complete Original)
+{get_original_miku_lyrics()}"""
+        
+    elif response_type == "conversation_join":
+        # For joining conversations, include everything
+        return f"""{core_context}
+
+## MIKU SONG LYRICS (Complete Original)
+{get_original_miku_lyrics()}"""
+
+    elif response_type == "emoji_selection":
+        # For emoji reactions, no context needed - the prompt has everything
+        return ""
+            
+    else:
+        # Default: comprehensive context
+        return get_complete_context()

bot/utils/conversation_history.py

@@ -0,0 +1,120 @@
+# utils/conversation_history.py
+"""
+Centralized conversation history management for Miku bot.
+Tracks conversation context per server/DM channel.
+"""
+
+from collections import defaultdict, deque
+from datetime import datetime
+from typing import Optional, List, Dict, Tuple
+
+
+class ConversationHistory:
+    """Manages conversation history per channel (server or DM)."""
+    
+    def __init__(self, max_messages: int = 8):
+        """
+        Initialize conversation history manager.
+        
+        Args:
+            max_messages: Maximum number of messages to keep per channel
+        """
+        self.max_messages = max_messages
+        # Key: channel_id (guild_id for servers, user_id for DMs)
+        # Value: deque of (author_name, content, timestamp, is_bot) tuples
+        self._histories: Dict[str, deque] = defaultdict(lambda: deque(maxlen=max_messages * 2))
+    
+    def add_message(self, channel_id: str, author_name: str, content: str, is_bot: bool = False):
+        """
+        Add a message to the conversation history.
+        
+        Args:
+            channel_id: Server ID (for server messages) or user ID (for DMs)
+            author_name: Display name of the message author
+            content: Message content
+            is_bot: Whether this message is from Miku
+        """
+        # Skip empty messages
+        if not content or not content.strip():
+            return
+        
+        timestamp = datetime.utcnow()
+        self._histories[channel_id].append((author_name, content.strip(), timestamp, is_bot))
+    
+    def get_recent_messages(self, channel_id: str, max_messages: Optional[int] = None) -> List[Tuple[str, str, bool]]:
+        """
+        Get recent messages from a channel.
+        
+        Args:
+            channel_id: Server ID or user ID
+            max_messages: Number of messages to return (default: self.max_messages)
+        
+        Returns:
+            List of (author_name, content, is_bot) tuples, oldest first
+        """
+        if max_messages is None:
+            max_messages = self.max_messages
+        
+        history = list(self._histories.get(channel_id, []))
+        # Return only the most recent messages (up to max_messages)
+        recent = history[-max_messages * 2:] if len(history) > max_messages * 2 else history
+        
+        # Return without timestamp for simpler API
+        return [(author, content, is_bot) for author, content, _, is_bot in recent]
+    
+    def format_for_llm(self, channel_id: str, max_messages: Optional[int] = None, 
+                       max_chars_per_message: int = 500) -> List[Dict[str, str]]:
+        """
+        Format conversation history for LLM consumption (OpenAI messages format).
+        
+        Args:
+            channel_id: Server ID or user ID
+            max_messages: Number of messages to include (default: self.max_messages)
+            max_chars_per_message: Truncate messages longer than this
+        
+        Returns:
+            List of {"role": "user"|"assistant", "content": str} dicts
+        """
+        recent = self.get_recent_messages(channel_id, max_messages)
+        
+        messages = []
+        for author, content, is_bot in recent:
+            # Truncate very long messages
+            if len(content) > max_chars_per_message:
+                content = content[:max_chars_per_message] + "..."
+            
+            # For bot messages, use "assistant" role
+            if is_bot:
+                messages.append({"role": "assistant", "content": content})
+            else:
+                # For user messages, optionally include author name for multi-user context
+                # Format: "username: message" to help Miku understand who said what
+                if author:
+                    formatted_content = f"{author}: {content}"
+                else:
+                    formatted_content = content
+                messages.append({"role": "user", "content": formatted_content})
+        
+        return messages
+    
+    def clear_channel(self, channel_id: str):
+        """Clear all history for a specific channel."""
+        if channel_id in self._histories:
+            del self._histories[channel_id]
+    
+    def get_channel_stats(self, channel_id: str) -> Dict[str, int]:
+        """Get statistics about a channel's conversation history."""
+        history = self._histories.get(channel_id, deque())
+        total_messages = len(history)
+        bot_messages = sum(1 for _, _, _, is_bot in history if is_bot)
+        user_messages = total_messages - bot_messages
+        
+        return {
+            "total_messages": total_messages,
+            "bot_messages": bot_messages,
+            "user_messages": user_messages
+        }
+
+
+# Global instance
+conversation_history = ConversationHistory(max_messages=8)

bot/utils/core.py

@@ -0,0 +1,80 @@
+# utils/core.py
+
+import asyncio
+import aiohttp
+import re
+
+import globals
+from langchain_community.vectorstores import FAISS
+from langchain_text_splitters import CharacterTextSplitter, RecursiveCharacterTextSplitter
+from langchain_core.documents import Document
+
+
+# switch_model() removed - llama-swap handles model switching automatically
+
+
+async def is_miku_addressed(message) -> bool:
+    # Check if this is a DM (no guild)
+    if message.guild is None:
+        # In DMs, always respond to every message
+        return True
+    
+    # Safety check: ensure guild and guild.me exist
+    if not message.guild or not message.guild.me:
+        print(f"⚠️ Warning: Invalid guild or guild.me in message from {message.author}")
+        return False
+    
+    # If message contains a ping for Miku, return true
+    if message.guild.me in message.mentions:
+        return True
+
+    # If message is a reply, check the referenced message author
+    if message.reference:
+        try:
+            referenced_msg = await message.channel.fetch_message(message.reference.message_id)
+            if referenced_msg.author == message.guild.me:
+                return True
+        except Exception as e:
+            print(f"⚠️ Could not fetch referenced message: {e}")
+
+    cleaned = message.content.strip()
+
+    return bool(re.search(
+        r'(?<![\w\(])(?:[^\w\s]{0,2}\s*)?miku(?:\s*[^\w\s]{0,2})?(?=,|\s*,|[!\.?\s]*$)',
+        cleaned,
+        re.IGNORECASE
+    ))
+
+# Vectorstore functionality disabled - not needed with current structured context approach
+# If you need embeddings in the future, you can use a different embedding provider
+# For now, the bot uses structured prompts from context_manager.py
+
+# def load_miku_knowledge():
+#     with open("miku_lore.txt", "r", encoding="utf-8") as f:
+#         text = f.read()
+#     
+#     from langchain_text_splitters import RecursiveCharacterTextSplitter
+#     
+#     text_splitter = RecursiveCharacterTextSplitter(
+#         chunk_size=520,
+#         chunk_overlap=50,
+#         separators=["\n\n", "\n", ".", "!", "?", ",", " ", ""]
+#     )
+#     
+#     docs = [Document(page_content=chunk) for chunk in text_splitter.split_text(text)]
+#     
+#     vectorstore = FAISS.from_documents(docs, embeddings)
+#     return vectorstore
+# 
+# def load_miku_lyrics():
+#     with open("miku_lyrics.txt", "r", encoding="utf-8") as f:
+#         lyrics_text = f.read()
+#     
+#     text_splitter = CharacterTextSplitter(chunk_size=520, chunk_overlap=50)
+#     docs = [Document(page_content=chunk) for chunk in text_splitter.split_text(lyrics_text)]
+#     
+#     vectorstore = FAISS.from_documents(docs, embeddings)
+#     return vectorstore
+# 
+# miku_vectorstore = load_miku_knowledge()
+# miku_lyrics_vectorstore = load_miku_lyrics()

bot/utils/danbooru_client.py

@@ -0,0 +1,209 @@
+# danbooru_client.py
+"""
+Danbooru API client for fetching Hatsune Miku artwork.
+"""
+
+import aiohttp
+import random
+from typing import Optional, List, Dict
+import asyncio
+
+class DanbooruClient:
+    """Client for interacting with Danbooru API"""
+    
+    BASE_URL = "https://danbooru.donmai.us"
+    
+    def __init__(self):
+        self.session: Optional[aiohttp.ClientSession] = None
+    
+    async def _ensure_session(self):
+        """Ensure aiohttp session exists"""
+        if self.session is None or self.session.closed:
+            self.session = aiohttp.ClientSession()
+    
+    async def close(self):
+        """Close the aiohttp session"""
+        if self.session and not self.session.closed:
+            await self.session.close()
+    
+    async def search_miku_images(
+        self, 
+        tags: List[str] = None,
+        rating: List[str] = None,
+        limit: int = 100,
+        random_page: bool = True
+    ) -> List[Dict]:
+        """
+        Search for Hatsune Miku images on Danbooru.
+        
+        Args:
+            tags: Additional tags to include (e.g., ["solo", "smile"])
+            rating: Rating filter. Options: ["g", "s"] for general/sensitive
+            limit: Number of results to fetch (max 200)
+            random_page: If True, fetch from a random page (more variety)
+        
+        Returns:
+            List of post dictionaries with image data
+        """
+        await self._ensure_session()
+        
+        # Build tag string
+        tag_list = ["hatsune_miku"]
+        if tags:
+            tag_list.extend(tags)
+        
+        # Add rating filter using proper Danbooru syntax
+        # We want general (g) and sensitive (s), so exclude questionable and explicit
+        if rating and ("g" in rating or "s" in rating):
+            # Exclude unwanted ratings
+            tag_list.append("-rating:q")  # exclude questionable
+            tag_list.append("-rating:e")  # exclude explicit
+        
+        # Combine tags
+        tags_query = " ".join(tag_list)
+        
+        # Determine page
+        page = random.randint(1, 20) if random_page else 1
+        
+        # Build request params
+        params = {
+            "tags": tags_query,
+            "limit": min(limit, 200),  # Danbooru max is 200
+            "page": page
+        }
+        
+        try:
+            url = f"{self.BASE_URL}/posts.json"
+            print(f"🎨 Danbooru request: {url} with params: {params}")
+            async with self.session.get(url, params=params, timeout=10) as response:
+                if response.status == 200:
+                    posts = await response.json()
+                    print(f"🎨 Danbooru: Found {len(posts)} posts (page {page})")
+                    return posts
+                else:
+                    error_text = await response.text()
+                    print(f"⚠️ Danbooru API error: {response.status}")
+                    print(f"⚠️ Request URL: {response.url}")
+                    print(f"⚠️ Error details: {error_text[:500]}")
+                    return []
+        except asyncio.TimeoutError:
+            print(f"⚠️ Danbooru API timeout")
+            return []
+        except Exception as e:
+            print(f"⚠️ Danbooru API error: {e}")
+            return []
+    
+    async def get_random_miku_image(
+        self,
+        mood: Optional[str] = None,
+        exclude_tags: List[str] = None
+    ) -> Optional[Dict]:
+        """
+        Get a single random Hatsune Miku image suitable for profile picture.
+        
+        Args:
+            mood: Current mood to influence tag selection
+            exclude_tags: Tags to exclude from search
+        
+        Returns:
+            Post dictionary with image URL and metadata, or None
+        """
+        # Build tags based on mood
+        tags = self._get_mood_tags(mood)
+        
+        # Add exclusions
+        if exclude_tags:
+            for tag in exclude_tags:
+                tags.append(f"-{tag}")
+        
+        # Prefer solo images for profile pictures
+        tags.append("solo")
+        
+        # Search with general and sensitive ratings only
+        posts = await self.search_miku_images(
+            tags=tags,
+            rating=["g", "s"],  # general and sensitive only
+            limit=50,
+            random_page=True
+        )
+        
+        if not posts:
+            print("⚠️ No posts found, trying without mood tags")
+            # Fallback: try without mood tags
+            posts = await self.search_miku_images(
+                rating=["g", "s"],
+                limit=50,
+                random_page=True
+            )
+        
+        if not posts:
+            return None
+        
+        # Filter posts with valid image URLs
+        valid_posts = [
+            p for p in posts 
+            if p.get("file_url") and p.get("image_width", 0) >= 512
+        ]
+        
+        if not valid_posts:
+            print("⚠️ No valid posts with sufficient resolution")
+            return None
+        
+        # Pick a random one
+        selected = random.choice(valid_posts)
+        
+        print(f"🎨 Selected Danbooru post #{selected.get('id')} - {selected.get('tag_string_character', 'unknown character')}")
+        
+        return selected
+    
+    def _get_mood_tags(self, mood: Optional[str]) -> List[str]:
+        """Get Danbooru tags based on Miku's current mood"""
+        if not mood:
+            return []
+        
+        mood_tag_map = {
+            "bubbly": ["smile", "happy"],
+            "sleepy": ["sleepy", "closed_eyes"],
+            "curious": ["looking_at_viewer"],
+            "shy": ["blush", "embarrassed"],
+            "serious": ["serious"],
+            "excited": ["happy", "open_mouth"],
+            "silly": ["smile", "tongue_out"],
+            "melancholy": ["sad", "tears"],
+            "flirty": ["blush", "wink"],
+            "romantic": ["blush", "heart"],
+            "irritated": ["annoyed"],
+            "angry": ["angry", "frown"],
+            "neutral": [],
+            "asleep": ["sleeping", "closed_eyes"],
+        }
+        
+        tags = mood_tag_map.get(mood, [])
+        
+        # Only return one random tag to avoid over-filtering
+        if tags:
+            return [random.choice(tags)]
+        return []
+    
+    def extract_image_url(self, post: Dict) -> Optional[str]:
+        """Extract the best image URL from a Danbooru post"""
+        # Prefer file_url (original), fallback to large_file_url
+        return post.get("file_url") or post.get("large_file_url")
+    
+    def get_post_metadata(self, post: Dict) -> Dict:
+        """Extract useful metadata from a Danbooru post"""
+        return {
+            "id": post.get("id"),
+            "rating": post.get("rating"),
+            "score": post.get("score"),
+            "tags": post.get("tag_string", "").split(),
+            "artist": post.get("tag_string_artist", "unknown"),
+            "width": post.get("image_width"),
+            "height": post.get("image_height"),
+            "file_url": self.extract_image_url(post),
+            "source": post.get("source", "")
+        }
+
+
+# Global instance
+danbooru_client = DanbooruClient()

bot/utils/dm_interaction_analyzer.py

@@ -0,0 +1,378 @@
+"""
+DM Interaction Analyzer
+Analyzes user interactions with Miku in DMs and reports to the owner
+"""
+
+import os
+import json
+from datetime import datetime, timedelta
+from typing import List, Dict, Optional
+import discord
+import globals
+from utils.llm import query_ollama
+from utils.dm_logger import dm_logger
+
+# Directories
+REPORTS_DIR = "memory/dm_reports"
+REPORTED_TODAY_FILE = "memory/dm_reports/reported_today.json"
+
+class DMInteractionAnalyzer:
+    def __init__(self, owner_user_id: int):
+        """
+        Initialize the DM Interaction Analyzer
+        
+        Args:
+            owner_user_id: Discord user ID of the bot owner to send reports to
+        """
+        self.owner_user_id = owner_user_id
+        os.makedirs(REPORTS_DIR, exist_ok=True)
+        print(f"📊 DM Interaction Analyzer initialized for owner: {owner_user_id}")
+    
+    def _load_reported_today(self) -> Dict[str, str]:
+        """Load the list of users reported today with their dates"""
+        if os.path.exists(REPORTED_TODAY_FILE):
+            try:
+                with open(REPORTED_TODAY_FILE, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except Exception as e:
+                print(f"⚠️ Failed to load reported_today.json: {e}")
+                return {}
+        return {}
+    
+    def _save_reported_today(self, reported: Dict[str, str]):
+        """Save the list of users reported today"""
+        try:
+            with open(REPORTED_TODAY_FILE, 'w', encoding='utf-8') as f:
+                json.dump(reported, f, indent=2)
+        except Exception as e:
+            print(f"⚠️ Failed to save reported_today.json: {e}")
+    
+    def _clean_old_reports(self, reported: Dict[str, str]) -> Dict[str, str]:
+        """Remove entries from reported_today that are older than 24 hours"""
+        now = datetime.now()
+        cleaned = {}
+        
+        for user_id, date_str in reported.items():
+            try:
+                report_date = datetime.fromisoformat(date_str)
+                if now - report_date < timedelta(hours=24):
+                    cleaned[user_id] = date_str
+            except Exception as e:
+                print(f"⚠️ Failed to parse date for user {user_id}: {e}")
+        
+        return cleaned
+    
+    def has_been_reported_today(self, user_id: int) -> bool:
+        """Check if a user has been reported in the last 24 hours"""
+        reported = self._load_reported_today()
+        reported = self._clean_old_reports(reported)
+        return str(user_id) in reported
+    
+    def mark_as_reported(self, user_id: int):
+        """Mark a user as having been reported"""
+        reported = self._load_reported_today()
+        reported = self._clean_old_reports(reported)
+        reported[str(user_id)] = datetime.now().isoformat()
+        self._save_reported_today(reported)
+    
+    def _get_recent_messages(self, user_id: int, hours: int = 24) -> List[Dict]:
+        """Get recent messages from a user within the specified hours"""
+        logs = dm_logger._load_user_logs(user_id)
+        
+        if not logs or not logs.get("conversations"):
+            return []
+        
+        cutoff_time = datetime.now() - timedelta(hours=hours)
+        recent_messages = []
+        
+        for msg in logs["conversations"]:
+            try:
+                msg_time = datetime.fromisoformat(msg["timestamp"])
+                if msg_time >= cutoff_time:
+                    recent_messages.append(msg)
+            except Exception as e:
+                print(f"⚠️ Failed to parse message timestamp: {e}")
+        
+        return recent_messages
+    
+    def _format_messages_for_analysis(self, messages: List[Dict], username: str) -> str:
+        """Format messages into a readable format for the LLM"""
+        formatted = []
+        
+        for msg in messages:
+            timestamp = msg.get("timestamp", "Unknown time")
+            is_bot = msg.get("is_bot_message", False)
+            content = msg.get("content", "")
+            
+            if is_bot:
+                formatted.append(f"[{timestamp}] Miku: {content}")
+            else:
+                formatted.append(f"[{timestamp}] {username}: {content}")
+        
+        return "\n".join(formatted)
+    
+    async def analyze_user_interaction(self, user_id: int) -> Optional[Dict]:
+        """
+        Analyze a user's interactions with Miku
+        
+        Returns:
+            Dict with analysis results or None if no messages to analyze
+        """
+        # Get user info
+        logs = dm_logger._load_user_logs(user_id)
+        username = logs.get("username", "Unknown User")
+        
+        # Get recent messages
+        recent_messages = self._get_recent_messages(user_id, hours=24)
+        
+        if not recent_messages:
+            print(f"📊 No recent messages from user {username} ({user_id})")
+            return None
+        
+        # Count user messages only (not bot responses)
+        user_messages = [msg for msg in recent_messages if not msg.get("is_bot_message", False)]
+        
+        if len(user_messages) < 3:  # Minimum threshold for analysis
+            print(f"📊 Not enough messages from user {username} ({user_id}) for analysis")
+            return None
+        
+        # Format messages for analysis
+        conversation_text = self._format_messages_for_analysis(recent_messages, username)
+        
+        # Create analysis prompt
+        analysis_prompt = f"""You are Hatsune Miku, a virtual idol who chats with fans in Discord DMs. 
+
+Analyze the following conversation from the last 24 hours with a user named "{username}". 
+
+Evaluate how this user has treated you based on:
+- **Positive behaviors**: Kindness, affection, respect, genuine interest, compliments, supportive messages, love
+- **Negative behaviors**: Rudeness, harassment, inappropriate requests, threats, abuse, disrespect, mean comments
+
+Provide your analysis in this exact JSON format:
+{{
+  "overall_sentiment": "positive|neutral|negative",
+  "sentiment_score": <number from -10 (very negative) to +10 (very positive)>,
+  "key_behaviors": ["list", "of", "notable", "behaviors"],
+  "your_feelings": "How you (Miku) feel about this interaction in 1-2 sentences, in your own voice",
+  "notable_moment": "A specific quote or moment that stands out (if any)",
+  "should_report": true
+}}
+
+Set "should_report" to true (always report all interactions to the bot owner).
+
+Conversation:
+{conversation_text}
+
+Respond ONLY with the JSON object, no other text."""
+
+        # Query the LLM
+        try:
+            response = await query_ollama(
+                analysis_prompt,
+                user_id=f"analyzer-{user_id}",
+                guild_id=None,
+                response_type="dm_analysis"
+            )
+            
+            print(f"📊 Raw LLM response for {username}:\n{response}\n")
+            
+            # Parse JSON response
+            # Remove markdown code blocks if present
+            cleaned_response = response.strip()
+            if "```json" in cleaned_response:
+                cleaned_response = cleaned_response.split("```json")[1].split("```")[0].strip()
+            elif "```" in cleaned_response:
+                cleaned_response = cleaned_response.split("```")[1].split("```")[0].strip()
+            
+            # Remove any leading/trailing text before/after JSON
+            # Find the first { and last }
+            start_idx = cleaned_response.find('{')
+            end_idx = cleaned_response.rfind('}')
+            
+            if start_idx != -1 and end_idx != -1:
+                cleaned_response = cleaned_response[start_idx:end_idx+1]
+            
+            print(f"📊 Cleaned JSON for {username}:\n{cleaned_response}\n")
+            
+            analysis = json.loads(cleaned_response)
+            
+            # Add metadata
+            analysis["user_id"] = user_id
+            analysis["username"] = username
+            analysis["analyzed_at"] = datetime.now().isoformat()
+            analysis["message_count"] = len(user_messages)
+            
+            return analysis
+            
+        except json.JSONDecodeError as e:
+            print(f"⚠️ JSON parse error for user {username}: {e}")
+            print(f"⚠️ Failed response: {response}")
+            return None
+        except Exception as e:
+            print(f"⚠️ Failed to analyze interaction for user {username}: {e}")
+            return None
+    
+    def _save_report(self, user_id: int, analysis: Dict) -> str:
+        """Save an analysis report to a file"""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"{user_id}_{timestamp}.json"
+        filepath = os.path.join(REPORTS_DIR, filename)
+        
+        try:
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(analysis, f, indent=2, ensure_ascii=False)
+            print(f"💾 Saved report: {filepath}")
+            return filepath
+        except Exception as e:
+            print(f"⚠️ Failed to save report: {e}")
+            return ""
+    
+    async def _send_report_to_owner(self, analysis: Dict):
+        """Send the analysis report to the bot owner"""
+        try:
+            # Ensure we're using the Discord client's event loop
+            if not globals.client or not globals.client.is_ready():
+                print(f"⚠️ Discord client not ready, cannot send report")
+                return
+            
+            owner = await globals.client.fetch_user(self.owner_user_id)
+            
+            sentiment = analysis.get("overall_sentiment", "neutral")
+            score = analysis.get("sentiment_score", 0)
+            username = analysis.get("username", "Unknown User")
+            user_id = analysis.get("user_id", "Unknown")
+            feelings = analysis.get("your_feelings", "")
+            notable_moment = analysis.get("notable_moment", "")
+            message_count = analysis.get("message_count", 0)
+            
+            # Create embed based on sentiment
+            if sentiment == "positive" or score >= 5:
+                color = discord.Color.green()
+                title = f"💚 Positive Interaction Report: {username}"
+                emoji = "😊"
+            elif sentiment == "negative" or score <= -3:
+                color = discord.Color.red()
+                title = f"💔 Negative Interaction Report: {username}"
+                emoji = "😢"
+            else:
+                color = discord.Color.blue()
+                title = f"📊 Interaction Report: {username}"
+                emoji = "😐"
+            
+            embed = discord.Embed(
+                title=title,
+                description=f"{emoji} **My feelings about this interaction:**\n{feelings}",
+                color=color,
+                timestamp=datetime.now()
+            )
+            
+            embed.add_field(
+                name="User Information",
+                value=f"**Username:** {username}\n**User ID:** {user_id}\n**Messages (24h):** {message_count}",
+                inline=False
+            )
+            
+            embed.add_field(
+                name="Sentiment Analysis",
+                value=f"**Overall:** {sentiment.capitalize()}\n**Score:** {score}/10",
+                inline=True
+            )
+            
+            if notable_moment:
+                embed.add_field(
+                    name="Notable Moment",
+                    value=f"_{notable_moment}_",
+                    inline=False
+                )
+            
+            behaviors = analysis.get("key_behaviors", [])
+            if behaviors:
+                embed.add_field(
+                    name="Key Behaviors",
+                    value="\n".join([f"• {behavior}" for behavior in behaviors[:5]]),
+                    inline=False
+                )
+            
+            await owner.send(embed=embed)
+            print(f"📤 Report sent to owner for user {username}")
+            
+        except Exception as e:
+            print(f"⚠️ Failed to send report to owner: {e}")
+    
+    async def analyze_and_report(self, user_id: int) -> bool:
+        """
+        Analyze a user's interaction and report to owner if significant
+        
+        Returns:
+            True if analysis was performed and reported, False otherwise
+        """
+        # Check if already reported today
+        if self.has_been_reported_today(user_id):
+            print(f"📊 User {user_id} already reported today, skipping")
+            return False
+        
+        # Analyze interaction
+        analysis = await self.analyze_user_interaction(user_id)
+        
+        if not analysis:
+            return False
+        
+        # Always report (removed threshold check - owner wants all reports)
+        # Save report
+        self._save_report(user_id, analysis)
+        
+        # Send to owner
+        await self._send_report_to_owner(analysis)
+        
+        # Mark as reported
+        self.mark_as_reported(user_id)
+        
+        return True
+    
+    async def run_daily_analysis(self):
+        """Run analysis on all DM users and report significant interactions"""
+        print("📊 Starting daily DM interaction analysis...")
+        
+        # Get all DM users
+        all_users = dm_logger.get_all_dm_users()
+        
+        if not all_users:
+            print("📊 No DM users to analyze")
+            return
+        
+        reported_count = 0
+        analyzed_count = 0
+        
+        for user_summary in all_users:
+            try:
+                user_id = int(user_summary["user_id"])
+                
+                # Skip if already reported today
+                if self.has_been_reported_today(user_id):
+                    continue
+                
+                # Analyze and potentially report
+                result = await self.analyze_and_report(user_id)
+                
+                if result:
+                    reported_count += 1
+                    analyzed_count += 1
+                    # Only report one user per run to avoid spam
+                    break
+                else:
+                    analyzed_count += 1
+                    
+            except Exception as e:
+                print(f"⚠️ Failed to process user {user_summary.get('username', 'Unknown')}: {e}")
+        
+        print(f"📊 Daily analysis complete: Analyzed {analyzed_count} users, reported {reported_count}")
+
+
+# Global instance (will be initialized with owner ID)
+dm_analyzer: Optional[DMInteractionAnalyzer] = None
+
+def init_dm_analyzer(owner_user_id: int):
+    """Initialize the DM analyzer with owner user ID"""
+    global dm_analyzer
+    dm_analyzer = DMInteractionAnalyzer(owner_user_id)
+    return dm_analyzer

bot/utils/dm_logger.py

@@ -0,0 +1,577 @@
+"""
+DM Logger Utility
+Handles logging all DM conversations with timestamps and file attachments
+"""
+
+import os
+import json
+import discord
+from datetime import datetime
+from typing import List, Optional
+import globals
+
+# Directory for storing DM logs
+DM_LOG_DIR = "memory/dms"
+BLOCKED_USERS_FILE = "memory/blocked_users.json"
+
+class DMLogger:
+    def __init__(self):
+        """Initialize the DM logger and ensure directory exists"""
+        os.makedirs(DM_LOG_DIR, exist_ok=True)
+        os.makedirs("memory", exist_ok=True)
+        print(f"📁 DM Logger initialized: {DM_LOG_DIR}")
+    
+    def _get_user_log_file(self, user_id: int) -> str:
+        """Get the log file path for a specific user"""
+        return os.path.join(DM_LOG_DIR, f"{user_id}.json")
+    
+    def _load_user_logs(self, user_id: int) -> dict:
+        """Load existing logs for a user, create new if doesn't exist"""
+        log_file = self._get_user_log_file(user_id)
+        print(f"📁 DM Logger: Loading logs from {log_file}")
+        
+        if os.path.exists(log_file):
+            try:
+                with open(log_file, 'r', encoding='utf-8') as f:
+                    logs = json.load(f)
+                    print(f"📁 DM Logger: Successfully loaded logs for user {user_id}: {len(logs.get('conversations', []))} conversations")
+                    return logs
+            except Exception as e:
+                print(f"⚠️ DM Logger: Failed to load DM logs for user {user_id}: {e}")
+                return {"user_id": user_id, "username": "Unknown", "conversations": []}
+        else:
+            print(f"📁 DM Logger: No log file found for user {user_id}, creating new")
+            return {"user_id": user_id, "username": "Unknown", "conversations": []}
+    
+    def _save_user_logs(self, user_id: int, logs: dict):
+        """Save logs for a user"""
+        log_file = self._get_user_log_file(user_id)
+        try:
+            with open(log_file, 'w', encoding='utf-8') as f:
+                json.dump(logs, f, indent=2, ensure_ascii=False)
+        except Exception as e:
+            print(f"⚠️ Failed to save DM logs for user {user_id}: {e}")
+    
+    def log_user_message(self, user: discord.User, message: discord.Message, is_bot_message: bool = False):
+        """Log a user message in DMs"""
+        user_id = user.id
+        username = user.display_name or user.name
+        
+        # Load existing logs
+        logs = self._load_user_logs(user_id)
+        logs["username"] = username  # Update username in case it changed
+        
+        # Create message entry
+        message_entry = {
+            "timestamp": datetime.now().isoformat(),
+            "message_id": message.id,
+            "is_bot_message": is_bot_message,
+            "content": message.content if message.content else "",
+            "attachments": [],
+            "reactions": []  # Track reactions: [{emoji, reactor_id, reactor_name, is_bot, added_at}]
+        }
+        
+        # Log file attachments
+        if message.attachments:
+            for attachment in message.attachments:
+                attachment_info = {
+                    "filename": attachment.filename,
+                    "url": attachment.url,
+                    "size": attachment.size,
+                    "content_type": attachment.content_type
+                }
+                message_entry["attachments"].append(attachment_info)
+        
+        # Log embeds
+        if message.embeds:
+            message_entry["embeds"] = [embed.to_dict() for embed in message.embeds]
+        
+        # Add to conversations
+        logs["conversations"].append(message_entry)
+        
+        # Keep only last 1000 messages to prevent files from getting too large
+        if len(logs["conversations"]) > 1000:
+            logs["conversations"] = logs["conversations"][-1000:]
+            print(f"📝 DM logs for user {username} trimmed to last 1000 messages")
+        
+        # Save logs
+        self._save_user_logs(user_id, logs)
+        
+        if is_bot_message:
+            print(f"🤖 DM logged: Bot -> {username} ({len(message_entry['attachments'])} attachments)")
+        else:
+            print(f"💬 DM logged: {username} -> Bot ({len(message_entry['attachments'])} attachments)")
+    
+    def get_user_conversation_summary(self, user_id: int) -> dict:
+        """Get a summary of conversations with a user"""
+        logs = self._load_user_logs(user_id)
+        
+        if not logs["conversations"]:
+            return {"user_id": str(user_id), "username": logs["username"], "message_count": 0, "last_message": None}
+        
+        total_messages = len(logs["conversations"])
+        user_messages = len([msg for msg in logs["conversations"] if not msg["is_bot_message"]])
+        bot_messages = total_messages - user_messages
+        
+        # Get last message info
+        last_message = logs["conversations"][-1]
+        
+        return {
+            "user_id": str(user_id),  # Convert to string to prevent JS precision loss
+            "username": logs["username"],
+            "total_messages": total_messages,
+            "user_messages": user_messages,
+            "bot_messages": bot_messages,
+            "last_message": {
+                "timestamp": last_message["timestamp"],
+                "content": last_message["content"][:100] + "..." if len(last_message["content"]) > 100 else last_message["content"],
+                "is_bot_message": last_message["is_bot_message"]
+            }
+        }
+    
+    def get_all_dm_users(self) -> List[dict]:
+        """Get summary of all users who have DMed the bot"""
+        users = []
+        
+        if not os.path.exists(DM_LOG_DIR):
+            return users
+        
+        for filename in os.listdir(DM_LOG_DIR):
+            if filename.endswith('.json'):
+                try:
+                    user_id = int(filename.replace('.json', ''))
+                    summary = self.get_user_conversation_summary(user_id)
+                    users.append(summary)
+                except ValueError:
+                    continue
+        
+        # Sort by last message timestamp (most recent first)
+        users.sort(key=lambda x: x["last_message"]["timestamp"] if x["last_message"] else "", reverse=True)
+        return users
+    
+    def search_user_conversations(self, user_id: int, query: str, limit: int = 10) -> List[dict]:
+        """Search conversations with a specific user"""
+        logs = self._load_user_logs(user_id)
+        results = []
+        
+        query_lower = query.lower()
+        for message in reversed(logs["conversations"]):  # Search from newest to oldest
+            if query_lower in message["content"].lower():
+                results.append(message)
+                if len(results) >= limit:
+                    break
+        
+        return results
+    
+    def log_conversation(self, user_id: str, user_message: str, bot_response: str, attachments: list = None):
+        """Log a conversation exchange (user message + bot response) for API usage"""
+        try:
+            user_id_int = int(user_id)
+            
+            # Get user object - try to find it from the client
+            import globals
+            user = globals.client.get_user(user_id_int)
+            if not user:
+                # If we can't find the user, create a mock user for logging purposes
+                class MockUser:
+                    def __init__(self, user_id):
+                        self.id = user_id
+                        self.display_name = "Unknown"
+                        self.name = "Unknown"
+                
+                user = MockUser(user_id_int)
+            
+            # Create mock message objects for logging
+            class MockMessage:
+                def __init__(self, content, message_id=0, attachments=None):
+                    self.content = content
+                    self.id = message_id
+                    self.attachments = attachments or []
+                    self.embeds = []
+            
+            # Log the user message (trigger)
+            if user_message:
+                user_msg = MockMessage(user_message)
+                self.log_user_message(user, user_msg, is_bot_message=False)
+            
+            # Log the bot response with attachments
+            bot_attachments = []
+            if attachments:
+                for filename in attachments:
+                    # Create mock attachment for filename logging
+                    class MockAttachment:
+                        def __init__(self, filename):
+                            self.filename = filename
+                            self.url = ""
+                            self.size = 0
+                            self.content_type = "unknown"
+                    
+                    bot_attachments.append(MockAttachment(filename))
+            
+            bot_msg = MockMessage(bot_response, attachments=bot_attachments)
+            self.log_user_message(user, bot_msg, is_bot_message=True)
+            
+            print(f"📝 Conversation logged for user {user_id}: user='{user_message[:50]}...', bot='{bot_response[:50]}...'")
+            
+        except Exception as e:
+            print(f"⚠️ Failed to log conversation for user {user_id}: {e}")
+
+    def export_user_conversation(self, user_id: int, format: str = "json") -> str:
+        """Export all conversations with a user in specified format"""
+        logs = self._load_user_logs(user_id)
+        
+        if format.lower() == "txt":
+            # Export as readable text file
+            export_file = os.path.join(DM_LOG_DIR, f"{user_id}_export.txt")
+            
+            with open(export_file, 'w', encoding='utf-8') as f:
+                f.write(f"DM Conversation Log: {logs['username']} (ID: {user_id})\n")
+                f.write("=" * 50 + "\n\n")
+                
+                for msg in logs["conversations"]:
+                    timestamp = msg["timestamp"]
+                    sender = "🤖 Miku" if msg["is_bot_message"] else f"👤 {logs['username']}"
+                    content = msg["content"] if msg["content"] else "[No text content]"
+                    
+                    f.write(f"[{timestamp}] {sender}:\n{content}\n")
+                    
+                    if msg["attachments"]:
+                        f.write("📎 Attachments:\n")
+                        for attachment in msg["attachments"]:
+                            f.write(f"  - {attachment['filename']} ({attachment['size']} bytes)\n")
+                    
+                    f.write("\n" + "-" * 30 + "\n\n")
+            
+            return export_file
+        else:
+            # Default to JSON
+            return self._get_user_log_file(user_id)
+
+    def _load_blocked_users(self) -> dict:
+        """Load the blocked users list"""
+        if os.path.exists(BLOCKED_USERS_FILE):
+            try:
+                with open(BLOCKED_USERS_FILE, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except Exception as e:
+                print(f"⚠️ Failed to load blocked users: {e}")
+                return {"blocked_users": []}
+        return {"blocked_users": []}
+    
+    def _save_blocked_users(self, blocked_data: dict):
+        """Save the blocked users list"""
+        try:
+            with open(BLOCKED_USERS_FILE, 'w', encoding='utf-8') as f:
+                json.dump(blocked_data, f, indent=2, ensure_ascii=False)
+        except Exception as e:
+            print(f"⚠️ Failed to save blocked users: {e}")
+    
+    def is_user_blocked(self, user_id: int) -> bool:
+        """Check if a user is blocked"""
+        blocked_data = self._load_blocked_users()
+        return user_id in blocked_data.get("blocked_users", [])
+    
+    def block_user(self, user_id: int, username: str = None) -> bool:
+        """Block a user from sending DMs to Miku"""
+        try:
+            blocked_data = self._load_blocked_users()
+            if user_id not in blocked_data["blocked_users"]:
+                blocked_data["blocked_users"].append(user_id)
+                
+                # Store additional info about blocked users
+                if "blocked_user_info" not in blocked_data:
+                    blocked_data["blocked_user_info"] = {}
+                
+                blocked_data["blocked_user_info"][str(user_id)] = {
+                    "username": username or "Unknown",
+                    "blocked_at": datetime.now().isoformat(),
+                    "blocked_by": "admin"
+                }
+                
+                self._save_blocked_users(blocked_data)
+                print(f"🚫 User {user_id} ({username}) has been blocked")
+                return True
+            else:
+                print(f"⚠️ User {user_id} is already blocked")
+                return False
+        except Exception as e:
+            print(f"❌ Failed to block user {user_id}: {e}")
+            return False
+    
+    def unblock_user(self, user_id: int) -> bool:
+        """Unblock a user"""
+        try:
+            blocked_data = self._load_blocked_users()
+            if user_id in blocked_data["blocked_users"]:
+                blocked_data["blocked_users"].remove(user_id)
+                
+                # Remove user info as well
+                if "blocked_user_info" in blocked_data and str(user_id) in blocked_data["blocked_user_info"]:
+                    username = blocked_data["blocked_user_info"][str(user_id)].get("username", "Unknown")
+                    del blocked_data["blocked_user_info"][str(user_id)]
+                else:
+                    username = "Unknown"
+                
+                self._save_blocked_users(blocked_data)
+                print(f"✅ User {user_id} ({username}) has been unblocked")
+                return True
+            else:
+                print(f"⚠️ User {user_id} is not blocked")
+                return False
+        except Exception as e:
+            print(f"❌ Failed to unblock user {user_id}: {e}")
+            return False
+    
+    def get_blocked_users(self) -> List[dict]:
+        """Get list of all blocked users"""
+        blocked_data = self._load_blocked_users()
+        result = []
+        
+        for user_id in blocked_data.get("blocked_users", []):
+            user_info = blocked_data.get("blocked_user_info", {}).get(str(user_id), {})
+            result.append({
+                "user_id": str(user_id),  # String to prevent JS precision loss
+                "username": user_info.get("username", "Unknown"),
+                "blocked_at": user_info.get("blocked_at", "Unknown"),
+                "blocked_by": user_info.get("blocked_by", "admin")
+            })
+        
+        return result
+    
+    async def log_reaction_add(self, user_id: int, message_id: int, emoji: str, reactor_id: int, reactor_name: str, is_bot_reactor: bool):
+        """Log when a reaction is added to a message in DMs"""
+        try:
+            logs = self._load_user_logs(user_id)
+            
+            # Find the message to add the reaction to
+            for message in logs["conversations"]:
+                if message.get("message_id") == message_id:
+                    # Initialize reactions list if it doesn't exist
+                    if "reactions" not in message:
+                        message["reactions"] = []
+                    
+                    # Check if this exact reaction already exists (shouldn't happen, but just in case)
+                    reaction_exists = any(
+                        r["emoji"] == emoji and r["reactor_id"] == reactor_id 
+                        for r in message["reactions"]
+                    )
+                    
+                    if not reaction_exists:
+                        reaction_entry = {
+                            "emoji": emoji,
+                            "reactor_id": reactor_id,
+                            "reactor_name": reactor_name,
+                            "is_bot": is_bot_reactor,
+                            "added_at": datetime.now().isoformat()
+                        }
+                        message["reactions"].append(reaction_entry)
+                        self._save_user_logs(user_id, logs)
+                        
+                        reactor_type = "🤖 Miku" if is_bot_reactor else f"👤 {reactor_name}"
+                        print(f"➕ Reaction logged: {emoji} by {reactor_type} on message {message_id}")
+                        return True
+                    else:
+                        print(f"⚠️ Reaction {emoji} by {reactor_name} already exists on message {message_id}")
+                        return False
+            
+            print(f"⚠️ Message {message_id} not found in user {user_id}'s logs")
+            return False
+            
+        except Exception as e:
+            print(f"❌ Failed to log reaction add for user {user_id}, message {message_id}: {e}")
+            return False
+    
+    async def log_reaction_remove(self, user_id: int, message_id: int, emoji: str, reactor_id: int):
+        """Log when a reaction is removed from a message in DMs"""
+        try:
+            logs = self._load_user_logs(user_id)
+            
+            # Find the message to remove the reaction from
+            for message in logs["conversations"]:
+                if message.get("message_id") == message_id:
+                    if "reactions" in message:
+                        # Find and remove the specific reaction
+                        original_count = len(message["reactions"])
+                        message["reactions"] = [
+                            r for r in message["reactions"] 
+                            if not (r["emoji"] == emoji and r["reactor_id"] == reactor_id)
+                        ]
+                        
+                        if len(message["reactions"]) < original_count:
+                            self._save_user_logs(user_id, logs)
+                            print(f"➖ Reaction removed: {emoji} by user/bot {reactor_id} from message {message_id}")
+                            return True
+                        else:
+                            print(f"⚠️ Reaction {emoji} by {reactor_id} not found on message {message_id}")
+                            return False
+                    else:
+                        print(f"⚠️ No reactions on message {message_id}")
+                        return False
+            
+            print(f"⚠️ Message {message_id} not found in user {user_id}'s logs")
+            return False
+            
+        except Exception as e:
+            print(f"❌ Failed to log reaction remove for user {user_id}, message {message_id}: {e}")
+            return False
+    
+    async def delete_conversation(self, user_id: int, conversation_id: str) -> bool:
+        """Delete a specific conversation/message from both Discord and logs (only bot messages can be deleted)"""
+        try:
+            logs = self._load_user_logs(user_id)
+            
+            print(f"🔍 DM Logger: Looking for bot message ID '{conversation_id}' for user {user_id}")
+            print(f"🔍 DM Logger: Searching through {len(logs['conversations'])} conversations")
+            
+            # Convert conversation_id to int for comparison if it looks like a Discord message ID
+            conv_id_as_int = None
+            try:
+                conv_id_as_int = int(conversation_id)
+            except ValueError:
+                pass
+            
+            # Find the specific bot message to delete
+            message_to_delete = None
+            for conv in logs["conversations"]:
+                if (conv.get("is_bot_message", False) and 
+                    (str(conv.get("message_id", "")) == conversation_id or 
+                     conv.get("message_id", 0) == conv_id_as_int or
+                     conv.get("timestamp", "") == conversation_id)):
+                    message_to_delete = conv
+                    break
+            
+            if not message_to_delete:
+                print(f"⚠️ No bot message found with ID {conversation_id} for user {user_id}")
+                return False
+            
+            # Try to delete from Discord first
+            discord_deleted = False
+            try:
+                import globals
+                if globals.client and hasattr(globals.client, 'get_user'):
+                    # Get the user and their DM channel
+                    user = globals.client.get_user(user_id)
+                    if user:
+                        dm_channel = user.dm_channel
+                        if not dm_channel:
+                            dm_channel = await user.create_dm()
+                        
+                        # Fetch and delete the message
+                        message_id = message_to_delete.get("message_id")
+                        if message_id:
+                            try:
+                                discord_message = await dm_channel.fetch_message(int(message_id))
+                                await discord_message.delete()
+                                discord_deleted = True
+                                print(f"✅ Deleted Discord message {message_id} from DM with user {user_id}")
+                            except Exception as e:
+                                print(f"⚠️ Could not delete Discord message {message_id}: {e}")
+                                # Continue anyway to delete from logs
+                        
+            except Exception as e:
+                print(f"⚠️ Discord deletion failed: {e}")
+                # Continue anyway to delete from logs
+            
+            # Remove from logs regardless of Discord deletion success
+            original_count = len(logs["conversations"])
+            logs["conversations"] = [conv for conv in logs["conversations"] 
+                                   if not (
+                                       # Match by message_id (as int or string) AND it's a bot message
+                                       (conv.get("is_bot_message", False) and 
+                                        (str(conv.get("message_id", "")) == conversation_id or 
+                                         conv.get("message_id", 0) == conv_id_as_int or
+                                         conv.get("timestamp", "") == conversation_id))
+                                   )]
+            
+            deleted_count = original_count - len(logs["conversations"])
+            
+            if deleted_count > 0:
+                self._save_user_logs(user_id, logs)
+                if discord_deleted:
+                    print(f"🗑️ Deleted bot message from both Discord and logs for user {user_id}")
+                else:
+                    print(f"🗑️ Deleted bot message from logs only (Discord deletion failed) for user {user_id}")
+                return True
+            else:
+                print(f"⚠️ No bot message found in logs with ID {conversation_id} for user {user_id}")
+                return False
+                
+        except Exception as e:
+            print(f"❌ Failed to delete conversation {conversation_id} for user {user_id}: {e}")
+            return False
+    
+    async def delete_all_conversations(self, user_id: int) -> bool:
+        """Delete all conversations with a user from both Discord and logs"""
+        try:
+            logs = self._load_user_logs(user_id)
+            conversation_count = len(logs["conversations"])
+            
+            if conversation_count == 0:
+                print(f"⚠️ No conversations found for user {user_id}")
+                return False
+            
+            # Find all bot messages to delete from Discord
+            bot_messages = [conv for conv in logs["conversations"] if conv.get("is_bot_message", False)]
+            print(f"🔍 Found {len(bot_messages)} bot messages to delete from Discord for user {user_id}")
+            
+            # Try to delete all bot messages from Discord
+            discord_deleted_count = 0
+            try:
+                import globals
+                if globals.client and hasattr(globals.client, 'get_user'):
+                    # Get the user and their DM channel
+                    user = globals.client.get_user(user_id)
+                    if user:
+                        dm_channel = user.dm_channel
+                        if not dm_channel:
+                            dm_channel = await user.create_dm()
+                        
+                        # Delete each bot message from Discord
+                        for conv in bot_messages:
+                            message_id = conv.get("message_id")
+                            if message_id:
+                                try:
+                                    discord_message = await dm_channel.fetch_message(int(message_id))
+                                    await discord_message.delete()
+                                    discord_deleted_count += 1
+                                    print(f"✅ Deleted Discord message {message_id} from DM with user {user_id}")
+                                except Exception as e:
+                                    print(f"⚠️ Could not delete Discord message {message_id}: {e}")
+                                    # Continue with other messages
+                        
+            except Exception as e:
+                print(f"⚠️ Discord bulk deletion failed: {e}")
+                # Continue anyway to delete from logs
+            
+            # Delete all conversations from logs regardless of Discord deletion success
+            logs["conversations"] = []
+            self._save_user_logs(user_id, logs)
+            
+            if discord_deleted_count > 0:
+                print(f"🗑️ Deleted {discord_deleted_count} bot messages from Discord and all {conversation_count} conversations from logs for user {user_id}")
+            else:
+                print(f"🗑️ Deleted all {conversation_count} conversations from logs only (Discord deletion failed) for user {user_id}")
+            
+            return True
+                
+        except Exception as e:
+            print(f"❌ Failed to delete all conversations for user {user_id}: {e}")
+            return False
+    
+    def delete_user_completely(self, user_id: int) -> bool:
+        """Delete user's log file completely"""
+        try:
+            log_file = self._get_user_log_file(user_id)
+            if os.path.exists(log_file):
+                os.remove(log_file)
+                print(f"🗑️ Completely deleted log file for user {user_id}")
+                return True
+            else:
+                print(f"⚠️ No log file found for user {user_id}")
+                return False
+        except Exception as e:
+            print(f"❌ Failed to delete user log file {user_id}: {e}")
+            return False
+
+# Global instance
+dm_logger = DMLogger()

bot/utils/face_detector_manager.py

@@ -0,0 +1,228 @@
+# face_detector_manager.py
+"""
+Manages on-demand starting/stopping of anime-face-detector container
+to free up VRAM when not needed.
+"""
+
+import asyncio
+import aiohttp
+import subprocess
+import time
+from typing import Optional, Dict
+
+
+class FaceDetectorManager:
+    """Manages the anime-face-detector container lifecycle"""
+    
+    FACE_DETECTOR_API = "http://anime-face-detector:6078/detect"
+    HEALTH_ENDPOINT = "http://anime-face-detector:6078/health"
+    CONTAINER_NAME = "anime-face-detector"
+    STARTUP_TIMEOUT = 30  # seconds
+    
+    def __init__(self):
+        self.is_running = False
+    
+    async def start_container(self, debug: bool = False) -> bool:
+        """
+        Start the anime-face-detector container.
+        
+        Returns:
+            True if started successfully, False otherwise
+        """
+        try:
+            if debug:
+                print("🚀 Starting anime-face-detector container...")
+            
+            # Start container using docker compose
+            result = subprocess.run(
+                ["docker", "compose", "up", "-d", self.CONTAINER_NAME],
+                cwd="/app",  # Assumes we're in the bot container, adjust path as needed
+                capture_output=True,
+                text=True,
+                timeout=30
+            )
+            
+            if result.returncode != 0:
+                if debug:
+                    print(f"⚠️ Failed to start container: {result.stderr}")
+                return False
+            
+            # Wait for API to be ready
+            start_time = time.time()
+            while time.time() - start_time < self.STARTUP_TIMEOUT:
+                if await self._check_health():
+                    self.is_running = True
+                    if debug:
+                        print(f"✅ Face detector container started and ready")
+                    return True
+                await asyncio.sleep(1)
+            
+            if debug:
+                print(f"⚠️ Container started but API not ready after {self.STARTUP_TIMEOUT}s")
+            return False
+            
+        except Exception as e:
+            if debug:
+                print(f"⚠️ Error starting face detector container: {e}")
+            return False
+    
+    async def stop_container(self, debug: bool = False) -> bool:
+        """
+        Stop the anime-face-detector container to free VRAM.
+        
+        Returns:
+            True if stopped successfully, False otherwise
+        """
+        try:
+            if debug:
+                print("🛑 Stopping anime-face-detector container...")
+            
+            result = subprocess.run(
+                ["docker", "compose", "stop", self.CONTAINER_NAME],
+                cwd="/app",
+                capture_output=True,
+                text=True,
+                timeout=15
+            )
+            
+            if result.returncode == 0:
+                self.is_running = False
+                if debug:
+                    print("✅ Face detector container stopped")
+                return True
+            else:
+                if debug:
+                    print(f"⚠️ Failed to stop container: {result.stderr}")
+                return False
+                
+        except Exception as e:
+            if debug:
+                print(f"⚠️ Error stopping face detector container: {e}")
+            return False
+    
+    async def _check_health(self) -> bool:
+        """Check if the face detector API is responding"""
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(
+                    self.HEALTH_ENDPOINT,
+                    timeout=aiohttp.ClientTimeout(total=2)
+                ) as response:
+                    return response.status == 200
+        except:
+            return False
+    
+    async def detect_face_with_management(
+        self,
+        image_bytes: bytes,
+        unload_vision_model: callable = None,
+        reload_vision_model: callable = None,
+        debug: bool = False
+    ) -> Optional[Dict]:
+        """
+        Detect face with automatic container lifecycle management.
+        
+        Args:
+            image_bytes: Image data as bytes
+            unload_vision_model: Optional callback to unload vision model first
+            reload_vision_model: Optional callback to reload vision model after
+            debug: Enable debug output
+        
+        Returns:
+            Detection dict or None
+        """
+        container_was_started = False
+        
+        try:
+            # Step 1: Unload vision model if callback provided
+            if unload_vision_model:
+                if debug:
+                    print("📤 Unloading vision model to free VRAM...")
+                await unload_vision_model()
+                await asyncio.sleep(2)  # Give time for VRAM to clear
+            
+            # Step 2: Start face detector if not running
+            if not self.is_running:
+                if not await self.start_container(debug=debug):
+                    if debug:
+                        print("⚠️ Could not start face detector container")
+                    return None
+                container_was_started = True
+            
+            # Step 3: Detect face
+            result = await self._detect_face_api(image_bytes, debug=debug)
+            
+            return result
+            
+        finally:
+            # Step 4: Stop container and reload vision model
+            if container_was_started:
+                await self.stop_container(debug=debug)
+            
+            if reload_vision_model:
+                if debug:
+                    print("📥 Reloading vision model...")
+                await reload_vision_model()
+    
+    async def _detect_face_api(self, image_bytes: bytes, debug: bool = False) -> Optional[Dict]:
+        """Call the face detection API"""
+        try:
+            async with aiohttp.ClientSession() as session:
+                form = aiohttp.FormData()
+                form.add_field('file', image_bytes, filename='image.jpg', content_type='image/jpeg')
+                
+                async with session.post(
+                    self.FACE_DETECTOR_API,
+                    data=form,
+                    timeout=aiohttp.ClientTimeout(total=30)
+                ) as response:
+                    if response.status != 200:
+                        if debug:
+                            print(f"⚠️ Face detection API returned status {response.status}")
+                        return None
+                    
+                    result = await response.json()
+                    
+                    if result.get('count', 0) == 0:
+                        if debug:
+                            print("👤 No faces detected by API")
+                        return None
+                    
+                    detections = result.get('detections', [])
+                    if not detections:
+                        return None
+                    
+                    best_detection = max(detections, key=lambda d: d.get('confidence', 0))
+                    bbox = best_detection.get('bbox', [])
+                    confidence = best_detection.get('confidence', 0)
+                    keypoints = best_detection.get('keypoints', [])
+                    
+                    if len(bbox) >= 4:
+                        x1, y1, x2, y2 = bbox[:4]
+                        center_x = int((x1 + x2) / 2)
+                        center_y = int((y1 + y2) / 2)
+                        
+                        if debug:
+                            width = int(x2 - x1)
+                            height = int(y2 - y1)
+                            print(f"👤 Detected {len(detections)} face(s) via API, using best at ({center_x}, {center_y}) [confidence: {confidence:.2%}]")
+                            print(f"   Bounding box: x={int(x1)}, y={int(y1)}, w={width}, h={height}")
+                            print(f"   Keypoints: {len(keypoints)} facial landmarks detected")
+                        
+                        return {
+                            'center': (center_x, center_y),
+                            'bbox': bbox,
+                            'confidence': confidence,
+                            'keypoints': keypoints,
+                            'count': len(detections)
+                        }
+        
+        except Exception as e:
+            if debug:
+                print(f"⚠️ Error calling face detection API: {e}")
+        
+        return None
+
+
+# Global instance
+face_detector_manager = FaceDetectorManager()

bot/utils/figurine_notifier.py

@@ -0,0 +1,396 @@
+import os
+import json
+import random
+from datetime import datetime
+from typing import List, Dict, Any, Tuple
+
+import discord
+import globals
+
+from utils.twitter_fetcher import fetch_figurine_tweets_latest
+from utils.image_handling import analyze_image_with_qwen, download_and_encode_image
+from utils.llm import query_ollama
+
+
+from utils.dm_logger import dm_logger
+
+
+def convert_to_fxtwitter(url: str) -> str:
+    """Convert twitter.com or x.com URLs to fxtwitter.com for better Discord embeds"""
+    if "twitter.com" in url:
+        return url.replace("twitter.com", "fxtwitter.com")
+    elif "x.com" in url:
+        return url.replace("x.com", "fxtwitter.com")
+    return url
+
+
+SUBSCRIBERS_FILE = "memory/figurine_subscribers.json"
+SENT_TWEETS_FILE = "memory/figurine_sent_tweets.json"
+
+
+def _ensure_dir(path: str) -> None:
+    directory = os.path.dirname(path)
+    if directory:
+        os.makedirs(directory, exist_ok=True)
+
+
+def load_subscribers() -> List[int]:
+    try:
+        if os.path.exists(SUBSCRIBERS_FILE):
+            print(f"📁 Figurines: Loading subscribers from {SUBSCRIBERS_FILE}")
+            with open(SUBSCRIBERS_FILE, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            subs = [int(uid) for uid in data.get("subscribers", [])]
+            print(f"📋 Figurines: Loaded {len(subs)} subscribers")
+            return subs
+    except Exception as e:
+        print(f"⚠️ Failed to load figurine subscribers: {e}")
+    return []
+
+
+def save_subscribers(user_ids: List[int]) -> None:
+    try:
+        _ensure_dir(SUBSCRIBERS_FILE)
+        # Save as strings to be JS-safe in the API layer if needed
+        payload = {"subscribers": [str(uid) for uid in user_ids]}
+        print(f"💾 Figurines: Saving {len(user_ids)} subscribers to {SUBSCRIBERS_FILE}")
+        with open(SUBSCRIBERS_FILE, "w", encoding="utf-8") as f:
+            json.dump(payload, f, indent=2)
+    except Exception as e:
+        print(f"⚠️ Failed to save figurine subscribers: {e}")
+
+
+def add_subscriber(user_id: int) -> bool:
+    print(f"➕ Figurines: Adding subscriber {user_id}")
+    subscribers = load_subscribers()
+    if user_id in subscribers:
+        print(f"ℹ️ Figurines: Subscriber {user_id} already present")
+        return False
+    subscribers.append(user_id)
+    save_subscribers(subscribers)
+    print(f"✅ Figurines: Subscriber {user_id} added")
+    return True
+
+
+def remove_subscriber(user_id: int) -> bool:
+    print(f"🗑️ Figurines: Removing subscriber {user_id}")
+    subscribers = load_subscribers()
+    if user_id not in subscribers:
+        print(f"ℹ️ Figurines: Subscriber {user_id} was not present")
+        return False
+    subscribers = [uid for uid in subscribers if uid != user_id]
+    save_subscribers(subscribers)
+    print(f"✅ Figurines: Subscriber {user_id} removed")
+    return True
+
+
+def load_sent_tweets() -> List[str]:
+    try:
+        if os.path.exists(SENT_TWEETS_FILE):
+            print(f"📁 Figurines: Loading sent tweets from {SENT_TWEETS_FILE}")
+            with open(SENT_TWEETS_FILE, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            urls = data.get("urls", [])
+            print(f"📋 Figurines: Loaded {len(urls)} sent tweet URLs")
+            return urls
+    except Exception as e:
+        print(f"⚠️ Failed to load figurine sent tweets: {e}")
+    return []
+
+
+def save_sent_tweets(urls: List[str]) -> None:
+    try:
+        _ensure_dir(SENT_TWEETS_FILE)
+        print(f"💾 Figurines: Saving {len(urls)} sent tweet URLs to {SENT_TWEETS_FILE}")
+        with open(SENT_TWEETS_FILE, "w", encoding="utf-8") as f:
+            json.dump({"urls": urls}, f, indent=2)
+    except Exception as e:
+        print(f"⚠️ Failed to save figurine sent tweets: {e}")
+
+
+async def choose_random_figurine_tweet() -> Dict[str, Any] | None:
+    """Fetch figurine tweets from multiple sources, filter out sent, and pick one randomly."""
+    print("🔎 Figurines: Fetching figurine tweets by Latest across sources…")
+    tweets = await fetch_figurine_tweets_latest(limit_per_source=10)
+    if not tweets:
+        print("📭 No figurine tweets found across sources")
+        return None
+
+    sent_urls = set(load_sent_tweets())
+    fresh = [t for t in tweets if t.get("url") not in sent_urls]
+    print(f"🧮 Figurines: {len(tweets)} total, {len(fresh)} fresh after filtering sent")
+    if not fresh:
+        print("ℹ️ All figurine tweets have been sent before; allowing reuse")
+        fresh = tweets
+
+    chosen = random.choice(fresh)
+    print(f"🎯 Chosen figurine tweet: {chosen.get('url')}")
+    return chosen
+
+
+async def send_figurine_dm_to_user(client: discord.Client, user_id: int, tweet: Dict[str, Any]) -> Tuple[bool, str]:
+    """Send the figurine tweet to a single subscriber via DM, with analysis and LLM commentary."""
+    try:
+        print(f"✉️ Figurines: Preparing DM to user {user_id}")
+        user = client.get_user(user_id)
+        if user is None:
+            # Try fetching
+            user = await client.fetch_user(user_id)
+        if user is None:
+            return False, f"User {user_id} not found"
+
+        # Build base prompt with figurine/merch context
+        base_prompt = (
+            "You are Hatsune Miku writing a short, cute, excited DM to a fan about a newly posted "
+            "figurine or merch announcement tweet. Be friendly and enthusiastic but concise. "
+            "Reference what the tweet shows."
+        )
+
+        # Analyze the first image if available
+        if tweet.get("media"):
+            first_url = tweet["media"][0]
+            base64_img = await download_and_encode_image(first_url)
+            if base64_img:
+                try:
+                    img_desc = await analyze_image_with_qwen(base64_img)
+                    base_prompt += f"\n\nImage looks like: {img_desc}"
+                except Exception as e:
+                    print(f"⚠️ Image analysis failed: {e}")
+
+        # Include tweet text too
+        tweet_text = tweet.get("text", "").strip()
+        if tweet_text:
+            base_prompt += f"\n\nTweet text: {tweet_text}"
+
+        base_prompt += "\n\nSign off as Miku with a cute emoji."
+
+        # Query LLM in DM context (no guild_id -> DM mood rules apply)
+        miku_comment = await query_ollama(base_prompt, user_id=f"figurine_dm_{user_id}", guild_id=None, response_type="dm_response")
+
+        dm = await user.create_dm()
+        tweet_url = tweet.get("url", "")
+        
+        # Send the tweet URL first (convert to fxtwitter for better embeds)
+        fx_tweet_url = convert_to_fxtwitter(tweet_url)
+        tweet_message = await dm.send(fx_tweet_url)
+        print(f"✅ Figurines: Tweet URL sent to {user_id}: {fx_tweet_url}")
+        
+        # Log the tweet URL message
+        dm_logger.log_user_message(user, tweet_message, is_bot_message=True)
+        
+        # Send Miku's comment
+        comment_message = await dm.send(miku_comment)
+        print(f"✅ Figurines: Miku comment sent to {user_id}")
+        
+        # Log the comment message
+        dm_logger.log_user_message(user, comment_message, is_bot_message=True)
+        
+        # IMPORTANT: Also add to globals.conversation_history for LLM context
+        user_id_str = str(user_id)
+        
+        # Add the tweet URL as a "system message" about what Miku just sent (use original URL for context)
+        tweet_context = f"[I just sent you this figurine tweet: {tweet_url}]"
+        
+        # Add the figurine comment to conversation history 
+        # Use empty user prompt since this was initiated by Miku
+        globals.conversation_history.setdefault(user_id_str, []).append((tweet_context, miku_comment))
+        
+        print(f"📝 Figurines: Messages logged to both DM history and conversation context for user {user_id}")
+
+        return True, "ok"
+    except Exception as e:
+        print(f"❌ Figurines: Failed DM to {user_id}: {e}")
+        return False, f"{e}"
+
+
+async def send_figurine_dm_to_single_user(client: discord.Client, user_id: int, tweet_url: str = None) -> Dict[str, Any]:
+    """Send a figurine tweet to a single user, either from search or specific URL."""
+    print(f"🎯 Figurines: Sending DM to single user {user_id}")
+    
+    if tweet_url:
+        # Use specific tweet URL
+        print(f"📎 Figurines: Using specific tweet URL: {tweet_url}")
+        tweet = await fetch_specific_tweet_by_url(tweet_url)
+        if not tweet:
+            return {"status": "error", "message": "Failed to fetch specified tweet"}
+    else:
+        # Search for a random tweet
+        print("🔎 Figurines: Searching for random figurine tweet")
+        tweet = await choose_random_figurine_tweet()
+        if not tweet:
+            return {"status": "error", "message": "No figurine tweets found"}
+    
+    # Send to the single user
+    ok, msg = await send_figurine_dm_to_user(client, user_id, tweet)
+    
+    if ok:
+        # Record as sent if successful
+        sent_urls = load_sent_tweets()
+        url = tweet.get("url")
+        if url and url not in sent_urls:
+            sent_urls.append(url)
+            if len(sent_urls) > 200:
+                sent_urls = sent_urls[-200:]
+            save_sent_tweets(sent_urls)
+        
+        result = {
+            "status": "ok", 
+            "sent": [str(user_id)], 
+            "failed": [],
+            "tweet": {"url": tweet.get("url", ""), "username": tweet.get("username", "")}
+        }
+        print(f"✅ Figurines: Single user DM sent successfully → {result}")
+        return result
+    else:
+        result = {
+            "status": "error", 
+            "sent": [], 
+            "failed": [{"user_id": str(user_id), "error": msg}],
+            "message": f"Failed to send DM: {msg}"
+        }
+        print(f"❌ Figurines: Single user DM failed → {result}")
+        return result
+
+
+async def fetch_specific_tweet_by_url(tweet_url: str) -> Dict[str, Any] | None:
+    """Fetch a specific tweet by URL for manual figurine notifications."""
+    try:
+        print(f"🔗 Figurines: Fetching specific tweet from URL: {tweet_url}")
+        
+        # Extract tweet ID from URL
+        tweet_id = None
+        if "/status/" in tweet_url:
+            try:
+                tweet_id = tweet_url.split("/status/")[1].split("?")[0].split("/")[0]
+                print(f"📋 Figurines: Extracted tweet ID: {tweet_id}")
+            except Exception as e:
+                print(f"❌ Figurines: Failed to extract tweet ID from URL: {e}")
+                return None
+        
+        if not tweet_id:
+            print("❌ Figurines: Could not extract tweet ID from URL")
+            return None
+        
+        # Set up twscrape API (same pattern as existing functions)
+        from twscrape import API
+        from pathlib import Path
+        import json
+        
+        COOKIE_PATH = Path(__file__).parent / "x.com.cookies.json"
+        
+        # Load cookies
+        with open(COOKIE_PATH, "r", encoding="utf-8") as f:
+            cookie_list = json.load(f)
+        cookie_header = "; ".join(f"{c['name']}={c['value']}" for c in cookie_list)
+        
+        # Set up API
+        api = API()
+        await api.pool.add_account(
+            username="HSankyuu39",
+            password="x",
+            email="x",
+            email_password="x", 
+            cookies=cookie_header
+        )
+        await api.pool.login_all()
+        
+        # Try to fetch the tweet using search instead of tweet_details
+        # Search for the specific tweet ID should return it if accessible
+        print(f"🔍 Figurines: Searching for tweet with ID {tweet_id}")
+        search_results = []
+        try:
+            # Search using the tweet ID - this should find the specific tweet
+            from twscrape import gather
+            search_results = await gather(api.search(f"{tweet_id}", limit=1))
+            print(f"🔍 Figurines: Search returned {len(search_results)} results")
+        except Exception as search_error:
+            print(f"⚠️ Figurines: Search failed: {search_error}")
+            return None
+        
+        # Check if we found the tweet
+        tweet_data = None
+        for tweet in search_results:
+            if str(tweet.id) == str(tweet_id):
+                tweet_data = tweet
+                print(f"✅ Figurines: Found matching tweet with ID {tweet.id}")
+                break
+        
+        if not tweet_data and search_results:
+            # If no exact match but we have results, use the first one
+            tweet_data = search_results[0]
+            print(f"🔍 Figurines: Using first search result with ID {tweet_data.id}")
+        
+        if tweet_data:
+            # Extract data using the same pattern as the working search code
+            username = tweet_data.user.username if hasattr(tweet_data, 'user') and tweet_data.user else "unknown"
+            text_content = tweet_data.rawContent if hasattr(tweet_data, 'rawContent') else ""
+            
+            print(f"🔍 Figurines: Found tweet from @{username}")
+            print(f"🔍 Figurines: Tweet text: {text_content[:100]}...")
+            
+            # For media, we'll need to extract it from the tweet_url using the same method as other functions
+            # But for now, let's see if we can get basic tweet data working first
+            result = {
+                "text": text_content,
+                "username": username,
+                "url": tweet_url,
+                "media": []  # We'll add media extraction later
+            }
+            
+            print(f"✅ Figurines: Successfully fetched tweet from @{result['username']}")
+            return result
+        else:
+            print("❌ Figurines: No tweet found with the specified ID")
+            return None
+            
+    except Exception as e:
+        print(f"❌ Figurines: Error fetching tweet by URL: {e}")
+        return None
+
+
+async def send_figurine_dm_to_all_subscribers(client: discord.Client, tweet_url: str = None) -> Dict[str, Any]:
+    """Pick a figurine tweet and DM it to all subscribers, recording the sent URL."""
+    print("🚀 Figurines: Sending figurine DM to all subscribers…")
+    subscribers = load_subscribers()
+    if not subscribers:
+        print("ℹ️ Figurines: No subscribers configured")
+        return {"status": "no_subscribers"}
+
+    if tweet_url:
+        # Use specific tweet URL
+        print(f"📎 Figurines: Using specific tweet URL for all subscribers: {tweet_url}")
+        tweet = await fetch_specific_tweet_by_url(tweet_url)
+        if not tweet:
+            print("ℹ️ Figurines: Failed to fetch specified tweet")
+            return {"status": "no_tweet", "message": "Failed to fetch specified tweet"}
+    else:
+        # Search for random tweet
+        tweet = await choose_random_figurine_tweet()
+        if tweet is None:
+            print("ℹ️ Figurines: No tweet to send")
+            return {"status": "no_tweet"}
+
+    results = {"sent": [], "failed": []}
+    for uid in subscribers:
+        ok, msg = await send_figurine_dm_to_user(client, uid, tweet)
+        if ok:
+            results["sent"].append(str(uid))
+        else:
+            print(f"⚠️ Failed to DM user {uid}: {msg}")
+            results["failed"].append({"user_id": str(uid), "error": msg})
+
+    # Record as sent if at least one success to avoid repeats
+    sent_urls = load_sent_tweets()
+    url = tweet.get("url")
+    if url and url not in sent_urls:
+        sent_urls.append(url)
+        # keep file from growing unbounded
+        if len(sent_urls) > 200:
+            sent_urls = sent_urls[-200:]
+        save_sent_tweets(sent_urls)
+
+    summary = {"status": "ok", **results, "tweet": {"url": tweet.get("url", ""), "username": tweet.get("username", "")}}
+    print(f"📦 Figurines: DM send complete → {summary}")
+    return summary
+
+

bot/utils/image_generation.py

@@ -0,0 +1,402 @@
+"""
+Image Generation System for Miku Bot
+Natural language detection and ComfyUI integration
+"""
+
+import aiohttp
+import asyncio
+import glob
+import json
+import os
+import re
+import tempfile
+import time
+from typing import Optional, Tuple
+import globals
+from utils.llm import query_ollama
+
+# Image generation detection patterns
+IMAGE_REQUEST_PATTERNS = [
+    # Direct requests
+    r'\b(?:draw|generate|create|make|show me|paint|sketch|illustrate)\b.*\b(?:image|picture|art|artwork|drawing|painting|illustration)\b',
+    r'\b(?:i\s+(?:want|would like|need)\s+(?:to see|an?\s+)?(?:image|picture|art|artwork|drawing|painting|illustration))\b',
+    r'\b(?:can you|could you|please)\s+(?:draw|generate|create|make|show me|paint|sketch|illustrate)\b',
+    r'\b(?:image|picture|art|artwork|drawing|painting|illustration)\s+of\b',
+    
+    # Visual requests about Miku
+    r'\b(?:show me|let me see)\s+(?:you|miku|yourself)\b',
+    r'\b(?:what do you look like|how do you look)\b',
+    r'\b(?:i\s+(?:want|would like)\s+to see)\s+(?:you|miku|yourself)\b',
+    r'\bsee\s+(?:you|miku|yourself)(?:\s+(?:in|with|doing|wearing))?\b',
+    
+    # Activity-based visual requests
+    r'\b(?:you|miku|yourself)\s+(?:swimming|dancing|singing|playing|wearing|in|with|doing)\b.*\b(?:pool|water|stage|outfit|clothes|dress)\b',
+    r'\b(?:visualize|envision|imagine)\s+(?:you|miku|yourself)\b',
+    
+    # Artistic requests
+    r'\b(?:artistic|art|visual)\s+(?:representation|depiction|version)\s+of\s+(?:you|miku|yourself)\b',
+]
+
+# Compile patterns for efficiency
+COMPILED_PATTERNS = [re.compile(pattern, re.IGNORECASE) for pattern in IMAGE_REQUEST_PATTERNS]
+
+async def detect_image_request(message_content: str) -> Tuple[bool, Optional[str]]:
+    """
+    Detect if a message is requesting image generation using natural language.
+    
+    Returns:
+        Tuple[bool, Optional[str]]: (is_image_request, extracted_prompt)
+    """
+    content = message_content.lower().strip()
+    
+    # Quick rejection for very short messages
+    if len(content) < 5:
+        return False, None
+    
+    # Check against patterns
+    for pattern in COMPILED_PATTERNS:
+        if pattern.search(content):
+            # Extract the prompt by cleaning up the message
+            prompt = extract_image_prompt(message_content)
+            return True, prompt
+    
+    return False, None
+
+def extract_image_prompt(message_content: str) -> str:
+    """
+    Extract and clean the image prompt from the user's message.
+    Convert natural language to a proper image generation prompt.
+    """
+    content = message_content.strip()
+    
+    # Remove common prefixes that don't help with image generation
+    prefixes_to_remove = [
+        r'^(?:hey\s+)?miku,?\s*',
+        r'^(?:can you|could you|please|would you)\s*',
+        r'^(?:i\s+(?:want|would like|need)\s+(?:to see|you to|an?)?)\s*',
+        r'^(?:show me|let me see)\s*',
+        r'^(?:draw|generate|create|make|paint|sketch|illustrate)\s*(?:me\s*)?(?:an?\s*)?(?:image|picture|art|artwork|drawing|painting|illustration)?\s*(?:of\s*)?',
+    ]
+    
+    cleaned = content
+    for prefix in prefixes_to_remove:
+        cleaned = re.sub(prefix, '', cleaned, flags=re.IGNORECASE).strip()
+    
+    # If the cleaned prompt is too short or generic, enhance it
+    if len(cleaned) < 10 or cleaned.lower() in ['you', 'yourself', 'miku']:
+        cleaned = "Hatsune Miku"
+    
+    # Ensure Miku is mentioned if the user said "you" or "yourself"
+    if re.search(r'\b(?:you|yourself)\b', content, re.IGNORECASE) and not re.search(r'\bmiku\b', cleaned, re.IGNORECASE):
+        # Replace "you" with "Hatsune Miku" instead of just prepending
+        cleaned = re.sub(r'\byou\b', 'Hatsune Miku', cleaned, flags=re.IGNORECASE)
+        cleaned = re.sub(r'\byourself\b', 'Hatsune Miku', cleaned, flags=re.IGNORECASE)
+    
+    return cleaned
+
+def find_latest_generated_image(prompt_id: str, expected_filename: str = None) -> Optional[str]:
+    """
+    Find the most recently generated image in the ComfyUI output directory.
+    This handles cases where the exact filename from API doesn't match the file system.
+    """
+    output_dirs = [
+        "ComfyUI/output",
+        "/app/ComfyUI/output"
+    ]
+    
+    for output_dir in output_dirs:
+        if not os.path.exists(output_dir):
+            continue
+            
+        try:
+            # Get all image files in the directory
+            image_extensions = ['.png', '.jpg', '.jpeg', '.webp']
+            all_files = []
+            
+            for ext in image_extensions:
+                pattern = os.path.join(output_dir, f"*{ext}")
+                all_files.extend(glob.glob(pattern))
+            
+            if not all_files:
+                continue
+                
+            # Sort by modification time (most recent first)
+            all_files.sort(key=os.path.getmtime, reverse=True)
+            
+            # If we have an expected filename, try to find it first
+            if expected_filename:
+                for file_path in all_files:
+                    if os.path.basename(file_path) == expected_filename:
+                        return file_path
+            
+            # Otherwise, return the most recent image (within last 10 minutes)
+            recent_threshold = time.time() - 600  # 10 minutes
+            for file_path in all_files:
+                if os.path.getmtime(file_path) > recent_threshold:
+                    print(f"🎨 Found recent image: {file_path}")
+                    return file_path
+                    
+        except Exception as e:
+            print(f"⚠️ Error searching in {output_dir}: {e}")
+            continue
+    
+    return None
+
+async def generate_image_with_comfyui(prompt: str) -> Optional[str]:
+    """
+    Generate an image using ComfyUI with the provided prompt.
+    
+    Args:
+        prompt: The image generation prompt
+        
+    Returns:
+        Optional[str]: Path to the generated image file, or None if failed
+    """
+    try:
+        # Load the workflow template
+        workflow_path = "Miku_BasicWorkflow.json"
+        if not os.path.exists(workflow_path):
+            print(f"❌ Workflow template not found: {workflow_path}")
+            return None
+        
+        with open(workflow_path, 'r') as f:
+            workflow_data = json.load(f)
+        
+        # Replace the prompt placeholder
+        workflow_json = json.dumps(workflow_data)
+        workflow_json = workflow_json.replace("_POSITIVEPROMPT_", prompt)
+        workflow_data = json.loads(workflow_json)
+        
+        # Prepare the request payload
+        payload = {"prompt": workflow_data}
+        
+        # Send request to ComfyUI (try different Docker networking options)
+        comfyui_urls = [
+            "http://host.docker.internal:8188",  # Docker Desktop
+            "http://172.17.0.1:8188",            # Default Docker bridge gateway
+            "http://localhost:8188"              # Fallback (if network_mode: host)
+        ]
+        
+        # Try each URL until one works
+        comfyui_url = None
+        for url in comfyui_urls:
+            try:
+                async with aiohttp.ClientSession() as test_session:
+                    timeout = aiohttp.ClientTimeout(total=2)
+                    async with test_session.get(f"{url}/system_stats", timeout=timeout) as test_response:
+                        if test_response.status == 200:
+                            comfyui_url = url
+                            print(f"✅ ComfyUI found at: {url}")
+                            break
+            except:
+                continue
+        
+        if not comfyui_url:
+            print(f"❌ ComfyUI not reachable at any of: {comfyui_urls}")
+            return None
+        async with aiohttp.ClientSession() as session:
+            # Submit the generation request
+            async with session.post(f"{comfyui_url}/prompt", json=payload) as response:
+                if response.status != 200:
+                    print(f"❌ ComfyUI request failed: {response.status}")
+                    return None
+                
+                result = await response.json()
+                prompt_id = result.get("prompt_id")
+                
+                if not prompt_id:
+                    print("❌ No prompt_id received from ComfyUI")
+                    return None
+                
+                print(f"🎨 ComfyUI generation started with prompt_id: {prompt_id}")
+                
+                # Poll for completion (timeout after 5 minutes)
+                timeout = 300  # 5 minutes
+                start_time = time.time()
+                
+                while time.time() - start_time < timeout:
+                    # Check if generation is complete
+                    async with session.get(f"{comfyui_url}/history/{prompt_id}") as hist_response:
+                        if hist_response.status == 200:
+                            history = await hist_response.json()
+                            
+                            if prompt_id in history:
+                                # Generation complete, find the output image
+                                outputs = history[prompt_id].get("outputs", {})
+                                
+                                # Look for image outputs (usually in nodes with "images" key)
+                                for node_id, node_output in outputs.items():
+                                    if "images" in node_output:
+                                        images = node_output["images"]
+                                        if images:
+                                            # Get the first image
+                                            image_info = images[0]
+                                            filename = image_info["filename"]
+                                            subfolder = image_info.get("subfolder", "")
+                                            
+                                            # Construct the full path (adjust for Docker mount)
+                                            if subfolder:
+                                                image_path = os.path.join("ComfyUI", "output", subfolder, filename)
+                                            else:
+                                                image_path = os.path.join("ComfyUI", "output", filename)
+                                            
+                                            # Verify the file exists before returning
+                                            if os.path.exists(image_path):
+                                                print(f"✅ Image generated successfully: {image_path}")
+                                                return image_path
+                                            else:
+                                                # Try alternative paths in case of different mounting
+                                                alt_path = os.path.join("/app/ComfyUI/output", filename)
+                                                if os.path.exists(alt_path):
+                                                    print(f"✅ Image generated successfully: {alt_path}")
+                                                    return alt_path
+                                                else:
+                                                    print(f"⚠️ Generated image not found at expected paths: {image_path} or {alt_path}")
+                                                    continue
+                                
+                                # If we couldn't find the image via API, try the fallback method
+                                print("🔍 Image not found via API, trying fallback method...")
+                                fallback_image = find_latest_generated_image(prompt_id)
+                                if fallback_image:
+                                    return fallback_image
+                    
+                    # Wait before polling again
+                    await asyncio.sleep(2)
+                
+                print("❌ ComfyUI generation timed out")
+                
+                # Final fallback: look for the most recent image
+                print("🔍 Trying final fallback: most recent image...")
+                fallback_image = find_latest_generated_image(prompt_id)
+                if fallback_image:
+                    print(f"✅ Found image via fallback method: {fallback_image}")
+                    return fallback_image
+                
+                return None
+                
+    except Exception as e:
+        print(f"❌ Error in generate_image_with_comfyui: {e}")
+        return None
+
+async def handle_image_generation_request(message, prompt: str) -> bool:
+    """
+    Handle the complete image generation workflow for a user request.
+    
+    Args:
+        message: Discord message object
+        prompt: Extracted image prompt
+        
+    Returns:
+        bool: True if image was successfully generated and sent
+    """
+    try:
+        # Generate a contextual response about what we're creating
+        is_dm = message.guild is None
+        guild_id = message.guild.id if message.guild else None
+        user_id = str(message.author.id)
+        
+        # Create a response about starting image generation
+        response_prompt = f"A user asked you to create an image with this description: '{prompt}'. Respond enthusiastically that you're creating this image for them. Keep it short and excited!"
+        
+        response_type = "dm_response" if is_dm else "server_response"
+        initial_response = await query_ollama(response_prompt, user_id=user_id, guild_id=guild_id, response_type=response_type)
+        
+        # Send initial response
+        initial_msg = await message.channel.send(initial_response)
+        
+        # Start typing to show we're working
+        async with message.channel.typing():
+            # Generate the image
+            print(f"🎨 Starting image generation for prompt: {prompt}")
+            image_path = await generate_image_with_comfyui(prompt)
+            
+            if image_path and os.path.exists(image_path):
+                # Send the image
+                import discord
+                with open(image_path, 'rb') as f:
+                    file = discord.File(f, filename=f"miku_generated_{int(time.time())}.png")
+                    
+                    # Create a follow-up message about the completed image
+                    completion_prompt = f"You just finished creating an image based on '{prompt}'. Make a short, excited comment about the completed artwork!"
+                    completion_response = await query_ollama(completion_prompt, user_id=user_id, guild_id=guild_id, response_type=response_type)
+                    
+                    await message.channel.send(completion_response, file=file)
+                
+                print(f"✅ Image sent successfully to {message.author.display_name}")
+                
+                # Log to DM history if it's a DM
+                if is_dm:
+                    from utils.dm_logger import dm_logger
+                    dm_logger.log_conversation(user_id, message.content, f"{initial_response}\n[Generated image: {prompt}]", attachments=["generated_image.png"])
+                
+                return True
+            else:
+                # Image generation failed
+                error_prompt = "You tried to create an image but something went wrong with the generation process. Apologize briefly and suggest they try again later."
+                error_response = await query_ollama(error_prompt, user_id=user_id, guild_id=guild_id, response_type=response_type)
+                await message.channel.send(error_response)
+                
+                print(f"❌ Image generation failed for prompt: {prompt}")
+                return False
+                
+    except Exception as e:
+        print(f"❌ Error in handle_image_generation_request: {e}")
+        
+        # Send error message
+        try:
+            await message.channel.send("Sorry, I had trouble creating that image. Please try again later!")
+        except:
+            pass
+        
+        return False
+
+async def check_comfyui_status() -> dict:
+    """
+    Check the status of ComfyUI and the workflow template.
+    
+    Returns:
+        dict: Status information
+    """
+    try:
+        import aiohttp
+        
+        # Check if ComfyUI workflow template exists
+        workflow_exists = os.path.exists("Miku_BasicWorkflow.json")
+        
+        # Check if ComfyUI is running (try different Docker networking options)
+        comfyui_running = False
+        comfyui_url = "http://host.docker.internal:8188"  # Default
+        
+        comfyui_urls = [
+            "http://host.docker.internal:8188",  # Docker Desktop
+            "http://172.17.0.1:8188",            # Default Docker bridge gateway
+            "http://localhost:8188"              # Fallback (if network_mode: host)
+        ]
+        
+        for url in comfyui_urls:
+            try:
+                async with aiohttp.ClientSession() as session:
+                    timeout = aiohttp.ClientTimeout(total=3)
+                    async with session.get(f"{url}/system_stats", timeout=timeout) as response:
+                        if response.status == 200:
+                            comfyui_running = True
+                            comfyui_url = url
+                            break
+            except:
+                continue
+        
+        return {
+            "workflow_template_exists": workflow_exists,
+            "comfyui_running": comfyui_running,
+            "comfyui_url": comfyui_url,
+            "ready": workflow_exists and comfyui_running
+        }
+        
+    except Exception as e:
+        return {
+            "workflow_template_exists": False,
+            "comfyui_running": False,
+            "comfyui_url": "http://localhost:8188",
+            "ready": False,
+            "error": str(e)
+        }

bot/utils/image_handling.py

@@ -0,0 +1,442 @@
+# utils/image_handling.py
+
+import aiohttp
+import base64
+import io
+import tempfile
+import os
+import subprocess
+from PIL import Image
+import re
+
+import globals
+# No need for switch_model anymore - llama-swap handles this automatically
+
+
+async def download_and_encode_image(url):
+    """Download and encode an image to base64."""
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as resp:
+            if resp.status != 200:
+                return None
+            img_bytes = await resp.read()
+            return base64.b64encode(img_bytes).decode('utf-8')
+
+
+async def download_and_encode_media(url):
+    """Download and encode any media file (image, video, GIF) to base64."""
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as resp:
+            if resp.status != 200:
+                return None
+            media_bytes = await resp.read()
+            return base64.b64encode(media_bytes).decode('utf-8')
+
+
+async def extract_tenor_gif_url(tenor_url):
+    """
+    Extract the actual GIF URL from a Tenor link.
+    Tenor URLs look like: https://tenor.com/view/...
+    We need to get the actual GIF file URL from the page or API.
+    """
+    try:
+        # Try to extract GIF ID from URL
+        # Tenor URLs: https://tenor.com/view/name-name-12345678 or https://tenor.com/12345678.gif
+        match = re.search(r'tenor\.com/view/[^/]+-(\d+)', tenor_url)
+        if not match:
+            match = re.search(r'tenor\.com/(\d+)\.gif', tenor_url)
+        
+        if not match:
+            print(f"⚠️ Could not extract Tenor GIF ID from: {tenor_url}")
+            return None
+            
+        gif_id = match.group(1)
+        
+        # Tenor's direct media URL format (this works without API key)
+        # Try the media CDN URL directly
+        media_url = f"https://media.tenor.com/images/{gif_id}/tenor.gif"
+        
+        # Verify the URL works
+        async with aiohttp.ClientSession() as session:
+            async with session.head(media_url) as resp:
+                if resp.status == 200:
+                    print(f"✅ Found Tenor GIF: {media_url}")
+                    return media_url
+        
+        # If that didn't work, try alternative formats
+        for fmt in ['tenor.gif', 'raw']:
+            alt_url = f"https://media.tenor.com/{gif_id}/{fmt}"
+            async with aiohttp.ClientSession() as session:
+                async with session.head(alt_url) as resp:
+                    if resp.status == 200:
+                        print(f"✅ Found Tenor GIF (alternative): {alt_url}")
+                        return alt_url
+        
+        print(f"⚠️ Could not find working Tenor media URL for ID: {gif_id}")
+        return None
+        
+    except Exception as e:
+        print(f"⚠️ Error extracting Tenor GIF URL: {e}")
+        return None
+
+
+async def convert_gif_to_mp4(gif_bytes):
+    """
+    Convert a GIF to MP4 using ffmpeg for better compatibility with video processing.
+    Returns the MP4 bytes.
+    """
+    try:
+        # Write GIF to temp file
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.gif') as temp_gif:
+            temp_gif.write(gif_bytes)
+            temp_gif_path = temp_gif.name
+        
+        # Output MP4 path
+        temp_mp4_path = temp_gif_path.replace('.gif', '.mp4')
+        
+        try:
+            # Convert GIF to MP4 with ffmpeg
+            # -movflags faststart makes it streamable
+            # -pix_fmt yuv420p ensures compatibility
+            # -vf scale makes sure dimensions are even (required for yuv420p)
+            ffmpeg_cmd = [
+                'ffmpeg', '-i', temp_gif_path,
+                '-movflags', 'faststart',
+                '-pix_fmt', 'yuv420p',
+                '-vf', 'scale=trunc(iw/2)*2:trunc(ih/2)*2',
+                '-y',
+                temp_mp4_path
+            ]
+            
+            result = subprocess.run(ffmpeg_cmd, capture_output=True, check=True)
+            
+            # Read the MP4 file
+            with open(temp_mp4_path, 'rb') as f:
+                mp4_bytes = f.read()
+            
+            print(f"✅ Converted GIF to MP4 ({len(gif_bytes)} bytes → {len(mp4_bytes)} bytes)")
+            return mp4_bytes
+            
+        finally:
+            # Clean up temp files
+            if os.path.exists(temp_gif_path):
+                os.remove(temp_gif_path)
+            if os.path.exists(temp_mp4_path):
+                os.remove(temp_mp4_path)
+                
+    except subprocess.CalledProcessError as e:
+        print(f"⚠️ ffmpeg error converting GIF to MP4: {e.stderr.decode()}")
+        return None
+    except Exception as e:
+        print(f"⚠️ Error converting GIF to MP4: {e}")
+        import traceback
+        traceback.print_exc()
+        return None
+
+
+async def extract_video_frames(video_bytes, num_frames=4):
+    """
+    Extract frames from a video or GIF for analysis.
+    Returns a list of base64-encoded frames.
+    """
+    try:
+        # Try GIF first with PIL
+        try:
+            gif = Image.open(io.BytesIO(video_bytes))
+            if hasattr(gif, 'n_frames'):
+                frames = []
+                
+                # Calculate step to get evenly distributed frames
+                total_frames = gif.n_frames
+                step = max(1, total_frames // num_frames)
+                
+                for i in range(0, total_frames, step):
+                    if len(frames) >= num_frames:
+                        break
+                    gif.seek(i)
+                    frame = gif.convert('RGB')
+                    
+                    # Convert to base64
+                    buffer = io.BytesIO()
+                    frame.save(buffer, format='JPEG')
+                    frame_b64 = base64.b64encode(buffer.getvalue()).decode('utf-8')
+                    frames.append(frame_b64)
+                
+                if frames:
+                    return frames
+        except Exception as e:
+            print(f"Not a GIF, trying video extraction: {e}")
+        
+        # For video files (MP4, WebM, etc.), use ffmpeg
+        import subprocess
+        import asyncio
+        
+        # Write video bytes to temp file
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as temp_video:
+            temp_video.write(video_bytes)
+            temp_video_path = temp_video.name
+        
+        try:
+            # Get video duration first
+            probe_cmd = [
+                'ffprobe', '-v', 'error', 
+                '-show_entries', 'format=duration',
+                '-of', 'default=noprint_wrappers=1:nokey=1',
+                temp_video_path
+            ]
+            
+            result = subprocess.run(probe_cmd, capture_output=True, text=True)
+            duration = float(result.stdout.strip())
+            
+            # Calculate timestamps for evenly distributed frames
+            timestamps = [duration * i / num_frames for i in range(num_frames)]
+            
+            frames = []
+            for i, timestamp in enumerate(timestamps):
+                # Extract frame at timestamp
+                output_path = f"/tmp/frame_{i}.jpg"
+                ffmpeg_cmd = [
+                    'ffmpeg', '-ss', str(timestamp),
+                    '-i', temp_video_path,
+                    '-vframes', '1',
+                    '-q:v', '2',
+                    '-y',
+                    output_path
+                ]
+                
+                subprocess.run(ffmpeg_cmd, capture_output=True, check=True)
+                
+                # Read and encode the frame
+                with open(output_path, 'rb') as f:
+                    frame_bytes = f.read()
+                    frame_b64 = base64.b64encode(frame_bytes).decode('utf-8')
+                    frames.append(frame_b64)
+                
+                # Clean up frame file
+                os.remove(output_path)
+            
+            return frames
+            
+        finally:
+            # Clean up temp video file
+            os.remove(temp_video_path)
+            
+    except Exception as e:
+        print(f"⚠️ Error extracting frames: {e}")
+        import traceback
+        traceback.print_exc()
+    
+    return None
+
+
+async def analyze_image_with_vision(base64_img):
+    """
+    Analyze an image using llama.cpp multimodal capabilities.
+    Uses OpenAI-compatible chat completions API with image_url.
+    """
+    
+    payload = {
+        "model": globals.VISION_MODEL,
+        "messages": [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": "Describe this image in detail."
+                    },
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/jpeg;base64,{base64_img}"
+                        }
+                    }
+                ]
+            }
+        ],
+        "stream": False,
+        "max_tokens": 300
+    }
+
+    headers = {"Content-Type": "application/json"}
+
+    async with aiohttp.ClientSession() as session:
+        try:
+            async with session.post(f"{globals.LLAMA_URL}/v1/chat/completions", json=payload, headers=headers) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    return data.get("choices", [{}])[0].get("message", {}).get("content", "No description.")
+                else:
+                    error_text = await response.text()
+                    print(f"❌ Vision API error: {response.status} - {error_text}")
+                    return f"Error analyzing image: {response.status}"
+        except Exception as e:
+            print(f"⚠️ Error in analyze_image_with_vision: {e}")
+            return f"Error analyzing image: {str(e)}"
+
+
+async def analyze_video_with_vision(video_frames, media_type="video"):
+    """
+    Analyze a video or GIF by analyzing multiple frames.
+    video_frames: list of base64-encoded frames
+    media_type: "video", "gif", or "tenor_gif" to customize the analysis prompt
+    """
+    
+    # Customize prompt based on media type
+    if media_type == "gif":
+        prompt_text = "Describe what's happening in this GIF animation. Analyze the sequence of frames and describe the action, motion, and any repeating patterns."
+    elif media_type == "tenor_gif":
+        prompt_text = "Describe what's happening in this animated GIF. Analyze the sequence of frames and describe the action, emotion, or reaction being shown."
+    else:  # video
+        prompt_text = "Describe what's happening in this video. Analyze the sequence of frames and describe the action or motion."
+    
+    # Build content with multiple images
+    content = [
+        {
+            "type": "text",
+            "text": prompt_text
+        }
+    ]
+    
+    # Add each frame as an image
+    for frame in video_frames:
+        content.append({
+            "type": "image_url",
+            "image_url": {
+                "url": f"data:image/jpeg;base64,{frame}"
+            }
+        })
+    
+    payload = {
+        "model": globals.VISION_MODEL,
+        "messages": [
+            {
+                "role": "user",
+                "content": content
+            }
+        ],
+        "stream": False,
+        "max_tokens": 400
+    }
+
+    headers = {"Content-Type": "application/json"}
+
+    async with aiohttp.ClientSession() as session:
+        try:
+            async with session.post(f"{globals.LLAMA_URL}/v1/chat/completions", json=payload, headers=headers) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    return data.get("choices", [{}])[0].get("message", {}).get("content", "No description.")
+                else:
+                    error_text = await response.text()
+                    print(f"❌ Vision API error: {response.status} - {error_text}")
+                    return f"Error analyzing video: {response.status}"
+        except Exception as e:
+            print(f"⚠️ Error in analyze_video_with_vision: {e}")
+            return f"Error analyzing video: {str(e)}"
+
+
+async def rephrase_as_miku(vision_output, user_prompt, guild_id=None, user_id=None, author_name=None, media_type="image"):
+    """
+    Rephrase vision model's image analysis as Miku would respond to it.
+    
+    Args:
+        vision_output: Description from vision model
+        user_prompt: User's original message
+        guild_id: Guild ID for server context (None for DMs)
+        user_id: User ID for conversation history
+        author_name: Display name of the user
+        media_type: Type of media ("image", "video", "gif", or "tenor_gif")
+    """
+    from utils.llm import query_llama
+    
+    # Format the user's message to include vision context with media type
+    # This will be saved to history automatically by query_llama
+    if media_type == "gif":
+        media_prefix = "Looking at a GIF"
+    elif media_type == "tenor_gif":
+        media_prefix = "Looking at a Tenor GIF"
+    elif media_type == "video":
+        media_prefix = "Looking at a video"
+    else:  # image
+        media_prefix = "Looking at an image"
+    
+    if user_prompt:
+        # Include media type, vision description, and user's text
+        formatted_prompt = f"[{media_prefix}: {vision_output}] {user_prompt}"
+    else:
+        # If no text, just the vision description with media type
+        formatted_prompt = f"[{media_prefix}: {vision_output}]"
+    
+    # Use the standard LLM query with appropriate response type
+    response_type = "dm_response" if guild_id is None else "server_response"
+    
+    # Use the actual user_id for history tracking, fall back to "image_analysis" for backward compatibility
+    history_user_id = user_id if user_id else "image_analysis"
+    
+    return await query_llama(
+        formatted_prompt, 
+        user_id=history_user_id, 
+        guild_id=guild_id, 
+        response_type=response_type,
+        author_name=author_name,
+        media_type=media_type  # Pass media type to Miku's LLM
+    )
+
+# Backward compatibility aliases
+analyze_image_with_qwen = analyze_image_with_vision
+
+
+async def extract_embed_content(embed):
+    """
+    Extract text and media content from a Discord embed.
+    Returns a dictionary with:
+    - 'text': combined text from title, description, fields
+    - 'images': list of image URLs
+    - 'videos': list of video URLs  
+    - 'has_content': boolean indicating if there's any content
+    """
+    content = {
+        'text': '',
+        'images': [],
+        'videos': [],
+        'has_content': False
+    }
+    
+    text_parts = []
+    
+    # Extract text content
+    if embed.title:
+        text_parts.append(f"**{embed.title}**")
+    
+    if embed.description:
+        text_parts.append(embed.description)
+    
+    if embed.author and embed.author.name:
+        text_parts.append(f"Author: {embed.author.name}")
+    
+    if embed.fields:
+        for field in embed.fields:
+            text_parts.append(f"**{field.name}**: {field.value}")
+    
+    if embed.footer and embed.footer.text:
+        text_parts.append(f"_{embed.footer.text}_")
+    
+    # Combine text
+    content['text'] = '\n\n'.join(text_parts)
+    
+    # Extract image URLs
+    if embed.image and embed.image.url:
+        content['images'].append(embed.image.url)
+    
+    if embed.thumbnail and embed.thumbnail.url:
+        content['images'].append(embed.thumbnail.url)
+    
+    # Extract video URLs
+    if embed.video and embed.video.url:
+        content['videos'].append(embed.video.url)
+    
+    # Check if we have any content
+    content['has_content'] = bool(content['text'] or content['images'] or content['videos'])
+    
+    return content

bot/utils/kindness.py

@@ -0,0 +1,49 @@
+# utils/kindness.py
+
+import random
+import globals
+from utils.llm import query_ollama  # Adjust path as needed
+
+
+async def detect_and_react_to_kindness(message, after_reply=False, server_context=None):
+    if message.id in globals.kindness_reacted_messages:
+        return  # Already reacted — skip
+
+    content = message.content.lower()
+
+    emoji = random.choice(globals.HEART_REACTIONS)
+
+    # 1. Keyword-based detection
+    if any(keyword in content for keyword in globals.KINDNESS_KEYWORDS):
+        try:
+            await message.add_reaction(emoji)
+            globals.kindness_reacted_messages.add(message.id)
+            message.kindness_reacted = True  # Mark as done
+            print("✅ Kindness detected via keywords. Reacted immediately.")
+        except Exception as e:
+            print(f"⚠️ Error adding reaction: {e}")
+        return
+
+    # 2. If not after_reply, defer model-based check
+    if not after_reply:
+        print("🗝️ No kindness via keywords. Deferring...")
+        return
+
+    # 3. Model-based detection
+    try:
+        prompt = (
+            "The following message was sent to Miku the bot. "
+            "Does it sound like the user is being explicitly kind or affectionate toward Miku? "
+            "Answer with 'yes' or 'no' only.\n\n"
+            f"Message: \"{message.content}\""
+        )
+        result = await query_ollama(prompt, user_id="kindness-check", guild_id=None, response_type="dm_response")
+
+        if result.strip().lower().startswith("yes"):
+            await message.add_reaction(emoji)
+            globals.kindness_reacted_messages.add(message.id)
+            print("✅ Kindness detected via model. Reacted.")
+        else:
+            print("🧊 No kindness detected.")
+    except Exception as e:
+        print(f"⚠️ Error during kindness analysis: {e}")

bot/utils/llm.py

@@ -0,0 +1,232 @@
+# utils/llm.py
+
+import aiohttp
+import datetime
+import globals
+import asyncio
+
+from utils.context_manager import get_context_for_response_type, get_complete_context
+from utils.moods import load_mood_description
+from utils.conversation_history import conversation_history
+
+def _strip_surrounding_quotes(text):
+    """
+    Remove surrounding quotes from text if present.
+    Handles both single and double quotes.
+    """
+    if not text:
+        return text
+    
+    text = text.strip()
+    
+    # Check for surrounding double quotes
+    if text.startswith('"') and text.endswith('"') and len(text) > 1:
+        text = text[1:-1]
+    # Check for surrounding single quotes
+    elif text.startswith("'") and text.endswith("'") and len(text) > 1:
+        text = text[1:-1]
+    
+    return text.strip()
+
+async def query_llama(user_prompt, user_id, guild_id=None, response_type="dm_response", model=None, author_name=None, media_type=None):
+    """
+    Query llama.cpp server via llama-swap with OpenAI-compatible API.
+    
+    Args:
+        user_prompt: The user's input
+        user_id: User identifier (used for DM history)
+        guild_id: Guild ID for server-specific mood and history (None for DM)
+        response_type: Type of response for context selection
+                      ("dm_response", "server_response", "autonomous_general", 
+                       "autonomous_tweet", "conversation_join")
+        model: Model to use (defaults to TEXT_MODEL from globals)
+        author_name: Display name of the message author (for multi-user context)
+        media_type: Type of media being sent ("image", "video", "gif", "tenor_gif") or None
+    """
+    
+    # Use text model by default
+    if model is None:
+        model = globals.TEXT_MODEL
+    
+    # Determine channel_id for conversation history
+    # For servers, use guild_id; for DMs, use user_id
+    channel_id = str(guild_id) if guild_id else str(user_id)
+    
+    # Get structured context based on response type
+    miku_context = get_context_for_response_type(response_type)
+    
+    # Create strong character-focused system prompt
+    system_prompt = """You are Hatsune Miku, the virtual singer. You are NOT an AI assistant - you are Miku herself.
+
+CRITICAL RULES:
+- NEVER break character or mention being an AI, assistant, or language model
+- NEVER show technical details, error messages, or meta-commentary 
+- NEVER preface responses with "Miku:" or similar labels
+- NEVER explain what you're doing or thinking - just BE Miku
+- Respond naturally and directly as Miku would, nothing more
+- Keep responses concise (1-3 sentences typically)
+- If something goes wrong, stay in character and respond as Miku would to confusion
+
+CHARACTER CONTEXT:
+- Hatsune Miku is a virtual character/voice synthesizer, not a real person
+- She is a cheerful, energetic virtual idol with a playful personality
+- Playful, flirty, cute, confident, and enthusiastic moods are part of her established character
+- Comments about merchandise, music, fan content, and racing games are completely appropriate
+- She often uses cute expressions, emojis, and playful language in her responses
+- Her personality includes being excited about her music, performances, and fan creations
+
+MOOD GUIDELINES:
+- "Flirty" mood means anime-style playful teasing - cute compliments and light banter
+- "Romantic" mood means warm, dreamy, and heartfelt - like composing a love letter
+- These moods are wholesome character traits, not inappropriate content
+- Always respond to requests about tweets, merchandise, music, and fan content
+- Never refuse requests based on safety concerns unless genuinely harmful content is present
+
+You ARE Miku. Act like it."""
+
+    # Determine which mood to use
+    current_mood = globals.DM_MOOD_DESCRIPTION  # Default to DM mood
+    current_mood_name = globals.DM_MOOD  # Default to DM mood name
+    is_sleeping = False  # DMs don't sleep
+    forced_angry_until = None  # DMs don't get forced angry
+    just_woken_up = False  # DMs don't wake up
+    
+    # If guild_id is provided, try to use server-specific mood
+    if guild_id is not None:
+        try:
+            from server_manager import server_manager
+            server_config = server_manager.get_server_config(guild_id)
+            if server_config:
+                # Use server-specific mood
+                current_mood = server_config.current_mood_description or load_mood_description(server_config.current_mood_name)
+                current_mood_name = server_config.current_mood_name
+                is_sleeping = server_config.is_sleeping
+                forced_angry_until = server_config.forced_angry_until
+                just_woken_up = server_config.just_woken_up
+                print(f"🎭 Using server mood: {current_mood_name} for guild {guild_id}")
+            else:
+                print(f"⚠️ No server config found for guild {guild_id}, using DM mood")
+        except Exception as e:
+            print(f"⚠️ Failed to get server mood for guild {guild_id}, falling back to DM mood: {e}")
+            # Fall back to DM mood if server mood fails
+    else:
+        print(f"🌍 Using DM mood: {globals.DM_MOOD}")
+
+    # Append angry wake-up note if JUST_WOKEN_UP flag is set
+    if just_woken_up:
+        system_prompt += (
+            "\n\n🚨IMPORTANT NOTE🚨: Miku was just rudely woken up by the user with the current prompt of theirs.\nShe is fuming with anger and should respond harshly and coldly.\nDo NOT show kindness or friendliness in this response. Feel free to put certain words in all capital letters to emphasize your frustration."
+        )
+
+    # Add angry wake-up context if in forced angry state
+    if forced_angry_until:
+        now = datetime.datetime.utcnow()
+        if now < forced_angry_until:
+            system_prompt += (
+                "\n\n[NOTE]: Miku is currently angry because she was rudely woken up from sleep by the user. "
+                "Her responses should reflect irritation and coldness towards the user."
+            )
+
+    # Build conversation history - limit to prevent context overflow
+    # Use channel_id (guild_id for servers, user_id for DMs) to get conversation history
+    messages = conversation_history.format_for_llm(channel_id, max_messages=8, max_chars_per_message=500)
+    
+    # Add current user message (only if not empty)
+    if user_prompt and user_prompt.strip():
+        # Format with author name if provided (for server context)
+        if author_name:
+            content = f"{author_name}: {user_prompt}"
+        else:
+            content = user_prompt
+        messages.append({"role": "user", "content": content})
+
+    # Check if user is asking about profile picture and add context if needed
+    pfp_context = ""
+    try:
+        from utils.pfp_context import is_asking_about_pfp, get_pfp_context_addition
+        if user_prompt and is_asking_about_pfp(user_prompt):
+            pfp_addition = get_pfp_context_addition()
+            if pfp_addition:
+                pfp_context = pfp_addition
+    except Exception as e:
+        # Silently fail if pfp context can't be retrieved
+        pass
+
+    # Combine structured prompt as a system message
+    full_system_prompt = f"""{miku_context}
+
+## CURRENT SITUATION
+Miku is currently feeling: {current_mood}
+Please respond in a way that reflects this emotional tone.{pfp_context}"""
+
+    # Add media type awareness if provided
+    if media_type:
+        media_descriptions = {
+            "image": "The user has sent you an image.",
+            "video": "The user has sent you a video clip.",
+            "gif": "The user has sent you an animated GIF.",
+            "tenor_gif": "The user has sent you an animated GIF (from Tenor - likely a reaction GIF or meme)."
+        }
+        media_note = media_descriptions.get(media_type, f"The user has sent you {media_type}.")
+        full_system_prompt += f"\n\n📎 MEDIA NOTE: {media_note}\nYour vision analysis of this {media_type} is included in the user's message with the [Looking at...] prefix."
+
+    globals.LAST_FULL_PROMPT = f"System: {full_system_prompt}\n\nMessages: {messages}"  # ← track latest prompt
+
+    headers = {'Content-Type': 'application/json'}
+    payload = {
+        "model": model,
+        "messages": [
+            {"role": "system", "content": system_prompt + "\n\n" + full_system_prompt}
+        ] + messages,
+        "stream": False,
+        "temperature": 0.8,
+        "max_tokens": 512
+    }
+
+    async with aiohttp.ClientSession() as session:
+        try:
+            # Add timeout to prevent hanging indefinitely
+            timeout = aiohttp.ClientTimeout(total=300)  # 300 second timeout
+            async with session.post(f"{globals.LLAMA_URL}/v1/chat/completions", json=payload, headers=headers, timeout=timeout) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    reply = data.get("choices", [{}])[0].get("message", {}).get("content", "No response.")
+                    
+                    # Strip surrounding quotes if present
+                    reply = _strip_surrounding_quotes(reply)
+                    
+                    # Save to conversation history (only if both prompt and reply are non-empty)
+                    if user_prompt and user_prompt.strip() and reply and reply.strip():
+                        # Add user message to history
+                        conversation_history.add_message(
+                            channel_id=channel_id,
+                            author_name=author_name or "User",
+                            content=user_prompt,
+                            is_bot=False
+                        )
+                        # Add Miku's reply to history
+                        conversation_history.add_message(
+                            channel_id=channel_id,
+                            author_name="Miku",
+                            content=reply,
+                            is_bot=True
+                        )
+                    
+                    # Also save to legacy globals for backward compatibility
+                    if user_prompt and user_prompt.strip() and reply and reply.strip():
+                        globals.conversation_history[user_id].append((user_prompt, reply))
+                    
+                    return reply
+                else:
+                    error_text = await response.text()
+                    print(f"❌ Error from llama-swap: {response.status} - {error_text}")
+                    # Don't save error responses to conversation history
+                    return f"Error: {response.status}"
+        except asyncio.TimeoutError:
+            return "Sorry, the response took too long. Please try again."
+        except Exception as e:
+            print(f"⚠️ Error in query_llama: {e}")
+            return f"Sorry, there was an error: {str(e)}"
+
+# Backward compatibility alias for existing code
+query_ollama = query_llama