Upload 91 files

.gitattributes

@@ -38,3 +38,5 @@ bot/cogs/__pycache__/community.cpython-311.pyc filter=lfs diff=lfs merge=lfs -te
 bot/cogs/__pycache__/engagement.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
 bot/cogs/__pycache__/media.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
 database.db filter=lfs diff=lfs merge=lfs -text
+bot/cogs/__pycache__/admin.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+bot/cogs/__pycache__/events.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text

bot/cogs/__pycache__/ai_suite.cpython-311.pyc

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cf125ae44086772a36fa22b27791a407f2e63f0fc7f9bf8b356e9e54695a1968
-size 143051
+oid sha256:e3d87a3a72d573124f17d8e63596d2f74a90fe1a464d7c3e483a0a7a1b97fae8
+size 142795

bot/cogs/__pycache__/community.cpython-311.pyc

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a34e59b7f605ed55c2ecfed7028c01ccf315cac7aea0be8ac3452cb8e3530c26
-size 119508
+oid sha256:87a05d115d6c14cd3607f3ce9d415d52e370582ddf9817c707a8002eb0f39d66
+size 131193

bot/cogs/__pycache__/engagement.cpython-311.pyc

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fbc07318ec00e7f522658a482610aa30df29d4ef3f95836f5d8eb7b0a6e794ca
-size 115797
+oid sha256:2dab296a18802c5fb56ad3d9d1e26cfcd915adc3b82be3c4dd50c7b294a781a2
+size 120855

bot/cogs/__pycache__/media.cpython-311.pyc

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9cd726a7fc89417a87ada78320e9485c5113bbbf0a053c4d9efbeb9c1ac8960a
-size 209239
+oid sha256:ca5f86939d327aa5b764e849e35198a8f0881667d5202772e915f0a92899da33
+size 220295

bot/cogs/ai_admin.py

@@ -1,479 +1,931 @@
-"""
-Autonomous AI Administrator - Senior Backend Engineer Implementation
-Permission Guard + Intelligence Layer + Execution Engine + Global Language Support
-"""
-
+"""
+Autonomous AI Administrator - Senior Backend Engineer Implementation
+Permission Guard + Intelligence Layer + Execution Engine + Global Language Support
+"""
+
 from __future__ import annotations
 
+import datetime as dt
 import json
 import re
 from typing import Any
+
+import discord
+from discord.ext import commands
+
+try:
+    import aiohttp
+except Exception:
+    aiohttp = None
+
+
+class PermissionGuard:
+    """Validates hierarchy before any AI admin action."""
+    
+    @staticmethod
+    def check(ctx: commands.Context) -> tuple[bool, str]:
+        if not ctx.guild:
+            return False, "Server only."
+        
+        if ctx.author.id == ctx.guild.owner_id:
+            return True, ""
+        
+        if not ctx.author.guild_permissions.manage_guild:
+            return False, "Manage Server permission required."
+        
+        member = ctx.guild.get_member(ctx.author.id)
+        bot_member = ctx.guild.me
+        
+        if member and member.top_role.position >= bot_member.top_role.position:
+            return False, "Insufficient Hierarchy: My role must be higher than yours."
+        
+        return True, ""
+
+
+class IntelligenceLayer:
+    """OpenRouter integration for AI decision making."""
+    
+    def __init__(self, bot: commands.Bot) -> None:
+        self.bot = bot
+        self._session: aiohttp.ClientSession | None = None
+    
+    async def _get_session(self) -> aiohttp.ClientSession:
+        if self._session is None or self._session.closed:
+            self._session = aiohttp.ClientSession()
+        return self._session
+    
+    async def ask_ai(self, prompt: str) -> list[dict[str, Any]] | None:
+        settings = self.bot.settings
+        api_key = getattr(settings, "openrouter_api_key", None)
+        if not api_key:
+            return None
+        
+        model = getattr(settings, "openrouter_model", "openai/gpt-4o-mini") or "openai/gpt-4o-mini"
+        
+        system_message = """You are an Autonomous AI Administrator for a Discord server.
+Output ONLY a valid JSON array of actions. Do not include any other text.
+
+Supported actions:
+
+1. CREATE ROLE:
+{
+  "action": "create_role",
+  "name": "Role Name",
+  "color": "#FF0000",
+  "hoist": true,
+  "reason": "Why this role is needed"
+}
+
+2. CREATE CHANNEL:
+{
+  "action": "create_channel",
+  "name": "channel-name",
+  "type": "text",
+  "category": "Category Name",
+  "locked_to_roles": ["Role1", "Role2"],
+  "reason": "Why this channel is needed"
+}
+
+3. ANNOUNCE:
+{
+  "action": "announce",
+  "channel": "channel-name",
+  "title": "Announcement Title",
+  "description": "Announcement content",
+  "color": "#00FFFF"
+}
+
+4. CREATE GIVEAWAY:
+{
+  "action": "create_giveaway",
+  "prize": "Prize description",
+  "duration_minutes": 60,
+  "winners": 1,
+  "channel": "channel-name"
+}
+
+5. CREATE TOURNAMENT:
+{
+  "action": "create_tournament",
+  "name": "Tournament Name",
+  "game": "Game name",
+  "max_participants": 16,
+  "channel": "channel-name"
+}
+
+6. CREATE POLL:
+{
+  "action": "create_poll",
+  "question": "Poll question",
+  "options": ["Option 1", "Option 2", "Option 3"],
+  "duration_minutes": 30
+}
+
+7. RUN COMMAND (for any other bot command):
+{
+  "action": "run_command",
+  "command": "command_name",
+  "args": {"arg1": "value1", "arg2": "value2"}
+}
 
-import discord
-from discord.ext import commands
-
-try:
-    import aiohttp
-except Exception:
-    aiohttp = None
-
-
-class PermissionGuard:
-    """Validates hierarchy before any AI admin action."""
-    
-    @staticmethod
-    def check(ctx: commands.Context) -> tuple[bool, str]:
-        if not ctx.guild:
-            return False, "Server only."
-        
-        if ctx.author.id == ctx.guild.owner_id:
-            return True, ""
-        
-        if not ctx.author.guild_permissions.manage_guild:
-            return False, "Manage Server permission required."
-        
-        member = ctx.guild.get_member(ctx.author.id)
-        bot_member = ctx.guild.me
-        
-        if member and member.top_role.position >= bot_member.top_role.position:
-            return False, "Insufficient Hierarchy: My role must be higher than yours."
-        
-        return True, ""
-
-
-class IntelligenceLayer:
-    """OpenRouter integration for AI decision making."""
-    
-    def __init__(self, bot: commands.Bot) -> None:
-        self.bot = bot
-        self._session: aiohttp.ClientSession | None = None
-    
-    async def _get_session(self) -> aiohttp.ClientSession:
-        if self._session is None or self._session.closed:
-            self._session = aiohttp.ClientSession()
-        return self._session
-    
-    async def ask_ai(self, prompt: str) -> list[dict[str, Any]] | None:
-        settings = self.bot.settings
-        api_key = getattr(settings, "openrouter_api_key", None)
-        if not api_key:
-            return None
-        
-        model = getattr(settings, "openrouter_model", "openai/gpt-4o-mini") or "openai/gpt-4o-mini"
-        
-        system_message = """You are an Autonomous AI Administrator for a Discord server.
-Output ONLY a valid JSON array of actions. Do not include any other text.
+8. TIMEOUT MEMBER:
+{
+  "action": "timeout_member",
+  "member": "@user or user_id",
+  "minutes": 30,
+  "reason": "Why timeout is needed"
+}
 
-Supported actions:
+9. UNTIMEOUT MEMBER:
+{
+  "action": "untimeout_member",
+  "member": "@user or user_id",
+  "reason": "Why timeout is removed"
+}
 
-1. CREATE ROLE:
+10. ADD ROLE:
 {
-  "action": "create_role",
-  "name": "Role Name",
-  "color": "#FF0000",
-  "hoist": true,
-  "reason": "Why this role is needed"
+  "action": "add_role",
+  "member": "@user or user_id",
+  "role": "Role Name",
+  "reason": "Why role is added"
 }
 
-2. CREATE CHANNEL:
+11. REMOVE ROLE:
 {
-  "action": "create_channel",
-  "name": "channel-name",
-  "type": "text",
-  "category": "Category Name",
-  "locked_to_roles": ["Role1", "Role2"],
-  "reason": "Why this channel is needed"
+  "action": "remove_role",
+  "member": "@user or user_id",
+  "role": "Role Name",
+  "reason": "Why role is removed"
 }
 
-3. ANNOUNCE:
+12. LOCK CHANNEL:
 {
-  "action": "announce",
+  "action": "lock_channel",
   "channel": "channel-name",
-  "title": "Announcement Title",
-  "description": "Announcement content",
-  "color": "#00FFFF"
+  "reason": "Why channel is locked"
 }
 
-4. CREATE GIVEAWAY:
+13. UNLOCK CHANNEL:
 {
-  "action": "create_giveaway",
-  "prize": "Prize description",
-  "duration_minutes": 60,
-  "winners": 1,
-  "channel": "channel-name"
+  "action": "unlock_channel",
+  "channel": "channel-name",
+  "reason": "Why channel is unlocked"
 }
 
-5. CREATE TOURNAMENT:
+14. SLOWMODE:
 {
-  "action": "create_tournament",
-  "name": "Tournament Name",
-  "game": "Game name",
-  "max_participants": 16,
-  "channel": "channel-name"
+  "action": "set_slowmode",
+  "channel": "channel-name",
+  "seconds": 10,
+  "reason": "Why slowmode is set"
 }
 
-6. CREATE POLL:
+15. PURGE MESSAGES:
 {
-  "action": "create_poll",
-  "question": "Poll question",
-  "options": ["Option 1", "Option 2", "Option 3"],
-  "duration_minutes": 30
+  "action": "purge_messages",
+  "channel": "channel-name",
+  "amount": 25,
+  "reason": "Why messages are purged"
 }
 
-7. RUN COMMAND (for any other bot command):
+16. DELETE CHANNEL:
 {
-  "action": "run_command",
-  "command": "command_name",
-  "args": {"arg1": "value1", "arg2": "value2"}
+  "action": "delete_channel",
+  "channel": "channel-name",
+  "reason": "Why channel is deleted"
 }
 
-ALWAYS include a "response_to_user" field in the SAME language as the input.
-Example: If input is Arabic, response_to_user must be in Arabic.
-
-IMPORTANT: For any request that involves creating events, giveaways, tournaments, polls, or other bot features, use the appropriate action above. If unsure, use run_command."""
+17. RENAME CHANNEL:
+{
+  "action": "rename_channel",
+  "channel": "old-channel-name",
+  "new_name": "new-channel-name",
+  "reason": "Why channel is renamed"
+}
 
-        payload = {
-            "model": model,
-            "messages": [
-                {"role": "system", "content": system_message},
-                {"role": "user", "content": prompt}
-            ],
-            "temperature": 0.3,
-            "max_tokens": 2000
-        }
-        
-        headers = {
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json",
-            "HTTP-Referer": "https://github.com/mega-bot",
-        }
-        
-        try:
-            session = await self._get_session()
-            async with session.post(
-                "https://openrouter.ai/api/v1/chat/completions",
-                json=payload,
-                headers=headers
-            ) as resp:
-                if resp.status != 200:
-                    return None
-                data = await resp.json()
-            
-            content = data.get("choices", [{}])[0].get("message", {}).get("content", "")
-            return self._parse_json_response(content)
-        except Exception:
-            return None
-    
-    def _parse_json_response(self, content: str) -> list[dict[str, Any]] | None:
-        try:
-            content = content.strip()
-            json_match = re.search(r'\[.*\]', content, re.DOTALL)
-            if json_match:
-                content = json_match.group(0)
-            return json.loads(content)
-        except Exception:
-            return None
-    
-    async def close(self) -> None:
-        if self._session and not self._session.closed:
-            await self._session.close()
+18. CREATE CATEGORY:
+{
+  "action": "create_category",
+  "name": "Category Name",
+  "reason": "Why this category is needed"
+}
 
+19. RENAME CATEGORY:
+{
+  "action": "rename_category",
+  "category": "Old Category Name",
+  "new_name": "New Category Name",
+  "reason": "Why category is renamed"
+}
 
-class ExecutionEngine:
-    """Executes AI decisions with proper error handling."""
-    
-    def __init__(self, bot: commands.Bot) -> None:
-        self.bot = bot
-    
-    async def execute(self, actions: list[dict[str, Any]], ctx: commands.Context) -> list[str]:
-        results = []
-        for action in actions:
-            action_type = action.get("action", "")
-            try:
-                if action_type == "create_role":
-                    result = await self._create_role(action, ctx)
-                elif action_type == "create_channel":
-                    result = await self._create_channel(action, ctx)
-                elif action_type == "announce":
-                    result = await self._announce(action, ctx)
-                elif action_type == "create_giveaway":
-                    result = await self._create_giveaway(action, ctx)
-                elif action_type == "create_tournament":
-                    result = await self._create_tournament(action, ctx)
-                elif action_type == "create_poll":
-                    result = await self._create_poll(action, ctx)
+20. DELETE CATEGORY:
+{
+  "action": "delete_category",
+  "category": "Category Name",
+  "reason": "Why category is deleted"
+}
+
+ALWAYS include a "response_to_user" field in the SAME language as the input.
+Example: If input is Arabic, response_to_user must be in Arabic.
+
+IMPORTANT: For any request that involves creating events, giveaways, tournaments, polls, or other bot features, use the appropriate action above. If unsure, use run_command."""
+
+        payload = {
+            "model": model,
+            "messages": [
+                {"role": "system", "content": system_message},
+                {"role": "user", "content": prompt}
+            ],
+            "temperature": 0.3,
+            "max_tokens": 2000
+        }
+        
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://github.com/mega-bot",
+        }
+        
+        try:
+            session = await self._get_session()
+            async with session.post(
+                "https://openrouter.ai/api/v1/chat/completions",
+                json=payload,
+                headers=headers
+            ) as resp:
+                if resp.status != 200:
+                    return None
+                data = await resp.json()
+            
+            content = data.get("choices", [{}])[0].get("message", {}).get("content", "")
+            return self._parse_json_response(content)
+        except Exception:
+            return None
+    
+    def _parse_json_response(self, content: str) -> list[dict[str, Any]] | None:
+        try:
+            content = content.strip()
+            json_match = re.search(r'\[.*\]', content, re.DOTALL)
+            if json_match:
+                content = json_match.group(0)
+            return json.loads(content)
+        except Exception:
+            return None
+    
+    async def close(self) -> None:
+        if self._session and not self._session.closed:
+            await self._session.close()
+
+
+class ExecutionEngine:
+    """Executes AI decisions with proper error handling."""
+    
+    def __init__(self, bot: commands.Bot) -> None:
+        self.bot = bot
+    
+    async def execute(self, actions: list[dict[str, Any]], ctx: commands.Context) -> list[str]:
+        results = []
+        for action in actions:
+            action_type = action.get("action", "")
+            try:
+                if action_type == "create_role":
+                    result = await self._create_role(action, ctx)
+                elif action_type == "create_channel":
+                    result = await self._create_channel(action, ctx)
+                elif action_type == "announce":
+                    result = await self._announce(action, ctx)
+                elif action_type == "create_giveaway":
+                    result = await self._create_giveaway(action, ctx)
+                elif action_type == "create_tournament":
+                    result = await self._create_tournament(action, ctx)
+                elif action_type == "create_poll":
+                    result = await self._create_poll(action, ctx)
                 elif action_type == "run_command":
                     result = await self._run_command(action, ctx)
+                elif action_type == "timeout_member":
+                    result = await self._timeout_member(action, ctx)
+                elif action_type == "untimeout_member":
+                    result = await self._untimeout_member(action, ctx)
+                elif action_type == "add_role":
+                    result = await self._add_role(action, ctx)
+                elif action_type == "remove_role":
+                    result = await self._remove_role(action, ctx)
+                elif action_type == "lock_channel":
+                    result = await self._lock_channel(action, ctx)
+                elif action_type == "unlock_channel":
+                    result = await self._unlock_channel(action, ctx)
+                elif action_type == "set_slowmode":
+                    result = await self._set_slowmode(action, ctx)
+                elif action_type == "purge_messages":
+                    result = await self._purge_messages(action, ctx)
+                elif action_type == "delete_channel":
+                    result = await self._delete_channel(action, ctx)
+                elif action_type == "rename_channel":
+                    result = await self._rename_channel(action, ctx)
+                elif action_type == "create_category":
+                    result = await self._create_category(action, ctx)
+                elif action_type == "rename_category":
+                    result = await self._rename_category(action, ctx)
+                elif action_type == "delete_category":
+                    result = await self._delete_category(action, ctx)
                 else:
                     result = f"Unknown action: {action_type}"
                 results.append(result)
             except Exception as e:
                 results.append(f"Error executing {action_type}: {str(e)}")
         return results
-    
-    async def _create_role(self, action: dict[str, Any], ctx: commands.Context) -> str:
-        name = action.get("name", "New Role")
-        color_str = action.get("color", "#99AAB5")
-        hoist = action.get("hoist", False)
-        reason = action.get("reason", "AI Admin")
-        
-        try:
-            color = discord.Color(int(color_str.lstrip("#"), 16))
-        except ValueError:
-            color = discord.Color.default()
-        
-        role = await ctx.guild.create_role(name=name, color=color, hoist=hoist, reason=reason)
-        return f"Created role: {role.mention}"
-    
+
+    @staticmethod
+    def _resolve_member(guild: discord.Guild, ref: str | int | None) -> discord.Member | None:
+        if ref is None:
+            return None
+        text = str(ref).strip()
+        mention = re.search(r"<@!?(\d+)>", text)
+        if mention:
+            return guild.get_member(int(mention.group(1)))
+        if text.isdigit():
+            return guild.get_member(int(text))
+        return discord.utils.find(lambda m: m.name.lower() == text.lower() or m.display_name.lower() == text.lower(), guild.members)
+
+    @staticmethod
+    def _resolve_channel(guild: discord.Guild, ref: str | None, fallback: discord.abc.GuildChannel | None = None) -> discord.TextChannel | None:
+        if ref:
+            text = str(ref).strip()
+            mention = re.search(r"<#(\d+)>", text)
+            if mention:
+                ch = guild.get_channel(int(mention.group(1)))
+                return ch if isinstance(ch, discord.TextChannel) else None
+            by_name = discord.utils.get(guild.text_channels, name=text)
+            if by_name:
+                return by_name
+        if isinstance(fallback, discord.TextChannel):
+            return fallback
+        return None
+
+    @staticmethod
+    def _resolve_guild_channel(
+        guild: discord.Guild,
+        ref: str | int | None,
+        fallback: discord.abc.GuildChannel | None = None,
+    ) -> discord.abc.GuildChannel | None:
+        if ref is not None:
+            text = str(ref).strip()
+            mention = re.search(r"<#(\d+)>", text)
+            if mention:
+                return guild.get_channel(int(mention.group(1)))
+            if text.isdigit():
+                return guild.get_channel(int(text))
+            by_name = discord.utils.find(lambda c: c.name.lower() == text.lower(), guild.channels)
+            if by_name:
+                return by_name
+        if isinstance(fallback, discord.abc.GuildChannel):
+            return fallback
+        return None
+
+    @staticmethod
+    def _resolve_category(guild: discord.Guild, ref: str | int | None) -> discord.CategoryChannel | None:
+        if ref is None:
+            return None
+        text = str(ref).strip()
+        mention = re.search(r"<#(\d+)>", text)
+        if mention:
+            ch = guild.get_channel(int(mention.group(1)))
+            return ch if isinstance(ch, discord.CategoryChannel) else None
+        if text.isdigit():
+            ch = guild.get_channel(int(text))
+            return ch if isinstance(ch, discord.CategoryChannel) else None
+        return discord.utils.find(lambda c: c.name.lower() == text.lower(), guild.categories)
+    
+    async def _create_role(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        name = action.get("name", "New Role")
+        color_str = action.get("color", "#99AAB5")
+        hoist = action.get("hoist", False)
+        reason = action.get("reason", "AI Admin")
+        
+        try:
+            color = discord.Color(int(color_str.lstrip("#"), 16))
+        except ValueError:
+            color = discord.Color.default()
+        
+        role = await ctx.guild.create_role(name=name, color=color, hoist=hoist, reason=reason)
+        return f"Created role: {role.mention}"
+    
     async def _create_channel(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        if not ctx.author.guild_permissions.manage_channels:
+            return "Manage Channels permission required."
         name = action.get("name", "new-channel")
         channel_type = action.get("type", "text")
-        category_name = action.get("category")
-        locked_roles = action.get("locked_to_roles", [])
-        reason = action.get("reason", "AI Admin")
-        
-        overwrites = {
-            ctx.guild.default_role: discord.PermissionOverwrite(view_channel=False),
-            ctx.guild.me: discord.PermissionOverwrite(view_channel=True, send_messages=True, manage_channels=True),
-        }
-        
-        for role_name in locked_roles:
-            role = discord.utils.get(ctx.guild.roles, name=role_name)
-            if role:
-                overwrites[role] = discord.PermissionOverwrite(view_channel=True, send_messages=True)
-        
-        category = None
-        if category_name:
-            category = discord.utils.get(ctx.guild.categories, name=category_name)
-        
-        if channel_type == "text":
-            channel = await ctx.guild.create_text_channel(
-                name=name, category=category, overwrites=overwrites, reason=reason
-            )
-        elif channel_type == "voice":
-            channel = await ctx.guild.create_voice_channel(
-                name=name, category=category, overwrites=overwrites, reason=reason
-            )
-        else:
-            return f"Unknown channel type: {channel_type}"
-        
-        return f"Created channel: {channel.mention}"
-    
-    async def _announce(self, action: dict[str, Any], ctx: commands.Context) -> str:
-        channel_name = action.get("channel")
-        title = action.get("title", "Announcement")
-        description = action.get("description", "")
-        color_str = action.get("color", "#00FFFF")
-        
-        try:
-            color = discord.Color(int(color_str.lstrip("#"), 16))
-        except ValueError:
-            color = discord.Color.blue()
-        
-        channel = None
-        if channel_name:
-            channel = discord.utils.get(ctx.guild.text_channels, name=channel_name)
-        
-        if not channel:
-            channel = ctx.channel
-        
-        embed = discord.Embed(title=title, description=description, color=color)
-        embed.timestamp = discord.utils.utcnow()
-        await channel.send(embed=embed)
-        return f"Announcement sent to {channel.mention}"
-    
-    async def _create_giveaway(self, action: dict[str, Any], ctx: commands.Context) -> str:
-        prize = action.get("prize", "Giveaway Prize")
-        duration = action.get("duration_minutes", 60)
-        winners = action.get("winners", 1)
-        channel_name = action.get("channel")
-        
-        channel = ctx.channel
-        if channel_name:
-            ch = discord.utils.get(ctx.guild.text_channels, name=channel_name)
-            if ch:
-                channel = ch
-        
-        cog = self.bot.get_cog("Community")
-        if not cog:
-            return "Community cog not found."
-        
-        await ctx.invoke(cog.giveaway, prize=prize, minutes=duration, winners=winners, channel=channel)
-        return f"Giveaway created: {prize}"
-    
-    async def _create_tournament(self, action: dict[str, Any], ctx: commands.Context) -> str:
-        name = action.get("name", "Tournament")
-        game = action.get("game", "Game")
-        max_participants = action.get("max_participants", 16)
-        channel_name = action.get("channel")
-        
-        channel = ctx.channel
-        if channel_name:
-            ch = discord.utils.get(ctx.guild.text_channels, name=channel_name)
-            if ch:
-                channel = ch
-        
-        cog = self.bot.get_cog("Engagement")
-        if not cog:
-            return "Engagement cog not found."
-        
-        await ctx.invoke(cog.tournament_create, name=name, game=game, max=max_participants, channel=channel)
-        return f"Tournament created: {name}"
-    
-    async def _create_poll(self, action: dict[str, Any], ctx: commands.Context) -> str:
-        question = action.get("question", "Poll")
-        options = action.get("options", ["Yes", "No"])
-        duration = action.get("duration_minutes", 30)
-        
-        cog = self.bot.get_cog("Community")
-        if not cog:
-            return "Community cog not found."
-        
-        options_str = ",".join(options)
-        await ctx.invoke(cog.poll, question=question, options=options_str, duration=duration)
-        return f"Poll created: {question}"
-    
-    async def _run_command(self, action: dict[str, Any], ctx: commands.Context) -> str:
-        command_name = action.get("command", "")
-        args = action.get("args", {})
-        
-        command = self.bot.get_command(command_name)
-        if not command:
-            return f"Command not found: {command_name}"
-        
-        try:
-            await ctx.invoke(command, **args)
-            return f"Command executed: {command_name}"
-        except Exception as e:
-            return f"Error running command: {str(e)}"
-    
-    async def _create_giveaway(self, action: dict[str, Any], ctx: commands.Context) -> str:
-        prize = action.get("prize", "Giveaway Prize")
-        duration = action.get("duration_minutes", 60)
-        winners = action.get("winners", 1)
-        channel_name = action.get("channel")
-        
-        channel = ctx.channel
-        if channel_name:
-            ch = discord.utils.get(ctx.guild.text_channels, name=channel_name)
-            if ch:
-                channel = ch
-        
-        cog = self.bot.get_cog("Community")
-        if not cog:
-            return "Community cog not found."
-        
-        await ctx.invoke(cog.giveaway, prize=prize, minutes=duration, winners=winners, channel=channel)
-        return f"Giveaway created: {prize}"
-    
+        category_name = action.get("category")
+        locked_roles = action.get("locked_to_roles", [])
+        reason = action.get("reason", "AI Admin")
+        
+        overwrites = {
+            ctx.guild.default_role: discord.PermissionOverwrite(view_channel=False),
+            ctx.guild.me: discord.PermissionOverwrite(view_channel=True, send_messages=True, manage_channels=True),
+        }
+        
+        for role_name in locked_roles:
+            role = discord.utils.get(ctx.guild.roles, name=role_name)
+            if role:
+                overwrites[role] = discord.PermissionOverwrite(view_channel=True, send_messages=True)
+        
+        category = None
+        if category_name:
+            category = discord.utils.get(ctx.guild.categories, name=category_name)
+        
+        if channel_type == "text":
+            channel = await ctx.guild.create_text_channel(
+                name=name, category=category, overwrites=overwrites, reason=reason
+            )
+        elif channel_type == "voice":
+            channel = await ctx.guild.create_voice_channel(
+                name=name, category=category, overwrites=overwrites, reason=reason
+            )
+        else:
+            return f"Unknown channel type: {channel_type}"
+        
+        return f"Created channel: {channel.mention}"
+    
+    async def _announce(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        channel_name = action.get("channel")
+        title = action.get("title", "Announcement")
+        description = action.get("description", "")
+        color_str = action.get("color", "#00FFFF")
+        
+        try:
+            color = discord.Color(int(color_str.lstrip("#"), 16))
+        except ValueError:
+            color = discord.Color.blue()
+        
+        channel = None
+        if channel_name:
+            channel = discord.utils.get(ctx.guild.text_channels, name=channel_name)
+        
+        if not channel:
+            channel = ctx.channel
+        
+        embed = discord.Embed(title=title, description=description, color=color)
+        embed.timestamp = discord.utils.utcnow()
+        await channel.send(embed=embed)
+        return f"Announcement sent to {channel.mention}"
+    
+    async def _create_giveaway(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        prize = action.get("prize", "Giveaway Prize")
+        duration = action.get("duration_minutes", 60)
+        winners = action.get("winners", 1)
+        channel_name = action.get("channel")
+        
+        channel = ctx.channel
+        if channel_name:
+            ch = discord.utils.get(ctx.guild.text_channels, name=channel_name)
+            if ch:
+                channel = ch
+        
+        cog = self.bot.get_cog("Community")
+        if not cog:
+            return "Community cog not found."
+        
+        await cog.giveaway_create(ctx, int(duration), int(winners), prize=prize)
+        return f"Giveaway created: {prize}"
+    
     async def _create_tournament(self, action: dict[str, Any], ctx: commands.Context) -> str:
         name = action.get("name", "Tournament")
         game = action.get("game", "Game")
         max_participants = action.get("max_participants", 16)
-        channel_name = action.get("channel")
-        
-        channel = ctx.channel
-        if channel_name:
-            ch = discord.utils.get(ctx.guild.text_channels, name=channel_name)
-            if ch:
-                channel = ch
         
         cog = self.bot.get_cog("Engagement")
         if not cog:
             return "Engagement cog not found."
-        
-        await ctx.invoke(cog.tournament_create, name=name, game=game, max=max_participants, channel=channel)
+
+        # Engagement exposes tournament creation via the base `/tournament` command.
+        games = f"{game}" if game else "chess, checkers, connect4, othello"
+        await ctx.invoke(cog.tournament, name=name, games=games)
         return f"Tournament created: {name}"
     
     async def _create_poll(self, action: dict[str, Any], ctx: commands.Context) -> str:
         question = action.get("question", "Poll")
         options = action.get("options", ["Yes", "No"])
-        duration = action.get("duration_minutes", 30)
         
-        cog = self.bot.get_cog("Community")
+        cog = self.bot.get_cog("Utility")
         if not cog:
-            return "Community cog not found."
+            return "Utility cog not found."
         
-        options_str = ",".join(options)
-        await ctx.invoke(cog.poll, question=question, options=options_str, duration=duration)
+        # Utility poll command accepts options as a "|" separated string.
+        options_str = "|".join(str(o) for o in options)
+        await ctx.invoke(cog.poll, question=question, options=options_str)
         return f"Poll created: {question}"
-    
+    
     async def _run_command(self, action: dict[str, Any], ctx: commands.Context) -> str:
         command_name = action.get("command", "")
         args = action.get("args", {})
-        
-        command = self.bot.get_command(command_name)
-        if not command:
-            return f"Command not found: {command_name}"
-        
+        
+        command = self.bot.get_command(command_name)
+        if not command:
+            return f"Command not found: {command_name}"
+        
         try:
             await ctx.invoke(command, **args)
             return f"Command executed: {command_name}"
         except Exception as e:
             return f"Error running command: {str(e)}"
 
+    async def _timeout_member(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        member = self._resolve_member(ctx.guild, action.get("member"))
+        if not member:
+            return "Member not found."
+        minutes = max(1, min(int(action.get("minutes", 10)), 40320))
+        reason = action.get("reason", "AI Admin timeout")
+        until = discord.utils.utcnow() + dt.timedelta(minutes=minutes)
+        await member.timeout(until, reason=reason)
+        return f"Timed out {member.mention} for {minutes} minute(s)."
+
+    async def _untimeout_member(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        member = self._resolve_member(ctx.guild, action.get("member"))
+        if not member:
+            return "Member not found."
+        reason = action.get("reason", "AI Admin untimeout")
+        await member.timeout(None, reason=reason)
+        return f"Removed timeout from {member.mention}."
+
+    async def _add_role(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        member = self._resolve_member(ctx.guild, action.get("member"))
+        if not member:
+            return "Member not found."
+        role_name = str(action.get("role", "")).strip()
+        role = discord.utils.find(lambda r: r.name.lower() == role_name.lower(), ctx.guild.roles)
+        if not role:
+            return f"Role not found: {role_name}"
+        reason = action.get("reason", "AI Admin add role")
+        await member.add_roles(role, reason=reason)
+        return f"Added role **{role.name}** to {member.mention}."
+
+    async def _remove_role(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        member = self._resolve_member(ctx.guild, action.get("member"))
+        if not member:
+            return "Member not found."
+        role_name = str(action.get("role", "")).strip()
+        role = discord.utils.find(lambda r: r.name.lower() == role_name.lower(), ctx.guild.roles)
+        if not role:
+            return f"Role not found: {role_name}"
+        reason = action.get("reason", "AI Admin remove role")
+        await member.remove_roles(role, reason=reason)
+        return f"Removed role **{role.name}** from {member.mention}."
+
+    async def _lock_channel(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        if not ctx.author.guild_permissions.manage_channels:
+            return "Manage Channels permission required."
+        channel = self._resolve_channel(ctx.guild, action.get("channel"), ctx.channel)
+        if not channel:
+            return "Channel not found."
+        reason = action.get("reason", "AI Admin lock channel")
+        await channel.set_permissions(ctx.guild.default_role, send_messages=False, reason=reason)
+        return f"Locked channel {channel.mention}."
+
+    async def _unlock_channel(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        if not ctx.author.guild_permissions.manage_channels:
+            return "Manage Channels permission required."
+        channel = self._resolve_channel(ctx.guild, action.get("channel"), ctx.channel)
+        if not channel:
+            return "Channel not found."
+        reason = action.get("reason", "AI Admin unlock channel")
+        await channel.set_permissions(ctx.guild.default_role, send_messages=True, reason=reason)
+        return f"Unlocked channel {channel.mention}."
+
+    async def _set_slowmode(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        if not ctx.author.guild_permissions.manage_channels:
+            return "Manage Channels permission required."
+        channel = self._resolve_channel(ctx.guild, action.get("channel"), ctx.channel)
+        if not channel:
+            return "Channel not found."
+        seconds = max(0, min(int(action.get("seconds", 0)), 21600))
+        reason = action.get("reason", "AI Admin slowmode")
+        await channel.edit(slowmode_delay=seconds, reason=reason)
+        return f"Set slowmode in {channel.mention} to {seconds}s."
+
+    async def _purge_messages(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        if not ctx.author.guild_permissions.manage_messages:
+            return "Manage Messages permission required."
+        channel = self._resolve_channel(ctx.guild, action.get("channel"), ctx.channel)
+        if not channel:
+            return "Channel not found."
+        amount = max(1, min(int(action.get("amount", 10)), 200))
+        deleted = await channel.purge(limit=amount)
+        return f"Purged {len(deleted)} message(s) in {channel.mention}."
 
+    async def _delete_channel(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        if not ctx.author.guild_permissions.manage_channels:
+            return "Manage Channels permission required."
+        channel = self._resolve_guild_channel(ctx.guild, action.get("channel"), None)
+        if not channel:
+            return "Channel not found."
+        if ctx.channel and channel.id == ctx.channel.id:
+            return "Refusing to delete the channel currently being used for command execution."
+        reason = action.get("reason", "AI Admin delete channel")
+        name = channel.name
+        await channel.delete(reason=reason)
+        return f"Deleted channel #{name}."
+
+    async def _rename_channel(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        if not ctx.author.guild_permissions.manage_channels:
+            return "Manage Channels permission required."
+        channel = self._resolve_guild_channel(ctx.guild, action.get("channel"), None)
+        if not channel:
+            return "Channel not found."
+        new_name = str(action.get("new_name", "")).strip()
+        if not new_name:
+            return "New channel name is required."
+        reason = action.get("reason", "AI Admin rename channel")
+        old_name = channel.name
+        await channel.edit(name=new_name[:100], reason=reason)
+        return f"Renamed channel **{old_name}** -> **{new_name[:100]}**."
+
+    async def _create_category(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        if not ctx.author.guild_permissions.manage_channels:
+            return "Manage Channels permission required."
+        name = str(action.get("name", "new-category")).strip()[:100]
+        if not name:
+            return "Category name is required."
+        reason = action.get("reason", "AI Admin create category")
+        category = await ctx.guild.create_category(name=name, reason=reason)
+        return f"Created category: **{category.name}**."
+
+    async def _rename_category(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        if not ctx.author.guild_permissions.manage_channels:
+            return "Manage Channels permission required."
+        category = self._resolve_category(ctx.guild, action.get("category"))
+        if not category:
+            return "Category not found."
+        new_name = str(action.get("new_name", "")).strip()[:100]
+        if not new_name:
+            return "New category name is required."
+        reason = action.get("reason", "AI Admin rename category")
+        old_name = category.name
+        await category.edit(name=new_name, reason=reason)
+        return f"Renamed category **{old_name}** -> **{new_name}**."
+
+    async def _delete_category(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        if not ctx.author.guild_permissions.manage_channels:
+            return "Manage Channels permission required."
+        category = self._resolve_category(ctx.guild, action.get("category"))
+        if not category:
+            return "Category not found."
+        reason = action.get("reason", "AI Admin delete category")
+        name = category.name
+        channels_inside = len(category.channels)
+        await category.delete(reason=reason)
+        return f"Deleted category **{name}** (had {channels_inside} channel(s))."
+    
 class AIAdmin(commands.Cog):
-    """Autonomous AI Administrator Cog."""
-    
+    """Autonomous AI Administrator Cog."""
+    
     def __init__(self, bot: commands.Bot) -> None:
         self.bot = bot
         self.permission_guard = PermissionGuard()
         self.intelligence = IntelligenceLayer(bot)
         self.execution = ExecutionEngine(bot)
-    
-    async def cog_unload(self) -> None:
-        await self.intelligence.close()
-    
+
+    @staticmethod
+    def _parse_duration_minutes(text: str) -> int | None:
+        match = re.search(r"(\d+)\s*(m|min|mins|minute|minutes|h|hr|hour|hours|d|day|days)?", text, re.IGNORECASE)
+        if not match:
+            return None
+        value = int(match.group(1))
+        unit = (match.group(2) or "m").lower()
+        if unit.startswith("h"):
+            value *= 60
+        elif unit.startswith("d"):
+            value *= 60 * 24
+        return max(1, min(value, 40320))
+
+    async def _try_direct_moderation(self, ctx: commands.Context, request: str) -> str | None:
+        if not ctx.guild:
+            return "Server only."
+        text = (request or "").strip()
+        lower = text.lower()
+
+        target = None
+        if ctx.message and ctx.message.mentions:
+            target = ctx.message.mentions[0]
+        else:
+            match = re.search(r"<@!?(\d+)>", text)
+            if match:
+                target = ctx.guild.get_member(int(match.group(1)))
+
+        if lower.startswith("kick ") and target:
+            if not ctx.author.guild_permissions.kick_members:
+                return "You need Kick Members permission."
+            await target.kick(reason=f"AI Admin by {ctx.author}")
+            return f"OK: Kicked {target.mention}"
+
+        if lower.startswith("ban ") and target:
+            if not ctx.author.guild_permissions.ban_members:
+                return "You need Ban Members permission."
+            await target.ban(reason=f"AI Admin by {ctx.author}", delete_message_days=0)
+            return f"OK: Banned {target.mention}"
+
+        if (lower.startswith("mute ") or lower.startswith("timeout ")) and target:
+            if not ctx.author.guild_permissions.moderate_members:
+                return "You need Moderate Members permission."
+            minutes = self._parse_duration_minutes(text) or 10
+            until = discord.utils.utcnow() + dt.timedelta(minutes=minutes)
+            await target.timeout(until, reason=f"AI Admin by {ctx.author}")
+            return f"OK: Timed out {target.mention} for {minutes} minute(s)"
+
+        if (lower.startswith("unmute ") or lower.startswith("untimeout ")) and target:
+            if not ctx.author.guild_permissions.moderate_members:
+                return "You need Moderate Members permission."
+            await target.timeout(None, reason=f"AI Admin by {ctx.author}")
+            return f"OK: Removed timeout from {target.mention}"
+
+        role_match = re.search(r"(?:give|add)\s+role\s+(.+?)\s+(?:to|for)\s+<@!?(\d+)>", text, re.IGNORECASE)
+        if role_match:
+            role_name = role_match.group(1).strip(" \"'")
+            member = ctx.guild.get_member(int(role_match.group(2)))
+            if not member:
+                return "Target member not found."
+            role = discord.utils.find(lambda r: r.name.lower() == role_name.lower(), ctx.guild.roles)
+            if not role:
+                return f"Role not found: {role_name}"
+            if not ctx.author.guild_permissions.manage_roles:
+                return "You need Manage Roles permission."
+            await member.add_roles(role, reason=f"AI Admin by {ctx.author}")
+            return f"OK: Added role **{role.name}** to {member.mention}"
+
+        remove_role_match = re.search(r"(?:remove)\s+role\s+(.+?)\s+(?:from)\s+<@!?(\d+)>", text, re.IGNORECASE)
+        if remove_role_match:
+            role_name = remove_role_match.group(1).strip(" \"'")
+            member = ctx.guild.get_member(int(remove_role_match.group(2)))
+            if not member:
+                return "Target member not found."
+            role = discord.utils.find(lambda r: r.name.lower() == role_name.lower(), ctx.guild.roles)
+            if not role:
+                return f"Role not found: {role_name}"
+            if not ctx.author.guild_permissions.manage_roles:
+                return "You need Manage Roles permission."
+            await member.remove_roles(role, reason=f"AI Admin by {ctx.author}")
+            return f"OK: Removed role **{role.name}** from {member.mention}"
+
+        lock_match = re.search(r"^lock(?:\s+<#(\d+)>)?", lower)
+        if lock_match:
+            if not ctx.author.guild_permissions.manage_channels:
+                return "You need Manage Channels permission."
+            channel = ctx.guild.get_channel(int(lock_match.group(1))) if lock_match.group(1) else ctx.channel
+            if isinstance(channel, discord.TextChannel):
+                await channel.set_permissions(ctx.guild.default_role, send_messages=False, reason=f"AI Admin by {ctx.author}")
+                return f"OK: Locked {channel.mention}"
+
+        unlock_match = re.search(r"^unlock(?:\s+<#(\d+)>)?", lower)
+        if unlock_match:
+            if not ctx.author.guild_permissions.manage_channels:
+                return "You need Manage Channels permission."
+            channel = ctx.guild.get_channel(int(unlock_match.group(1))) if unlock_match.group(1) else ctx.channel
+            if isinstance(channel, discord.TextChannel):
+                await channel.set_permissions(ctx.guild.default_role, send_messages=True, reason=f"AI Admin by {ctx.author}")
+                return f"OK: Unlocked {channel.mention}"
+
+        rename_channel_match = re.search(
+            r"(?:rename)\s+channel\s+(.+?)\s+(?:to|->)\s+(.+)$",
+            text,
+            re.IGNORECASE,
+        )
+        if rename_channel_match:
+            if not ctx.author.guild_permissions.manage_channels:
+                return "You need Manage Channels permission."
+            old_ref = rename_channel_match.group(1).strip(" \"'")
+            new_name = rename_channel_match.group(2).strip(" \"'")
+            channel = ExecutionEngine._resolve_guild_channel(ctx.guild, old_ref)
+            if not channel:
+                return f"Channel not found: {old_ref}"
+            if not new_name:
+                return "New channel name is required."
+            old_name = channel.name
+            await channel.edit(name=new_name[:100], reason=f"AI Admin by {ctx.author}")
+            return f"OK: Renamed channel **{old_name}** -> **{new_name[:100]}**"
+
+        delete_channel_match = re.search(r"(?:delete|remove)\s+channel\s+(.+)$", text, re.IGNORECASE)
+        if delete_channel_match:
+            if not ctx.author.guild_permissions.manage_channels:
+                return "You need Manage Channels permission."
+            ref = delete_channel_match.group(1).strip(" \"'")
+            channel = ExecutionEngine._resolve_guild_channel(ctx.guild, ref)
+            if not channel:
+                return f"Channel not found: {ref}"
+            if ctx.channel and channel.id == ctx.channel.id:
+                return "Refusing to delete the channel currently being used for command execution."
+            name = channel.name
+            await channel.delete(reason=f"AI Admin by {ctx.author}")
+            return f"OK: Deleted channel **{name}**"
+
+        rename_category_match = re.search(
+            r"(?:rename)\s+(?:category|directory)\s+(.+?)\s+(?:to|->)\s+(.+)$",
+            text,
+            re.IGNORECASE,
+        )
+        if rename_category_match:
+            if not ctx.author.guild_permissions.manage_channels:
+                return "You need Manage Channels permission."
+            old_ref = rename_category_match.group(1).strip(" \"'")
+            new_name = rename_category_match.group(2).strip(" \"'")
+            category = ExecutionEngine._resolve_category(ctx.guild, old_ref)
+            if not category:
+                return f"Category not found: {old_ref}"
+            if not new_name:
+                return "New category name is required."
+            old_name = category.name
+            await category.edit(name=new_name[:100], reason=f"AI Admin by {ctx.author}")
+            return f"OK: Renamed category **{old_name}** -> **{new_name[:100]}**"
+
+        delete_category_match = re.search(r"(?:delete|remove)\s+(?:category|directory)\s+(.+)$", text, re.IGNORECASE)
+        if delete_category_match:
+            if not ctx.author.guild_permissions.manage_channels:
+                return "You need Manage Channels permission."
+            ref = delete_category_match.group(1).strip(" \"'")
+            category = ExecutionEngine._resolve_category(ctx.guild, ref)
+            if not category:
+                return f"Category not found: {ref}"
+            name = category.name
+            channels_inside = len(category.channels)
+            await category.delete(reason=f"AI Admin by {ctx.author}")
+            return f"OK: Deleted category **{name}** (had {channels_inside} channel(s))"
+
+        return None
+    
+    async def cog_unload(self) -> None:
+        await self.intelligence.close()
+    
     @commands.hybrid_command(name="ai_admin", description="Let AI administrate the server")
     async def ai_admin(self, ctx: commands.Context, *, request: str) -> None:
-        if not self.permission_guard.check(ctx)[0]:
-            await ctx.send(self.permission_guard.check(ctx)[1], ephemeral=True)
-            return
-        
-        await ctx.defer()
-        
-        actions = await self.intelligence.ask_ai(request)
-        if not actions:
-            await ctx.send("AI failed to generate actions. Try again.", ephemeral=True)
+        allowed, deny_reason = self.permission_guard.check(ctx)
+        if not allowed:
+            await ctx.send(deny_reason, ephemeral=True)
             return
-        
-        response_text = None
-        for action in actions:
-            if "response_to_user" in action:
-                response_text = action.pop("response_to_user")
-                break
-        
-        results = await self.execution.execute(actions, ctx)
-        
-        if response_text:
-            await ctx.send(response_text)
-        else:
-            await ctx.send("\n".join(results))
-    
-    @commands.hybrid_command(name="ai_help", description="Show AI Admin capabilities")
-    async def ai_help(self, ctx: commands.Context) -> None:
-        embed = discord.Embed(
-            title="AI Administrator Help",
-            description=(
-                "I can help manage your server using AI. Examples:\n\n"
-                "**Create a role:**\n"
-                "`/ai_admin create a moderator role with purple color`\n\n"
-                "**Create a channel:**\n"
-                "`/ai_admin make a private channel for staff`\n\n"
-                "**Create a giveaway:**\n"
-                "`/ai_admin create a giveaway for Discord Nitro 24 hours`\n\n"
-                "**Create a tournament:**\n"
-                "`/ai_admin setup a Valorant tournament for 16 players`\n\n"
-                "**Create a poll:**\n"
-                "`/ai_admin make a poll about server events`\n\n"
+
+        direct_result = await self._try_direct_moderation(ctx, request)
+        if direct_result is not None:
+            await ctx.send(direct_result, ephemeral=True)
+            return
+
+        if ctx.interaction and not ctx.interaction.response.is_done():
+            try:
+                await ctx.defer()
+            except discord.InteractionResponded:
+                pass
+        
+        actions = await self.intelligence.ask_ai(request)
+        if not actions:
+            await ctx.send("AI failed to generate actions. Try again.", ephemeral=True)
+            return
+        
+        response_text = None
+        for action in actions:
+            if "response_to_user" in action:
+                response_text = action.pop("response_to_user")
+                break
+        
+        results = await self.execution.execute(actions, ctx)
+        
+        if response_text:
+            await ctx.send(response_text)
+        else:
+            await ctx.send("\n".join(results))
+    
+    @commands.hybrid_command(name="ai_help", description="Show AI Admin capabilities")
+    async def ai_help(self, ctx: commands.Context) -> None:
+        embed = discord.Embed(
+            title="AI Administrator Help",
+            description=(
+                "I can help manage your server using AI. Examples:\n\n"
+                "**Create a role:**\n"
+                "`/ai_admin create a moderator role with purple color`\n\n"
+                "**Create a channel:**\n"
+                "`/ai_admin make a private channel for staff`\n\n"
+                "**Create a giveaway:**\n"
+                "`/ai_admin create a giveaway for Discord Nitro 24 hours`\n\n"
+                "**Create a tournament:**\n"
+                "`/ai_admin setup a Valorant tournament for 16 players`\n\n"
+                "**Create a poll:**\n"
+                "`/ai_admin make a poll about server events`\n\n"
                 "**Announce:**\n"
-                "`/ai_admin announce server maintenance in 1 hour`"
+                "`/ai_admin announce server maintenance in 1 hour`\n\n"
+                "**Direct moderation shortcuts:**\n"
+                "`/ai_admin kick @user`\n"
+                "`/ai_admin ban @user`\n"
+                "`/ai_admin mute @user 30m`\n"
+                "`/ai_admin unmute @user`\n"
+                "`/ai_admin add role VIP to @user`\n"
+                "`/ai_admin remove role VIP from @user`\n"
+                "`/ai_admin lock #channel`\n"
+                "`/ai_admin unlock #channel`\n"
+                "`/ai_admin rename channel old-name to new-name`\n"
+                "`/ai_admin delete channel old-name`\n"
+                "`/ai_admin rename category Staff to Team-Staff`\n"
+                "`/ai_admin delete category Team-Staff`"
             ),
             color=discord.Color.blue()
         )
-        await ctx.send(embed=embed, ephemeral=True)
-
-
-async def setup(bot: commands.Bot) -> None:
-    await bot.add_cog(AIAdmin(bot))
+        await ctx.send(embed=embed, ephemeral=True)
+
+
+async def setup(bot: commands.Bot) -> None:
+    await bot.add_cog(AIAdmin(bot))

bot/cogs/ai_suite.py

@@ -1354,12 +1354,11 @@ class AISuite(commands.Cog):
         # Fallback mappings for panel bootstrapping when planner is unavailable.
         lowered = text.lower()
         if any(k in lowered for k in ("اقتراح", "suggestion panel", "suggest panel", "suggestions panel")):
-            if ctx:
-                cmd = self.bot.get_command("suggestion_panel")
-                if cmd:
-                    await ctx.invoke(cmd)
-                    return "✅ تم نشر لوحة الاقتراحات." if guild_lang == "ar" else "✅ Suggestion panel requested."
-            return "استخدم `/suggestion_panel` لنشر لوحة الاقتراحات التفاعلية." if guild_lang == "ar" else "Use `/suggestion_panel` to deploy the interactive suggestions UI."
+            return (
+                "نظام الاقتراحات يعمل عبر قناة مخصصة. استخدم `/setsuggestionchannel #channel` ثم أرسل اقتراحك هناك."
+                if guild_lang == "ar"
+                else "Suggestions use a dedicated channel. Run `/setsuggestionchannel #channel` then post suggestions there."
+            )
         if any(k in lowered for k in ("تذكرة", "tickets", "ticket panel", "دعم")):
             if ctx:
                 cmd = self.bot.get_command("ticket_panel")

bot/cogs/banner_manager.py

@@ -4,6 +4,9 @@ Server Banner Management Cog - Allows servers to set custom banners
 
 from __future__ import annotations
 
+import sqlite3
+from urllib.parse import urlparse
+
 import discord
 from discord.ext import commands
 from discord import app_commands
@@ -26,15 +29,19 @@ class SetBannerModal(discord.ui.Modal, title="🖼️ Set Server Banner"):
         self.cog = cog
     
     async def on_submit(self, interaction: discord.Interaction) -> None:
-        url = self.banner_url.value.strip()
+        url = self.banner_url.value.strip().strip("<>")
         
         # Validate URL
-        if not url.startswith(("http://", "https://")):
-            await interaction.response.send_message("❌ Invalid URL. Must start with http:// or https://", ephemeral=True)
+        if not self.cog._looks_like_image_url(url):
+            await interaction.response.send_message(
+                "Invalid image URL. Use a public http(s) link ending with png/jpg/jpeg/webp/gif.",
+                ephemeral=True,
+            )
             return
         
         guild_id = interaction.guild.id if interaction.guild else 0
-        
+
+        await self.cog._ensure_schema()
         # Save to database
         await self.cog.bot.db.execute(
             "INSERT INTO guild_config(guild_id, custom_banner_url) VALUES (?, ?) "
@@ -56,6 +63,30 @@ class SetBannerModal(discord.ui.Modal, title="🖼️ Set Server Banner"):
 class BannerManager(commands.Cog):
     def __init__(self, bot: commands.Bot) -> None:
         self.bot = bot
+        self._schema_checked = False
+
+    async def _ensure_schema(self) -> None:
+        if self._schema_checked:
+            return
+        try:
+            await self.bot.db.execute(
+                "ALTER TABLE guild_config ADD COLUMN custom_banner_url TEXT"
+            )
+        except sqlite3.OperationalError as exc:
+            if "duplicate column name" not in str(exc).lower():
+                raise
+        self._schema_checked = True
+
+    @staticmethod
+    def _looks_like_image_url(url: str) -> bool:
+        try:
+            parsed = urlparse(url)
+        except Exception:
+            return False
+        if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+            return False
+        path = (parsed.path or "").lower()
+        return path.endswith((".png", ".jpg", ".jpeg", ".webp", ".gif"))
     
     @app_commands.command(name="set_banner", description="Set a custom banner for this server")
     @app_commands.checks.has_permissions(manage_guild=True)
@@ -65,6 +96,7 @@ class BannerManager(commands.Cog):
             await interaction.response.send_message("❌ This command can only be used in a server.", ephemeral=True)
             return
         
+        await self._ensure_schema()
         await interaction.response.send_modal(SetBannerModal(self))
     
     @app_commands.command(name="remove_banner", description="Remove the custom banner from this server")
@@ -75,6 +107,7 @@ class BannerManager(commands.Cog):
             await interaction.response.send_message("❌ This command can only be used in a server.", ephemeral=True)
             return
         
+        await self._ensure_schema()
         guild_id = interaction.guild.id
         
         await self.bot.db.execute(
@@ -97,6 +130,7 @@ class BannerManager(commands.Cog):
             await interaction.response.send_message("❌ This command can only be used in a server.", ephemeral=True)
             return
         
+        await self._ensure_schema()
         guild_id = interaction.guild.id
         
         row = await self.bot.db.fetchone(

bot/cogs/board_games.py

@@ -808,7 +808,7 @@ class BoardGames(commands.Cog):
 
     @commands.hybrid_command(name="games_panel", hidden=True, description="Deprecated: use /gamehub", with_app_command=False)
     async def games_panel(self, ctx: commands.Context) -> None:
-        await ctx.reply("🟢 This panel is deprecated. Use `/gamehub` for the improved game experience.")
+        await ctx.reply("<:animatedarrowgreen:1477261279428087979> This panel is deprecated. Use `/gamehub` for the improved game experience.")
 
     @commands.hybrid_command(name="board_forfeit", hidden=True, description="Forfeit active board game", with_app_command=False)
     async def board_forfeit(self, ctx: commands.Context) -> None:

bot/cogs/community.py

@@ -474,7 +474,7 @@ class QuickOptionsView(discord.ui.View):
     
     @discord.ui.button(label="Priority", style=discord.ButtonStyle.primary, row=2)
     async def priority(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        self.parent.options = ["🔴 High", "🟡 Medium", "🟢 Low"]
+        self.parent.options = ["🔴 High", "<:animatedarrowyellow:1477261257592668271> Medium", "<:animatedarrowgreen:1477261279428087979> Low"]
         await self._apply_options(interaction)
     
     async def _apply_options(self, interaction: discord.Interaction) -> None:
@@ -933,9 +933,9 @@ class Community(commands.Cog):
                 await msg.edit(embed=embed, view=None)
             if winner_id:
                 await channel.send(f"🎉 Giveaway **#{giveaway_id}** winner: <@{winner_id}> • Prize: **{prize}**")
-                log_channel_id = await self.bot.db.fetchone("SELECT log_channel_id FROM guild_config WHERE guild_id = ?", ctx.guild.id)
+            log_channel_id = await self.bot.db.fetchone("SELECT log_channel_id FROM guild_config WHERE guild_id = ?", guild.id)
             if log_channel_id and log_channel_id[0]:
-                log_channel = ctx.guild.get_channel(log_channel_id[0])
+                log_channel = guild.get_channel(log_channel_id[0])
                 if log_channel:
                     log_embed = discord.Embed(
                         title="🎁 Giveaway Ended",
@@ -946,8 +946,6 @@ class Community(commands.Cog):
                     log_embed.add_field(name="Prize", value=prize, inline=True)
                     log_embed.add_field(name="Giveaway ID", value=str(giveaway_id), inline=True)
                     await log_channel.send(embed=log_embed)
-        else:
-            await ctx.reply(f"Winner: <@{winner_id}>")
     
     @commands.hybrid_command(name="setsuggestionchannel", description="Set suggestion channel")
     @commands.has_permissions(manage_guild=True)
@@ -1007,6 +1005,134 @@ class Community(commands.Cog):
         )
         await ctx.reply(embed=embed, view=view)
 
+    @commands.hybrid_group(name="giveaway", description="Giveaway commands")
+    @commands.has_permissions(manage_guild=True)
+    async def giveaway_group(self, ctx: commands.Context) -> None:
+        if ctx.invoked_subcommand is None:
+            await ctx.reply("Use: `/giveaway start`, `/giveaway end`, `/giveaway reroll`.")
+
+    async def giveaway_create(self, ctx_or_interaction: commands.Context | discord.Interaction, minutes: int, winner_count: int, *, prize: str) -> None:
+        guild = ctx_or_interaction.guild
+        channel = ctx_or_interaction.channel
+        if not guild or not isinstance(channel, discord.TextChannel):
+            if isinstance(ctx_or_interaction, commands.Context):
+                await ctx_or_interaction.reply("Server text channel only.")
+            else:
+                await ctx_or_interaction.followup.send("Server text channel only.", ephemeral=True)
+            return
+        end_time = int(time.time()) + max(1, minutes) * 60
+        view = GiveawayJoinView(self, guild.id)
+        view.winners_count = max(1, winner_count)
+        embed = view.build_embed(prize=prize, end_time=end_time, winners=view.winners_count, entrants=0, ended=False)
+        msg = await channel.send(embed=embed, view=view)
+        await self.bot.db.execute(
+            "INSERT INTO giveaways(guild_id, channel_id, message_id, prize, end_time, winner_id, ended) VALUES (?, ?, ?, ?, ?, NULL, 0)",
+            guild.id,
+            channel.id,
+            msg.id,
+            prize[:250],
+            end_time,
+        )
+        row = await self.bot.db.fetchone("SELECT id FROM giveaways WHERE message_id = ?", msg.id)
+        view.giveaway_id = int(row[0]) if row else 0
+        if view.giveaway_id:
+            await msg.edit(embed=view.build_embed(prize=prize, end_time=end_time, winners=view.winners_count, entrants=0, ended=False), view=view)
+        response = f"✅ Giveaway created (ID: `{view.giveaway_id}`) • ends <t:{end_time}:R>"
+        if isinstance(ctx_or_interaction, commands.Context):
+            await ctx_or_interaction.reply(response)
+        else:
+            await ctx_or_interaction.followup.send(response, ephemeral=True)
+
+    async def giveaway_end(self, ctx_or_interaction: commands.Context | discord.Interaction, giveaway_id: int) -> None:
+        row = await self.bot.db.fetchone(
+            "SELECT guild_id, channel_id, message_id, prize, ended FROM giveaways WHERE id = ?",
+            giveaway_id,
+        )
+        if not row:
+            msg = "Giveaway not found."
+            if isinstance(ctx_or_interaction, commands.Context):
+                await ctx_or_interaction.reply(msg)
+            else:
+                await ctx_or_interaction.followup.send(msg, ephemeral=True)
+            return
+        guild_id, channel_id, message_id, prize, ended = row
+        if int(ended or 0) == 1:
+            msg = "Giveaway already ended."
+            if isinstance(ctx_or_interaction, commands.Context):
+                await ctx_or_interaction.reply(msg)
+            else:
+                await ctx_or_interaction.followup.send(msg, ephemeral=True)
+            return
+        entries = await self.bot.db.fetchall("SELECT user_id FROM giveaway_entries WHERE giveaway_id = ?", giveaway_id)
+        users = [uid for (uid,) in entries]
+        winner_id = random.choice(users) if users else None
+        await self.bot.db.execute("UPDATE giveaways SET ended = 1, winner_id = ? WHERE id = ?", winner_id, giveaway_id)
+        guild = self.bot.get_guild(int(guild_id))
+        channel = guild.get_channel(int(channel_id)) if guild else None
+        if isinstance(channel, discord.TextChannel):
+            try:
+                msg_obj = await channel.fetch_message(int(message_id))
+                embed = msg_obj.embeds[0] if msg_obj.embeds else discord.Embed(title="🎁 Giveaway")
+                embed.color = NEON_ORANGE
+                embed.add_field(name="Winner", value=(f"<@{winner_id}>" if winner_id else "No entrants"), inline=False)
+                await msg_obj.edit(embed=embed, view=None)
+            except Exception:
+                pass
+            if winner_id:
+                await channel.send(f"🎉 Giveaway **#{giveaway_id}** winner: <@{winner_id}> • Prize: **{prize}**")
+            else:
+                await channel.send(f"🎉 Giveaway **#{giveaway_id}** ended with no entrants.")
+        reply = f"✅ Giveaway `{giveaway_id}` ended."
+        if isinstance(ctx_or_interaction, commands.Context):
+            await ctx_or_interaction.reply(reply)
+        else:
+            await ctx_or_interaction.followup.send(reply, ephemeral=True)
+
+    @giveaway_group.command(name="start", description="Start a giveaway in current channel")
+    async def giveaway_start(self, ctx: commands.Context, minutes: int, winners: int, *, prize: str) -> None:
+        await self.giveaway_create(ctx, minutes, winners, prize=prize)
+
+    @giveaway_group.command(name="end", description="End a giveaway by ID")
+    async def giveaway_end_cmd(self, ctx: commands.Context, giveaway_id: int) -> None:
+        await self.giveaway_end(ctx, giveaway_id)
+
+    @giveaway_group.command(name="reroll", description="Reroll winner for ended giveaway")
+    async def giveaway_reroll(self, ctx: commands.Context, giveaway_id: int) -> None:
+        row = await self.bot.db.fetchone("SELECT ended FROM giveaways WHERE id = ?", giveaway_id)
+        if not row or int(row[0] or 0) != 1:
+            await ctx.reply("Giveaway must be ended before reroll.")
+            return
+        await self.bot.db.execute("UPDATE giveaways SET ended = 0, winner_id = NULL WHERE id = ?", giveaway_id)
+        await self.giveaway_end(ctx, giveaway_id)
+
+    @commands.hybrid_group(name="ticket", description="Ticket commands")
+    async def ticket_group(self, ctx: commands.Context) -> None:
+        if ctx.invoked_subcommand is None:
+            await ctx.reply("Use: `/ticket close` or `/ticket delete` in a ticket channel.")
+
+    @ticket_group.command(name="close", description="Close current ticket channel")
+    async def ticket_close_cmd(self, ctx: commands.Context) -> None:
+        channel = ctx.channel
+        if not isinstance(channel, discord.TextChannel) or not channel.name.startswith("ticket-"):
+            await ctx.reply("This is not a ticket channel.")
+            return
+        await self.bot.db.execute("UPDATE tickets SET status = 'closed' WHERE channel_id = ?", channel.id)
+        await ctx.reply("🔒 Closing ticket in 5 seconds...")
+        await asyncio.sleep(5)
+        await channel.delete(reason=f"Closed by {ctx.author}")
+
+    @ticket_group.command(name="delete", description="Delete current ticket channel")
+    @commands.has_permissions(manage_channels=True)
+    async def ticket_delete_cmd(self, ctx: commands.Context) -> None:
+        channel = ctx.channel
+        if not isinstance(channel, discord.TextChannel) or not channel.name.startswith("ticket-"):
+            await ctx.reply("This is not a ticket channel.")
+            return
+        await self.bot.db.execute("DELETE FROM tickets WHERE channel_id = ?", channel.id)
+        await ctx.reply("🗑️ Deleting ticket in 3 seconds...")
+        await asyncio.sleep(3)
+        await channel.delete(reason=f"Deleted by {ctx.author}")
+
 
 # ═══════════════════════════════════════════════════════════════════════════════
 # GLOBAL TICKETS + GIVEAWAYS

bot/cogs/configuration.py

@@ -273,15 +273,15 @@ class FreeGameSetupView(discord.ui.View):
         min_values=1,
         max_values=3,
         options=[
-            discord.SelectOption(label="Epic Games", value="epic", emoji="🟢"),
-            discord.SelectOption(label="Steam", value="steam", emoji="🟢"),
-            discord.SelectOption(label="GOG", value="gog", emoji="🟢"),
+            discord.SelectOption(label="Epic Games", value="epic", emoji="<:animatedarrowgreen:1477261279428087979>"),
+            discord.SelectOption(label="Steam", value="steam", emoji="<:animatedarrowgreen:1477261279428087979>"),
+            discord.SelectOption(label="GOG", value="gog", emoji="<:animatedarrowgreen:1477261279428087979>"),
         ],
     )
     async def stores(self, interaction: discord.Interaction, select: discord.ui.Select) -> None:
         self.platforms = set(select.values)
         await self._save(interaction)
-        await interaction.response.send_message("🟢 Free games stores updated.", ephemeral=True)
+        await interaction.response.send_message("<:animatedarrowgreen:1477261279428087979> Free games stores updated.", ephemeral=True)
 
     @discord.ui.select(
         placeholder="Choose ping role (optional)",
@@ -620,7 +620,7 @@ class Configuration(commands.Cog):
         )
         view = FreeGameSetupView(self, ctx.guild.id, channel.id, role.id if role else None)
         embed = discord.Embed(
-            title="🟢 Free Games Setup",
+            title="<:animatedarrowgreen:1477261279428087979> Free Games Setup",
             description=(
                 f"Channel: {channel.mention}\n"
                 f"Role ping: {role.mention if role else 'None'}\n"

bot/cogs/engagement.py

@@ -15,7 +15,7 @@ from bot.theme import (
     level_display, economy_embed, success_embed, error_embed, info_embed,
     leaderboard_embed, profile_embed, gaming_embed, tournament_embed,
     format_leaderboard, money_display, timestamp_display, double_line, triple_line,
-    pick_neon_color, shimmer
+    pick_neon_color, shimmer, idle_embed_for_guild
 )
 from bot.emojis import (
     ui, E_DIAMOND, E_STAR, E_CATJAM, E_ARROW_BLUE, E_ARROW_GREEN, 
@@ -189,8 +189,27 @@ class EconomyPanelView(discord.ui.View):
         if not interaction.guild:
             await interaction.response.send_message("Server only.", ephemeral=True)
             return
-        guild_id = interaction.guild.id
-        await interaction.response.send_modal(GambleModal(self.cog, guild_id, interaction.user.id))
+        gambling_cog = interaction.client.get_cog("Gambling")
+        if gambling_cog is None:
+            guild_id = interaction.guild.id
+            await interaction.response.send_modal(GambleModal(self.cog, guild_id, interaction.user.id))
+            return
+        from bot.cogs.gambling import GamblingPanelView
+        embed = discord.Embed(
+            title="Casino & Gambling Panel",
+            description=(
+                "Choose a game:\n\n"
+                "Blackjack\n"
+                "Roulette\n"
+                "RPG Adventure"
+            ),
+            color=NEON_ORANGE,
+        )
+        await interaction.response.send_message(
+            embed=embed,
+            view=GamblingPanelView(gambling_cog, interaction.guild.id, interaction.user.id),
+            ephemeral=True,
+        )
 
     @discord.ui.button(label="Rob", emoji=ui("gun"), style=discord.ButtonStyle.danger, custom_id="economy:rob", row=1)
     async def rob_btn(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
@@ -224,7 +243,15 @@ class EconomyPanelView(discord.ui.View):
             guild_id,
         )
         if not rows:
-            await interaction.followup.send("No economy data yet.", ephemeral=True)
+            await interaction.followup.send(
+                embed=await idle_embed_for_guild(
+                    "Economy Leaderboard Idle",
+                    "No economy data is available yet.",
+                    guild=interaction.guild,
+                    bot=self.cog.bot,
+                ),
+                ephemeral=True,
+            )
             return
         lines = []
         for rank, (uid, total) in enumerate(rows, 1):
@@ -461,9 +488,9 @@ class GambleModal(discord.ui.Modal, title="🎲 Gamble Coins"):
 
 class RobModal(discord.ui.Modal, title="🔫 Rob a User"):
     target = discord.ui.TextInput(
-        label="User ID or Mention",
-        placeholder="123456789 or @user",
-        required=True,
+        label="User ID or Mention (optional)",
+        placeholder="Leave empty for random target",
+        required=False,
         max_length=64,
     )
 
@@ -475,11 +502,23 @@ class RobModal(discord.ui.Modal, title="🔫 Rob a User"):
 
     async def on_submit(self, interaction: discord.Interaction) -> None:
         await interaction.response.defer(ephemeral=True)
+        tid: int | None = None
         val = self.target.value.strip().replace("<", "").replace(">", "").replace("@", "").replace("!", "")
-        try:
-            tid = int(val)
-        except ValueError:
-            await interaction.followup.send("Invalid user ID.", ephemeral=True)
+        if val:
+            try:
+                tid = int(val)
+            except ValueError:
+                await interaction.followup.send("Invalid user ID.", ephemeral=True)
+                return
+        elif interaction.guild:
+            eligible = [
+                m for m in interaction.guild.members
+                if (not m.bot) and m.id != self.user_id and m.guild_permissions.send_messages
+            ]
+            if eligible:
+                tid = random.choice(eligible).id
+        if tid is None:
+            await interaction.followup.send("No valid robbery target found.", ephemeral=True)
             return
         if tid == self.user_id:
             await interaction.followup.send("You can't rob yourself!", ephemeral=True)
@@ -721,9 +760,19 @@ class Engagement(commands.Cog):
         )
         if not row:
             if lang == "ar":
-                await ctx.reply("📊 لا توجد بيانات مستوى بعد. ابدأ الدردشة لكسب XP!")
+                await ctx.reply(embed=await idle_embed_for_guild(
+                    "حالة الرتبة الخاملة",
+                    "لا توجد بيانات مستوى بعد. ابدأ الدردشة لكسب XP!",
+                    guild=ctx.guild,
+                    bot=self.bot,
+                ))
             else:
-                await ctx.reply("📊 No rank data yet. Start chatting to earn XP!")
+                await ctx.reply(embed=await idle_embed_for_guild(
+                    "Rank Idle",
+                    "No rank data yet. Start chatting to earn XP!",
+                    guild=ctx.guild,
+                    bot=self.bot,
+                ))
             return
             
         xp, level = row
@@ -766,9 +815,19 @@ class Engagement(commands.Cog):
         )
         if not rows:
             if lang == "ar":
-                await ctx.reply("📊 لا توجد بيانات بعد. ابدأ الدردشة لكسب XP!")
+                await ctx.reply(embed=await idle_embed_for_guild(
+                    "اللوحة الخاملة",
+                    "لا توجد بيانات بعد. ابدأ الدردشة لكسب XP!",
+                    guild=ctx.guild,
+                    bot=self.bot,
+                ))
             else:
-                await ctx.reply("📊 No data yet. Start chatting to earn XP!")
+                await ctx.reply(embed=await idle_embed_for_guild(
+                    "Leaderboard Idle",
+                    "No data yet. Start chatting to earn XP!",
+                    guild=ctx.guild,
+                    bot=self.bot,
+                ))
             return
             
         lines = []
@@ -969,10 +1028,20 @@ class Engagement(commands.Cog):
         await ctx.reply(embed=embed)
 
     @commands.hybrid_command(name="rob", description="Attempt to rob another user (risky!)", hidden=True, with_app_command=False)
-    async def rob(self, ctx: commands.Context, target: discord.Member) -> None:
+    async def rob(self, ctx: commands.Context, target: discord.Member | None = None) -> None:
         guild_id = ctx.guild.id
         lang = await self.bot.get_guild_language(guild_id)
-        
+
+        if target is None:
+            eligible = [
+                member for member in ctx.guild.members
+                if (not member.bot) and member.id != ctx.author.id and member.guild_permissions.send_messages
+            ]
+            target = random.choice(eligible) if eligible else None
+            if target is None:
+                await ctx.reply("❌ No valid robbery targets found.")
+                return
+
         if target.id == ctx.author.id or target.bot:
             if lang == "ar":
                 await ctx.reply("❌ هدف غير صالح.")
@@ -1082,7 +1151,7 @@ class Engagement(commands.Cog):
         await self.gamble(ctx, bet)
 
     @economy.command(name="rob", description="Attempt to rob another user")
-    async def economy_rob(self, ctx: commands.Context, target: discord.Member) -> None:
+    async def economy_rob(self, ctx: commands.Context, target: discord.Member | None = None) -> None:
         await self.rob(ctx, target)
 
     @commands.hybrid_command(name="profile")
@@ -1486,9 +1555,19 @@ class Engagement(commands.Cog):
         )
         if not row:
             if lang == "ar":
-                await ctx.reply("❌ البطولة غير موجودة.")
+                await ctx.reply(embed=await idle_embed_for_guild(
+                    "البطولة غير متاحة",
+                    "لا توجد بطولة بهذا الاسم حالياً.",
+                    guild=ctx.guild,
+                    bot=self.bot,
+                ))
             else:
-                await ctx.reply("❌ Tournament not found.")
+                await ctx.reply(embed=await idle_embed_for_guild(
+                    "Tournament Not Found",
+                    "No tournament exists with that name right now.",
+                    guild=ctx.guild,
+                    bot=self.bot,
+                ))
             return
             
         _, status, winner_id = row
@@ -1542,9 +1621,19 @@ class Engagement(commands.Cog):
         )
         if not rows:
             if lang == "ar":
-                await ctx.reply("❌ لا توجد ألعاب محددة لهذه البطولة.")
+                await ctx.reply(embed=await idle_embed_for_guild(
+                    "قائمة الألعاب فارغة",
+                    "لم يتم إعداد ألعاب لهذه البطولة بعد.",
+                    guild=ctx.guild,
+                    bot=self.bot,
+                ))
             else:
-                await ctx.reply("❌ No games set for this tournament.")
+                await ctx.reply(embed=await idle_embed_for_guild(
+                    "Tournament Games Idle",
+                    "No games are configured for this tournament yet.",
+                    guild=ctx.guild,
+                    bot=self.bot,
+                ))
             return
             
         games = "🎮 " + " • ".join(game for (game,) in rows)
@@ -1579,9 +1668,19 @@ class Engagement(commands.Cog):
         )
         if not row:
             if lang == "ar":
-                await ctx.reply("❌ البطولة غير موجودة.")
+                await ctx.reply(embed=await idle_embed_for_guild(
+                    "البطولة غير متاحة",
+                    "لا توجد بطولة بهذا الاسم حالياً.",
+                    guild=ctx.guild,
+                    bot=self.bot,
+                ))
             else:
-                await ctx.reply("❌ Tournament not found.")
+                await ctx.reply(embed=await idle_embed_for_guild(
+                    "Tournament Not Found",
+                    "No tournament exists with that name right now.",
+                    guild=ctx.guild,
+                    bot=self.bot,
+                ))
             return
 
         game_rows = await self.bot.db.fetchall(
@@ -1635,7 +1734,20 @@ class Engagement(commands.Cog):
             name,
         )
         if not row:
-            await ctx.reply("❌ Tournament not found." if lang != "ar" else "❌ البطولة غير موجودة.")
+            if lang == "ar":
+                await ctx.reply(embed=await idle_embed_for_guild(
+                    "البطولة غير متاحة",
+                    "لا توجد بطولة بهذا الاسم حالياً.",
+                    guild=ctx.guild,
+                    bot=self.bot,
+                ))
+            else:
+                await ctx.reply(embed=await idle_embed_for_guild(
+                    "Tournament Not Found",
+                    "No tournament exists with that name right now.",
+                    guild=ctx.guild,
+                    bot=self.bot,
+                ))
             return
         if lang == "ar":
             msg = (
@@ -1662,9 +1774,19 @@ class Engagement(commands.Cog):
         )
         if not rows:
             if lang == "ar":
-                await ctx.reply("🏆 لا يوجد فائزون بالبطولات بعد.")
+                await ctx.reply(embed=await idle_embed_for_guild(
+                    "لوحة البطولات الخاملة",
+                    "لا يوجد فائزون مسجلون حتى الآن.",
+                    guild=ctx.guild,
+                    bot=self.bot,
+                ))
             else:
-                await ctx.reply("🏆 No tournament winners yet.")
+                await ctx.reply(embed=await idle_embed_for_guild(
+                    "Tournament Leaderboard Idle",
+                    "No tournament winners are recorded yet.",
+                    guild=ctx.guild,
+                    bot=self.bot,
+                ))
             return
             
         lines = []

bot/cogs/events.py

@@ -4,6 +4,7 @@ import asyncio
 import base64
 import datetime as dt
 import hashlib
+import io
 import json
 import os
 import re
@@ -28,15 +29,23 @@ try:
 except Exception:  # pragma: no cover
     genai = None
 
+try:
+    from PIL import Image, ImageFilter, ImageStat
+except Exception:  # pragma: no cover
+    Image = None
+    ImageFilter = None
+    ImageStat = None
+
 BAD_WORDS = {"badword1", "badword2", "badword3"}
 SCAM_LINK_RE = re.compile(r"(https?://\S+|discord\.gg/\S+|t\.me/\S+)", re.IGNORECASE)
 SCAM_SYSTEM_PROMPT = """You are a strict Discord anti-scam classifier specialized in detecting:
 1. Low-quality scam images (blurry, pixelated, poor compression)
 2. Fake giveaways and fraudulent offers
-3. Phishing attempts and social engineering
-4. Misleading or deceptive content
+3. Celebrity/creator impersonation scams (example: MrBeast giveaway, fake verified pages)
+4. Phishing attempts and social engineering
+5. Misleading/deceptive content (wallet verification, Telegram/WhatsApp contact, urgent claim flow)
 
-Analyze the image quality, text content, and context carefully.
+Analyze image text, logos, badges, links/handles, and context carefully.
 Reply ONLY TRUE (if scam) or FALSE (if safe)."""
 
 SCAM_CALL_TO_ACTION_RE = re.compile(
@@ -45,7 +54,7 @@ SCAM_CALL_TO_ACTION_RE = re.compile(
     re.IGNORECASE,
 )
 SCAM_KEYWORDS_RE = re.compile(
-    r"\b(free money|free nitro|crypto|airdrop|giveaway|gift card|usdt|btc|eth|investment|"
+    r"\b(free money|free nitro|crypto|airdrop|giveaway|gift card|usdt|btc|eth|investment|mrbeast|mr beast|"
     r"ربح مجاني|نيترو مجاني|كريبتو|هدية|هدايا|قسيمة|استثمار|محفظة)\b",
     re.IGNORECASE,
 )
@@ -64,6 +73,21 @@ BENIGN_DM_RE = re.compile(
     r"راسلني إذا|راسلني للمساعدة|خاص للمساعدة)\b",
     re.IGNORECASE,
 )
+CUSTOM_EMOJI_RE = re.compile(r"<a?:[A-Za-z0-9_~\-]{2,32}:\d{6,}>")
+UNICODE_EMOJI_RE = re.compile(
+    r"[\U0001F1E6-\U0001F1FF]"  # flags
+    r"|[\U0001F300-\U0001FAFF]"  # symbols & pictographs
+    r"|[\u2600-\u27BF]"          # dingbats/misc
+)
+SCAM_LURE_EMOJIS = {
+    "🎁", "💰", "💸", "🏆", "🚀", "🔥", "✅", "💎", "🔗", "🎉", "🪙", "📈", "💳", "💵", "🤑"
+}
+SCAM_PRESSURE_EMOJIS = {"⚠️", "⏰", "🚨", "❗", "‼️", "⌛"}
+OCR_SCAM_RE = re.compile(
+    r"\b(mrbeast|mr beast|giveaway|airdrop|free|claim|winner|verify wallet|wallet|crypto|usdt|btc|eth|"
+    r"telegram|whatsapp|dm me|join now|limited time|urgent|bit\.ly|tinyurl)\b",
+    re.IGNORECASE,
+)
 
 
 
@@ -72,6 +96,8 @@ class Events(commands.Cog):
         self.bot = bot
         self._scam_scan_semaphore = asyncio.Semaphore(4)
         self._recent_user_messages: dict[tuple[int, int], deque[tuple[float, str]]] = defaultdict(lambda: deque(maxlen=8))
+        self._recent_user_context: dict[tuple[int, int], deque[tuple[float, int, str, list[str]]]] = defaultdict(lambda: deque(maxlen=40))
+        self._last_context_ai_check: dict[tuple[int, int], float] = {}
         self._gemini_key = (os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY") or "").strip()
         if self._gemini_key and genai is not None:
             try:
@@ -197,6 +223,149 @@ class Events(commands.Cog):
             reasons.append("benign dm-context detected")
         return (score, reasons)
 
+    @staticmethod
+    def _extract_emojis(content: str) -> list[str]:
+        text = (content or "").strip()
+        if not text:
+            return []
+        custom = CUSTOM_EMOJI_RE.findall(text)
+        # Keep unicode emoji extraction approximate but fast.
+        unicode_hits = UNICODE_EMOJI_RE.findall(text)
+        return custom + unicode_hits
+
+    def _emoji_scam_heuristics(self, content: str, emojis: list[str]) -> tuple[int, list[str]]:
+        if not emojis:
+            return (0, [])
+        text = (content or "").strip().lower()
+        score = 0
+        reasons: list[str] = []
+
+        lure_count = sum(1 for e in emojis if e in SCAM_LURE_EMOJIS)
+        pressure_count = sum(1 for e in emojis if e in SCAM_PRESSURE_EMOJIS)
+        has_link = bool(SCAM_LINK_RE.search(text))
+        has_cta = bool(SCAM_CALL_TO_ACTION_RE.search(text))
+        has_keyword = bool(SCAM_KEYWORDS_RE.search(text))
+
+        if lure_count >= 2:
+            score += 2
+            reasons.append("multiple lure emojis")
+        if pressure_count >= 1:
+            score += 1
+            reasons.append("urgency/pressure emojis")
+        if len(emojis) >= 6:
+            score += 1
+            reasons.append("emoji-heavy promotional style")
+        if has_link and (lure_count >= 1 or pressure_count >= 1):
+            score += 2
+            reasons.append("link + lure/pressure emojis")
+        if has_cta and (lure_count >= 1 or has_keyword):
+            score += 2
+            reasons.append("cta + emoji bait")
+        if has_keyword and lure_count >= 1:
+            score += 2
+            reasons.append("financial/scam keywords + emoji bait")
+        return (score, reasons)
+
+    async def _shield_level(self, guild_id: int) -> str:
+        row = await self.bot.db.fetchone("SELECT level FROM shield_settings WHERE guild_id = ?", guild_id)
+        level = str(row[0]).strip().lower() if row and row[0] else "medium"
+        if level not in {"low", "medium", "high"}:
+            return "medium"
+        return level
+
+    @staticmethod
+    def _context_window_seconds(level: str) -> int:
+        if level == "high":
+            return 6 * 60 * 60
+        if level == "low":
+            return 90 * 60
+        return 3 * 60 * 60
+
+    @staticmethod
+    def _context_check_cooldown_seconds(level: str) -> int:
+        if level == "high":
+            return 8
+        if level == "low":
+            return 25
+        return 15
+
+    def _build_recent_context(self, guild_id: int, user_id: int, *, now_ts: float, horizon_seconds: int) -> list[tuple[float, int, str, list[str]]]:
+        key = (guild_id, user_id)
+        bucket = self._recent_user_context[key]
+        return [entry for entry in bucket if (now_ts - entry[0]) <= horizon_seconds]
+
+    async def _openrouter_contextual_scam_verdict(
+        self,
+        message: discord.Message,
+        *,
+        emojis: list[str],
+        stitched_text: str,
+        emoji_score: int,
+        emoji_reasons: list[str],
+    ) -> bool:
+        api_key = (self.bot.settings.openrouter_api_key or "").strip()
+        if not api_key or aiohttp is None:
+            return False
+
+        level = await self._shield_level(message.guild.id)
+        now_ts = time.time()
+        key = (message.guild.id, message.author.id)
+        cooldown = self._context_check_cooldown_seconds(level)
+        if (now_ts - self._last_context_ai_check.get(key, 0.0)) < cooldown:
+            return False
+        self._last_context_ai_check[key] = now_ts
+
+        horizon = self._context_window_seconds(level)
+        context_rows = self._build_recent_context(message.guild.id, message.author.id, now_ts=now_ts, horizon_seconds=horizon)
+        context_rows = context_rows[-20:]  # keep prompt bounded
+
+        context_lines: list[str] = []
+        for ts, channel_id, text, row_emojis in context_rows:
+            delta_min = int(max(0, now_ts - ts) // 60)
+            compact_text = (text or "").replace("\n", " ").strip()[:220]
+            emoji_str = " ".join(row_emojis[:10]) if row_emojis else "-"
+            context_lines.append(f"[{delta_min}m ago][#{channel_id}] text={compact_text} | emojis={emoji_str}")
+
+        prompt = (
+            "You are a Discord anti-scam contextual classifier.\n"
+            "Goal: detect hacked-account scam campaigns and phishing even when messages are separated over time.\n"
+            "Treat repeated lure emojis + links/CTA + fake rewards/wallet verification as high risk.\n"
+            "Do not flag harmless emoji-only chatting.\n"
+            "Reply with one word only: SCAM or SAFE.\n\n"
+            f"Guild shield level: {level}\n"
+            f"Current message text: {(message.content or '').strip()[:1200]}\n"
+            f"Current message emojis: {' '.join(emojis[:30]) if emojis else '-'}\n"
+            f"Emoji heuristic score: {emoji_score} ({', '.join(emoji_reasons) if emoji_reasons else 'none'})\n"
+            f"Recent stitched text: {stitched_text[:1200] if stitched_text else '-'}\n\n"
+            "Recent same-user context (can be different channels/time):\n"
+            + ("\n".join(context_lines) if context_lines else "-")
+        )
+
+        payload = {
+            "model": (self.bot.settings.openrouter_model or "").strip() or "meta-llama/llama-3.3-70b-instruct:free",
+            "messages": [
+                {"role": "system", "content": "Classify as SCAM or SAFE only."},
+                {"role": "user", "content": prompt},
+            ],
+            "temperature": 0,
+        }
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        }
+
+        try:
+            async with self._scam_scan_semaphore:
+                async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=18)) as session:
+                    async with session.post("https://openrouter.ai/api/v1/chat/completions", json=payload, headers=headers) as resp:
+                        if resp.status >= 400:
+                            return False
+                        data = await resp.json(content_type=None)
+            verdict = str((((data.get("choices") or [{}])[0].get("message") or {}).get("content") or "")).strip().upper()
+            return "SCAM" in verdict and "SAFE" not in verdict
+        except Exception:
+            return False
+
     async def _log_image_scan(self, message: discord.Message, result: str, detail: str) -> None:
         try:
             await self.send_log(
@@ -208,17 +377,30 @@ class Events(commands.Cog):
         except Exception:
             return
 
-    async def _image_bytes_from_text_urls(self, content: str) -> list[bytes]:
+    async def _store_scam_hash(self, guild_id: int, digest: str, *, created_by: int = 0) -> None:
+        if not digest:
+            return
+        try:
+            await self.bot.db.execute(
+                "INSERT OR IGNORE INTO scam_images(guild_id, image_hash, created_by) VALUES (?, ?, ?)",
+                guild_id,
+                digest,
+                created_by,
+            )
+        except Exception:
+            return
+
+    async def _image_items_from_text_urls(self, content: str) -> list[tuple[str, bytes, str]]:
         if aiohttp is None:
             return []
         urls = re.findall(r"https?://\S+", content or "")
         image_urls = [u.rstrip(").,!?") for u in urls if re.search(r"\.(png|jpg|jpeg|webp|gif)(\?|$)", u, re.IGNORECASE)]
         if not image_urls:
             return []
-        out: list[bytes] = []
+        out: list[tuple[str, bytes, str]] = []
         timeout = aiohttp.ClientTimeout(total=8)
         async with aiohttp.ClientSession(timeout=timeout) as session:
-            for url in image_urls[:2]:
+            for url in image_urls[:3]:
                 try:
                     async with session.get(url) as resp:
                         if resp.status >= 400:
@@ -227,12 +409,169 @@ class Events(commands.Cog):
                         if "image/" not in ctype:
                             continue
                         data = await resp.read()
-                        if data:
-                            out.append(data[:2_000_000])
+                        if not data:
+                            continue
+                        raw = data[:2_000_000]
+                        digest = hashlib.sha256(raw).hexdigest()
+                        out.append((url, raw, digest))
                 except Exception:
                     continue
         return out
 
+    async def _image_bytes_from_text_urls(self, content: str) -> list[bytes]:
+        return [raw for _, raw, _ in await self._image_items_from_text_urls(content)]
+
+    @staticmethod
+    def _image_quality_heuristics(images: list[bytes]) -> tuple[int, list[str], dict[str, float | int]]:
+        if not images:
+            return (0, [], {})
+        if Image is None or ImageFilter is None or ImageStat is None:
+            return (0, [], {})
+
+        score = 0
+        reasons: list[str] = []
+        total_pixels = 0
+        total_bytes = 0
+        min_dim = None
+        edge_mean_avg = 0.0
+        analyzed = 0
+
+        for raw in images[:4]:
+            try:
+                with Image.open(io.BytesIO(raw)) as img:
+                    img.load()
+                    w, h = img.size
+                    if w <= 0 or h <= 0:
+                        continue
+                    analyzed += 1
+                    total_pixels += (w * h)
+                    total_bytes += len(raw)
+                    md = min(w, h)
+                    min_dim = md if min_dim is None else min(min_dim, md)
+
+                    gray = img.convert("L")
+                    edges = gray.filter(ImageFilter.FIND_EDGES)
+                    st = ImageStat.Stat(edges)
+                    edge_mean = float(st.mean[0]) if st.mean else 0.0
+                    edge_mean_avg += edge_mean
+            except Exception:
+                continue
+
+        if analyzed == 0 or total_pixels <= 0:
+            return (0, [], {})
+
+        mp = total_pixels / 1_000_000.0
+        bpp = total_bytes / float(total_pixels)
+        edge_mean_avg = edge_mean_avg / analyzed if analyzed else 0.0
+
+        if mp < 0.45 or (min_dim is not None and min_dim < 520):
+            score += 2
+            reasons.append("low resolution image quality")
+        if edge_mean_avg < 11.0:
+            score += 2
+            reasons.append("blurry/soft edges (likely low quality)")
+        if bpp < 0.16:
+            score += 1
+            reasons.append("high compression artifacts likely")
+
+        metrics: dict[str, float | int] = {
+            "analyzed_images": analyzed,
+            "megapixels": round(mp, 3),
+            "bytes_per_pixel": round(bpp, 4),
+            "edge_mean": round(edge_mean_avg, 3),
+            "min_dimension": int(min_dim or 0),
+        }
+        return (score, reasons, metrics)
+
+    @staticmethod
+    def _ocr_scam_heuristics(ocr_text: str) -> tuple[int, list[str]]:
+        text = (ocr_text or "").strip().lower()
+        if not text:
+            return (0, [])
+        reasons: list[str] = []
+        score = 0
+
+        hits = OCR_SCAM_RE.findall(text)
+        hit_count = len(hits)
+        if hit_count >= 2:
+            score += 2
+            reasons.append("ocr contains multiple scam terms")
+        if ("verify" in text and "wallet" in text) or "verify wallet" in text:
+            score += 2
+            reasons.append("ocr indicates wallet verification flow")
+        if ("mrbeast" in text or "mr beast" in text) and ("giveaway" in text or "free" in text or "winner" in text):
+            score += 2
+            reasons.append("ocr indicates creator impersonation giveaway")
+        if ("bit.ly" in text or "tinyurl" in text) and ("claim" in text or "winner" in text or "free" in text):
+            score += 1
+            reasons.append("short-link + prize phrasing in ocr")
+
+        return (score, reasons)
+
+    async def _openrouter_extract_image_text(self, message: discord.Message, *, preloaded_images: list[bytes] | None = None) -> str:
+        api_key = (self.bot.settings.openrouter_api_key or "").strip()
+        if not api_key or aiohttp is None:
+            return ""
+
+        images: list[bytes] = []
+        if preloaded_images:
+            images.extend(preloaded_images[:3])
+        else:
+            for att in message.attachments[:3]:
+                if not ((att.content_type or "").startswith("image/")):
+                    continue
+                try:
+                    raw = await att.read(use_cached=True)
+                    if raw:
+                        images.append(raw[:2_000_000])
+                except Exception:
+                    continue
+            if not images:
+                images.extend((await self._image_bytes_from_text_urls(message.content or ""))[:3])
+
+        if not images:
+            return ""
+
+        content_parts: list[dict] = [
+            {
+                "type": "text",
+                "text": (
+                    "Extract all visible text from these images (OCR). "
+                    "Return plain text only. Keep URLs, @handles, numbers, and symbols exactly if visible."
+                ),
+            }
+        ]
+        for raw in images[:3]:
+            try:
+                data_url = "data:image/png;base64," + base64.b64encode(raw[:2_000_000]).decode("utf-8")
+                content_parts.append({"type": "image_url", "image_url": {"url": data_url}})
+            except Exception:
+                continue
+
+        payload = {
+            "model": "meta-llama/llama-3.2-11b-vision-instruct:free",
+            "messages": [
+                {"role": "system", "content": "You are OCR. Return extracted text only."},
+                {"role": "user", "content": content_parts},
+            ],
+            "temperature": 0,
+        }
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        }
+
+        try:
+            async with self._scam_scan_semaphore:
+                async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=20)) as session:
+                    async with session.post("https://openrouter.ai/api/v1/chat/completions", json=payload, headers=headers) as resp:
+                        if resp.status >= 400:
+                            return ""
+                        data = await resp.json(content_type=None)
+            return str((((data.get("choices") or [{}])[0].get("message") or {}).get("content") or "")).strip()
+        except Exception:
+            return ""
+
     async def _analyze_scam_with_openrouter(self, message: discord.Message) -> bool:
         if aiohttp is None or not self.bot.settings.openrouter_api_key:
             return False
@@ -242,7 +581,18 @@ class Events(commands.Cog):
             "meta-llama/llama-3.2-11b-vision-instruct:free",
             "nvidia/llama-3.1-nemotron-nano-vl-8b-v1:free",
         ]
-        score, reasons = self._scam_heuristics(message.content or "", has_images=bool(message.attachments))
+        has_url_images = bool(re.search(r"https?://\S+\.(png|jpg|jpeg|webp|gif)(\?|$)", message.content or "", re.IGNORECASE))
+        score, reasons = self._scam_heuristics(message.content or "", has_images=bool(message.attachments) or has_url_images)
+        level = await self._shield_level(message.guild.id)
+        now_ts = time.time()
+        horizon = self._context_window_seconds(level)
+        recent_rows = self._build_recent_context(message.guild.id, message.author.id, now_ts=now_ts, horizon_seconds=horizon)
+        recent_lines: list[str] = []
+        for ts, channel_id, text, row_emojis in recent_rows[-12:]:
+            delta_min = int(max(0, now_ts - ts) // 60)
+            compact_text = (text or "").replace("\n", " ").strip()[:180]
+            emoji_str = " ".join(row_emojis[:8]) if row_emojis else "-"
+            recent_lines.append(f"[{delta_min}m][#{channel_id}] {compact_text} | emojis={emoji_str}")
         base_text = (
             "You are an advanced scam detector for Discord specialized in identifying:\n"
             "1. LOW-QUALITY IMAGES: Blurry, pixelated, heavily compressed, or distorted images are HIGH RISK\n"
@@ -251,7 +601,9 @@ class Events(commands.Cog):
             "4. SOCIAL ENGINEERING: Impersonation, urgency tactics, pressure to act quickly\n\n"
             "IMPORTANT: Low image quality + suspicious content = ALMOST ALWAYS SCAM\n\n"
             f"Heuristic analysis: score={score}/10, reasons: {', '.join(reasons) if reasons else 'none'}.\n\n"
-            f"Message content:\n{(message.content or '')[:2000]}"
+            f"Message content:\n{(message.content or '')[:2000]}\n\n"
+            "Recent same-user context (for delayed scam campaigns):\n"
+            f"{chr(10).join(recent_lines) if recent_lines else '-'}"
         )
         content_parts: list[dict] = [{"type": "text", "text": base_text}]
         image_count = 0
@@ -265,6 +617,14 @@ class Events(commands.Cog):
                 image_count += 1
             except Exception:
                 continue
+        url_images = await self._image_bytes_from_text_urls(message.content or "")
+        for raw in url_images[:3]:
+            try:
+                data_url = "data:image/png;base64," + base64.b64encode(raw[:2_000_000]).decode("utf-8")
+                content_parts.append({"type": "image_url", "image_url": {"url": data_url}})
+                image_count += 1
+            except Exception:
+                continue
         if image_count == 0 and not message.content.strip():
             return False
 
@@ -302,11 +662,23 @@ class Events(commands.Cog):
             return False
         try:
             model = genai.GenerativeModel("gemini-1.5-flash")
+            level = await self._shield_level(message.guild.id)
+            now_ts = time.time()
+            horizon = self._context_window_seconds(level)
+            recent_rows = self._build_recent_context(message.guild.id, message.author.id, now_ts=now_ts, horizon_seconds=horizon)
+            recent_lines: list[str] = []
+            for ts, channel_id, text, row_emojis in recent_rows[-12:]:
+                delta_min = int(max(0, now_ts - ts) // 60)
+                compact_text = (text or "").replace("\n", " ").strip()[:180]
+                emoji_str = " ".join(row_emojis[:8]) if row_emojis else "-"
+                recent_lines.append(f"[{delta_min}m][#{channel_id}] {compact_text} | emojis={emoji_str}")
             prompt = (
                 "Classify if this Discord message is a scam/phishing attempt.\n"
                 "Use context. Do NOT flag harmless 'dm me' alone.\n"
                 "Reply with TRUE or FALSE only.\n\n"
-                f"Message: {(message.content or '')[:2000]}"
+                f"Message: {(message.content or '')[:2000]}\n\n"
+                "Recent same-user context (for delayed scam campaigns):\n"
+                f"{chr(10).join(recent_lines) if recent_lines else '-'}"
             )
             parts: list = [prompt]
             for att in message.attachments[:3]:
@@ -790,6 +1162,7 @@ class Events(commands.Cog):
         if message.author.bot or not message.guild:
             return
         text_content = message.content or ""
+        emoji_tokens = self._extract_emojis(text_content)
         await self.send_log(
             message.guild,
             "💬 Message Sent",
@@ -801,6 +1174,23 @@ class Events(commands.Cog):
         bucket = self._recent_user_messages[key]
         bucket.append((now_ts, text_content.strip()))
         stitched = " ".join(chunk for ts, chunk in bucket if now_ts - ts <= 90 and chunk)
+        context_bucket = self._recent_user_context[key]
+        context_bucket.append((now_ts, message.channel.id, text_content.strip()[:350], emoji_tokens[:20]))
+
+        level = await self._shield_level(message.guild.id)
+        emoji_score, emoji_reasons = self._emoji_scam_heuristics(text_content, emoji_tokens)
+        emoji_threshold = 3 if level == "low" else (2 if level == "medium" else 1)
+        if emoji_tokens and emoji_score >= emoji_threshold:
+            contextual_scam = await self._openrouter_contextual_scam_verdict(
+                message,
+                emojis=emoji_tokens,
+                stitched_text=stitched,
+                emoji_score=emoji_score,
+                emoji_reasons=emoji_reasons,
+            )
+            if contextual_scam:
+                await self._apply_ai_shield(message, "SCAM")
+                return
 
         if stitched and self._is_high_risk_scam_text(stitched):
             violation = await self._openrouter_shield_violation(stitched)
@@ -811,6 +1201,8 @@ class Events(commands.Cog):
         if message.attachments:
             has_image = any((att.content_type or "").startswith("image/") for att in message.attachments)
             if has_image:
+                attachment_hashes: list[str] = []
+                attachment_images: list[bytes] = []
                 for att in message.attachments:
                     if not (att.content_type or "").startswith("image/"):
                         continue
@@ -819,6 +1211,8 @@ class Events(commands.Cog):
                     except Exception:
                         continue
                     digest = hashlib.sha256(raw).hexdigest()
+                    attachment_hashes.append(digest)
+                    attachment_images.append(raw[:2_000_000])
                     row = await self.bot.db.fetchone(
                         "SELECT image_hash FROM scam_images WHERE guild_id = ? AND image_hash = ?",
                         message.guild.id,
@@ -829,24 +1223,90 @@ class Events(commands.Cog):
                         deleted = await message.channel.purge(limit=15, check=lambda m: m.author.id == message.author.id and m.attachments)
                         await self.send_log(message.guild, "🧹 Scam Image Purge", f"Deleted {len(deleted)} image messages from {message.author.mention}")
                         return
+                quality_score, quality_reasons, quality_metrics = self._image_quality_heuristics(attachment_images)
+                score, reasons = self._scam_heuristics(message.content or "", has_images=True)
+                ocr_text = ""
+                ocr_score = 0
+                ocr_reasons: list[str] = []
+                if score >= 2 or quality_score >= 2:
+                    ocr_text = await self._openrouter_extract_image_text(message, preloaded_images=attachment_images)
+                    ocr_score, ocr_reasons = self._ocr_scam_heuristics(ocr_text)
+
                 is_image_scam = await self._analyze_scam_with_openrouter(message)
                 if not is_image_scam:
                     is_image_scam = await self._analyze_scam_with_gemini(message)
-                score, reasons = self._scam_heuristics(message.content or "", has_images=True)
-                detail = f"heuristic_score={score}; reasons={', '.join(reasons) if reasons else 'none'}; ai_scam={is_image_scam}"
+
+                combined_score = score + quality_score + ocr_score
+                has_direct_scam_cue = bool(
+                    SCAM_LINK_RE.search(message.content or "")
+                    or SCAM_KEYWORDS_RE.search((message.content or "") + " " + (ocr_text or ""))
+                    or ocr_score >= 2
+                )
+                if not is_image_scam and combined_score >= 7 and has_direct_scam_cue:
+                    is_image_scam = True
+
+                quality_text = ", ".join(quality_reasons) if quality_reasons else "none"
+                ocr_snippet = (ocr_text or "").replace("\n", " ")[:180]
+                detail = (
+                    f"heuristic_score={score}; heuristic_reasons={', '.join(reasons) if reasons else 'none'}; "
+                    f"quality_score={quality_score}; quality_reasons={quality_text}; quality_metrics={quality_metrics}; "
+                    f"ocr_score={ocr_score}; ocr_reasons={', '.join(ocr_reasons) if ocr_reasons else 'none'}; "
+                    f"ocr_text={ocr_snippet or 'none'}; combined_score={combined_score}; ai_scam={is_image_scam}"
+                )
                 await self._log_image_scan(message, "SCAM" if is_image_scam else "SAFE", detail)
                 if is_image_scam:
+                    for digest in attachment_hashes:
+                        await self._store_scam_hash(message.guild.id, digest, created_by=(self.bot.user.id if self.bot.user else 0))
                     await self._apply_ai_shield(message, "SCAM")
                     return
         elif re.search(r"https?://\S+\.(png|jpg|jpeg|webp|gif)(\?|$)", message.content or "", re.IGNORECASE):
+            url_items = await self._image_items_from_text_urls(message.content or "")
+            url_hashes = [digest for _, _, digest in url_items]
+            url_images = [raw for _, raw, _ in url_items]
+            for digest in url_hashes:
+                row = await self.bot.db.fetchone(
+                    "SELECT image_hash FROM scam_images WHERE guild_id = ? AND image_hash = ?",
+                    message.guild.id,
+                    digest,
+                )
+                if row:
+                    await self._apply_ai_shield(message, "SCAM")
+                    return
             proxy_message = message
+            quality_score, quality_reasons, quality_metrics = self._image_quality_heuristics(url_images)
+            score, reasons = self._scam_heuristics(message.content or "", has_images=True)
+            ocr_text = ""
+            ocr_score = 0
+            ocr_reasons: list[str] = []
+            if score >= 2 or quality_score >= 2:
+                ocr_text = await self._openrouter_extract_image_text(proxy_message, preloaded_images=url_images)
+                ocr_score, ocr_reasons = self._ocr_scam_heuristics(ocr_text)
+
             is_image_scam = await self._analyze_scam_with_openrouter(proxy_message)
             if not is_image_scam:
                 is_image_scam = await self._analyze_scam_with_gemini(proxy_message)
-            score, reasons = self._scam_heuristics(message.content or "", has_images=True)
-            detail = f"url_image_scan=1; heuristic_score={score}; reasons={', '.join(reasons) if reasons else 'none'}; ai_scam={is_image_scam}"
+
+            combined_score = score + quality_score + ocr_score
+            has_direct_scam_cue = bool(
+                SCAM_LINK_RE.search(message.content or "")
+                or SCAM_KEYWORDS_RE.search((message.content or "") + " " + (ocr_text or ""))
+                or ocr_score >= 2
+            )
+            if not is_image_scam and combined_score >= 7 and has_direct_scam_cue:
+                is_image_scam = True
+
+            quality_text = ", ".join(quality_reasons) if quality_reasons else "none"
+            ocr_snippet = (ocr_text or "").replace("\n", " ")[:180]
+            detail = (
+                f"url_image_scan=1; heuristic_score={score}; heuristic_reasons={', '.join(reasons) if reasons else 'none'}; "
+                f"quality_score={quality_score}; quality_reasons={quality_text}; quality_metrics={quality_metrics}; "
+                f"ocr_score={ocr_score}; ocr_reasons={', '.join(ocr_reasons) if ocr_reasons else 'none'}; "
+                f"ocr_text={ocr_snippet or 'none'}; combined_score={combined_score}; ai_scam={is_image_scam}"
+            )
             await self._log_image_scan(message, "SCAM" if is_image_scam else "SAFE", detail)
             if is_image_scam:
+                for digest in url_hashes:
+                    await self._store_scam_hash(message.guild.id, digest, created_by=(self.bot.user.id if self.bot.user else 0))
                 await self._apply_ai_shield(message, "SCAM")
                 return
         if self._is_high_risk_scam_text(text_content):
@@ -919,10 +1379,26 @@ class Events(commands.Cog):
             elif mention_type == "role" and role_id:
                 mention = f"<@&{role_id}> "
             for item in fresh[:3]:
-                embed = discord.Embed(title=item.get("title", ""), url=item.get("url", ""), color=NEON_CYAN)
+                link = item.get("link", "")
+                embed = discord.Embed(
+                    title=f"🎁 Free Game Drop: {item.get('title', '')}",
+                    url=link,
+                    color=NEON_CYAN,
+                    description=(
+                        f"**{item.get('description', 'Limited-time free game offer!')}**\n\n"
+                        f"Grab it before the offer expires."
+                    ),
+                )
                 if item.get("image"):
                     embed.set_image(url=item["image"])
-                view = None
+                embed.set_thumbnail(url=self._store_icon(item.get("platform", "")))
+                embed.add_field(name="🏪 Platform", value=item.get("platform", "Unknown"), inline=True)
+                embed.add_field(name="🧩 Type", value=item.get("game_type", "Game"), inline=True)
+                embed.add_field(name="💸 Previous Price", value=item.get("original_price", "N/A"), inline=True)
+                embed.add_field(name="⏳ Offer Ends", value=item.get("end_date", "N/A"), inline=True)
+                embed.add_field(name="🔗 Claim Link", value=f"[Open Giveaway]({link})" if link else "N/A", inline=True)
+                embed.set_footer(text="BOT- Free Games Radar • Epic / Steam / GOG")
+                view = FreeGameClaimView(link, item.get("id", "")) if link else None
                 await channel.send(content=mention or None, embed=embed, view=view)
             latest_ids = ",".join(item["id"] for item in items[:20])
             await self.bot.db.execute(

bot/cogs/fun.py

@@ -605,14 +605,19 @@ class Fun(commands.Cog):
         link = item["link"]
         embed = ImperialMotaz.craft_embed(
             title=f"[FREE GAME] | {title}",
-            description="Live free-game deal from trusted store.",
+            description=(
+                f"**{item.get('description', 'Limited-time free game offer!')}**\n\n"
+                "Claim it now from the official store page before it expires."
+            ),
             color=NEON_PINK,
             footer="Free Games Tracker",
         )
         embed.url = link
         embed.add_field(name="Platform", value=f"「 {item.get('platform', 'Unknown')} 」", inline=True)
+        embed.add_field(name="Type", value=f"「 {item.get('game_type', 'Game')} 」", inline=True)
         embed.add_field(name="Original Price", value=f"「 {item.get('original_price', 'N/A')} 」", inline=True)
         embed.add_field(name="Ends On", value=f"「 {item.get('end_date', 'N/A')} 」", inline=True)
+        embed.add_field(name="Link", value=f"[Open Giveaway]({link})", inline=False)
         if item.get("image"):
             embed.set_image(url=item["image"])
         embed.set_thumbnail(url=self._store_icon(item.get("platform", "")))
@@ -760,7 +765,7 @@ class Fun(commands.Cog):
 
     @gamehub.command(name="trivia", description="Gaming/Movies/Series trivia")
     async def gamehub_trivia(self, ctx: commands.Context, category: str = "gaming", difficulty: str = "medium") -> None:
-        await self.trivia(ctx, category=category, difficulty=difficulty)
+        await self.trivia(ctx, category=category)
 
     @commands.hybrid_command(name="xo", description="TicTacToe vs member or bot", hidden=True, with_app_command=False)
     async def xo(self, ctx: commands.Context, opponent: discord.Member | None = None) -> None:
@@ -845,7 +850,7 @@ class Fun(commands.Cog):
                 ),
                 color=NEON_ORANGE,
             )
-            embed.add_field(name="🎁 مكافأة", value="تم فتح combo باك مان! 🟡", inline=False)
+            embed.add_field(name="🎁 مكافأة", value="تم فتح combo باك مان! <:animatedarrowyellow:1477261257592668271>", inline=False)
         else:
             embed = discord.Embed(
                 title="🍄 Arcade Challenge",
@@ -857,7 +862,7 @@ class Fun(commands.Cog):
                 ),
                 color=NEON_ORANGE,
             )
-            embed.add_field(name="🎁 Bonus", value="Pac-Man combo unlocked! 🟡", inline=False)
+            embed.add_field(name="🎁 Bonus", value="Pac-Man combo unlocked! <:animatedarrowyellow:1477261257592668271>", inline=False)
         embed.set_thumbnail(url="https://upload.wikimedia.org/wikipedia/en/a/a9/MarioNSMBUDeluxe.png")
         await ctx.reply(embed=embed)
 

bot/cogs/gambling.py

@@ -1,771 +1,689 @@
-"""
-Interactive Gambling & RPG Cog - Casino Games with UI and Full RPG System
-"""
-
-from __future__ import annotations
-
-import random
-import asyncio
-from typing import List, Optional, Dict
-
-import discord
-from discord.ext import commands
-
-from bot.theme import NEON_CYAN, NEON_LIME, NEON_RED, NEON_GOLD, NEON_PURPLE, NEON_PINK, NEON_BLUE, panel_divider, add_banner_to_embed
-from bot.emojis import ui
-
-
-class Card:
-    def __init__(self, suit: str, rank: str):
-        self.suit = suit
-        self.rank = rank
-        self.value = self._get_value()
-    
-    def _get_value(self) -> int:
-        if self.rank in ['J', 'Q', 'K']:
-            return 10
-        elif self.rank == 'A':
-            return 11
-        else:
-            return int(self.rank)
-    
-    def __str__(self) -> str:
-        return f"{self.rank}{self.suit}"
-
-
-class Deck:
-    def __init__(self):
-        self.cards = []
-        suits = ['♠', '♥', '♦', '♣']
-        ranks = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
-        for suit in suits:
-            for rank in ranks:
-                self.cards.append(Card(suit, rank))
-        random.shuffle(self.cards)
-    
-    def draw(self) -> Card:
-        return self.cards.pop()
-
-
-class BlackjackView(discord.ui.View):
-    def __init__(self, cog, guild_id: int, user_id: int, bet: int):
-        super().__init__(timeout=300)
-        self.cog = cog
-        self.guild_id = guild_id
-        self.user_id = user_id
-        self.bet = bet
-        self.deck = Deck()
-        self.player_hand = [self.deck.draw(), self.deck.draw()]
-        self.dealer_hand = [self.deck.draw(), self.deck.draw()]
-        self.game_over = False
-        self.message: Optional[discord.Message] = None
-    
-    def hand_value(self, hand: List[Card]) -> int:
-        value = sum(card.value for card in hand)
-        aces = sum(1 for card in hand if card.rank == 'A')
-        while value > 21 and aces:
-            value -= 10
-            aces -= 1
-        return value
-    
-    def format_hand(self, hand: List[Card], hide_first: bool = False) -> str:
-        if hide_first and len(hand) >= 2:
-            return f"[❓❓] [{hand[1]}]"
-        return ' '.join([f"[{str(card)}]" for card in hand])
-    
-    def build_embed(self, show_dealer_card: bool = True) -> discord.Embed:
-        player_value = self.hand_value(self.player_hand)
-        dealer_value = self.hand_value(self.dealer_hand) if show_dealer_card else '?'
-        
-        embed = discord.Embed(
-            title="🃏 Blackjack Casino",
-            description=panel_divider('purple'),
-            color=NEON_PURPLE,
-        )
-        
-        dealer_display = self.format_hand(self.dealer_hand, hide_first=not show_dealer_card)
-        embed.add_field(
-            name="🎩 Dealer's Hand",
-            value=f"{dealer_display}\n**Value:** {dealer_value}",
-            inline=False,
-        )
-        
-        player_display = self.format_hand(self.player_hand)
-        embed.add_field(
-            name="👤 Your Hand",
-            value=f"{player_display}\n**Value:** {player_value}",
-            inline=False,
-        )
-        
-        embed.add_field(name="💰 Bet", value=f"`{self.bet:,}` coins", inline=False)
-        
-        if self.game_over:
-            if player_value > 21:
-                embed.description = f"❌ **BUST!** You lost `{self.bet:,}` coins."
-                embed.color = NEON_RED
-            elif dealer_value == 21 and len(self.dealer_hand) == 2:
-                embed.description = f"❌ **Dealer Blackjack!** You lost `{self.bet:,}` coins."
-                embed.color = NEON_RED
-            elif dealer_value > 21:
-                winnings = self.bet
-                embed.description = f"✅ **Dealer Busts! You Win!** +`{winnings:,}` coins!"
-                embed.color = NEON_LIME
-            elif player_value > dealer_value:
-                winnings = self.bet
-                embed.description = f"✅ **You Win!** +`{winnings:,}` coins!"
-                embed.color = NEON_LIME
-            elif player_value < dealer_value:
-                embed.description = f"❌ **Dealer Wins!** You lost `{self.bet:,}` coins."
-                embed.color = NEON_RED
-            else:
-                embed.description = f"🤝 **Push!** Bet returned."
-                embed.color = NEON_GOLD
-        
-        return embed
-    
-    async def end_game(self, interaction: discord.Interaction):
-        self.game_over = True
-        
-        engagement_cog = interaction.bot.get_cog("Engagement")
-        if not engagement_cog:
-            return
-        
-        player_value = self.hand_value(self.player_hand)
-        dealer_value = self.hand_value(self.dealer_hand)
-        
-        if player_value > 21:
-            await engagement_cog._remove_coins(self.guild_id, self.user_id, self.bet)
-        elif dealer_value == 21 and len(self.dealer_hand) == 2:
-            await engagement_cog._remove_coins(self.guild_id, self.user_id, self.bet)
-        elif dealer_value > 21 or player_value > dealer_value:
-            await engagement_cog._add_coins(self.guild_id, self.user_id, self.bet)
-        elif player_value < dealer_value:
-            await engagement_cog._remove_coins(self.guild_id, self.user_id, self.bet)
-        
-        embed = self.build_embed(show_dealer_card=True)
-        for child in self.children:
-            child.disabled = True
-        if self.message:
-            await self.message.edit(embed=embed, view=self)
-    
-    @discord.ui.button(label="Hit", emoji=ui("plus"), style=discord.ButtonStyle.primary, custom_id="bj_hit")
-    async def hit(self, interaction: discord.Interaction, button: discord.ui.Button):
-        if self.game_over or interaction.user.id != self.user_id:
-            await interaction.response.send_message("❌ Not your game.", ephemeral=True)
-            return
-        
-        self.player_hand.append(self.deck.draw())
-        player_value = self.hand_value(self.player_hand)
-        
-        if player_value > 21:
-            await self.end_game(interaction)
-        else:
-            embed = self.build_embed(show_dealer_card=False)
-            await interaction.response.edit_message(embed=embed, view=self)
-    
-    @discord.ui.button(label="Stand", emoji=ui("stop"), style=discord.ButtonStyle.danger, custom_id="bj_stand")
-    async def stand(self, interaction: discord.Interaction, button: discord.ui.Button):
-        if self.game_over or interaction.user.id != self.user_id:
-            await interaction.response.send_message("❌ Not your game.", ephemeral=True)
-            return
-        
-        while self.hand_value(self.dealer_hand) < 17:
-            self.dealer_hand.append(self.deck.draw())
-        
-        await self.end_game(interaction)
-    
-    @discord.ui.button(label="Double Down", emoji=ui("star"), style=discord.ButtonStyle.success, custom_id="bj_double")
-    async def double_down(self, interaction: discord.Interaction, button: discord.ui.Button):
-        if self.game_over or interaction.user.id != self.user_id:
-            await interaction.response.send_message("❌ Not your game.", ephemeral=True)
-            return
-        
-        if len(self.player_hand) != 2:
-            await interaction.response.send_message("❌ Can only double on first turn.", ephemeral=True)
-            return
-        
-        engagement_cog = interaction.bot.get_cog("Engagement")
-        if not engagement_cog:
-            return
-        
-        row = await interaction.bot.db.fetchone(
-            "SELECT wallet FROM user_balance WHERE guild_id = ? AND user_id = ?",
-            self.guild_id, self.user_id,
-        )
-        wallet = row[0] if row else 0
-        
-        if wallet < self.bet:
-            await interaction.response.send_message("❌ Insufficient funds to double.", ephemeral=True)
-            return
-        
-        self.bet *= 2
-        self.player_hand.append(self.deck.draw())
-        
-        player_value = self.hand_value(self.player_hand)
-        if player_value > 21:
-            await self.end_game(interaction)
-        else:
-            while self.hand_value(self.dealer_hand) < 17:
-                self.dealer_hand.append(self.deck.draw())
-            await self.end_game(interaction)
-
-
-class RouletteGameView(discord.ui.View):
-    def __init__(self, cog, guild_id: int, user_id: int):
-        super().__init__(timeout=300)
-        self.cog = cog
-        self.guild_id = guild_id
-        self.user_id = user_id
-        self.bet_amount = 0
-        self.bet_type = ""
-        self.spinning = False
-    
-    RED_NUMBERS = [1, 3, 5, 7, 9, 12, 14, 16, 18, 19, 21, 23, 25, 27, 30, 32, 34, 36]
-    BLACK_NUMBERS = [2, 4, 6, 8, 10, 11, 13, 15, 17, 20, 22, 24, 26, 28, 29, 31, 33, 35]
-    
-    def get_color(self, number: int) -> str:
-        if number == 0:
-            return "🟢"
-        elif number in self.RED_NUMBERS:
-            return "🔴"
-        else:
-            return "⚫"
-    
-    def build_embed(self, number: Optional[int] = None, won: bool = False, winnings: int = 0) -> discord.Embed:
-        embed = discord.Embed(
-            title="🎰 Roulette Casino",
-            description=panel_divider('gold'),
-            color=NEON_GOLD,
-        )
-        
-        if number is not None:
-            color_emoji = self.get_color(number)
-            embed.add_field(name="🎯 Result", value=f"{color_emoji} **{number}**", inline=False)
-            embed.add_field(name="💰 Bet", value=f"`{self.bet_amount:,}` on {self.bet_type}", inline=True)
-            embed.add_field(name="💵 Result", value=f"`{'+' if won else '-'}{abs(winnings):,}` coins", inline=True)
-            
-            if won:
-                embed.description = f"✅ **You Won!** +`{winnings:,}` coins!"
-                embed.color = NEON_LIME
-            else:
-                embed.description = f"❌ **You Lost!** -`{abs(winnings):,}` coins."
-                embed.color = NEON_RED
-        else:
-            embed.description = "Place your bet and spin the wheel!"
-            grid = ""
-            for i in range(0, 37, 3):
-                if i == 0:
-                    grid += "🟢 **0**  "
-                else:
-                    c1 = "🔴" if i in self.RED_NUMBERS else "⚫"
-                    c2 = "🔴" if (i+1) in self.RED_NUMBERS else "⚫"
-                    c3 = "🔴" if (i+2) in self.RED_NUMBERS else "⚫"
-                    grid += f"{c1} {i}  {c2} {i+1}  {c3} {i+2}\n"
-            embed.add_field(name="🎡 Roulette Wheel", value=f"```\n{grid}```", inline=False)
-        
-        return embed
-    
-    @discord.ui.button(label="Bet Red 🔴", style=discord.ButtonStyle.danger, custom_id="roulette_red")
-    async def bet_red(self, interaction: discord.Interaction, button: discord.ui.Button):
-        await self.prompt_bet(interaction, "red")
-    
-    @discord.ui.button(label="Bet Black ⚫", style=discord.ButtonStyle.gray, custom_id="roulette_black")
-    async def bet_black(self, interaction: discord.Interaction, button: discord.ui.Button):
-        await self.prompt_bet(interaction, "black")
-    
-    @discord.ui.button(label="Bet Even", style=discord.ButtonStyle.primary, custom_id="roulette_even")
-    async def bet_even(self, interaction: discord.Interaction, button: discord.ui.Button):
-        await self.prompt_bet(interaction, "even")
-    
-    @discord.ui.button(label="Bet Odd", style=discord.ButtonStyle.primary, custom_id="roulette_odd")
-    async def bet_odd(self, interaction: discord.Interaction, button: discord.ui.Button):
-        await self.prompt_bet(interaction, "odd")
-    
-    async def prompt_bet(self, interaction: discord.Interaction, bet_type: str):
-        if interaction.user.id != self.user_id:
-            return
-        await interaction.response.send_modal(RouletteBetModal(self.cog, self.guild_id, self.user_id, bet_type))
-
-
-class RouletteBetModal(discord.ui.Modal, title="🎰 Place Your Bet"):
-    bet_amount = discord.ui.TextInput(
-        label="Bet Amount",
-        placeholder="Enter amount (min 10)",
-        required=True,
-        min_length=1,
-        max_length=10,
-    )
-    
-    def __init__(self, cog, guild_id: int, user_id: int, bet_type: str):
-        super().__init__()
-        self.cog = cog
-        self.guild_id = guild_id
-        self.user_id = user_id
-        self.bet_type = bet_type
-    
-    async def on_submit(self, interaction: discord.Interaction) -> None:
-        try:
-            bet = int(self.bet_amount.value.strip())
-        except ValueError:
-            await interaction.response.send_message("❌ Invalid bet amount.", ephemeral=True)
-            return
-        
-        if bet < 10:
-            await interaction.response.send_message("❌ Minimum bet is 10 coins.", ephemeral=True)
-            return
-        
-        engagement_cog = interaction.bot.get_cog("Engagement")
-        if not engagement_cog:
-            await interaction.response.send_message("❌ Economy not available.", ephemeral=True)
-            return
-        
-        row = await interaction.bot.db.fetchone(
-            "SELECT wallet FROM user_balance WHERE guild_id = ? AND user_id = ?",
-            self.guild_id, self.user_id,
-        )
-        wallet = row[0] if row else 0
-        
-        if wallet < bet:
-            await interaction.response.send_message(f"❌ Insufficient funds. You have {wallet:,} coins.", ephemeral=True)
-            return
-        
-        await interaction.response.defer()
-        
-        number = random.randint(0, 36)
-        is_red = number in RouletteGameView.RED_NUMBERS
-        is_black = number in RouletteGameView.BLACK_NUMBERS
-        is_even = number != 0 and number % 2 == 0
-        is_odd = number != 0 and number % 2 == 1
-        
-        won = False
-        multiplier = 2
-        
-        if self.bet_type == 'red' and is_red:
-            won = True
-        elif self.bet_type == 'black' and is_black:
-            won = True
-        elif self.bet_type == 'even' and is_even:
-            won = True
-        elif self.bet_type == 'odd' and is_odd:
-            won = True
-        
-        winnings = bet * multiplier if won else -bet
-        
-        if won:
-            await engagement_cog._add_coins(self.guild_id, self.user_id, winnings)
-        else:
-            await engagement_cog._remove_coins(self.guild_id, self.user_id, bet)
-        
-        view = RouletteGameView(self.cog, self.guild_id, self.user_id)
-        view.bet_amount = bet
-        view.bet_type = self.bet_type
-        embed = view.build_embed(number=number, won=won, winnings=winnings)
-        
-        for child in view.children:
-            child.disabled = False
-        
-        await interaction.followup.send(embed=embed, view=view)
-
-
-class RPGView(discord.ui.View):
-    def __init__(self, cog, guild_id: int, user_id: int):
-        super().__init__(timeout=None)
-        self.cog = cog
-        self.guild_id = guild_id
-        self.user_id = user_id
-        self.adventure_image = "https://images.unsplash.com/photo-1519074069444-1ba4fff66d16?w=500"
-    
-    def build_embed(self, title: str, description: str, color: discord.Color) -> discord.Embed:
-        embed = discord.Embed(
-            title=title,
-            description=description,
-            color=color,
-        )
-        embed.set_image(url=self.adventure_image)
-        return embed
-    
-    @discord.ui.button(label="⚔️ Fight Monster", emoji=ui("game"), style=discord.ButtonStyle.danger, custom_id="rpg_fight")
-    async def fight_monster(self, interaction: discord.Interaction, button: discord.ui.Button):
-        if interaction.user.id != self.user_id:
-            return
-        
-        engagement_cog = interaction.bot.get_cog("Engagement")
-        if not engagement_cog:
-            await interaction.response.send_message("❌ Economy not available.", ephemeral=True)
-            return
-        
-        row = await interaction.bot.db.fetchone(
-            "SELECT level FROM user_xp WHERE guild_id = ? AND user_id = ?",
-            self.guild_id, self.user_id,
-        )
-        level = row[0] if row else 1
-        
-        monsters = [
-            ("Goblin", 50, 100, 20, 40),
-            ("Dragon", 200, 500, 50, 100),
-            ("Skeleton", 30, 80, 15, 30),
-            ("Orc", 80, 200, 25, 50),
-            ("Troll", 150, 350, 40, 80),
-            ("Demon", 300, 600, 60, 120),
-        ]
-        
-        monster_name, min_reward, max_reward, min_xp, max_xp = random.choice(monsters)
-        win_chance = min(0.8, 0.3 + (level * 0.05))
-        won = random.random() < win_chance
-        
-        if won:
-            reward = random.randint(min_reward, max_reward) + (level * 10)
-            xp_gain = random.randint(min_xp, max_xp)
-            await engagement_cog._add_coins(self.guild_id, self.user_id, reward)
-            await engagement_cog.add_xp(self.guild_id, self.user_id, xp_gain)
-            
-            embed = discord.Embed(
-                title="⚔️ RPG Adventure - Victory!",
-                description=f"✅ **You defeated the {monster_name}!**\n\n💰 **+{reward:,} coins**\n⭐ **+{xp_gain} XP**\n📈 Level {level} → {level + (1 if xp_gain > 40 else 0)}",
-                color=NEON_LIME,
-            )
-            embed.set_image(url="https://images.unsplash.com/photo-1535905557558-afc4877a26fc?w=500")
-        else:
-            penalty = random.randint(10, 50) + (level * 5)
-            await engagement_cog._remove_coins(self.guild_id, self.user_id, penalty)
-            
-            embed = discord.Embed(
-                title="⚔️ RPG Adventure - Defeat!",
-                description=f"❌ **The {monster_name} defeated you!**\n\n💀 **-{penalty:,} coins**\n\n💡 Tip: Level up to increase win chance!",
-                color=NEON_RED,
-            )
-            embed.set_image(url="https://images.unsplash.com/photo-1519791883288-dc8bd696e667?w=500")
-        
-        if interaction.guild:
-            await add_banner_to_embed(embed, interaction.guild)
-        
-        await interaction.response.send_message(embed=embed, ephemeral=True)
-    
-    @discord.ui.button(label="🎁 Find Treasure", emoji=ui("gift"), style=discord.ButtonStyle.success, custom_id="rpg_treasure")
-    async def find_treasure(self, interaction: discord.Interaction, button: discord.ui.Button):
-        if interaction.user.id != self.user_id:
-            return
-        
-        engagement_cog = interaction.bot.get_cog("Engagement")
-        if not engagement_cog:
-            await interaction.response.send_message("❌ Economy not available.", ephemeral=True)
-            return
-        
-        found = random.random() < 0.4
-        
-        if found:
-            reward = random.randint(30, 150)
-            await engagement_cog._add_coins(self.guild_id, self.user_id, reward)
-            
-            embed = discord.Embed(
-                title="🎁 Treasure Hunt - Success!",
-                description=f"✅ **You found a hidden treasure!**\n\n💰 **+{reward:,} coins**\n\n🗺️ The treasure map led you to riches!",
-                color=NEON_GOLD,
-            )
-            embed.set_image(url="https://images.unsplash.com/photo-1518709268805-4e9042af9f23?w=500")
-        else:
-            embed = discord.Embed(
-                title="🎁 Treasure Hunt - Nothing Found",
-                description="❌ **No treasure found in this area...**\n\n🗺️ Try exploring a different location next time!",
-                color=NEON_RED,
-            )
-            embed.set_image(url="https://images.unsplash.com/photo-1500353391678-d7b57970d9b2?w=500")
-        
-        if interaction.guild:
-            await add_banner_to_embed(embed, interaction.guild)
-        
-        await interaction.response.send_message(embed=embed, ephemeral=True)
-    
-    @discord.ui.button(label="🏪 Shop", emoji=ui("cart"), style=discord.ButtonStyle.blurple, custom_id="rpg_shop")
-    async def shop(self, interaction: discord.Interaction, button: discord.ui.Button):
-        if interaction.user.id != self.user_id:
-            return
-        
-        embed = discord.Embed(
-            title="🏪 RPG Shop",
-            description=(
-                "Welcome to the shop! Buy items to help in your adventures.\n\n"
-                "🗡️ **Sword** - Increase win chance (Coming Soon)\n"
-                "🛡️ **Shield** - Reduce coin loss on defeat (Coming Soon)\n"
-                "🧪 **Potion** - Heal after battle (Coming Soon)\n"
-                "📜 **Map** - Better treasure finds (Coming Soon)"
-            ),
-            color=NEON_CYAN,
-        )
-        embed.set_image(url="https://images.unsplash.com/photo-1589829545856-d10d557cf95f?w=500")
-        
-        if interaction.guild:
-            await add_banner_to_embed(embed, interaction.guild)
-        
-        await interaction.response.send_message(embed=embed, ephemeral=True)
-    
-    @discord.ui.button(label="📊 Stats", emoji=ui("stats"), style=discord.ButtonStyle.secondary, custom_id="rpg_stats")
-    async def stats(self, interaction: discord.Interaction, button: discord.ui.Button):
-        if interaction.user.id != self.user_id:
-            return
-        
-        engagement_cog = interaction.bot.get_cog("Engagement")
-        if not engagement_cog:
-            return
-        
-        row = await interaction.bot.db.fetchone(
-            "SELECT wallet, bank FROM user_balance WHERE guild_id = ? AND user_id = ?",
-            self.guild_id, self.user_id,
-        )
-        wallet, bank = row if row else (0, 0)
-        
-        xp_row = await interaction.bot.db.fetchone(
-            "SELECT xp, level FROM user_xp WHERE guild_id = ? AND user_id = ?",
-            self.guild_id, self.user_id,
-        )
-        xp, level = xp_row if xp_row else (0, 1)
-        
-        embed = discord.Embed(
-            title="📊 RPG Stats",
-            description=(
-                f"**Level:** {level}\n"
-                f"**XP:** {xp:,}\n"
-                f"**Wallet:** {wallet:,} coins\n"
-                f"**Bank:** {bank:,} coins\n"
-                f"**Total Wealth:** {wallet + bank:,} coins"
-            ),
-            color=NEON_PURPLE,
-        )
-        
-        if interaction.guild:
-            await add_banner_to_embed(embed, interaction.guild)
-        
-        await interaction.response.send_message(embed=embed, ephemeral=True)
-
-
-class GamblingPanelView(discord.ui.View):
-    def __init__(self, cog, guild_id: int, user_id: int):
-        super().__init__(timeout=None)
-        self.cog = cog
-        self.guild_id = guild_id
-        self.user_id = user_id
-    
-    @discord.ui.button(label="🃏 Play Blackjack", emoji=ui("game"), style=discord.ButtonStyle.danger, custom_id="gambling_blackjack")
-    async def play_blackjack(self, interaction: discord.Interaction, button: discord.ui.Button):
-        if interaction.user.id != self.user_id:
-            return
-        await interaction.response.send_modal(BlackjackBetModal(self.cog, self.guild_id, self.user_id))
-    
-    @discord.ui.button(label="🎰 Play Roulette", emoji=ui("game"), style=discord.ButtonStyle.danger, custom_id="gambling_roulette")
-    async def play_roulette(self, interaction: discord.Interaction, button: discord.ui.Button):
-        if interaction.user.id != self.user_id:
-            return
-        view = RouletteGameView(self.cog, self.guild_id, self.user_id)
-        embed = view.build_embed()
-        await interaction.response.send_message(embed=embed, view=view, ephemeral=True)
-    
-    @discord.ui.button(label="⚔️ RPG Adventure", emoji=ui("game"), style=discord.ButtonStyle.success, custom_id="gambling_rpg")
-    async def play_rpg(self, interaction: discord.Interaction, button: discord.ui.Button):
-        if interaction.user.id != self.user_id:
-            return
-        view = RPGView(self.cog, self.guild_id, self.user_id)
-        embed = view.build_embed(
-            title="⚔️ RPG Adventure",
-            description="Choose your action below to begin your adventure!",
-            color=NEON_PURPLE,
-        )
-        await interaction.response.send_message(embed=embed, view=view, ephemeral=True)
-
-
-class BlackjackBetModal(discord.ui.Modal, title="🃏 Place Your Bet"):
-    bet_amount = discord.ui.TextInput(
-        label="Bet Amount",
-        placeholder="Enter amount (min 10)",
-        required=True,
-        min_length=1,
-        max_length=10,
-    )
-    
-    def __init__(self, cog, guild_id: int, user_id: int):
-        super().__init__()
-        self.cog = cog
-        self.guild_id = guild_id
-        self.user_id = user_id
-    
-    async def on_submit(self, interaction: discord.Interaction) -> None:
-        try:
-            bet = int(self.bet_amount.value.strip())
-        except ValueError:
-            await interaction.response.send_message("❌ Invalid bet amount.", ephemeral=True)
-            return
-        
-        if bet < 10:
-            await interaction.response.send_message("❌ Minimum bet is 10 coins.", ephemeral=True)
-            return
-        
-        engagement_cog = interaction.bot.get_cog("Engagement")
-        if not engagement_cog:
-            await interaction.response.send_message("❌ Economy not available.", ephemeral=True)
-            return
-        
-        row = await interaction.bot.db.fetchone(
-            "SELECT wallet FROM user_balance WHERE guild_id = ? AND user_id = ?",
-            self.guild_id, self.user_id,
-        )
-        wallet = row[0] if row else 0
-        
-        if wallet < bet:
-            await interaction.response.send_message(f"❌ Insufficient funds. You have {wallet:,} coins.", ephemeral=True)
-            return
-        
-        view = BlackjackView(self.cog, self.guild_id, self.user_id, bet)
-        embed = view.build_embed(show_dealer_card=False)
-        message = await interaction.channel.send(embed=embed, view=view)
-        view.message = message
-        await interaction.response.send_message("✅ Blackjack game started!", ephemeral=True)
-
-
-class GamblingPanelView(discord.ui.View):
-    def __init__(self, cog, guild_id: int, user_id: int):
-        super().__init__(timeout=None)
-        self.cog = cog
-        self.guild_id = guild_id
-        self.user_id = user_id
-    
-    @discord.ui.button(label="🃏 Play Blackjack", emoji=ui("game"), style=discord.ButtonStyle.danger, custom_id="gambling_blackjack")
-    async def play_blackjack(self, interaction: discord.Interaction, button: discord.ui.Button):
-        if interaction.user.id != self.user_id:
-            return
-        await interaction.response.send_modal(BlackjackBetModal(self.cog, self.guild_id, self.user_id))
-    
-    @discord.ui.button(label="🎰 Play Roulette", emoji=ui("game"), style=discord.ButtonStyle.danger, custom_id="gambling_roulette")
-    async def play_roulette(self, interaction: discord.Interaction, button: discord.ui.Button):
-        if interaction.user.id != self.user_id:
-            return
-        view = RouletteGameView(self.cog, self.guild_id, self.user_id)
-        embed = view.build_embed()
-        await interaction.response.send_message(embed=embed, view=view, ephemeral=True)
-    
-    @discord.ui.button(label="⚔️ RPG Adventure", emoji=ui("game"), style=discord.ButtonStyle.success, custom_id="gambling_rpg")
-    async def play_rpg(self, interaction: discord.Interaction, button: discord.ui.Button):
-        if interaction.user.id != self.user_id:
-            return
-        view = RPGView(self.cog, self.guild_id, self.user_id)
-        embed = view.build_embed(
-            title="⚔️ RPG Adventure",
-            description="Choose your action below to begin your adventure!",
-            color=NEON_PURPLE,
-        )
-        await interaction.response.send_message(embed=embed, view=view, ephemeral=True)
-
-
-class BlackjackBetModal(discord.ui.Modal, title="🃏 Place Your Bet"):
-    bet_amount = discord.ui.TextInput(
-        label="Bet Amount",
-        placeholder="Enter amount (min 10)",
-        required=True,
-        min_length=1,
-        max_length=10,
-    )
-    
-    def __init__(self, cog, guild_id: int, user_id: int):
-        super().__init__()
-        self.cog = cog
-        self.guild_id = guild_id
-        self.user_id = user_id
-    
-    async def on_submit(self, interaction: discord.Interaction) -> None:
-        try:
-            bet = int(self.bet_amount.value.strip())
-        except ValueError:
-            await interaction.response.send_message("❌ Invalid bet amount.", ephemeral=True)
-            return
-        
-        if bet < 10:
-            await interaction.response.send_message("❌ Minimum bet is 10 coins.", ephemeral=True)
-            return
-        
-        engagement_cog = interaction.bot.get_cog("Engagement")
-        if not engagement_cog:
-            await interaction.response.send_message("❌ Economy not available.", ephemeral=True)
-            return
-        
-        row = await interaction.bot.db.fetchone(
-            "SELECT wallet FROM user_balance WHERE guild_id = ? AND user_id = ?",
-            self.guild_id, self.user_id,
-        )
-        wallet = row[0] if row else 0
-        
-        if wallet < bet:
-            await interaction.response.send_message(f"❌ Insufficient funds. You have {wallet:,} coins.", ephemeral=True)
-            return
-        
-        view = BlackjackView(self.cog, self.guild_id, self.user_id, bet)
-        embed = view.build_embed(show_dealer_card=False)
-        message = await interaction.channel.send(embed=embed, view=view)
-        view.message = message
-        await interaction.response.send_message("✅ Blackjack game started!", ephemeral=True)
-
-
+"""
+Interactive Gambling & RPG Cog - Casino Games with UI and Full RPG System
+"""
+
+from __future__ import annotations
+
+import random
+import asyncio
+from typing import List, Optional, Dict
+
+import discord
+from discord.ext import commands
+
+from bot.theme import NEON_CYAN, NEON_LIME, NEON_RED, NEON_GOLD, NEON_PURPLE, NEON_PINK, NEON_BLUE, panel_divider, add_banner_to_embed
+from bot.emojis import ui
+
+
+class Card:
+    def __init__(self, suit: str, rank: str):
+        self.suit = suit
+        self.rank = rank
+        self.value = self._get_value()
+    
+    def _get_value(self) -> int:
+        if self.rank in ['J', 'Q', 'K']:
+            return 10
+        elif self.rank == 'A':
+            return 11
+        else:
+            return int(self.rank)
+    
+    def __str__(self) -> str:
+        return f"{self.rank}{self.suit}"
+
+
+class Deck:
+    def __init__(self):
+        self.cards = []
+        suits = ['♠', '♥', '♦', '♣']
+        ranks = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
+        for suit in suits:
+            for rank in ranks:
+                self.cards.append(Card(suit, rank))
+        random.shuffle(self.cards)
+    
+    def draw(self) -> Card:
+        return self.cards.pop()
+
+
+class BlackjackView(discord.ui.View):
+    def __init__(self, cog, guild_id: int, user_id: int, bet: int):
+        super().__init__(timeout=300)
+        self.cog = cog
+        self.guild_id = guild_id
+        self.user_id = user_id
+        self.bet = bet
+        self.deck = Deck()
+        self.player_hand = [self.deck.draw(), self.deck.draw()]
+        self.dealer_hand = [self.deck.draw(), self.deck.draw()]
+        self.game_over = False
+        self.message: Optional[discord.Message] = None
+    
+    def hand_value(self, hand: List[Card]) -> int:
+        value = sum(card.value for card in hand)
+        aces = sum(1 for card in hand if card.rank == 'A')
+        while value > 21 and aces:
+            value -= 10
+            aces -= 1
+        return value
+    
+    def format_hand(self, hand: List[Card], hide_first: bool = False) -> str:
+        if hide_first and len(hand) >= 2:
+            return f"[❓❓] [{hand[1]}]"
+        return ' '.join([f"[{str(card)}]" for card in hand])
+    
+    def build_embed(self, show_dealer_card: bool = True) -> discord.Embed:
+        player_value = self.hand_value(self.player_hand)
+        dealer_value = self.hand_value(self.dealer_hand) if show_dealer_card else '?'
+        
+        embed = discord.Embed(
+            title="🃏 Blackjack Casino",
+            description=panel_divider('purple'),
+            color=NEON_PURPLE,
+        )
+        
+        dealer_display = self.format_hand(self.dealer_hand, hide_first=not show_dealer_card)
+        embed.add_field(
+            name="🎩 Dealer's Hand",
+            value=f"{dealer_display}\n**Value:** {dealer_value}",
+            inline=False,
+        )
+        
+        player_display = self.format_hand(self.player_hand)
+        embed.add_field(
+            name="👤 Your Hand",
+            value=f"{player_display}\n**Value:** {player_value}",
+            inline=False,
+        )
+        
+        embed.add_field(name="💰 Bet", value=f"`{self.bet:,}` coins", inline=False)
+        
+        if self.game_over:
+            if player_value > 21:
+                embed.description = f"❌ **BUST!** You lost `{self.bet:,}` coins."
+                embed.color = NEON_RED
+            elif dealer_value == 21 and len(self.dealer_hand) == 2:
+                embed.description = f"❌ **Dealer Blackjack!** You lost `{self.bet:,}` coins."
+                embed.color = NEON_RED
+            elif dealer_value > 21:
+                winnings = self.bet
+                embed.description = f"✅ **Dealer Busts! You Win!** +`{winnings:,}` coins!"
+                embed.color = NEON_LIME
+            elif player_value > dealer_value:
+                winnings = self.bet
+                embed.description = f"✅ **You Win!** +`{winnings:,}` coins!"
+                embed.color = NEON_LIME
+            elif player_value < dealer_value:
+                embed.description = f"❌ **Dealer Wins!** You lost `{self.bet:,}` coins."
+                embed.color = NEON_RED
+            else:
+                embed.description = f"🤝 **Push!** Bet returned."
+                embed.color = NEON_GOLD
+        
+        return embed
+    
+    async def end_game(self, interaction: discord.Interaction):
+        self.game_over = True
+        
+        engagement_cog = interaction.client.get_cog("Engagement")
+        if not engagement_cog:
+            return
+        
+        player_value = self.hand_value(self.player_hand)
+        dealer_value = self.hand_value(self.dealer_hand)
+        
+        if player_value > 21:
+            await engagement_cog._remove_coins(self.guild_id, self.user_id, self.bet)
+        elif dealer_value == 21 and len(self.dealer_hand) == 2:
+            await engagement_cog._remove_coins(self.guild_id, self.user_id, self.bet)
+        elif dealer_value > 21 or player_value > dealer_value:
+            await engagement_cog._add_coins(self.guild_id, self.user_id, self.bet)
+        elif player_value < dealer_value:
+            await engagement_cog._remove_coins(self.guild_id, self.user_id, self.bet)
+        
+        embed = self.build_embed(show_dealer_card=True)
+        for child in self.children:
+            child.disabled = True
+        if self.message:
+            await self.message.edit(embed=embed, view=self)
+    
+    @discord.ui.button(label="Hit", emoji=ui("plus"), style=discord.ButtonStyle.primary, custom_id="bj_hit")
+    async def hit(self, interaction: discord.Interaction, button: discord.ui.Button):
+        if self.game_over or interaction.user.id != self.user_id:
+            await interaction.response.send_message("❌ Not your game.", ephemeral=True)
+            return
+        
+        self.player_hand.append(self.deck.draw())
+        player_value = self.hand_value(self.player_hand)
+        
+        if player_value > 21:
+            await self.end_game(interaction)
+        else:
+            embed = self.build_embed(show_dealer_card=False)
+            await interaction.response.edit_message(embed=embed, view=self)
+    
+    @discord.ui.button(label="Stand", emoji=ui("stop"), style=discord.ButtonStyle.danger, custom_id="bj_stand")
+    async def stand(self, interaction: discord.Interaction, button: discord.ui.Button):
+        if self.game_over or interaction.user.id != self.user_id:
+            await interaction.response.send_message("❌ Not your game.", ephemeral=True)
+            return
+        
+        while self.hand_value(self.dealer_hand) < 17:
+            self.dealer_hand.append(self.deck.draw())
+        
+        await self.end_game(interaction)
+    
+    @discord.ui.button(label="Double Down", emoji=ui("star"), style=discord.ButtonStyle.success, custom_id="bj_double")
+    async def double_down(self, interaction: discord.Interaction, button: discord.ui.Button):
+        if self.game_over or interaction.user.id != self.user_id:
+            await interaction.response.send_message("❌ Not your game.", ephemeral=True)
+            return
+        
+        if len(self.player_hand) != 2:
+            await interaction.response.send_message("❌ Can only double on first turn.", ephemeral=True)
+            return
+        
+        engagement_cog = interaction.client.get_cog("Engagement")
+        if not engagement_cog:
+            return
+        
+        row = await interaction.client.db.fetchone(
+            "SELECT wallet FROM user_balance WHERE guild_id = ? AND user_id = ?",
+            self.guild_id, self.user_id,
+        )
+        wallet = row[0] if row else 0
+        
+        if wallet < self.bet:
+            await interaction.response.send_message("❌ Insufficient funds to double.", ephemeral=True)
+            return
+        
+        self.bet *= 2
+        self.player_hand.append(self.deck.draw())
+        
+        player_value = self.hand_value(self.player_hand)
+        if player_value > 21:
+            await self.end_game(interaction)
+        else:
+            while self.hand_value(self.dealer_hand) < 17:
+                self.dealer_hand.append(self.deck.draw())
+            await self.end_game(interaction)
+
+
+class RouletteGameView(discord.ui.View):
+    def __init__(self, cog, guild_id: int, user_id: int):
+        super().__init__(timeout=300)
+        self.cog = cog
+        self.guild_id = guild_id
+        self.user_id = user_id
+        self.bet_amount = 0
+        self.bet_type = ""
+        self.spinning = False
+    
+    RED_NUMBERS = [1, 3, 5, 7, 9, 12, 14, 16, 18, 19, 21, 23, 25, 27, 30, 32, 34, 36]
+    BLACK_NUMBERS = [2, 4, 6, 8, 10, 11, 13, 15, 17, 20, 22, 24, 26, 28, 29, 31, 33, 35]
+    
+    def get_color(self, number: int) -> str:
+        if number == 0:
+            return "<:animatedarrowgreen:1477261279428087979>"
+        elif number in self.RED_NUMBERS:
+            return "🔴"
+        else:
+            return "⚫"
+    
+    def build_embed(self, number: Optional[int] = None, won: bool = False, winnings: int = 0) -> discord.Embed:
+        embed = discord.Embed(
+            title="🎰 Roulette Casino",
+            description=panel_divider('gold'),
+            color=NEON_GOLD,
+        )
+        
+        if number is not None:
+            color_emoji = self.get_color(number)
+            embed.add_field(name="🎯 Result", value=f"{color_emoji} **{number}**", inline=False)
+            embed.add_field(name="💰 Bet", value=f"`{self.bet_amount:,}` on {self.bet_type}", inline=True)
+            embed.add_field(name="💵 Result", value=f"`{'+' if won else '-'}{abs(winnings):,}` coins", inline=True)
+            
+            if won:
+                embed.description = f"✅ **You Won!** +`{winnings:,}` coins!"
+                embed.color = NEON_LIME
+            else:
+                embed.description = f"❌ **You Lost!** -`{abs(winnings):,}` coins."
+                embed.color = NEON_RED
+        else:
+            embed.description = "Place your bet and spin the wheel!"
+            grid = ""
+            for i in range(0, 37, 3):
+                if i == 0:
+                    grid += "<:animatedarrowgreen:1477261279428087979> **0**  "
+                else:
+                    c1 = "🔴" if i in self.RED_NUMBERS else "��"
+                    c2 = "🔴" if (i+1) in self.RED_NUMBERS else "⚫"
+                    c3 = "🔴" if (i+2) in self.RED_NUMBERS else "⚫"
+                    grid += f"{c1} {i}  {c2} {i+1}  {c3} {i+2}\n"
+            embed.add_field(name="🎡 Roulette Wheel", value=f"```\n{grid}```", inline=False)
+        
+        return embed
+    
+    @discord.ui.button(label="Bet Red 🔴", style=discord.ButtonStyle.danger, custom_id="roulette_red")
+    async def bet_red(self, interaction: discord.Interaction, button: discord.ui.Button):
+        await self.prompt_bet(interaction, "red")
+    
+    @discord.ui.button(label="Bet Black ⚫", style=discord.ButtonStyle.gray, custom_id="roulette_black")
+    async def bet_black(self, interaction: discord.Interaction, button: discord.ui.Button):
+        await self.prompt_bet(interaction, "black")
+    
+    @discord.ui.button(label="Bet Even", style=discord.ButtonStyle.primary, custom_id="roulette_even")
+    async def bet_even(self, interaction: discord.Interaction, button: discord.ui.Button):
+        await self.prompt_bet(interaction, "even")
+    
+    @discord.ui.button(label="Bet Odd", style=discord.ButtonStyle.primary, custom_id="roulette_odd")
+    async def bet_odd(self, interaction: discord.Interaction, button: discord.ui.Button):
+        await self.prompt_bet(interaction, "odd")
+    
+    async def prompt_bet(self, interaction: discord.Interaction, bet_type: str):
+        if self.user_id and interaction.user.id != self.user_id:
+            return
+        await interaction.response.send_modal(RouletteBetModal(self.cog, self.guild_id, self.user_id, bet_type))
+
+
+class RouletteBetModal(discord.ui.Modal, title="🎰 Place Your Bet"):
+    bet_amount = discord.ui.TextInput(
+        label="Bet Amount",
+        placeholder="Enter amount (min 10)",
+        required=True,
+        min_length=1,
+        max_length=10,
+    )
+    
+    def __init__(self, cog, guild_id: int, user_id: int, bet_type: str):
+        super().__init__()
+        self.cog = cog
+        self.guild_id = guild_id
+        self.user_id = user_id
+        self.bet_type = bet_type
+    
+    async def on_submit(self, interaction: discord.Interaction) -> None:
+        try:
+            bet = int(self.bet_amount.value.strip())
+        except ValueError:
+            await interaction.response.send_message("❌ Invalid bet amount.", ephemeral=True)
+            return
+        
+        if bet < 10:
+            await interaction.response.send_message("❌ Minimum bet is 10 coins.", ephemeral=True)
+            return
+        
+        engagement_cog = interaction.client.get_cog("Engagement")
+        if not engagement_cog:
+            await interaction.response.send_message("❌ Economy not available.", ephemeral=True)
+            return
+        
+        row = await interaction.client.db.fetchone(
+            "SELECT wallet FROM user_balance WHERE guild_id = ? AND user_id = ?",
+            self.guild_id, self.user_id,
+        )
+        wallet = row[0] if row else 0
+        
+        if wallet < bet:
+            await interaction.response.send_message(f"❌ Insufficient funds. You have {wallet:,} coins.", ephemeral=True)
+            return
+        
+        await interaction.response.defer()
+        
+        number = random.randint(0, 36)
+        is_red = number in RouletteGameView.RED_NUMBERS
+        is_black = number in RouletteGameView.BLACK_NUMBERS
+        is_even = number != 0 and number % 2 == 0
+        is_odd = number != 0 and number % 2 == 1
+        
+        won = False
+        multiplier = 2
+        
+        if self.bet_type == 'red' and is_red:
+            won = True
+        elif self.bet_type == 'black' and is_black:
+            won = True
+        elif self.bet_type == 'even' and is_even:
+            won = True
+        elif self.bet_type == 'odd' and is_odd:
+            won = True
+        
+        winnings = bet * multiplier if won else -bet
+        
+        if won:
+            await engagement_cog._add_coins(self.guild_id, self.user_id, winnings)
+        else:
+            await engagement_cog._remove_coins(self.guild_id, self.user_id, bet)
+        
+        view = RouletteGameView(self.cog, self.guild_id, self.user_id)
+        view.bet_amount = bet
+        view.bet_type = self.bet_type
+        embed = view.build_embed(number=number, won=won, winnings=winnings)
+        
+        for child in view.children:
+            child.disabled = False
+        
+        await interaction.followup.send(embed=embed, view=view)
+
+
+class RPGView(discord.ui.View):
+    def __init__(self, cog, guild_id: int, user_id: int):
+        super().__init__(timeout=None)
+        self.cog = cog
+        self.guild_id = guild_id
+        self.user_id = user_id
+        self.adventure_image = "https://images.unsplash.com/photo-1519074069444-1ba4fff66d16?w=500"
+    
+    def build_embed(self, title: str, description: str, color: discord.Color) -> discord.Embed:
+        embed = discord.Embed(
+            title=title,
+            description=description,
+            color=color,
+        )
+        embed.set_image(url=self.adventure_image)
+        return embed
+    
+    @discord.ui.button(label="⚔️ Fight Monster", emoji=ui("game"), style=discord.ButtonStyle.danger, custom_id="rpg_fight")
+    async def fight_monster(self, interaction: discord.Interaction, button: discord.ui.Button):
+        if self.user_id and interaction.user.id != self.user_id:
+            return
+        
+        engagement_cog = interaction.client.get_cog("Engagement")
+        if not engagement_cog:
+            await interaction.response.send_message("❌ Economy not available.", ephemeral=True)
+            return
+        
+        row = await interaction.client.db.fetchone(
+            "SELECT level FROM user_xp WHERE guild_id = ? AND user_id = ?",
+            self.guild_id, self.user_id,
+        )
+        level = row[0] if row else 1
+        
+        monsters = [
+            ("Goblin", 50, 100, 20, 40),
+            ("Dragon", 200, 500, 50, 100),
+            ("Skeleton", 30, 80, 15, 30),
+            ("Orc", 80, 200, 25, 50),
+            ("Troll", 150, 350, 40, 80),
+            ("Demon", 300, 600, 60, 120),
+        ]
+        
+        monster_name, min_reward, max_reward, min_xp, max_xp = random.choice(monsters)
+        win_chance = min(0.8, 0.3 + (level * 0.05))
+        won = random.random() < win_chance
+        
+        if won:
+            reward = random.randint(min_reward, max_reward) + (level * 10)
+            xp_gain = random.randint(min_xp, max_xp)
+            await engagement_cog._add_coins(self.guild_id, self.user_id, reward)
+            await engagement_cog.add_xp(self.guild_id, self.user_id, xp_gain)
+            
+            embed = discord.Embed(
+                title="⚔️ RPG Adventure - Victory!",
+                description=f"✅ **You defeated the {monster_name}!**\n\n💰 **+{reward:,} coins**\n⭐ **+{xp_gain} XP**\n📈 Level {level} → {level + (1 if xp_gain > 40 else 0)}",
+                color=NEON_LIME,
+            )
+            embed.set_image(url="https://images.unsplash.com/photo-1535905557558-afc4877a26fc?w=500")
+        else:
+            penalty = random.randint(10, 50) + (level * 5)
+            await engagement_cog._remove_coins(self.guild_id, self.user_id, penalty)
+            
+            embed = discord.Embed(
+                title="⚔️ RPG Adventure - Defeat!",
+                description=f"❌ **The {monster_name} defeated you!**\n\n💀 **-{penalty:,} coins**\n\n💡 Tip: Level up to increase win chance!",
+                color=NEON_RED,
+            )
+            embed.set_image(url="https://images.unsplash.com/photo-1519791883288-dc8bd696e667?w=500")
+        
+        if interaction.guild:
+            await add_banner_to_embed(embed, interaction.guild)
+        
+        await interaction.response.send_message(embed=embed, ephemeral=True)
+    
+    @discord.ui.button(label="🎁 Find Treasure", emoji=ui("gift"), style=discord.ButtonStyle.success, custom_id="rpg_treasure")
+    async def find_treasure(self, interaction: discord.Interaction, button: discord.ui.Button):
+        if self.user_id and interaction.user.id != self.user_id:
+            return
+        
+        engagement_cog = interaction.client.get_cog("Engagement")
+        if not engagement_cog:
+            await interaction.response.send_message("❌ Economy not available.", ephemeral=True)
+            return
+        
+        found = random.random() < 0.4
+        
+        if found:
+            reward = random.randint(30, 150)
+            await engagement_cog._add_coins(self.guild_id, self.user_id, reward)
+            
+            embed = discord.Embed(
+                title="🎁 Treasure Hunt - Success!",
+                description=f"✅ **You found a hidden treasure!**\n\n💰 **+{reward:,} coins**\n\n🗺️ The treasure map led you to riches!",
+                color=NEON_GOLD,
+            )
+            embed.set_image(url="https://images.unsplash.com/photo-1518709268805-4e9042af9f23?w=500")
+        else:
+            embed = discord.Embed(
+                title="🎁 Treasure Hunt - Nothing Found",
+                description="❌ **No treasure found in this area...**\n\n🗺️ Try exploring a different location next time!",
+                color=NEON_RED,
+            )
+            embed.set_image(url="https://images.unsplash.com/photo-1500353391678-d7b57970d9b2?w=500")
+        
+        if interaction.guild:
+            await add_banner_to_embed(embed, interaction.guild)
+        
+        await interaction.response.send_message(embed=embed, ephemeral=True)
+    
+    @discord.ui.button(label="🏪 Shop", emoji=ui("cart"), style=discord.ButtonStyle.blurple, custom_id="rpg_shop")
+    async def shop(self, interaction: discord.Interaction, button: discord.ui.Button):
+        if interaction.user.id != self.user_id:
+            return
+        
+        embed = discord.Embed(
+            title="🏪 RPG Shop",
+            description=(
+                "Welcome to the shop! Buy items to help in your adventures.\n\n"
+                "🗡️ **Sword** - Increase win chance (Coming Soon)\n"
+                "🛡️ **Shield** - Reduce coin loss on defeat (Coming Soon)\n"
+                "🧪 **Potion** - Heal after battle (Coming Soon)\n"
+                "📜 **Map** - Better treasure finds (Coming Soon)"
+            ),
+            color=NEON_CYAN,
+        )
+        embed.set_image(url="https://images.unsplash.com/photo-1589829545856-d10d557cf95f?w=500")
+        
+        if interaction.guild:
+            await add_banner_to_embed(embed, interaction.guild)
+        
+        await interaction.response.send_message(embed=embed, ephemeral=True)
+    
+    @discord.ui.button(label="📊 Stats", emoji=ui("stats"), style=discord.ButtonStyle.secondary, custom_id="rpg_stats")
+    async def stats(self, interaction: discord.Interaction, button: discord.ui.Button):
+        if interaction.user.id != self.user_id:
+            return
+        
+        engagement_cog = interaction.client.get_cog("Engagement")
+        if not engagement_cog:
+            return
+        
+        row = await interaction.client.db.fetchone(
+            "SELECT wallet, bank FROM user_balance WHERE guild_id = ? AND user_id = ?",
+            self.guild_id, self.user_id,
+        )
+        wallet, bank = row if row else (0, 0)
+        
+        xp_row = await interaction.client.db.fetchone(
+            "SELECT xp, level FROM user_xp WHERE guild_id = ? AND user_id = ?",
+            self.guild_id, self.user_id,
+        )
+        xp, level = xp_row if xp_row else (0, 1)
+        
+        embed = discord.Embed(
+            title="📊 RPG Stats",
+            description=(
+                f"**Level:** {level}\n"
+                f"**XP:** {xp:,}\n"
+                f"**Wallet:** {wallet:,} coins\n"
+                f"**Bank:** {bank:,} coins\n"
+                f"**Total Wealth:** {wallet + bank:,} coins"
+            ),
+            color=NEON_PURPLE,
+        )
+        
+        if interaction.guild:
+            await add_banner_to_embed(embed, interaction.guild)
+        
+        await interaction.response.send_message(embed=embed, ephemeral=True)
+
+
+class GamblingPanelView(discord.ui.View):
+    def __init__(self, cog, guild_id: int, user_id: int):
+        super().__init__(timeout=None)
+        self.cog = cog
+        self.guild_id = guild_id
+        self.user_id = user_id
+    
+    @discord.ui.button(label="🃏 Play Blackjack", emoji=ui("game"), style=discord.ButtonStyle.danger, custom_id="gambling_blackjack")
+    async def play_blackjack(self, interaction: discord.Interaction, button: discord.ui.Button):
+        if interaction.user.id != self.user_id:
+            return
+        await interaction.response.send_modal(BlackjackBetModal(self.cog, self.guild_id, self.user_id))
+    
+    @discord.ui.button(label="🎰 Play Roulette", emoji=ui("game"), style=discord.ButtonStyle.danger, custom_id="gambling_roulette")
+    async def play_roulette(self, interaction: discord.Interaction, button: discord.ui.Button):
+        if interaction.user.id != self.user_id:
+            return
+        view = RouletteGameView(self.cog, self.guild_id, self.user_id)
+        embed = view.build_embed()
+        await interaction.response.send_message(embed=embed, view=view, ephemeral=True)
+    
+    @discord.ui.button(label="⚔️ RPG Adventure", emoji=ui("game"), style=discord.ButtonStyle.success, custom_id="gambling_rpg")
+    async def play_rpg(self, interaction: discord.Interaction, button: discord.ui.Button):
+        if interaction.user.id != self.user_id:
+            return
+        view = RPGView(self.cog, self.guild_id, self.user_id)
+        embed = view.build_embed(
+            title="⚔️ RPG Adventure",
+            description="Choose your action below to begin your adventure!",
+            color=NEON_PURPLE,
+        )
+        await interaction.response.send_message(embed=embed, view=view, ephemeral=True)
+
+
+class BlackjackBetModal(discord.ui.Modal, title="🃏 Place Your Bet"):
+    bet_amount = discord.ui.TextInput(
+        label="Bet Amount",
+        placeholder="Enter amount (min 10)",
+        required=True,
+        min_length=1,
+        max_length=10,
+    )
+    
+    def __init__(self, cog, guild_id: int, user_id: int):
+        super().__init__()
+        self.cog = cog
+        self.guild_id = guild_id
+        self.user_id = user_id
+    
+    async def on_submit(self, interaction: discord.Interaction) -> None:
+        try:
+            bet = int(self.bet_amount.value.strip())
+        except ValueError:
+            await interaction.response.send_message("❌ Invalid bet amount.", ephemeral=True)
+            return
+        
+        if bet < 10:
+            await interaction.response.send_message("❌ Minimum bet is 10 coins.", ephemeral=True)
+            return
+        
+        engagement_cog = interaction.client.get_cog("Engagement")
+        if not engagement_cog:
+            await interaction.response.send_message("❌ Economy not available.", ephemeral=True)
+            return
+        
+        row = await interaction.client.db.fetchone(
+            "SELECT wallet FROM user_balance WHERE guild_id = ? AND user_id = ?",
+            self.guild_id, self.user_id,
+        )
+        wallet = row[0] if row else 0
+        
+        if wallet < bet:
+            await interaction.response.send_message(f"❌ Insufficient funds. You have {wallet:,} coins.", ephemeral=True)
+            return
+        
+        view = BlackjackView(self.cog, self.guild_id, self.user_id, bet)
+        embed = view.build_embed(show_dealer_card=False)
+        message = await interaction.channel.send(embed=embed, view=view)
+        view.message = message
+        await interaction.response.send_message("✅ Blackjack game started!", ephemeral=True)
+
+
 class Gambling(commands.Cog):
-    def __init__(self, bot: commands.Bot) -> None:
-        self.bot = bot
-    
-    @commands.hybrid_command(name="blackjack", description="Play interactive Blackjack")
-    async def blackjack(self, ctx: commands.Context, bet: int) -> None:
-        if bet < 10:
-            await ctx.send("❌ Minimum bet is 10 coins.", ephemeral=True)
-            return
-        
-        engagement_cog = self.bot.get_cog("Engagement")
-        if not engagement_cog:
-            await ctx.send("❌ Economy not available.", ephemeral=True)
-            return
-        
-        row = await self.bot.db.fetchone(
-            "SELECT wallet FROM user_balance WHERE guild_id = ? AND user_id = ?",
-            ctx.guild.id if ctx.guild else 0, ctx.author.id,
-        )
-        wallet = row[0] if row else 0
-        
-        if wallet < bet:
-            await ctx.send(f"❌ Insufficient funds. You have {wallet:,} coins.", ephemeral=True)
-            return
-        
-        view = BlackjackView(self, ctx.guild.id if ctx.guild else 0, ctx.author.id, bet)
-        embed = view.build_embed(show_dealer_card=False)
-        message = await ctx.send(embed=embed, view=view)
-        view.message = message
-    
-    @commands.hybrid_command(name="roulette", description="Play interactive Roulette")
-    async def roulette(self, ctx: commands.Context) -> None:
-        view = RouletteGameView(self, ctx.guild.id if ctx.guild else 0, ctx.author.id)
-        embed = view.build_embed()
-        await ctx.send(embed=embed, view=view)
-    
-    @commands.hybrid_command(name="rpg", description="Start an RPG adventure")
-    async def rpg(self, ctx: commands.Context) -> None:
-        view = RPGView(self, ctx.guild.id if ctx.guild else 0, ctx.author.id)
-        embed = view.build_embed(
-            title="⚔️ RPG Adventure",
-            description="Choose your action below to begin your adventure!",
-            color=NEON_PURPLE,
-        )
-        await ctx.send(embed=embed, view=view, ephemeral=True)
-    
-    @commands.hybrid_command(name="gambling_panel", description="Open the gambling panel")
-    async def gambling_panel(self, ctx: commands.Context) -> None:
-        view = GamblingPanelView(self, ctx.guild.id if ctx.guild else 0, ctx.author.id)
-        embed = discord.Embed(
-            title="🎰 Casino & Gambling Panel",
-            description=(
-                "Welcome to the Casino! Choose a game to play:\n\n"
-                "🃏 **Blackjack** - Beat the dealer to 21\n"
-                "🎰 **Roulette** - Bet on numbers and colors\n"
-                "⚔️ **RPG Adventure** - Fight monsters and find treasure"
-            ),
-            color=NEON_GOLD,
-        )
-        if ctx.guild:
-            from bot.theme import add_banner_to_embed
-            await add_banner_to_embed(embed, ctx.guild)
-        await ctx.send(embed=embed, view=view, ephemeral=True)
-
-
-async def setup(bot: commands.Bot) -> None:
-    await bot.add_cog(Gambling(bot))
+    def __init__(self, bot: commands.Bot) -> None:
+        self.bot = bot
+    
+    @commands.hybrid_command(name="blackjack", description="Play interactive Blackjack")
+    async def blackjack(self, ctx: commands.Context, bet: int) -> None:
+        if bet < 10:
+            await ctx.send("❌ Minimum bet is 10 coins.", ephemeral=True)
+            return
+        
+        engagement_cog = self.bot.get_cog("Engagement")
+        if not engagement_cog:
+            await ctx.send("❌ Economy not available.", ephemeral=True)
+            return
+        
+        row = await self.bot.db.fetchone(
+            "SELECT wallet FROM user_balance WHERE guild_id = ? AND user_id = ?",
+            ctx.guild.id if ctx.guild else 0, ctx.author.id,
+        )
+        wallet = row[0] if row else 0
+        
+        if wallet < bet:
+            await ctx.send(f"❌ Insufficient funds. You have {wallet:,} coins.", ephemeral=True)
+            return
+        
+        view = BlackjackView(self, ctx.guild.id if ctx.guild else 0, ctx.author.id, bet)
+        embed = view.build_embed(show_dealer_card=False)
+        message = await ctx.send(embed=embed, view=view)
+        view.message = message
+    
+    @commands.hybrid_command(name="roulette", description="Play interactive Roulette")
+    async def roulette(self, ctx: commands.Context) -> None:
+        view = RouletteGameView(self, ctx.guild.id if ctx.guild else 0, ctx.author.id)
+        embed = view.build_embed()
+        await ctx.send(embed=embed, view=view)
+    
+    @commands.hybrid_command(name="rpg", description="Start an RPG adventure")
+    async def rpg(self, ctx: commands.Context) -> None:
+        view = RPGView(self, ctx.guild.id if ctx.guild else 0, ctx.author.id)
+        embed = view.build_embed(
+            title="⚔️ RPG Adventure",
+            description="Choose your action below to begin your adventure!",
+            color=NEON_PURPLE,
+        )
+        await ctx.send(embed=embed, view=view, ephemeral=True)
+    
+    @commands.hybrid_command(name="gambling_panel", description="Open the gambling panel")
+    async def gambling_panel(self, ctx: commands.Context) -> None:
+        view = GamblingPanelView(self, ctx.guild.id if ctx.guild else 0, ctx.author.id)
+        embed = discord.Embed(
+            title="🎰 Casino & Gambling Panel",
+            description=(
+                "Welcome to the Casino! Choose a game to play:\n\n"
+                "🃏 **Blackjack** - Beat the dealer to 21\n"
+                "🎰 **Roulette** - Bet on numbers and colors\n"
+                "⚔️ **RPG Adventure** - Fight monsters and find treasure"
+            ),
+            color=NEON_GOLD,
+        )
+        if ctx.guild:
+            from bot.theme import add_banner_to_embed
+            await add_banner_to_embed(embed, ctx.guild)
+        await ctx.send(embed=embed, view=view, ephemeral=True)
+
+
+async def setup(bot: commands.Bot) -> None:
+    await bot.add_cog(Gambling(bot))

bot/cogs/language.py

@@ -23,6 +23,7 @@ LANGUAGE_META: dict[str, tuple[str, str]] = {
     "id": ("Indonesia", "🇮🇩"),
     "ja": ("日本語", "🇯🇵"),
     "zh": ("中文", "🇨🇳"),
+    "he": ("עברית", "🇮🇱"),
 }
 
 
@@ -32,7 +33,10 @@ class LanguageSelect(discord.ui.Select):
         self.guild_id = guild_id
 
         options: list[discord.SelectOption] = []
-        for code in SUPPORTED_LANGUAGES:
+        dynamic_supported = sorted(
+            getattr(getattr(cog.bot, "translator", None), "supported_languages", set(SUPPORTED_LANGUAGES))
+        )
+        for code in dynamic_supported:
             label, emoji = LANGUAGE_META.get(code, (code.upper(), "🌐"))
             options.append(
                 discord.SelectOption(
@@ -58,6 +62,17 @@ class LanguageSelect(discord.ui.Select):
             return
 
         selected = self.values[0]
+
+        # Special rule requested by owner: Hebrew is visible but cannot be set.
+        if selected == "he":
+            current_code = await self.cog._current_code(interaction.guild.id)
+            for option in self.options:
+                option.default = option.value == current_code
+            embed = await self.cog._language_embed(interaction.guild.id, current_code)
+            await interaction.response.edit_message(embed=embed, view=self.view)
+            await interaction.followup.send("only you know this language", ephemeral=True)
+            return
+
         await self.cog.bot.db.execute(
             "INSERT INTO guild_config(guild_id, guild_language) VALUES (?, ?) "
             "ON CONFLICT(guild_id) DO UPDATE SET guild_language = excluded.guild_language",
@@ -98,14 +113,18 @@ class Language(commands.Cog):
 
     async def _current_code(self, guild_id: int) -> str:
         row = await self.bot.db.fetchone("SELECT guild_language FROM guild_config WHERE guild_id = ?", guild_id)
-        return row[0] if row and row[0] in LANGUAGE_META else "ar"
+        supported = set(getattr(getattr(self.bot, "translator", None), "supported_languages", set(SUPPORTED_LANGUAGES)))
+        return row[0] if row and row[0] in supported else "ar"
 
     async def _language_embed(self, guild_id: int, current_code: str) -> discord.Embed:
         current_name = LANGUAGE_META.get(current_code, (current_code.upper(), "🌐"))[0]
         current_emoji = LANGUAGE_META.get(current_code, (current_code.upper(), "🌐"))[1]
         
         lines = []
-        for code in LANGUAGE_META:
+        supported = sorted(
+            getattr(getattr(self.bot, "translator", None), "supported_languages", set(SUPPORTED_LANGUAGES))
+        )
+        for code in supported:
             name, emoji = LANGUAGE_META.get(code, (code.upper(), "🌐"))
             marker = "✅" if code == current_code else "▫️"
             lines.append(f"{marker} {emoji} **{name}** `({code})`")

bot/cogs/media.py

@@ -87,12 +87,21 @@ if wavelink is not None:
             else:
                 self._connection_event.set()
 
-from bot.theme import NEON_CYAN, NEON_ORANGE, NEON_LIME, NEON_PURPLE, panel_divider
+from bot.theme import (
+    NEON_CYAN,
+    NEON_ORANGE,
+    NEON_LIME,
+    NEON_PURPLE,
+    panel_divider,
+    idle_embed_for_guild,
+    idle_text,
+    add_banner_to_embed,
+)
 from bot.emojis import resolve_emoji_value, set_emoji_bot
 
 # Import views from separate module
 from .media_helpers import (
-    MusicPanelView, QueueView, FiltersView, FiltersPanelView,
+    MusicPanelView, QueueView, FiltersView, FiltersPanelView, AudioActionsView,
     AUDIO_FILTERS, get_filter_emoji, safe_defer, safe_send, safe_edit,
     safe_interaction
 )
@@ -469,44 +478,6 @@ class SuggestionSelect(discord.ui.Select):
             return
 
         selected = self.suggestions[selected_index]
-        
-        # Get guild and player
-        guild = interaction.guild
-        if not guild:
-            await interaction.followup.send("Server only.", ephemeral=True)
-            return
-        
-        player = guild.voice_client
-        if not player or not isinstance(player, wavelink.Player):
-            await interaction.followup.send("Not connected to voice.", ephemeral=True)
-            return
-        
-        # Add ALL suggestions to wavelink queue first (in order)
-        for idx, item in enumerate(self.suggestions):
-            try:
-                search_q = item.query if item.query else f"ytsearch1:{item.title}"
-                results = await wavelink.Playable.search(search_q)
-                if results:
-                    await player.queue.put_wait(results[0])
-            except Exception:
-                continue
-        
-        # Now play the selected track immediately by moving it to front
-        # Get the selected track from queue and move to front
-        queue_list = list(player.queue)
-        if selected_index < len(queue_list):
-            selected_track = queue_list.pop(selected_index)
-            # Clear queue and re-add with selected first
-            player.queue._queue.clear()
-            player.queue._queue.append(selected_track)
-            for track in queue_list:
-                player.queue._queue.append(track)
-        
-        # Play the selected track
-        if player.queue:
-            track_to_play = player.queue.get()
-            await player.play(track_to_play)
-        
         choice = (selected.query or selected.title).strip()
         result = await self.cog.play_from_query(interaction, choice)
         await interaction.followup.send(
@@ -741,6 +712,9 @@ class Media(commands.Cog):
             or os.getenv("YT_API_KEY", "").strip()
         )
         self._youtube_region_code = (os.getenv("YOUTUBE_REGION_CODE", "US").strip() or "US").upper()
+        self._playlist_track_limit = max(50, min(500, int((os.getenv("PLAYLIST_TRACK_LIMIT", "300").strip() or "300"))))
+        self._playlist_batch_sleep = max(0.05, min(1.0, float((os.getenv("PLAYLIST_BATCH_SLEEP", "0.35").strip() or "0.35"))))
+        self._resolved_url_query_cache: dict[str, str] = {}
 
         if hasattr(self.bot, "logger"):
             if self._ffmpeg_path:
@@ -751,6 +725,7 @@ class Media(commands.Cog):
     async def cog_load(self) -> None:
         """Set up event listeners for wavelink."""
         self.bot.add_view(MusicPanelView(self))
+        self.bot.add_view(AudioActionsView(self))
         
         # Register wavelink event listeners
         if wavelink is not None:
@@ -1182,6 +1157,7 @@ class Media(commands.Cog):
 
     def _to_lavalink_identifier(self, query: str) -> str:
         normalized = self._sanitize_query(query)
+        forced_search = False
         prefixes = ("ytsearch1:", "ytsearch:", "ytmsearch:")
         while True:
             lowered = normalized.casefold()
@@ -1189,19 +1165,124 @@ class Media(commands.Cog):
             for prefix in prefixes:
                 if lowered.startswith(prefix):
                     normalized = normalized[len(prefix):].strip()
+                    forced_search = True
                     matched = True
                     break
             if not matched:
                 break
+        if forced_search:
+            return f"ytsearch:{normalized}"
         if self._looks_like_url(normalized):
+            lowered = normalized.casefold()
+            if "open.spotify.com/track/" in lowered or "music.apple.com/" in lowered:
+                return f"ytsearch:{normalized}"
             return normalized
         return f"ytsearch:{normalized}"
 
+    async def _resolve_music_url_to_search_term(self, raw_url: str) -> str | None:
+        url = (raw_url or "").strip()
+        if not url:
+            return None
+        cached = self._resolved_url_query_cache.get(url)
+        if cached:
+            return cached
+
+        lowered = url.casefold()
+        timeout = aiohttp.ClientTimeout(total=5)
+
+        # Spotify: lightweight oEmbed endpoint (no auth token needed for title/artist string).
+        if "open.spotify.com/track/" in lowered:
+            try:
+                oembed = f"https://open.spotify.com/oembed?url={quote_plus(url)}"
+                async with aiohttp.ClientSession(timeout=timeout) as session:
+                    async with session.get(oembed) as resp:
+                        payload = await resp.json(content_type=None) if resp.status == 200 else None
+                if isinstance(payload, dict):
+                    title = str(payload.get("title") or "").strip()
+                    author = str(payload.get("author_name") or "").strip()
+                    term = f"{author} - {title}".strip(" -")
+                    if term:
+                        self._resolved_url_query_cache[url] = term
+                        return term
+            except Exception:
+                pass
+
+        # Apple Music track URLs usually include iTunes id-like token (/id123456789).
+        if "music.apple.com/" in lowered:
+            match = re.search(r"/id(\d+)", url)
+            if match:
+                try:
+                    lookup = f"https://itunes.apple.com/lookup?id={match.group(1)}"
+                    async with aiohttp.ClientSession(timeout=timeout) as session:
+                        async with session.get(lookup) as resp:
+                            payload = await resp.json(content_type=None) if resp.status == 200 else None
+                    if isinstance(payload, dict):
+                        rows = payload.get("results") or []
+                        if rows and isinstance(rows[0], dict):
+                            artist = str(rows[0].get("artistName") or "").strip()
+                            title = str(rows[0].get("trackName") or rows[0].get("collectionName") or "").strip()
+                            term = f"{artist} - {title}".strip(" -")
+                            if term:
+                                self._resolved_url_query_cache[url] = term
+                                return term
+                except Exception:
+                    pass
+        return None
+
+    async def _identifier_fallbacks(self, identifier: str) -> list[str]:
+        primary = (identifier or "").strip()
+        if not primary:
+            return []
+        candidates: list[str] = [primary]
+
+        plain = primary
+        if plain.lower().startswith("ytsearch:"):
+            plain = plain[len("ytsearch:") :].strip()
+
+        if self._looks_like_url(plain):
+            term = await self._resolve_music_url_to_search_term(plain)
+            if term:
+                alt = f"ytsearch:{term}"
+                if alt not in candidates:
+                    candidates.append(alt)
+
+        return candidates
+
+    async def _search_playable_with_retry(self, identifier: str, *, attempts: int = 3) -> list[object]:
+        if wavelink is None:
+            return []
+        last_error: Exception | None = None
+        candidates = await self._identifier_fallbacks(identifier)
+        for candidate in candidates:
+            for attempt in range(1, max(1, attempts) + 1):
+                try:
+                    return await wavelink.Playable.search(candidate)
+                except Exception as exc:
+                    last_error = exc
+                    text = str(exc).lower()
+                    if "429" not in text and "rate" not in text:
+                        break
+                    await asyncio.sleep((0.35 * attempt) + random.uniform(0.05, 0.2))
+        if last_error is not None:
+            raise last_error
+        return []
+
     def _guild_state(self, guild_id: int) -> GuildPlaybackState:
         if guild_id not in self.state:
             self.state[guild_id] = GuildPlaybackState()
         return self.state[guild_id]
 
+    async def _safe_ctx_defer(self, ctx: commands.Context, *, ephemeral: bool = False) -> None:
+        interaction = getattr(ctx, "interaction", None)
+        if not interaction:
+            return
+        try:
+            if interaction.response.is_done():
+                return
+            await interaction.response.defer(ephemeral=ephemeral)
+        except (discord.InteractionResponded, discord.NotFound, discord.HTTPException):
+            return
+
     async def _dj_permitted(self, ctx_or_interaction: commands.Context | discord.Interaction) -> bool:
         return True
 
@@ -1535,7 +1616,13 @@ class Media(commands.Cog):
                     continue
                 direct = str(entry.get("url") or entry.get("webpage_url") or "").strip()
                 vid = str(entry.get("id") or "").strip()
+                title = str(entry.get("title") or "").strip()
+                uploader = str(entry.get("uploader") or entry.get("channel") or "").strip()
                 if direct and direct.startswith("http"):
+                    if "open.spotify.com/track/" in direct and title:
+                        query = f"{uploader} - {title}" if uploader else title
+                        urls.append(f"ytsearch1:{query}")
+                        continue
                     urls.append(direct)
                     continue
                 if direct and not direct.startswith("http") and "youtube" in playlist_url:
@@ -1543,9 +1630,14 @@ class Media(commands.Cog):
                     continue
                 if vid:
                     urls.append(f"https://www.youtube.com/watch?v={vid}")
+                    continue
+                if title:
+                    query = f"{uploader} - {title}" if uploader else title
+                    urls.append(f"ytsearch1:{query}")
             return urls
 
-        return await asyncio.to_thread(_run)
+        urls = await asyncio.to_thread(_run)
+        return [u for u in urls if u][: max(1, min(limit, self._playlist_track_limit))]
 
     async def _resolve_query_with_ytdlp(self, query: str) -> str | None:
         """Resolve a text query to a direct video URL using yt-dlp search."""
@@ -1656,7 +1748,11 @@ class Media(commands.Cog):
                     lines.append(f"*...and {len(queue) - 5} more*")
                 embed.add_field(name=up_next, value="\n".join(lines), inline=False)
             else:
-                embed.add_field(name=up_next, value="Queue is empty.", inline=False)
+                embed.add_field(
+                    name=up_next,
+                    value=idle_text("Queue is empty.", "Add tracks with `/music play` or the music panel."),
+                    inline=False,
+                )
 
             status_icon = "📡"
             loop_text = "Off" if state.loop_mode == "off" else ("Track" if state.loop_mode == "track" else "Queue")
@@ -1674,6 +1770,8 @@ class Media(commands.Cog):
 
             server_name = guild.name if guild else "Server"
             embed.set_footer(text=f"⛩️ 〣 🔄 Auto-refreshing every 10s • {server_name} 〣 🏮")
+            if guild:
+                await add_banner_to_embed(embed, guild, self.bot)
         
         return embed
 
@@ -1807,7 +1905,7 @@ class Media(commands.Cog):
                 self.now_playing.pop(guild.id, None)
                 if lang == "ar":
                     return "⏭️ تم التخطي. الطابور فارغ."
-                return "⏭️ Skipped. Queue is empty."
+                return idle_text("Queue is empty.", "Skipped current track. Nothing is queued.")
         
         # For non-wavelink players
         if not self._voice_is_playing(player):
@@ -1982,7 +2080,7 @@ class Media(commands.Cog):
         tracks = ([now] if now else []) + list(state_queue)
         uris = [t.webpage_url for t in tracks if t and t.webpage_url]
         if not uris:
-            return "Queue is empty."
+            return idle_text("Queue is empty.", "Play songs first, then try saving again.")
         cleaned_name = (playlist_name or "quicksave").strip()[:40]
         await self.bot.db.execute(
             "INSERT INTO saved_playlists(user_id, name, tracks_json) VALUES (?, ?, ?) "
@@ -2000,7 +2098,7 @@ class Media(commands.Cog):
         )
         embed = discord.Embed(title="💾 Saved Playlists", color=NEON_CYAN)
         if not rows:
-            embed.description = "No playlists saved yet. Use the **Save Queue** button."
+            embed.description = idle_text("No playlists saved yet.", "Use the **Save Queue** button.")
             return embed
         lines: list[str] = []
         for name, tracks_json, created_at in rows:
@@ -2057,16 +2155,17 @@ class Media(commands.Cog):
         self.queues.setdefault(guild.id, [])
         count = 0
         first_track: str | None = None
-        for url in urls[:100]:
+        for idx, url in enumerate(urls[: self._playlist_track_limit], start=1):
             try:
-                results = await wavelink.Playable.search(url)
+                search_identifier = self._to_lavalink_identifier(url)
+                results = await self._search_playable_with_retry(search_identifier, attempts=3)
             except Exception as exc:
                 await self._log_media_issue(guild, "saved_playlist_play_search", url, exc)
                 continue
             if not results:
                 continue
             wl_items = list(results.tracks) if (wavelink is not None and isinstance(results, wavelink.Playlist)) else list(results)
-            for wl_track in wl_items[:100]:
+            for wl_track in wl_items[: self._playlist_track_limit]:
                 track = self._wavelink_to_track(wl_track, actor.id)
                 if count == 0 and not player.playing and not player.paused:
                     await player.play(wl_track, volume=self._guild_state(guild.id).volume)
@@ -2076,6 +2175,11 @@ class Media(commands.Cog):
                     self.queues[guild.id].append(track)
                     await player.queue.put_wait(wl_track)
                 count += 1
+                # Smooth out provider/API bursts for large playlist loads.
+                if count % 5 == 0:
+                    await asyncio.sleep(self._playlist_batch_sleep)
+            if idx % 3 == 0:
+                await asyncio.sleep(self._playlist_batch_sleep)
 
         if count == 0:
             if lang == "ar":
@@ -2180,7 +2284,32 @@ class Media(commands.Cog):
 
         urls: list[str] = []
         if self._looks_like_playlist(source):
-            urls = await self._extract_playlist_entries(source, limit=100)
+            urls = await self._extract_playlist_entries(source, limit=self._playlist_track_limit)
+            if not urls:
+                # Secondary fallback: try Lavalink playlist parsing and store track URIs.
+                try:
+                    lavalink_results = await self._search_playable_with_retry(
+                        self._to_lavalink_identifier(source),
+                        attempts=2,
+                    )
+                except Exception:
+                    lavalink_results = []
+                if lavalink_results:
+                    items = (
+                        list(lavalink_results.tracks)
+                        if (wavelink is not None and isinstance(lavalink_results, wavelink.Playlist))
+                        else list(lavalink_results)
+                    )
+                    for item in items[: self._playlist_track_limit]:
+                        uri = str(getattr(item, "uri", "") or getattr(item, "url", "") or "").strip()
+                        if uri:
+                            urls.append(uri)
+                        else:
+                            title = str(getattr(item, "title", "") or "").strip()
+                            author = str(getattr(item, "author", "") or "").strip()
+                            if title:
+                                term = f"{author} - {title}".strip(" -")
+                                urls.append(f"ytsearch:{term}")
         else:
             chosen = source
             if not self._looks_like_url(source):
@@ -2190,7 +2319,7 @@ class Media(commands.Cog):
             if chosen:
                 urls = [chosen]
 
-        urls = [u for u in urls if u][:100]
+        urls = [u for u in urls if u][: self._playlist_track_limit]
         if not urls:
             if lang == "ar":
                 return "تعذر استخراج مقاطع للحفظ."
@@ -2252,7 +2381,7 @@ class Media(commands.Cog):
         tracks = self._get_saved_playlist(guild_id)
         embed = discord.Embed(title="📚 Saved Playlist", color=NEON_CYAN)
         if not tracks:
-            embed.description = "No saved tracks yet. Use `/music playlist_add <query>`."
+            embed.description = idle_text("No saved tracks yet.", "Use `/music playlist_add <query>`.")
             return embed
         lines = [
             f"**{idx}.** {track.title[:70]} • `{track.format_duration()}`"
@@ -2467,20 +2596,22 @@ class Media(commands.Cog):
         )
         if is_supported_playlist:
             try:
-                pre_extracted_urls = await self._extract_playlist_entries(playlist_query, limit=100)
+                pre_extracted_urls = await self._extract_playlist_entries(playlist_query, limit=self._playlist_track_limit)
             except Exception:
                 pre_extracted_urls = []
 
         try:
             if pre_extracted_urls:
                 results = []
-                for url in pre_extracted_urls:
-                    found = await wavelink.Playable.search(url)
+                for index, url in enumerate(pre_extracted_urls, start=1):
+                    found = await self._search_playable_with_retry(self._to_lavalink_identifier(url), attempts=3)
                     if found:
                         results.append(found[0])
+                    if index % 3 == 0:
+                        await asyncio.sleep(self._playlist_batch_sleep)
             else:
                 # Search for playlist
-                results = await wavelink.Playable.search(playlist_query)
+                results = await self._search_playable_with_retry(self._to_lavalink_identifier(playlist_query), attempts=3)
         except Exception:
             if lang == "ar":
                 return "تعذر تحميل قائمة التشغيل."
@@ -2505,7 +2636,7 @@ class Media(commands.Cog):
         first = True
         
         # Process tracks in order
-        for wl_track in tracks_list[:100]:  # Limit to 100 tracks
+        for wl_track in tracks_list[: self._playlist_track_limit]:
             try:
                 track = self._wavelink_to_track(wl_track, actor.id)
                 
@@ -2552,8 +2683,7 @@ class Media(commands.Cog):
 
     @commands.hybrid_group(name="music", fallback="panel", description="Music controls", with_app_command=False)
     async def music_group(self, ctx: commands.Context) -> None:
-        if ctx.interaction and not ctx.interaction.response.is_done():
-            await ctx.interaction.response.defer(ephemeral=True)
+        await self._safe_ctx_defer(ctx, ephemeral=True)
         guild_id = ctx.guild.id if ctx.guild else None
         embed = await self._music_panel_embed(guild_id)
         panel_view = MusicPanelView(self, guild_id)
@@ -2563,8 +2693,7 @@ class Media(commands.Cog):
 
     @commands.hybrid_command(name="music_panel", description="Open interactive music panel")
     async def music_panel(self, ctx: commands.Context) -> None:
-        if ctx.interaction and not ctx.interaction.response.is_done():
-            await ctx.interaction.response.defer(ephemeral=True)
+        await self._safe_ctx_defer(ctx, ephemeral=True)
         guild_id = ctx.guild.id if ctx.guild else None
         embed = await self._music_panel_embed(guild_id)
         panel_view = MusicPanelView(self, guild_id)
@@ -2586,14 +2715,12 @@ class Media(commands.Cog):
             guild_id = ctx.guild.id if ctx.guild else None
             embed = await self._music_panel_embed(guild_id)
             panel_view = MusicPanelView(self, guild_id)
-            if ctx.interaction and not ctx.interaction.response.is_done():
-                await ctx.interaction.response.defer(ephemeral=True)
+            await self._safe_ctx_defer(ctx, ephemeral=True)
             panel_msg = await (ctx.interaction.followup.send("Use the panel below or provide a query:", embed=embed, view=panel_view, wait=True) if ctx.interaction else ctx.reply("Use the panel below or provide a query:", embed=embed, view=panel_view))
             if isinstance(panel_msg, discord.Message):
                 await panel_view.start_auto_refresh(panel_msg)
             return
-        if ctx.interaction and not ctx.interaction.response.is_done():
-            await ctx.defer()
+        await self._safe_ctx_defer(ctx)
         if not self._looks_like_url(query):
             suggestions = await self._unified_play_search(query, limit=10)
             if suggestions:
@@ -2678,22 +2805,19 @@ class Media(commands.Cog):
 
     @music_group.command(name="playlist_add", description="Add a track to saved playlist only")
     async def music_playlist_add(self, ctx: commands.Context, *, query: str) -> None:
-        if ctx.interaction and not ctx.interaction.response.is_done():
-            await ctx.defer()
+        await self._safe_ctx_defer(ctx)
         result = await self.add_query_to_saved_playlist(ctx, query)
         await ctx.reply(result)
 
     @music_group.command(name="playlist_play", description="Play one of your saved playlists by name")
     async def music_playlist_play(self, ctx: commands.Context, *, name: str) -> None:
-        if ctx.interaction and not ctx.interaction.response.is_done():
-            await ctx.defer()
+        await self._safe_ctx_defer(ctx)
         result = await self.play_user_saved_playlist(ctx, name)
         await ctx.reply(result)
 
     @music_group.command(name="playlist_save", description="Save URL/query (track or playlist) into named playlist")
     async def music_playlist_save(self, ctx: commands.Context, name: str, *, source: str) -> None:
-        if ctx.interaction and not ctx.interaction.response.is_done():
-            await ctx.defer(ephemeral=True)
+        await self._safe_ctx_defer(ctx, ephemeral=True)
         result = await self.save_query_to_named_playlist(ctx, name, source)
         if ctx.interaction:
             await ctx.interaction.followup.send(result, ephemeral=True)
@@ -2702,8 +2826,7 @@ class Media(commands.Cog):
 
     @music_group.command(name="playlist_delete", description="Delete one of your saved playlists by name")
     async def music_playlist_delete(self, ctx: commands.Context, *, name: str) -> None:
-        if ctx.interaction and not ctx.interaction.response.is_done():
-            await ctx.defer(ephemeral=True)
+        await self._safe_ctx_defer(ctx, ephemeral=True)
         result = await self.delete_user_playlist(ctx, name)
         if ctx.interaction:
             await ctx.interaction.followup.send(result, ephemeral=True)
@@ -2712,8 +2835,7 @@ class Media(commands.Cog):
 
     @music_group.command(name="playlist_rename", description="Rename one of your saved playlists")
     async def music_playlist_rename(self, ctx: commands.Context, old_name: str, *, new_name: str) -> None:
-        if ctx.interaction and not ctx.interaction.response.is_done():
-            await ctx.defer(ephemeral=True)
+        await self._safe_ctx_defer(ctx, ephemeral=True)
         result = await self.rename_user_playlist(ctx, old_name, new_name)
         if ctx.interaction:
             await ctx.interaction.followup.send(result, ephemeral=True)
@@ -2725,11 +2847,18 @@ class Media(commands.Cog):
         if not ctx.guild:
             await ctx.reply("Server only.")
             return
-        if ctx.interaction and not ctx.interaction.response.is_done():
-            await ctx.defer()
+        await self._safe_ctx_defer(ctx)
         normalized = self._sanitize_query(query)
         if not normalized:
-            await ctx.reply("Type a search query.")
+            await ctx.reply(
+                embed=await idle_embed_for_guild(
+                    "YouTube Search Idle",
+                    "Type a search query first.",
+                    "Example: /music yt_search weeknd blinding lights",
+                    guild=ctx.guild,
+                    bot=self.bot,
+                )
+            )
             return
 
         used_api = bool((self._youtube_api_key or "").strip())
@@ -2749,7 +2878,15 @@ class Media(commands.Cog):
                 )
                 await ctx.reply("No direct YouTube results found. Try one of these:", embed=fallback_embed)
                 return
-            await ctx.reply("No YouTube results found.")
+            await ctx.reply(
+                embed=await idle_embed_for_guild(
+                    "No Results",
+                    "No YouTube results were found for this query.",
+                    "Try a different title, artist name, or direct URL.",
+                    guild=ctx.guild,
+                    bot=self.bot,
+                )
+            )
             return
 
         embed = discord.Embed(
@@ -2771,8 +2908,7 @@ class Media(commands.Cog):
 
     @commands.hybrid_command(name="playlists", description="View your saved playlists")
     async def playlists(self, ctx: commands.Context) -> None:
-        if ctx.interaction and not ctx.interaction.response.is_done():
-            await ctx.defer(ephemeral=True)
+        await self._safe_ctx_defer(ctx, ephemeral=True)
         embed = await self.user_playlists_embed(ctx.author.id)
         if ctx.interaction:
             await ctx.interaction.followup.send(embed=embed, ephemeral=True)
@@ -2792,7 +2928,15 @@ class Media(commands.Cog):
             return
         queue = self.queues.get(ctx.guild.id, [])
         if len(queue) < 2:
-            await ctx.reply("Need at least 2 tracks to shuffle.")
+            await ctx.reply(
+                embed=await idle_embed_for_guild(
+                    "Shuffle Idle",
+                    "Need at least 2 tracks in queue to shuffle.",
+                    "Add more tracks first, then run /music shuffle.",
+                    guild=ctx.guild,
+                    bot=self.bot,
+                )
+            )
             return
         random.shuffle(queue)
         
@@ -3007,7 +3151,15 @@ class Media(commands.Cog):
             if lang == "ar":
                 await ctx.reply("❌ الطابور فارغ.")
             else:
-                await ctx.reply("❌ Queue is empty.")
+                await ctx.reply(
+                    embed=await idle_embed_for_guild(
+                        "Queue Idle",
+                        "Queue is empty. Nothing to move.",
+                        "Use /music play to add tracks.",
+                        guild=ctx.guild,
+                        bot=self.bot,
+                    )
+                )
             return
         
         # Convert to 0-indexed
@@ -3062,7 +3214,15 @@ class Media(commands.Cog):
             if lang == "ar":
                 await ctx.reply("❌ الطابور فارغ.")
             else:
-                await ctx.reply("❌ Queue is empty.")
+                await ctx.reply(
+                    embed=await idle_embed_for_guild(
+                        "Queue Idle",
+                        "Queue is empty. Nothing to swap.",
+                        "Use /music play to add tracks.",
+                        guild=ctx.guild,
+                        bot=self.bot,
+                    )
+                )
             return
         
         # Convert to 0-indexed
@@ -3115,7 +3275,15 @@ class Media(commands.Cog):
             if lang == "ar":
                 await ctx.reply("❌ الطابور فارغ.")
             else:
-                await ctx.reply("❌ Queue is empty.")
+                await ctx.reply(
+                    embed=await idle_embed_for_guild(
+                        "Queue Idle",
+                        "Queue is empty. Nothing to remove.",
+                        "Use /music play to add tracks.",
+                        guild=ctx.guild,
+                        bot=self.bot,
+                    )
+                )
             return
         
         idx = position - 1
@@ -3164,7 +3332,15 @@ class Media(commands.Cog):
             if lang == "ar":
                 await ctx.reply("❌ الطابور فارغ.")
             else:
-                await ctx.reply("❌ Queue is empty.")
+                await ctx.reply(
+                    embed=await idle_embed_for_guild(
+                        "Queue Idle",
+                        "Queue is empty. Nothing to jump to.",
+                        "Use /music play to add tracks.",
+                        guild=ctx.guild,
+                        bot=self.bot,
+                    )
+                )
             return
         
         idx = position - 1

bot/cogs/media_helpers.py

@@ -22,7 +22,7 @@ except Exception:
 from bot.theme import (
     NEON_CYAN, NEON_PURPLE, NEON_ORANGE, NEON_LIME, NEON_PINK,
     panel_divider, fancy_divider, fancy_header, progress_bar,
-    music_embed, music_now_playing, music_status, beautiful_list
+    music_embed, music_now_playing, music_status, beautiful_list, idle_embed_for_guild, idle_text, add_banner_to_embed
 )
 
 def _emoji(key: str, default: str) -> str:
@@ -896,7 +896,13 @@ class MusicPanelView(discord.ui.View, AutoRefreshMixin):
             return
         queue = self.cog.queues.get(interaction.guild.id, [])
         if len(queue) < 2:
-            await safe_send(interaction, "Need at least 2 tracks to shuffle.")
+            await safe_send(interaction, embed=await idle_embed_for_guild(
+                "Shuffle Idle",
+                "Need at least 2 tracks in queue to shuffle.",
+                "Add tracks from Play/Search, then retry.",
+                guild=interaction.guild,
+                bot=self.cog.bot,
+            ))
             return
         random.shuffle(queue)
         player = interaction.guild.voice_client
@@ -1175,9 +1181,12 @@ class QueueView(discord.ui.View, AutoRefreshMixin):
         else:
             embed.add_field(
                 name="📋 Up Next",
-                value="Add tracks with `/play`!\n" + fancy_divider('music'),
+                value=idle_text("Queue is empty.", "Add tracks with `/music play`.\n" + fancy_divider('music')),
                 inline=False
             )
+        guild = self.cog.bot.get_guild(self.guild_id) if hasattr(self.cog, "bot") else None
+        if guild:
+            await add_banner_to_embed(embed, guild, self.cog.bot)
         
         return embed
     

bot/cogs/menu.py

@@ -1,768 +1,819 @@
-"""
-Menu cog: Interactive command explorer with beautiful panels.
-Enhanced with stunning decorations, rich formatting, and multi-language support.
-"""
-
-import random
-
-import discord
-from discord.ext import commands
-
-from bot.cogs.ai_suite import ImperialMotaz
-from bot.emojis import ui, E_DIAMOND, E_STAR, E_FIRE, E_SPARKLE, E_GEM, E_CROWN
-from bot.theme import (
-    fancy_header, pick_neon_color, progress_bar, shimmer, panel_divider,
-    NEON_CYAN, NEON_PINK, NEON_PURPLE, NEON_LIME, NEON_YELLOW, NEON_BLUE,
-    NEON_GOLD, NEON_MAGENTA,
-    double_line, triple_line, mega_title, fancy_divider, animated_header,
-    gradient_header, panel_title, section_header, quick_stats_grid
-)
-from bot.i18n import translate, t
-
-
-# Beautiful unicode emojis for select menu categories
-_CATEGORY_EMOJIS = {
-    "Music": "🎵",
-    "Admin": "🛡️",
-    "Fun": "🎮",
-    "AI": "🤖",
-    "Utility": "🔧",
-    "Config": "⚙️",
-    "Economy": "💰",
-    "Moderation": "⚔️",
-    "Tickets": "🎫",
-    "Welcome": "👋",
-    "Giveaway": "🎁",
-    "Verification": "✅",
-    "Tournament": "🏆",
-    "Games": "🎲",
-    "Level": "✅",
-    "AutoMod": "🤖",
-    "Logs": "📋",
-    "DJ": "🎧",
-    "Developer": "💻",
-    "default": "📁",
-}
-
-# Category descriptions with emojis
-_CATEGORY_DESCRIPTIONS = {
-    "Music": "🎵 Music commands for playback control",
-    "Admin": "🛡️ Server administration tools",
-    "Fun": "🎮 Fun games and entertainment",
-    "AI": "🤖 AI-powered features",
-    "Utility": "🔧 Useful utility commands",
-    "Config": "⚙️ Bot configuration settings",
-    "Economy": "💰 Economy and currency system",
-    "Moderation": "⚔️ Moderation commands",
-    "Tickets": "🎫 Ticket support system",
-    "Welcome": "👋 Welcome and goodbye messages",
-    "Giveaway": "🎁 Giveaway management",
-    "Verification": "✅ Member verification",
-    "Tournament": "🏆 Tournament brackets",
-    "Games": "🎲 Mini games and fun",
-    "Level": "✅ XP and leveling system",
-    "AutoMod": "🤖 Auto-moderation features",
-    "Logs": "📋 Logging configuration",
-    "DJ": "🎧 DJ music controls",
-    "Developer": "💻 Developer tools",
-}
-
-_CATEGORY_BILINGUAL = {
-    "__all__": "📚 All Commands | جميع الأوامر",
-    "__ai__": "🤖 AI | الذكاء الاصطناعي",
-    "Music": "🎵 Music | الموسيقى",
-    "Admin": "🛡️ Admin | الإدارة",
-    "Fun": "🎮 Games | الألعاب",
-    "AI": "🤖 AI | الذكاء الاصطناعي",
-    "Utility": "🔧 Utility | الأدوات",
-    "Config": "⚙️ Config | الإعدادات",
-    "Economy": "💰 Economy | الاقتصاد",
-    "Moderation": "⚔️ Moderation | الإشراف",
-    "Community": "💡 Community | المجتمع",
-    "AISuite": "🤖 AI Suite | الذكاء",
-    "Configuration": "⚙️ Configuration | الإعدادات",
-    "Events": "📋 Events | الأحداث",
-    "Verification": "✅ Verification | التحقق",
-}
-
-
-def _bilingual_category(name: str) -> str:
-    return _CATEGORY_BILINGUAL.get(name, f"📁 {name} | {name}")
-
-
-class CommandsMenuSelect(discord.ui.Select):
-    """Beautiful dropdown menu for selecting command categories."""
-    
-    def __init__(self, cog_names: list[str], all_label: str, ai_label: str, lang: str = "en", selected_cog: str = "__all__") -> None:
-        self.lang = lang
-        
-        # Localized descriptions
-        all_desc = translate(lang, "menu.select_all_desc")
-        ai_desc = translate(lang, "menu.select_ai_desc")
-
-        options = [
-            discord.SelectOption(
-                label=_bilingual_category("__all__"),
-                description=all_desc,
-                emoji=ui("book"),
-                value="__all__",
-                default=selected_cog == "__all__",
-            ),
-            discord.SelectOption(
-                label=_bilingual_category("__ai__"),
-                description=ai_desc,
-                emoji=ui("robot"),
-                value="__ai__",
-                default=selected_cog == "__ai__",
-            ),
-        ]
-        
-        # Add cog options with beautiful emojis
-        for name in sorted(cog_names):
-            emoji = _CATEGORY_EMOJIS.get(name, _CATEGORY_EMOJIS["default"])
-            desc = translate(lang, f"menu.category_desc.{name.lower()}")
-            if desc == f"menu.category_desc.{name.lower()}":
-                desc = _CATEGORY_DESCRIPTIONS.get(name, f"📁 {name} commands")
-            # Truncate description to fit Discord's limits
-            desc = desc[:100]
-            options.append(
-                discord.SelectOption(
-                    label=_bilingual_category(name)[:100],
-                    description=desc,
-                    emoji=emoji,
-                    value=name,
-                    default=selected_cog == name,
-                )
-            )
-        
-        placeholder = translate(lang, "menu.select_placeholder")
-        super().__init__(
-            placeholder=placeholder,
-            min_values=1,
-            max_values=1,
-            options=options
-        )
-
-    async def callback(self, interaction: discord.Interaction) -> None:
-        await interaction.response.defer()
-        view = self.view
-        if not isinstance(view, CommandsMenuView):
-            return
-        selected = self.values[0]
-        view.selected_cog = selected
-        view.page = 0
-        await view.setup_items()
-        embed = await view.build_embed(interaction.guild.id if interaction.guild else None, selected)
-        await interaction.followup.edit_message(interaction.message.id, embed=embed, view=view)
-
-
-class CommandsMenuView(discord.ui.View):
-    """Beautiful command menu view with rich decorations."""
-    
-    def __init__(self, bot: commands.Bot, guild_id: int | None = None) -> None:
-        super().__init__(timeout=None)
-        self.bot = bot
-        self.guild_id = guild_id
-        self.selected_cog = "__all__"
-        self.page = 0
-        self.page_size = 18
-        self._accent_seed = random.randrange(0, 1024)
-        self._color_palette = [NEON_CYAN, NEON_PINK, NEON_PURPLE, NEON_LIME, NEON_GOLD, NEON_MAGENTA]
-
-    async def setup_items(self) -> None:
-        """Setup the menu items."""
-        cog_names = list(self.bot.cogs.keys())
-        lang = await self.bot.get_guild_language(self.guild_id)
-        all_label = translate(lang, "menu.all")
-        ai_label = translate(lang, "menu.ai")
-        self.clear_items()
-        self.add_item(CommandsMenuSelect(cog_names, all_label, ai_label, lang, self.selected_cog))
-        
-        refresh_label = translate(lang, "menu.refresh")
-        invite_label = translate(lang, "menu.invite_button")
-        self.add_item(RefreshButton(self, refresh_label))
-        self.add_item(QuickCategoryButton(self, "Economy | الاقتصاد", "Economy", "💰", row=1))
-        self.add_item(QuickCategoryButton(self, "Music | الموسيقى", "Music", "🎵", row=1))
-        self.add_item(QuickCategoryButton(self, "Admin | الإدارة", "Admin", "🛡️", row=1))
-        self.add_item(QuickCategoryButton(self, "Utility | الأدوات", "Utility", "ℹ️", row=1))
-        self.add_item(QuickCategoryButton(self, "Community | المجتمع", "Community", "💡", row=2))
-        self.add_item(QuickCategoryButton(self, "AI | الذكاء", "AISuite", "🤖", row=2))
-        self.add_item(QuickCategoryButton(self, "Config | الإعداد", "Configuration", "⚙️", row=2))
-        if self.page > 0:
-            self.add_item(PageButton(self, "prev"))
-        if self._has_next_page(self.selected_cog):
-            self.add_item(PageButton(self, "next"))
-        
-        if self.bot.user:
-            self.add_item(InviteButton(invite_label, self.bot.user.id))
-
-    def _desc_key(self, qualified_name: str) -> str:
-        """Get the translation key for a command description."""
-        norm = qualified_name.strip().lower().replace(" ", "_")
-        key_mapping = {
-            # Music commands
-            "play": "menu.cmd.play",
-            "music_play": "menu.cmd.music_play",
-            "music_panel": "menu.cmd.music_panel",
-            "music_skip": "menu.cmd.music_skip",
-            "music_stop": "menu.cmd.music_stop",
-            "music_pause": "menu.cmd.music_pause",
-            "music_resume": "menu.cmd.music_resume",
-            "music_queue": "menu.cmd.music_queue",
-            "music_playlist": "menu.cmd.music_playlist",
-            "music_playlist_save": "menu.cmd.music_playlist_save",
-            "music_playlist_rename": "menu.cmd.music_playlist_rename",
-            "music_playlist_delete": "menu.cmd.music_playlist_delete",
-            "music_volume": "menu.cmd.music_volume",
-            "music_nowplaying": "menu.cmd.music_nowplaying",
-            "music_filter": "menu.cmd.music_filter",
-            "music_loop": "menu.cmd.music_loop",
-            "music_shuffle": "menu.cmd.music_shuffle",
-            "music_247": "menu.cmd.music_247",
-            "music_previous": "menu.cmd.music_previous",
-            "music_seek": "menu.cmd.music_seek",
-            "music_clear": "menu.cmd.music_clear",
-            "music_remove": "menu.cmd.music_remove",
-            "music_move": "menu.cmd.music_move",
-            "music_jump": "menu.cmd.music_jump",
-            "music_lyrics": "menu.cmd.music_lyrics",
-            
-            # Admin commands
-            "purge": "menu.cmd.purge",
-            "ban": "menu.cmd.ban",
-            "unban": "menu.cmd.unban",
-            "kick": "menu.cmd.kick",
-            "mute": "menu.cmd.mute",
-            "unmute": "menu.cmd.unmute",
-            "warn": "menu.cmd.warn",
-            "warnings": "menu.cmd.warnings",
-            "clearwarn": "menu.cmd.clearwarn",
-            "slowmode": "menu.cmd.slowmode",
-            "lock": "menu.cmd.lock",
-            "unlock": "menu.cmd.unlock",
-            "cloneemoji": "menu.cmd.cloneemoji",
-            "awesomeroles": "menu.cmd.awesomeroles",
-            "backupserver": "menu.cmd.backupserver",
-            
-            # Fun commands
-            "8ball": "menu.cmd.8ball",
-            "meme": "menu.cmd.meme",
-            "trivia": "menu.cmd.trivia",
-            "gaming_news": "menu.cmd.gaming_news",
-            "free_games": "menu.cmd.free_games",
-            "gamehub": "menu.cmd.gamehub",
-            "xo": "menu.cmd.xo",
-            "choose": "menu.cmd.choose",
-            "mario": "menu.cmd.mario",
-            "dice": "menu.cmd.dice",
-            "slots": "menu.cmd.slots",
-            "coinflip": "menu.cmd.coinflip",
-            "roll": "menu.cmd.roll",
-            
-            # AI commands
-            "chat": "menu.cmd.chat",
-            "ask_image": "menu.cmd.ask_image",
-            "imagine": "menu.cmd.imagine",
-            "image_gen": "menu.cmd.image_gen",
-            "upscale": "menu.cmd.upscale",
-            "summarize": "menu.cmd.summarize",
-            "ai": "menu.cmd.ai",
-            "ai_chat": "menu.cmd.chat",
-            "ai_ask_image": "menu.cmd.ask_image",
-            "ai_imagine": "menu.cmd.imagine",
-            "ai_image_gen": "menu.cmd.image_gen",
-            "ai_upscale": "menu.cmd.upscale",
-            "ai_summarize": "menu.cmd.summarize",
-            "ai_debug": "menu.cmd.debug",
-            "ai_code_gen": "menu.cmd.code_gen",
-            "ai_voice": "menu.cmd.speak",
-            "ai_speak": "menu.cmd.speak",
-            "ai_tts": "menu.cmd.tts",
-            "ai_translate_voice": "menu.cmd.translate_voice",
-            "ai_model": "menu.cmd.ai_model",
-            "ai_channel": "menu.cmd.ai_channel",
-            "ai_auto": "menu.cmd.ai_auto",
-            "ai_setup": "menu.cmd.ai",
-            "ai_execute": "menu.cmd.ai_execute",
-            
-            # Utility commands
-            "serverinfo": "menu.cmd.serverinfo",
-            "userinfo": "menu.cmd.userinfo",
-            "botstats": "menu.cmd.botstats",
-            "poll": "menu.cmd.poll",
-            "remind": "menu.cmd.remind",
-            "avatar": "menu.cmd.avatar",
-            "banner": "menu.cmd.banner",
-            "translate": "menu.cmd.translate",
-            
-            # Config commands
-            "set": "menu.cmd.set",
-            "set_log": "menu.cmd.set_log",
-            "set_welcome": "menu.cmd.set_welcome",
-            "set_suggestions": "menu.cmd.set_suggestions",
-            "set_automod": "menu.cmd.set_automod",
-            "set_dailymessage": "menu.cmd.set_dailymessage",
-            "set_dailychannel": "menu.cmd.set_dailychannel",
-            "set_dailytime": "menu.cmd.set_dailytime",
-            "set_dailytitle": "menu.cmd.set_dailytitle",
-            "set_dailyimage": "menu.cmd.set_dailyimage",
-            "set_dailybutton": "menu.cmd.set_dailybutton",
-            "set_dailytoggle": "menu.cmd.set_dailytoggle",
-            "set_pollchannel": "menu.cmd.set_pollchannel",
-            "set_freegames": "menu.cmd.set_freegames",
-            "set_gamenews": "menu.cmd.set_gamenews",
-            "set_supportai": "menu.cmd.set_supportai",
-            "set_wisdom": "menu.cmd.set_wisdom",
-            
-            # Language commands
-            "language": "menu.cmd.language",
-            "languages": "menu.cmd.languages",
-            
-            # Menu commands
-            "menu": "menu.cmd.menu",
-            "ping": "menu.cmd.ping",
-            "load": "menu.cmd.load",
-            "unload": "menu.cmd.unload",
-            "reload": "menu.cmd.reload",
-            "sync": "menu.cmd.sync",
-            "shutdown": "menu.cmd.shutdown",
-            
-            # Verification commands
-            "verify": "menu.cmd.verify",
-            "verifysetup": "menu.cmd.verifysetup",
-            "verify_config": "menu.cmd.verify",
-            "verify_config_panel": "menu.cmd.verify",
-            "verify_config_setup": "menu.cmd.verifysetup",
-            
-            # Economy commands
-            "economy": "menu.cmd.economy",
-            "economy_deposit": "menu.cmd.economy_deposit",
-            "economy_withdraw": "menu.cmd.economy_withdraw",
-            "economy_gamble": "menu.cmd.economy_gamble",
-            "economy_rob": "menu.cmd.economy_rob",
-            "balance": "menu.cmd.balance",
-            "daily": "menu.cmd.daily",
-            "work": "menu.cmd.work",
-            "gamble": "menu.cmd.gamble",
-            "rob": "menu.cmd.rob",
-            "leaderboard": "menu.cmd.leaderboard",
-            "shop": "menu.cmd.shop",
-            "buy": "menu.cmd.buy",
-            "inventory": "menu.cmd.inventory",
-            "transfer": "menu.cmd.transfer",
-            
-            # Engagement commands
-            "xp": "menu.cmd.xp",
-            "level": "menu.cmd.level",
-            "rank": "menu.cmd.rank",
-            "suggest": "menu.cmd.suggest",
-            "suggestion": "menu.cmd.suggestion",
-            "suggestion_show": "menu.cmd.suggestion_show",
-            "suggestion_panel": "menu.cmd.suggestion_panel",
-            "suggestion_voters": "menu.cmd.suggestion_voters",
-            "giveaway_create": "menu.cmd.giveaway_create",
-            "giveaway_end": "menu.cmd.giveaway_end",
-            "ticket_panel": "menu.cmd.ticket_panel",
-            
-            # Tournament commands
-            "tournament": "menu.cmd.tournament",
-            "tournament_panel": "menu.cmd.tournament_panel",
-            "tournament_create": "menu.cmd.tournament_create",
-            "tournament_join": "menu.cmd.tournament_join",
-            "tournament_start": "menu.cmd.tournament_start",
-            "tournament_end": "menu.cmd.tournament_end",
-            "tournament_gamehub": "menu.cmd.tournament_gamehub",
-            
-            # Gambling commands
-            "blackjack": "menu.cmd.blackjack",
-            "roulette": "menu.cmd.roulette",
-            "rpg": "menu.cmd.rpg",
-            
+"""
+Menu cog: Interactive command explorer with beautiful panels.
+Enhanced with stunning decorations, rich formatting, and multi-language support.
+"""
+
+import random
+
+import discord
+from discord.ext import commands
+
+from bot.cogs.ai_suite import ImperialMotaz
+from bot.emojis import ui, E_DIAMOND, E_STAR, E_FIRE, E_SPARKLE, E_GEM, E_CROWN
+from bot.theme import (
+    fancy_header, pick_neon_color, progress_bar, shimmer, panel_divider,
+    NEON_CYAN, NEON_PINK, NEON_PURPLE, NEON_LIME, NEON_YELLOW, NEON_BLUE,
+    NEON_GOLD, NEON_MAGENTA,
+    double_line, triple_line, mega_title, fancy_divider, animated_header,
+    gradient_header, panel_title, section_header, quick_stats_grid
+)
+
+
+# Beautiful unicode emojis for select menu categories
+_CATEGORY_EMOJIS = {
+    "Music": "🎵",
+    "Admin": "🛡️",
+    "Fun": "🎮",
+    "AI": "🤖",
+    "Utility": "🔧",
+    "Config": "⚙️",
+    "Economy": "💰",
+    "Moderation": "⚔️",
+    "Tickets": "🎫",
+    "Welcome": "👋",
+    "Giveaway": "🎁",
+    "Verification": "✅",
+    "Tournament": "🏆",
+    "Games": "🎲",
+    "Level": "✅",
+    "AutoMod": "🤖",
+    "Logs": "📋",
+    "DJ": "🎧",
+    "Developer": "💻",
+    "default": "📁",
+}
+
+# Category descriptions with emojis
+_CATEGORY_DESCRIPTIONS = {
+    "Music": "🎵 Music commands for playback control",
+    "Admin": "🛡️ Server administration tools",
+    "Fun": "🎮 Fun games and entertainment",
+    "AI": "🤖 AI-powered features",
+    "Utility": "🔧 Useful utility commands",
+    "Config": "⚙️ Bot configuration settings",
+    "Economy": "💰 Economy and currency system",
+    "Moderation": "⚔️ Moderation commands",
+    "Tickets": "🎫 Ticket support system",
+    "Welcome": "👋 Welcome and goodbye messages",
+    "Giveaway": "🎁 Giveaway management",
+    "Verification": "✅ Member verification",
+    "Tournament": "🏆 Tournament brackets",
+    "Games": "🎲 Mini games and fun",
+    "Level": "✅ XP and leveling system",
+    "AutoMod": "🤖 Auto-moderation features",
+    "Logs": "📋 Logging configuration",
+    "DJ": "🎧 DJ music controls",
+    "Developer": "💻 Developer tools",
+}
+
+_CATEGORY_BILINGUAL = {
+    "__all__": "📚 All Commands | جميع الأوامر",
+    "__ai__": "🤖 AI | الذكاء الاصطناعي",
+    "Music": "🎵 Music | الموسيقى",
+    "Admin": "🛡️ Admin | الإدارة",
+    "Fun": "🎮 Games | الألعاب",
+    "AI": "🤖 AI | الذكاء الاصطناعي",
+    "Utility": "🔧 Utility | الأدوات",
+    "Config": "⚙️ Config | الإعدادات",
+    "Economy": "💰 Economy | الاقتصاد",
+    "Moderation": "⚔️ Moderation | الإشراف",
+    "Community": "💡 Community | المجتمع",
+    "AISuite": "🤖 AI Suite | الذكاء",
+    "Configuration": "⚙️ Configuration | الإعدادات",
+    "Events": "📋 Events | الأحداث",
+    "Verification": "✅ Verification | التحقق",
+}
+
+
+def _bilingual_category(name: str) -> str:
+    return _CATEGORY_BILINGUAL.get(name, f"📁 {name} | {name}")
+
+
+class CommandsMenuSelect(discord.ui.Select):
+    """Beautiful dropdown menu for selecting command categories."""
+    
+    def __init__(
+        self,
+        cog_names: list[str],
+        all_label: str,
+        ai_label: str,
+        *,
+        placeholder: str,
+        all_desc: str,
+        ai_desc: str,
+        cog_desc_map: dict[str, str],
+        selected_cog: str = "__all__",
+    ) -> None:
+
+        options = [
+            discord.SelectOption(
+                label=_bilingual_category("__all__"),
+                description=all_desc,
+                emoji=ui("book"),
+                value="__all__",
+                default=selected_cog == "__all__",
+            ),
+            discord.SelectOption(
+                label=_bilingual_category("__ai__"),
+                description=ai_desc,
+                emoji=ui("robot"),
+                value="__ai__",
+                default=selected_cog == "__ai__",
+            ),
+        ]
+        
+        # Add cog options with beautiful emojis
+        for name in sorted(cog_names):
+            emoji = _CATEGORY_EMOJIS.get(name, _CATEGORY_EMOJIS["default"])
+            desc = cog_desc_map.get(name, _CATEGORY_DESCRIPTIONS.get(name, f"{name} commands"))
+            # Truncate description to fit Discord's limits
+            desc = desc[:100]
+            options.append(
+                discord.SelectOption(
+                    label=_bilingual_category(name)[:100],
+                    description=desc,
+                    emoji=emoji,
+                    value=name,
+                    default=selected_cog == name,
+                )
+            )
+        
+        super().__init__(
+            placeholder=placeholder,
+            min_values=1,
+            max_values=1,
+            options=options
+        )
+
+    async def callback(self, interaction: discord.Interaction) -> None:
+        await interaction.response.defer()
+        view = self.view
+        if not isinstance(view, CommandsMenuView):
+            return
+        selected = self.values[0]
+        view.selected_cog = selected
+        view.page = 0
+        await view.setup_items()
+        embed = await view.build_embed(interaction.guild.id if interaction.guild else None, selected)
+        await interaction.followup.edit_message(interaction.message.id, embed=embed, view=view)
+
+
+class CommandsMenuView(discord.ui.View):
+    """Beautiful command menu view with rich decorations."""
+    
+    def __init__(self, bot: commands.Bot, guild_id: int | None = None) -> None:
+        super().__init__(timeout=None)
+        self.bot = bot
+        self.guild_id = guild_id
+        self.selected_cog = "__all__"
+        self.page = 0
+        self.page_size = 18
+        self._accent_seed = random.randrange(0, 1024)
+        self._color_palette = [NEON_CYAN, NEON_PINK, NEON_PURPLE, NEON_LIME, NEON_GOLD, NEON_MAGENTA]
+
+    async def setup_items(self) -> None:
+        """Setup the menu items."""
+        cog_names = list(self.bot.cogs.keys())
+        all_label = await self.bot.get_text(self.guild_id, "menu.all")
+        ai_label = await self.bot.get_text(self.guild_id, "menu.ai")
+        placeholder = await self.bot.get_text(self.guild_id, "menu.select_placeholder")
+        all_desc = await self.bot.get_text(self.guild_id, "menu.select_all_desc")
+        ai_desc = await self.bot.get_text(self.guild_id, "menu.select_ai_desc")
+        cog_desc_map: dict[str, str] = {}
+        for name in cog_names:
+            key = f"menu.category_desc.{name.lower()}"
+            desc = await self.bot.get_text(self.guild_id, key)
+            if desc == key:
+                desc = _CATEGORY_DESCRIPTIONS.get(name, f"📁 {name} commands")
+            cog_desc_map[name] = desc
+        self.clear_items()
+        self.add_item(
+            CommandsMenuSelect(
+                cog_names,
+                all_label,
+                ai_label,
+                placeholder=placeholder,
+                all_desc=all_desc,
+                ai_desc=ai_desc,
+                cog_desc_map=cog_desc_map,
+                selected_cog=self.selected_cog,
+            )
+        )
+
+        refresh_label = await self.bot.get_text(self.guild_id, "menu.refresh")
+        invite_label = await self.bot.get_text(self.guild_id, "menu.invite_button")
+        self.add_item(RefreshButton(self, refresh_label))
+        self.add_item(QuickCategoryButton(self, "Economy | الاقتصاد", "Economy", "💰", row=1))
+        self.add_item(QuickCategoryButton(self, "Music | الموسيقى", "Music", "🎵", row=1))
+        self.add_item(QuickCategoryButton(self, "Admin | الإدارة", "Admin", "🛡️", row=1))
+        self.add_item(QuickCategoryButton(self, "Utility | الأدوات", "Utility", "ℹ️", row=1))
+        self.add_item(QuickCategoryButton(self, "Community | المجتمع", "Community", "💡", row=2))
+        self.add_item(QuickCategoryButton(self, "AI | الذكاء", "AISuite", "🤖", row=2))
+        self.add_item(QuickCategoryButton(self, "Config | الإعداد", "Configuration", "⚙️", row=2))
+        if self.page > 0:
+            self.add_item(PageButton(self, "prev"))
+        if self._has_next_page(self.selected_cog):
+            self.add_item(PageButton(self, "next"))
+        
+        if self.bot.user:
+            self.add_item(InviteButton(invite_label, self.bot.user.id))
+
+    def _desc_key(self, qualified_name: str) -> str:
+        """Get the translation key for a command description."""
+        norm = qualified_name.strip().lower().replace(" ", "_")
+        key_mapping = {
+            # Music commands
+            "play": "menu.cmd.play",
+            "music_play": "menu.cmd.music_play",
+            "music_panel": "menu.cmd.music_panel",
+            "music_skip": "menu.cmd.music_skip",
+            "music_stop": "menu.cmd.music_stop",
+            "music_pause": "menu.cmd.music_pause",
+            "music_resume": "menu.cmd.music_resume",
+            "music_queue": "menu.cmd.music_queue",
+            "music_playlist": "menu.cmd.music_playlist",
+            "music_playlist_save": "menu.cmd.music_playlist_save",
+            "music_playlist_rename": "menu.cmd.music_playlist_rename",
+            "music_playlist_delete": "menu.cmd.music_playlist_delete",
+            "music_volume": "menu.cmd.music_volume",
+            "music_nowplaying": "menu.cmd.music_nowplaying",
+            "music_filter": "menu.cmd.music_filter",
+            "music_loop": "menu.cmd.music_loop",
+            "music_shuffle": "menu.cmd.music_shuffle",
+            "music_247": "menu.cmd.music_247",
+            "music_previous": "menu.cmd.music_previous",
+            "music_seek": "menu.cmd.music_seek",
+            "music_clear": "menu.cmd.music_clear",
+            "music_remove": "menu.cmd.music_remove",
+            "music_move": "menu.cmd.music_move",
+            "music_jump": "menu.cmd.music_jump",
+            "music_lyrics": "menu.cmd.music_lyrics",
+            
+            # Admin commands
+            "purge": "menu.cmd.purge",
+            "ban": "menu.cmd.ban",
+            "unban": "menu.cmd.unban",
+            "kick": "menu.cmd.kick",
+            "mute": "menu.cmd.mute",
+            "unmute": "menu.cmd.unmute",
+            "warn": "menu.cmd.warn",
+            "warnings": "menu.cmd.warnings",
+            "clearwarn": "menu.cmd.clearwarn",
+            "slowmode": "menu.cmd.slowmode",
+            "lock": "menu.cmd.lock",
+            "unlock": "menu.cmd.unlock",
+            "cloneemoji": "menu.cmd.cloneemoji",
+            "awesomeroles": "menu.cmd.awesomeroles",
+            "backupserver": "menu.cmd.backupserver",
+            
+            # Fun commands
+            "8ball": "menu.cmd.8ball",
+            "meme": "menu.cmd.meme",
+            "trivia": "menu.cmd.trivia",
+            "gaming_news": "menu.cmd.gaming_news",
+            "free_games": "menu.cmd.free_games",
+            "gamehub": "menu.cmd.gamehub",
+            "xo": "menu.cmd.xo",
+            "choose": "menu.cmd.choose",
+            "mario": "menu.cmd.mario",
+            "dice": "menu.cmd.dice",
+            "slots": "menu.cmd.slots",
+            "coinflip": "menu.cmd.coinflip",
+            "roll": "menu.cmd.roll",
+            
+            # AI commands
+            "chat": "menu.cmd.chat",
+            "ask_image": "menu.cmd.ask_image",
+            "imagine": "menu.cmd.imagine",
+            "image_gen": "menu.cmd.image_gen",
+            "upscale": "menu.cmd.upscale",
+            "summarize": "menu.cmd.summarize",
+            "ai": "menu.cmd.ai",
+            "ai_chat": "menu.cmd.chat",
+            "ai_ask_image": "menu.cmd.ask_image",
+            "ai_imagine": "menu.cmd.imagine",
+            "ai_image_gen": "menu.cmd.image_gen",
+            "ai_upscale": "menu.cmd.upscale",
+            "ai_summarize": "menu.cmd.summarize",
+            "ai_debug": "menu.cmd.debug",
+            "ai_code_gen": "menu.cmd.code_gen",
+            "ai_voice": "menu.cmd.speak",
+            "ai_speak": "menu.cmd.speak",
+            "ai_tts": "menu.cmd.tts",
+            "ai_translate_voice": "menu.cmd.translate_voice",
+            "ai_model": "menu.cmd.ai_model",
+            "ai_channel": "menu.cmd.ai_channel",
+            "ai_auto": "menu.cmd.ai_auto",
+            "ai_setup": "menu.cmd.ai",
+            "ai_execute": "menu.cmd.ai_execute",
+            
+            # Utility commands
+            "serverinfo": "menu.cmd.serverinfo",
+            "userinfo": "menu.cmd.userinfo",
+            "botstats": "menu.cmd.botstats",
+            "poll": "menu.cmd.poll",
+            "remind": "menu.cmd.remind",
+            "avatar": "menu.cmd.avatar",
+            "banner": "menu.cmd.banner",
+            "translate": "menu.cmd.translate",
+            
+            # Config commands
+            "set": "menu.cmd.set",
+            "set_log": "menu.cmd.set_log",
+            "set_welcome": "menu.cmd.set_welcome",
+            "set_suggestions": "menu.cmd.set_suggestions",
+            "set_automod": "menu.cmd.set_automod",
+            "set_dailymessage": "menu.cmd.set_dailymessage",
+            "set_dailychannel": "menu.cmd.set_dailychannel",
+            "set_dailytime": "menu.cmd.set_dailytime",
+            "set_dailytitle": "menu.cmd.set_dailytitle",
+            "set_dailyimage": "menu.cmd.set_dailyimage",
+            "set_dailybutton": "menu.cmd.set_dailybutton",
+            "set_dailytoggle": "menu.cmd.set_dailytoggle",
+            "set_pollchannel": "menu.cmd.set_pollchannel",
+            "set_freegames": "menu.cmd.set_freegames",
+            "set_gamenews": "menu.cmd.set_gamenews",
+            "set_supportai": "menu.cmd.set_supportai",
+            "set_wisdom": "menu.cmd.set_wisdom",
+            
+            # Language commands
+            "language": "menu.cmd.language",
+            "languages": "menu.cmd.languages",
+            
+            # Menu commands
+            "menu": "menu.cmd.menu",
+            "ping": "menu.cmd.ping",
+            "load": "menu.cmd.load",
+            "unload": "menu.cmd.unload",
+            "reload": "menu.cmd.reload",
+            "sync": "menu.cmd.sync",
+            "shutdown": "menu.cmd.shutdown",
+            
+            # Verification commands
+            "verify": "menu.cmd.verify",
+            "verifysetup": "menu.cmd.verifysetup",
+            "verify_config": "menu.cmd.verify",
+            "verify_config_panel": "menu.cmd.verify",
+            "verify_config_setup": "menu.cmd.verifysetup",
+            
+            # Economy commands
+            "economy": "menu.cmd.economy",
+            "economy_deposit": "menu.cmd.economy_deposit",
+            "economy_withdraw": "menu.cmd.economy_withdraw",
+            "economy_gamble": "menu.cmd.economy_gamble",
+            "economy_rob": "menu.cmd.economy_rob",
+            "balance": "menu.cmd.balance",
+            "daily": "menu.cmd.daily",
+            "work": "menu.cmd.work",
+            "gamble": "menu.cmd.gamble",
+            "rob": "menu.cmd.rob",
+            "leaderboard": "menu.cmd.leaderboard",
+            "shop": "menu.cmd.shop",
+            "buy": "menu.cmd.buy",
+            "inventory": "menu.cmd.inventory",
+            "transfer": "menu.cmd.transfer",
+            
+            # Engagement commands
+            "xp": "menu.cmd.xp",
+            "level": "menu.cmd.level",
+            "rank": "menu.cmd.rank",
+            "suggest": "menu.cmd.suggest",
+            "suggestion": "menu.cmd.suggestion",
+            "suggestion_show": "menu.cmd.suggestion_show",
+            "suggestion_panel": "menu.cmd.suggestion_panel",
+            "suggestion_voters": "menu.cmd.suggestion_voters",
+            "giveaway_create": "menu.cmd.giveaway_create",
+            "giveaway_end": "menu.cmd.giveaway_end",
+            "ticket_panel": "menu.cmd.ticket_panel",
+            
+            # Tournament commands
+            "tournament": "menu.cmd.tournament",
+            "tournament_panel": "menu.cmd.tournament_panel",
+            "tournament_create": "menu.cmd.tournament_create",
+            "tournament_join": "menu.cmd.tournament_join",
+            "tournament_start": "menu.cmd.tournament_start",
+            "tournament_end": "menu.cmd.tournament_end",
+            "tournament_gamehub": "menu.cmd.tournament_gamehub",
+            
+            # Gambling commands
+            "blackjack": "menu.cmd.blackjack",
+            "roulette": "menu.cmd.roulette",
+            "rpg": "menu.cmd.rpg",
+            
             # AI Admin commands
             "ai_admin": "menu.cmd.ai_admin",
             "ai_help": "menu.cmd.ai_help",
+            # Additional commands/groups to keep menu fully mapped
+            "admin": "menu.cmd.admin_panel",
+            "admin_panel": "menu.cmd.admin_panel",
+            "shield_level": "menu.cmd.shield_level",
+            "shield_state": "menu.cmd.shield_state",
+            "econ_admin": "menu.cmd.econ_admin",
+            "econadmin": "menu.cmd.econ_admin",
+            "economy_admin": "menu.cmd.econ_admin",
+            "giveaway": "menu.cmd.giveaway",
+            "ticket": "menu.cmd.ticket",
+            "poll_legacy": "menu.cmd.poll",
+            "setpollchannel": "menu.cmd.set_pollchannel",
+            "setsuggestionchannel": "menu.cmd.set_suggestions",
+            "set_freegame": "menu.cmd.set_freegames",
+            "setupserver": "menu.cmd.setupserver",
+            "organizechannels": "menu.cmd.organizechannels",
+            "backup_panel": "menu.cmd.backup_panel",
+            "system_audit": "menu.cmd.system_audit",
+            "wisdom_today": "menu.cmd.wisdom_today",
+            "freegames": "menu.cmd.free_games",
+            "playlists": "menu.cmd.music_playlist",
+            "music": "menu.cmd.music_panel",
+            "profile": "menu.cmd.profile",
+            "rps": "menu.cmd.rps",
+            "guess": "menu.cmd.guess",
+            "make_event": "menu.cmd.make_event",
+            "gambling_panel": "menu.cmd.gambling_panel",
+            "add_scam_image": "menu.cmd.add_scam_image",
+            "set_banner": "menu.cmd.set_banner",
+            "view_banner": "menu.cmd.view_banner",
+            "remove_banner": "menu.cmd.remove_banner",
+            "banner_help": "menu.cmd.banner_help",
+            "boardgames": "menu.cmd.boardgames",
+            "board_start": "menu.cmd.board_start",
+            "board_move": "menu.cmd.board_move",
+            "board_forfeit": "menu.cmd.board_forfeit",
+            "games_panel": "menu.cmd.games_panel",
+            "chess": "menu.cmd.chess",
+            "checkers": "menu.cmd.checkers",
+            "connect4": "menu.cmd.connect4",
+            "othello": "menu.cmd.othello",
+            "start": "menu.cmd.menu",
+            "command_fill": "menu.cmd.menu",
+            "tournament_lb": "menu.cmd.tournament_lb",
+            "aisetup": "menu.cmd.ai",
         }
-        return key_mapping.get(norm, f"menu.cmd.{norm}")
-
-    async def _format_commands(self, guild_id: int | None, cmds: list[commands.Command], max_lines: int = 20, max_chars: int = 980) -> str:
-        """Format commands list with beautiful decorations."""
-        lang = await self.bot.get_guild_language(guild_id)
-        lines: list[str] = []
-        used = 0
-        
-        for idx, cmd in enumerate(sorted(cmds, key=lambda c: c.qualified_name), start=1):
-            if cmd.hidden:
-                continue
-            
-            # Get translated description
-            desc_key = self._desc_key(cmd.qualified_name)
-            translated_desc = translate(lang, desc_key)
-            
-            if translated_desc == desc_key:
-                fallback_desc = (cmd.description or cmd.help or "").strip()
-                desc = fallback_desc if fallback_desc else "—"
-            else:
-                desc = translated_desc
-            
-            # Hybrid commands are shown with slash syntax; prefix-only commands use !
-            is_hybrid = isinstance(cmd, commands.HybridCommand)
-            if is_hybrid:
-                invoke = f"`/{cmd.qualified_name}`"
-            else:
-                invoke = f"`!{cmd.qualified_name}`"
-            line = f"• {invoke} — {desc[:78]}"
-            projected = used + len(line) + (1 if lines else 0)
-            
-            if projected > max_chars:
-                break
-            lines.append(line)
-            used = projected
-            
-            if len(lines) >= max_lines:
-                break
-        
+        return key_mapping.get(norm, f"menu.cmd.{norm}")
+
+    async def _format_commands(self, guild_id: int | None, cmds: list[commands.Command], max_lines: int = 20, max_chars: int = 980) -> str:
+        """Format commands list with beautiful decorations."""
+        lines: list[str] = []
+        used = 0
+
+        for idx, cmd in enumerate(sorted(cmds, key=lambda c: c.qualified_name), start=1):
+            if cmd.hidden:
+                continue
+
+            desc_key = self._desc_key(cmd.qualified_name)
+            translated_desc = await self.bot.get_text(guild_id, desc_key)
+            json_key = ""
+            if translated_desc == desc_key:
+                cog_key = (cmd.cog_name or "").lower()
+                json_key = f"commands.{cog_key}.{cmd.name}_desc" if cog_key else ""
+                if json_key:
+                    translated_desc = await self.bot.get_text(guild_id, json_key)
+
+            if translated_desc == desc_key or (json_key and translated_desc == json_key):
+                fallback_desc = (cmd.description or cmd.help or "").strip()
+                desc = fallback_desc if fallback_desc else "-"
+            else:
+                desc = translated_desc
+
+            is_hybrid = isinstance(cmd, commands.HybridCommand)
+            invoke = f"`/{cmd.qualified_name}`" if is_hybrid else f"`!{cmd.qualified_name}`"
+            line = f"- {invoke} - {desc[:78]}"
+            projected = used + len(line) + (1 if lines else 0)
+
+            if projected > max_chars:
+                break
+            lines.append(line)
+            used = projected
+
+            if len(lines) >= max_lines:
+                break
+
         if len(lines) < len([c for c in cmds if not c.hidden]):
-            suffix = "\n• ┈┈┈┈┈┈┈┈┈┈┈┈"
+            suffix = "\n- ------------"
             if used + len(suffix) <= max_chars:
-                lines.append("• ┈┈┈┈┈┈┈┈┈┈┈┈")
-        
-        return "\n".join(lines)
-
-    def _visible_commands_page(self, selected_cog: str) -> tuple[list[commands.Command], int]:
-        commands_list = sorted(self._selected_commands(selected_cog), key=lambda c: c.qualified_name)
-        if not commands_list:
-            return [], 1
-        total_pages = max(1, (len(commands_list) + self.page_size - 1) // self.page_size)
-        if self.page >= total_pages:
-            self.page = total_pages - 1
-        start = self.page * self.page_size
-        return commands_list[start:start + self.page_size], total_pages
-
-    def _has_next_page(self, selected_cog: str) -> bool:
-        commands_list = self._selected_commands(selected_cog)
-        total_pages = max(1, (len(commands_list) + self.page_size - 1) // self.page_size)
-        return self.page + 1 < total_pages
-
-    def _category_stats(self) -> list[tuple[str, int]]:
-        """Get category statistics."""
-        stats: list[tuple[str, int]] = []
-        for name, cog in self.bot.cogs.items():
-            cog_commands = [c for c in (cog.get_commands() if cog else []) if not c.hidden]
-            if cog_commands:
-                stats.append((name, len(cog_commands)))
-        return sorted(stats, key=lambda pair: (-pair[1], pair[0]))
+                lines.append("- ------------")
 
-    async def _category_value(self, stats: list[tuple[str, int]], guild_id: int | None) -> str:
-        """Format category statistics with beautiful decorations."""
-        lang = await self.bot.get_guild_language(guild_id)
-        if not stats:
-            return translate(lang, "menu.none")
-        
-        lines: list[str] = []
-        for index, (name, count) in enumerate(stats[:8], start=1):
-            badge = {1: "🥇", 2: "🥈", 3: "🥉"}.get(index, f"#{index}")
-            emoji = _CATEGORY_EMOJIS.get(name, "📁")
-            
-            if lang == "ar":
-                lines.append(f"{badge} {emoji} **{name}** — `{count}` أمر")
-            else:
-                lines.append(f"{badge} {emoji} **{name}** — `{count}` cmds")
-        
-        if len(stats) > 8:
-            lines.append("✦ ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈")
-        
         return "\n".join(lines)
-
-    async def _stats_text(
-        self,
-        guild_id: int | None,
-        total_commands: int,
-        category_count: int,
-        selection_label: str,
-        visible_commands: int,
-    ) -> str:
-        """Format statistics with beautiful decorations."""
-        lang = await self.bot.get_guild_language(guild_id)
-        
-        if lang == "ar":
-            pieces = [
-                f"📊 **إجمالي الأوامر:** `{total_commands}`",
-                f"📁 **الفئات:** `{category_count}`",
-                f"✨ **المحدد:** {selection_label} (`{visible_commands}` أمر)",
-                f"📈 {progress_bar(visible_commands, total_commands, size=14)}",
-            ]
-        else:
-            pieces = [
-                f"📊 **Total Commands:** `{total_commands}`",
-                f"📁 **Categories:** `{category_count}`",
-                f"✨ **Selected:** {selection_label} (`{visible_commands}` cmds)",
-                f"📈 {progress_bar(visible_commands, total_commands, size=14)}",
-            ]
-        return "\n".join(pieces)
-
-    async def _selected_label(self, guild_id: int | None, selected_cog: str) -> str:
-        """Get the label for the selected category."""
-        return _bilingual_category(selected_cog)
-
-    def _selected_commands(self, selected_cog: str) -> list[commands.Command]:
-        """Get commands for the selected category."""
-        def _flatten(cmds: list[commands.Command]) -> list[commands.Command]:
-            collected: list[commands.Command] = []
-            for command in cmds:
-                if command.hidden:
-                    continue
-                collected.append(command)
-                if isinstance(command, commands.Group):
-                    collected.extend([sub for sub in command.walk_commands() if not sub.hidden])
-            unique: dict[str, commands.Command] = {c.qualified_name: c for c in collected}
-            return list(unique.values())
-
-        if selected_cog == "__all__":
-            return _flatten(list(self.bot.commands))
-        if selected_cog == "__ai__":
-            ai_cog = self.bot.get_cog("AISuite")
-            return _flatten(list(ai_cog.get_commands() if ai_cog else []))
-        cog = self.bot.get_cog(selected_cog)
-        return _flatten(list(cog.get_commands() if cog else []))
-
-    def _top_level_slash_count(self) -> int:
-        """Count top-level slash-registered hybrid commands/groups (Discord limit: 100)."""
-        total = 0
-        for cmd in self.bot.commands:
-            if not isinstance(cmd, commands.HybridCommand):
-                continue
-            if getattr(cmd, "with_app_command", True):
-                total += 1
-        return total
-
-    async def build_embed(self, guild_id: int | None, selected_cog: str) -> discord.Embed:
-        """Build the beautiful embed for the menu."""
-        lang = await self.bot.get_guild_language(guild_id)
-        color = discord.Color(0x2B2D31)
-
-        title = "BOT- AI System"
-        desc = (
-            f"{translate(lang, 'menu.hub_welcome')}\n"
-            f"{translate(lang, 'menu.hub_explore')}\n"
-            f"{translate(lang, 'menu.hub_usage')}"
-        )
-        stats_title = translate(lang, "menu.stats_heading")
-        categories_title = translate(lang, "menu.categories_heading")
-        tips_title = translate(lang, "menu.tips_heading")
-        quick_title = translate(lang, "menu.quick_heading")
-        updates_title = translate(lang, "menu.updates_heading")
-        tips = (
-            f"• {translate(lang, 'menu.tip_line_1')}\n"
-            f"• {translate(lang, 'menu.tip_line_2')}\n"
-            f"• {translate(lang, 'menu.tip_line_3')}"
-        )
+
+    def _visible_commands_page(self, selected_cog: str) -> tuple[list[commands.Command], int]:
+        commands_list = sorted(self._selected_commands(selected_cog), key=lambda c: c.qualified_name)
+        if not commands_list:
+            return [], 1
+        total_pages = max(1, (len(commands_list) + self.page_size - 1) // self.page_size)
+        if self.page >= total_pages:
+            self.page = total_pages - 1
+        start = self.page * self.page_size
+        return commands_list[start:start + self.page_size], total_pages
+
+    def _has_next_page(self, selected_cog: str) -> bool:
+        commands_list = self._selected_commands(selected_cog)
+        total_pages = max(1, (len(commands_list) + self.page_size - 1) // self.page_size)
+        return self.page + 1 < total_pages
+
+    def _category_stats(self) -> list[tuple[str, int]]:
+        """Get category statistics."""
+        stats: list[tuple[str, int]] = []
+        for name, cog in self.bot.cogs.items():
+            cog_commands = [c for c in (cog.get_commands() if cog else []) if not c.hidden]
+            if cog_commands:
+                stats.append((name, len(cog_commands)))
+        return sorted(stats, key=lambda pair: (-pair[1], pair[0]))
+
+    async def _category_value(self, stats: list[tuple[str, int]], guild_id: int | None) -> str:
+        """Format category statistics with beautiful decorations."""
+        lang = await self.bot.get_guild_language(guild_id)
+        if not stats:
+            return await self.bot.get_text(guild_id, "menu.none")
+        
+        lines: list[str] = []
+        for index, (name, count) in enumerate(stats[:8], start=1):
+            badge = {1: "🥇", 2: "🥈", 3: "🥉"}.get(index, f"#{index}")
+            emoji = _CATEGORY_EMOJIS.get(name, "📁")
+            
+            if lang == "ar":
+                lines.append(f"{badge} {emoji} **{name}** — `{count}` أمر")
+            else:
+                lines.append(f"{badge} {emoji} **{name}** — `{count}` cmds")
+        
+        if len(stats) > 8:
+            lines.append("✦ ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈")
+        
+        return "\n".join(lines)
+
+    async def _stats_text(
+        self,
+        guild_id: int | None,
+        total_commands: int,
+        category_count: int,
+        selection_label: str,
+        visible_commands: int,
+    ) -> str:
+        """Format statistics with beautiful decorations."""
+        lang = await self.bot.get_guild_language(guild_id)
+        
+        if lang == "ar":
+            pieces = [
+                f"📊 **إجمالي الأوامر:** `{total_commands}`",
+                f"📁 **الفئات:** `{category_count}`",
+                f"✨ **المحدد:** {selection_label} (`{visible_commands}` أمر)",
+                f"📈 {progress_bar(visible_commands, total_commands, size=14)}",
+            ]
+        else:
+            pieces = [
+                f"📊 **Total Commands:** `{total_commands}`",
+                f"📁 **Categories:** `{category_count}`",
+                f"✨ **Selected:** {selection_label} (`{visible_commands}` cmds)",
+                f"📈 {progress_bar(visible_commands, total_commands, size=14)}",
+            ]
+        return "\n".join(pieces)
+
+    async def _selected_label(self, guild_id: int | None, selected_cog: str) -> str:
+        """Get the label for the selected category."""
+        return _bilingual_category(selected_cog)
+
+    def _selected_commands(self, selected_cog: str) -> list[commands.Command]:
+        """Get commands for the selected category."""
+        def _flatten(cmds: list[commands.Command]) -> list[commands.Command]:
+            collected: list[commands.Command] = []
+            for command in cmds:
+                if command.hidden:
+                    continue
+                collected.append(command)
+                if isinstance(command, commands.Group):
+                    collected.extend([sub for sub in command.walk_commands() if not sub.hidden])
+            unique: dict[str, commands.Command] = {c.qualified_name: c for c in collected}
+            return list(unique.values())
+
+        if selected_cog == "__all__":
+            return _flatten(list(self.bot.commands))
+        if selected_cog == "__ai__":
+            ai_cog = self.bot.get_cog("AISuite")
+            return _flatten(list(ai_cog.get_commands() if ai_cog else []))
+        cog = self.bot.get_cog(selected_cog)
+        return _flatten(list(cog.get_commands() if cog else []))
+
+    def _top_level_slash_count(self) -> int:
+        """Count top-level slash-registered hybrid commands/groups (Discord limit: 100)."""
+        total = 0
+        for cmd in self.bot.commands:
+            if not isinstance(cmd, commands.HybridCommand):
+                continue
+            if getattr(cmd, "with_app_command", True):
+                total += 1
+        return total
+
+    async def build_embed(self, guild_id: int | None, selected_cog: str) -> discord.Embed:
+        """Build the beautiful embed for the menu."""
+        color = discord.Color(0x2B2D31)
+
+        hub_welcome = await self.bot.get_text(guild_id, "menu.hub_welcome")
+        hub_explore = await self.bot.get_text(guild_id, "menu.hub_explore")
+        hub_usage = await self.bot.get_text(guild_id, "menu.hub_usage")
+        stats_title = await self.bot.get_text(guild_id, "menu.stats_heading")
+        categories_title = await self.bot.get_text(guild_id, "menu.categories_heading")
+        tips_title = await self.bot.get_text(guild_id, "menu.tips_heading")
+        quick_title = await self.bot.get_text(guild_id, "menu.quick_heading")
+        updates_title = await self.bot.get_text(guild_id, "menu.updates_heading")
+
+        title = "BOT- AI System"
+        desc = f"{hub_welcome}\n{hub_explore}\n{hub_usage}"
+        tips = (
+            f"? {await self.bot.get_text(guild_id, 'menu.tip_line_1')}\n"
+            f"? {await self.bot.get_text(guild_id, 'menu.tip_line_2')}\n"
+            f"? {await self.bot.get_text(guild_id, 'menu.tip_line_3')}"
+        )
         quick = (
-            f"🎵 `/music_panel` — {translate(lang, 'menu.quick_music')}\n"
-            f"🎮 `/gamehub` — {translate(lang, 'menu.quick_gamehub')}\n"
-            f"🏆 `/tournament panel` — {translate(lang, 'menu.quick_tournament')}\n"
-            f"💰 `/economy` — {translate(lang, 'menu.quick_economy')}"
+            f"- `/music_panel` - {await self.bot.get_text(guild_id, 'menu.quick_music')}\n"
+            f"- `/gamehub` - {await self.bot.get_text(guild_id, 'menu.quick_gamehub')}\n"
+            f"- `/tournament panel` - {await self.bot.get_text(guild_id, 'menu.quick_tournament')}\n"
+            f"- `/economy` - {await self.bot.get_text(guild_id, 'menu.quick_economy')}"
         )
+        quick_ai = await self.bot.get_text(guild_id, 'menu.quick_ai')
         updates = (
-            f"🧩 `/admin emoji clone` — {translate(lang, 'menu.update_cloneemoji')}\n"
-            f"🛡️ `/admin shield add_image` — {translate(lang, 'menu.update_shield_image')}\n"
-            f"🗳️ `/poll create` — {translate(lang, 'menu.update_poll_group')}\n"
-            f"💸 `/economy deposit` — {translate(lang, 'menu.update_economy_group')}\n"
-            f"🤖 `/ai execute` — {translate(lang, 'menu.quick_ai') if translate(lang, 'menu.quick_ai') != 'menu.quick_ai' else 'AI admin request'}"
-        )
-        footer = "🏮 Powered by BOT- AI Suite 🏮"
-
-        top_divider = panel_divider("cyan")
-        mid_divider = panel_divider("purple")
-        embed = ImperialMotaz.craft_embed(
-            title=title,
-            description=f"{top_divider}\n{desc}\n{mid_divider}",
-            color=color,
-            footer=footer,
-        )
-
-        if self.bot.user:
-            embed.set_thumbnail(url=self.bot.user.display_avatar.url)
-
-        all_commands = self._selected_commands("__all__")
-        category_stats = self._category_stats()
-        selected_label = await self._selected_label(guild_id, selected_cog)
-        selected_cmds = self._selected_commands(selected_cog)
-        visible_cmds, total_pages = self._visible_commands_page(selected_cog)
-        max_lines = 18
-        content = await self._format_commands(guild_id, visible_cmds, max_lines=max_lines)
-        
-        # Add fields with beautiful decorations
-        total_guilds = len(self.bot.guilds)
-        total_members = sum((g.member_count or 0) for g in self.bot.guilds)
-        latency_ms = f"{round(self.bot.latency * 1000)}ms"
-        slash_used = self._top_level_slash_count()
-        slash_budget = f"{slash_used}/100"
-        stats_grid = quick_stats_grid(
-            [
-                ("Guilds", str(total_guilds), "🌐"),
-                ("Members", f"{total_members:,}", "👥"),
-                ("Latency", latency_ms, "⚡"),
-                ("Slash", slash_budget, "🧮"),
-            ],
-            columns=2,
-        )
-        embed.add_field(name=stats_title, value=stats_grid, inline=False)
-        
-        embed.add_field(
-            name=categories_title,
-            value=await self._category_value(category_stats, guild_id),
-            inline=True,
-        )
-        
-        emoji = _CATEGORY_EMOJIS.get(selected_cog, "📁")
-        embed.add_field(
-            name=f"{emoji} {selected_label}",
-            value=content or translate(lang, "menu.none"),
-            inline=False,
-        )
-        
-        embed.add_field(
-            name=quick_title,
-            value=quick,
-            inline=True,
-        )
-
-        embed.add_field(
-            name=tips_title,
-            value=tips,
-            inline=True,
-        )
-
-        embed.add_field(
-            name=updates_title,
-            value=updates,
-            inline=False,
+            f"- `/admin emoji clone` - {await self.bot.get_text(guild_id, 'menu.update_cloneemoji')}\n"
+            f"- `/admin shield add_image` - {await self.bot.get_text(guild_id, 'menu.update_shield_image')}\n"
+            f"- `/poll create` - {await self.bot.get_text(guild_id, 'menu.update_poll_group')}\n"
+            f"- `/economy deposit` - {await self.bot.get_text(guild_id, 'menu.update_economy_group')}\n"
+            f"- `/ai execute` - {quick_ai if quick_ai != 'menu.quick_ai' else 'AI admin request'}"
         )
-        
-        embed.set_footer(text=footer)
-        embed.description = f"{embed.description}\n\n📄 Page {self.page + 1}/{total_pages}"
-        return embed
-
-
-class MainMenuView(CommandsMenuView):
-    """Named alias for persistent registration."""
-
-
-class InviteButton(discord.ui.Button):
-    """Beautiful invite button."""
-    
-    def __init__(self, label: str, client_id: int) -> None:
-        url = f"https://discord.com/api/oauth2/authorize?client_id={client_id}&permissions=0&scope=applications.commands%20bot"
-        super().__init__(
-            label=label,
-            style=discord.ButtonStyle.link,
-            url=url,
-            emoji=ui("link")
-        )
-
-
-class RefreshButton(discord.ui.Button):
-    """Beautiful refresh button."""
-    
-    def __init__(self, parent: CommandsMenuView, label: str) -> None:
-        super().__init__(
-            label=label,
-            emoji=ui("refresh"),
-            style=discord.ButtonStyle.secondary
-        )
-        self.parent_view = parent
-
-    async def callback(self, interaction: discord.Interaction) -> None:
-        await interaction.response.defer()
+        footer = "Powered by BOT- AI Suite"
+
+        top_divider = panel_divider("cyan")
+        mid_divider = panel_divider("purple")
+        embed = ImperialMotaz.craft_embed(
+            title=title,
+            description=f"{top_divider}\n{desc}\n{mid_divider}",
+            color=color,
+            footer=footer,
+        )
+
+        if self.bot.user:
+            embed.set_thumbnail(url=self.bot.user.display_avatar.url)
+
+        category_stats = self._category_stats()
+        selected_label = await self._selected_label(guild_id, selected_cog)
+        visible_cmds, total_pages = self._visible_commands_page(selected_cog)
+        content = await self._format_commands(guild_id, visible_cmds, max_lines=18)
+
+        total_guilds = len(self.bot.guilds)
+        total_members = sum((g.member_count or 0) for g in self.bot.guilds)
+        latency_ms = f"{round(self.bot.latency * 1000)}ms"
+        slash_used = self._top_level_slash_count()
+        slash_budget = f"{slash_used}/100"
+        stats_grid = quick_stats_grid(
+            [
+                ("Guilds", str(total_guilds), "G"),
+                ("Members", f"{total_members:,}", "M"),
+                ("Latency", latency_ms, "L"),
+                ("Slash", slash_budget, "S"),
+            ],
+            columns=2,
+        )
+        embed.add_field(name=stats_title, value=stats_grid, inline=False)
+
+        embed.add_field(
+            name=categories_title,
+            value=await self._category_value(category_stats, guild_id),
+            inline=True,
+        )
+
+        emoji = _CATEGORY_EMOJIS.get(selected_cog, "C")
+        none_text = await self.bot.get_text(guild_id, "menu.none")
+        embed.add_field(
+            name=f"{emoji} {selected_label}",
+            value=content or none_text,
+            inline=False,
+        )
+
+        embed.add_field(name=quick_title, value=quick, inline=True)
+        embed.add_field(name=tips_title, value=tips, inline=True)
+        embed.add_field(name=updates_title, value=updates, inline=False)
+
+        embed.set_footer(text=footer)
+        embed.description = f"{embed.description}\n\nPage {self.page + 1}/{total_pages}"
+        return embed
+
+
+class MainMenuView(CommandsMenuView):
+    """Named alias for persistent registration."""
+
+
+class InviteButton(discord.ui.Button):
+    """Beautiful invite button."""
+    
+    def __init__(self, label: str, client_id: int) -> None:
+        url = f"https://discord.com/api/oauth2/authorize?client_id={client_id}&permissions=0&scope=applications.commands%20bot"
+        super().__init__(
+            label=label,
+            style=discord.ButtonStyle.link,
+            url=url,
+            emoji=ui("link")
+        )
+
+
+class RefreshButton(discord.ui.Button):
+    """Beautiful refresh button."""
+    
+    def __init__(self, parent: CommandsMenuView, label: str) -> None:
+        super().__init__(
+            label=label,
+            emoji=ui("refresh"),
+            style=discord.ButtonStyle.secondary
+        )
+        self.parent_view = parent
+
+    async def callback(self, interaction: discord.Interaction) -> None:
+        await interaction.response.defer()
         guild_id = interaction.guild.id if interaction.guild else None
-        lang = await self.parent_view.bot.get_guild_language(guild_id)
-        self.label = translate(lang, "menu.refresh")
-        await self.parent_view.setup_items()
-        embed = await self.parent_view.build_embed(guild_id, "__all__")
-        await interaction.followup.edit_message(interaction.message.id, embed=embed, view=self.parent_view)
-
-
-class QuickCategoryButton(discord.ui.Button):
-    def __init__(self, parent: CommandsMenuView, label: str, category: str, emoji: str, *, row: int = 1) -> None:
-        super().__init__(
-            label=label,
-            emoji=emoji,
-            style=discord.ButtonStyle.secondary,
-            custom_id=f"menu:quick:{label.lower()}",
-            row=row,
-        )
-        self.parent_view = parent
-        self.category = category
-
-    async def callback(self, interaction: discord.Interaction) -> None:
-        await interaction.response.defer()
-        self.parent_view.selected_cog = self.category
-        self.parent_view.page = 0
-        await self.parent_view.setup_items()
-        embed = await self.parent_view.build_embed(interaction.guild.id if interaction.guild else None, self.category)
-        await interaction.followup.edit_message(interaction.message.id, embed=embed, view=self.parent_view)
-
-
-class PageButton(discord.ui.Button):
-    def __init__(self, parent: CommandsMenuView, direction: str) -> None:
-        self.parent_view = parent
-        self.direction = direction
-        label = "Previous" if direction == "prev" else "Next"
-        emoji = "⬅️" if direction == "prev" else "➡️"
-        super().__init__(label=label, emoji=emoji, style=discord.ButtonStyle.secondary)
-
-    async def callback(self, interaction: discord.Interaction) -> None:
-        await interaction.response.defer()
-        if self.direction == "prev":
-            self.parent_view.page = max(0, self.parent_view.page - 1)
-        else:
-            if self.parent_view._has_next_page(self.parent_view.selected_cog):
-                self.parent_view.page += 1
-        await self.parent_view.setup_items()
-        embed = await self.parent_view.build_embed(interaction.guild.id if interaction.guild else None, self.parent_view.selected_cog)
-        await interaction.followup.edit_message(interaction.message.id, embed=embed, view=self.parent_view)
-
-
-class Menu(commands.Cog):
-    """Interactive command menu with beautiful panels and multi-language support."""
-
-    def __init__(self, bot: commands.Bot) -> None:
-        self.bot = bot
-
+        self.label = await self.parent_view.bot.get_text(guild_id, "menu.refresh")
+        await self.parent_view.setup_items()
+        embed = await self.parent_view.build_embed(guild_id, "__all__")
+        await interaction.followup.edit_message(interaction.message.id, embed=embed, view=self.parent_view)
+
+
+class QuickCategoryButton(discord.ui.Button):
+    def __init__(self, parent: CommandsMenuView, label: str, category: str, emoji: str, *, row: int = 1) -> None:
+        super().__init__(
+            label=label,
+            emoji=emoji,
+            style=discord.ButtonStyle.secondary,
+            custom_id=f"menu:quick:{label.lower()}",
+            row=row,
+        )
+        self.parent_view = parent
+        self.category = category
+
+    async def callback(self, interaction: discord.Interaction) -> None:
+        await interaction.response.defer()
+        self.parent_view.selected_cog = self.category
+        self.parent_view.page = 0
+        await self.parent_view.setup_items()
+        embed = await self.parent_view.build_embed(interaction.guild.id if interaction.guild else None, self.category)
+        await interaction.followup.edit_message(interaction.message.id, embed=embed, view=self.parent_view)
+
+
+class PageButton(discord.ui.Button):
+    def __init__(self, parent: CommandsMenuView, direction: str) -> None:
+        self.parent_view = parent
+        self.direction = direction
+        label = "Previous" if direction == "prev" else "Next"
+        emoji = "⬅️" if direction == "prev" else "➡️"
+        super().__init__(label=label, emoji=emoji, style=discord.ButtonStyle.secondary)
+
+    async def callback(self, interaction: discord.Interaction) -> None:
+        await interaction.response.defer()
+        if self.direction == "prev":
+            self.parent_view.page = max(0, self.parent_view.page - 1)
+        else:
+            if self.parent_view._has_next_page(self.parent_view.selected_cog):
+                self.parent_view.page += 1
+        await self.parent_view.setup_items()
+        embed = await self.parent_view.build_embed(interaction.guild.id if interaction.guild else None, self.parent_view.selected_cog)
+        await interaction.followup.edit_message(interaction.message.id, embed=embed, view=self.parent_view)
+
+
+class Menu(commands.Cog):
+    """Interactive command menu with beautiful panels and multi-language support."""
+
+    def __init__(self, bot: commands.Bot) -> None:
+        self.bot = bot
+
     async def cog_load(self) -> None:
-        self.bot.add_view(CommandsMenuView(self))
-
-    @commands.hybrid_command(name="menu", description="Bot menu | قائمة أوامر واضحة")
-    async def menu(self, ctx: commands.Context) -> None:
-        """Display the beautiful command menu."""
-        if ctx.interaction and not ctx.interaction.response.is_done():
-            await ctx.interaction.response.defer()
-        guild_id = ctx.guild.id if ctx.guild else None
-        view = CommandsMenuView(self.bot, guild_id)
-        await view.setup_items()
-        embed = await view.build_embed(guild_id, "__all__")
-        if ctx.interaction:
-            await ctx.interaction.followup.send(embed=embed, view=view)
-        else:
-            await ctx.reply(embed=embed, view=view)
-
-    @commands.hybrid_command(name="start", description="Start menu | القائمة الرئيسية", with_app_command=False)
-    async def start_menu(self, ctx: commands.Context) -> None:
-        await self.menu(ctx)
-
-    async def cog_command_error(self, ctx: commands.Context, error: Exception) -> None:
-        embed = ImperialMotaz.craft_embed(
-            title="⚠️ Command Error | خطأ في الأمر",
-            description=f"「 {str(error)[:1000]} 」",
-            color=discord.Color(0x2B2D31),
-            footer="🏮 Powered by BOT- AI Suite 🏮",
-        )
-        try:
-            await ctx.reply(embed=embed)
-        except Exception:
-            if ctx.channel:
-                await ctx.channel.send(embed=embed)
-
-
-async def setup(bot: commands.Bot) -> None:
-    await bot.add_cog(Menu(bot))
+        self.bot.add_view(CommandsMenuView(self.bot))
+
+    @commands.hybrid_command(name="menu", description="Bot menu | قائمة أوامر واضحة")
+    async def menu(self, ctx: commands.Context) -> None:
+        """Display the beautiful command menu."""
+        if ctx.interaction and not ctx.interaction.response.is_done():
+            await ctx.interaction.response.defer()
+        guild_id = ctx.guild.id if ctx.guild else None
+        view = CommandsMenuView(self.bot, guild_id)
+        await view.setup_items()
+        embed = await view.build_embed(guild_id, "__all__")
+        if ctx.interaction:
+            await ctx.interaction.followup.send(embed=embed, view=view)
+        else:
+            await ctx.reply(embed=embed, view=view)
+
+    @commands.hybrid_command(name="start", description="Start menu | القائمة الرئيسية", with_app_command=False)
+    async def start_menu(self, ctx: commands.Context) -> None:
+        await self.menu(ctx)
+
+    async def cog_command_error(self, ctx: commands.Context, error: Exception) -> None:
+        embed = ImperialMotaz.craft_embed(
+            title="⚠️ Command Error | خطأ في الأمر",
+            description=f"「 {str(error)[:1000]} 」",
+            color=discord.Color(0x2B2D31),
+            footer="🏮 Powered by BOT- AI Suite 🏮",
+        )
+        try:
+            await ctx.reply(embed=embed)
+        except Exception:
+            if ctx.channel:
+                await ctx.channel.send(embed=embed)
+
+
+async def setup(bot: commands.Bot) -> None:
+    await bot.add_cog(Menu(bot))
+
+

bot/cogs/observability.py

@@ -1,14 +1,16 @@
-from __future__ import annotations
-
-import difflib
-import traceback
-from typing import get_args, get_origin
+from __future__ import annotations
+
+import difflib
+import json
+import traceback
+from pathlib import Path
+from typing import get_args, get_origin
 
 import discord
 from discord.ext import commands
 
 
-class Observability(commands.Cog):
+class Observability(commands.Cog):
     def __init__(self, bot: commands.Bot) -> None:
         self.bot = bot
 
@@ -122,8 +124,8 @@ class Observability(commands.Cog):
         embed.add_field(name="Error", value=f"```py\n{tb[-900:]}\n```", inline=False)
         await channel.send(embed=embed)
 
-    @commands.hybrid_command(name="command_fill", description="Show how to fill command arguments")
-    async def command_fill(self, ctx: commands.Context, *, command_name: str) -> None:
+    @commands.hybrid_command(name="command_fill", description="Show how to fill command arguments")
+    async def command_fill(self, ctx: commands.Context, *, command_name: str) -> None:
         command = self.bot.get_command(command_name.strip())
         if not command:
             close = self._closest_commands(command_name.strip())
@@ -141,8 +143,70 @@ class Observability(commands.Cog):
         usage = f"{ctx.prefix}{command.qualified_name} " + " ".join(pieces)
         embed = discord.Embed(title="🧩 Command Fill Helper", color=discord.Color.blurple())
         embed.add_field(name="Usage", value=f"`{usage.strip()}`", inline=False)
-        embed.add_field(name="Argument hints", value="\n".join(details) if details else "No arguments", inline=False)
-        await ctx.reply(embed=embed)
+        embed.add_field(name="Argument hints", value="\n".join(details) if details else "No arguments", inline=False)
+        await ctx.reply(embed=embed)
+
+    @commands.hybrid_command(name="system_audit", description="Run a quick runtime health audit")
+    @commands.has_permissions(manage_guild=True)
+    async def system_audit(self, ctx: commands.Context) -> None:
+        await self._safe_reply(ctx, "Running system audit...")
+
+        total_commands = len(self.bot.commands)
+        loaded_cogs = len(self.bot.cogs)
+
+        row = await self.bot.db.fetchone("PRAGMA table_info(guild_config)")
+        has_guild_config = bool(row)
+        cols = await self.bot.db.fetchall("PRAGMA table_info(guild_config)")
+        col_names = {str(r[1]) for r in cols} if cols else set()
+        has_banner_col = "custom_banner_url" in col_names
+        has_lang_col = "guild_language" in col_names
+
+        locale_dir = Path("bot/locales")
+        locale_files = sorted(p.name for p in locale_dir.glob("*.json")) if locale_dir.exists() else []
+        locale_issues = 0
+        if locale_files:
+            try:
+                base = json.loads((locale_dir / "en.json").read_text(encoding="utf-8"))
+                def flatten(obj, prefix=""):
+                    out = {}
+                    if isinstance(obj, dict):
+                        for k, v in obj.items():
+                            key = f"{prefix}.{k}" if prefix else k
+                            out.update(flatten(v, key))
+                    else:
+                        out[prefix] = obj
+                    return out
+                base_keys = set(flatten(base).keys())
+                for name in locale_files:
+                    data = json.loads((locale_dir / name).read_text(encoding="utf-8"))
+                    keys = set(flatten(data).keys())
+                    if base_keys - keys:
+                        locale_issues += 1
+            except Exception:
+                locale_issues += 1
+
+        checks = [
+            ("Commands registered", total_commands >= 50, str(total_commands)),
+            ("Cogs loaded", loaded_cogs >= 8, str(loaded_cogs)),
+            ("guild_config table", has_guild_config, "ok" if has_guild_config else "missing"),
+            ("guild_language column", has_lang_col, "ok" if has_lang_col else "missing"),
+            ("custom_banner_url column", has_banner_col, "ok" if has_banner_col else "missing"),
+            ("Locale files", bool(locale_files), f"{len(locale_files)} files"),
+            ("Locale consistency", locale_issues == 0, "ok" if locale_issues == 0 else f"{locale_issues} issue(s)"),
+        ]
+
+        passed = sum(1 for _, ok, _ in checks if ok)
+        status = "HEALTHY" if passed == len(checks) else "NEEDS ATTENTION"
+        color = discord.Color.green() if passed == len(checks) else discord.Color.orange()
+        lines = [f"{'✅' if ok else '⚠️'} {name}: `{detail}`" for name, ok, detail in checks]
+
+        embed = discord.Embed(
+            title=f"System Audit: {status}",
+            description="\n".join(lines),
+            color=color,
+        )
+        embed.set_footer(text=f"Passed {passed}/{len(checks)} checks")
+        await ctx.reply(embed=embed)
 
 
 async def setup(bot: commands.Bot) -> None:

bot/database.py

@@ -59,6 +59,8 @@ class Database:
             Path(self.path).parent.mkdir(parents=True, exist_ok=True)
             await asyncio.to_thread(shutil.copy2, local_file, self.path)
         except Exception:
+            # Disable further sync attempts to avoid repeated noisy auth/network failures.
+            self._hf_sync_enabled = False
             return
 
     async def _push_remote_db(self) -> None:
@@ -75,6 +77,8 @@ class Database:
                 commit_message="Bot DB sync",
             )
         except Exception:
+            # Disable further sync attempts to avoid repeated noisy auth/network failures.
+            self._hf_sync_enabled = False
             return
 
     async def _ensure_column(
@@ -337,6 +341,15 @@ class Database:
                 created_at TEXT DEFAULT CURRENT_TIMESTAMP,
                 PRIMARY KEY (guild_id, image_hash)
             );
+
+            CREATE TABLE IF NOT EXISTS bot_presence_config (
+                id INTEGER PRIMARY KEY CHECK (id = 1),
+                status TEXT DEFAULT 'online',
+                activity_type TEXT DEFAULT 'playing',
+                activity_text TEXT DEFAULT 'CYBER // GRID',
+                updated_by INTEGER,
+                updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+            );
             """
         )
 
@@ -375,6 +388,7 @@ class Database:
         await self._ensure_column(db, "guild_config", "game_news_channel_id", "INTEGER")
         await self._ensure_column(db, "guild_config", "game_news_role_id", "INTEGER")
         await self._ensure_column(db, "guild_config", "game_news_last_ids", "TEXT")
+        await self._ensure_column(db, "guild_config", "custom_banner_url", "TEXT")
 
         await db.commit()
         await self._push_remote_db()
@@ -405,15 +419,16 @@ class Database:
         """Clean up all data for a guild (for when bot leaves a server)."""
         async with self._lock:
             db = await self._get_connection()
-            await db.execute("DELETE FROM guild_config WHERE guild_id = ?", guild_id)
-            await db.execute("DELETE FROM user_xp WHERE guild_id = ?", guild_id)
-            await db.execute("DELETE FROM user_balance WHERE guild_id = ?", guild_id)
-            await db.execute("DELETE FROM user_daily_claim WHERE guild_id = ?", guild_id)
-            await db.execute("DELETE FROM user_work_cooldown WHERE guild_id = ?", guild_id)
-            await db.execute("DELETE FROM warns WHERE guild_id = ?", guild_id)
-            await db.execute("DELETE FROM tournaments WHERE guild_id = ?", guild_id)
-            await db.execute("DELETE FROM tournament_participants WHERE guild_id = ?", guild_id)
-            await db.execute("DELETE FROM tournament_games WHERE guild_id = ?", guild_id)
-            await db.execute("DELETE FROM voice_sessions WHERE guild_id = ?", guild_id)
+            params = (guild_id,)
+            await db.execute("DELETE FROM guild_config WHERE guild_id = ?", params)
+            await db.execute("DELETE FROM user_xp WHERE guild_id = ?", params)
+            await db.execute("DELETE FROM user_balance WHERE guild_id = ?", params)
+            await db.execute("DELETE FROM user_daily_claim WHERE guild_id = ?", params)
+            await db.execute("DELETE FROM user_work_cooldown WHERE guild_id = ?", params)
+            await db.execute("DELETE FROM warns WHERE guild_id = ?", params)
+            await db.execute("DELETE FROM tournaments WHERE guild_id = ?", params)
+            await db.execute("DELETE FROM tournament_participants WHERE guild_id = ?", params)
+            await db.execute("DELETE FROM tournament_games WHERE guild_id = ?", params)
+            await db.execute("DELETE FROM voice_sessions WHERE guild_id = ?", params)
             await db.commit()
         await self._push_remote_db()

bot/emojis.py

@@ -33,8 +33,8 @@ FALLBACK_EMOJIS: dict[str, str] = {
     "catjam": "😺", "djpeepo": "🎧", "spotify": "🎵", "partytime": "🎉", "letsgo": "🚀",
     
     # Arrows & decorations
-    "arrow_green": "🟢", "arrow_pink": "✅", "arrow_blue": "🔵", "arrow_purple": "🟢",
-    "arrow_orange": "🟠", "arrow_yellow": "🟡", "shield": "🛡️", "gift": "🎁", "hype": "🔥",
+    "arrow_green": "<:animatedarrowgreen:1477261279428087979>", "arrow_pink": "✅", "arrow_blue": "🔵", "arrow_purple": "<:animatedarrowgreen:1477261279428087979>",
+    "arrow_orange": "🟠", "arrow_yellow": "<:animatedarrowyellow:1477261257592668271>", "shield": "🛡️", "gift": "🎁", "hype": "🔥",
     
     # UI elements
     "notebook": "📓", "ticket": "🎫", "verified": "✅", "error": "❌", "loading": "⏳",
@@ -44,8 +44,8 @@ FALLBACK_EMOJIS: dict[str, str] = {
     "num_6": "6️⃣", "num_7": "7️⃣", "num_8": "8️⃣", "num_9": "9️⃣", "num_10": "🔟",
     
     # Enhanced decorations
-    "sparkle": "✨", "fire": "🔥", "heart": "✅", "purple_heart": "🟢", "blue_heart": "🔵",
-    "green_heart": "🟢", "yellow_heart": "🟡", "orange_heart": "🟠", "pink_heart": "✅",
+    "sparkle": "✨", "fire": "🔥", "heart": "✅", "purple_heart": "<:animatedarrowgreen:1477261279428087979>", "blue_heart": "🔵",
+    "green_heart": "<:animatedarrowgreen:1477261279428087979>", "yellow_heart": "<:animatedarrowyellow:1477261257592668271>", "orange_heart": "🟠", "pink_heart": "✅",
     "crown": "👑", "trophy": "🏆", "medal": "🎖️", "ribbon": "🎀", "gem": "💎",
     "crystal_ball": "🔮", "comet": "☄️", "star2": "✅", "star3": "✅", "dizzy": "💫",
     "boom": "💥", "zap": "⚡", "warning": "⚠️", "information": "ℹ️", "question": "❓",
@@ -67,7 +67,7 @@ FALLBACK_EMOJIS: dict[str, str] = {
     "credit_card": "💳", "chart": "📈", "bank": "🏦", "atm": "🏧", "receipt": "🧾",
     
     # Decorative borders
-    "line": "▬", "dash": "—", "dot": "•", "bullet": "•", "circle": "🟢",
+    "line": "▬", "dash": "—", "dot": "•", "bullet": "•", "circle": "<:animatedarrowgreen:1477261279428087979>",
     "square": "■", "diamond_shape": "◆", "triangle": "▲", "star_border": "✅",
 }
 
@@ -96,6 +96,16 @@ def _normalize_key(value: str) -> str:
     return (value or "").strip().lower().replace(" ", "_")
 
 
+def _sanitize_emoji_name(name: str) -> str:
+    cleaned = re.sub(r"[^A-Za-z0-9_]", "_", (name or "").strip())
+    cleaned = re.sub(r"_+", "_", cleaned).strip("_")
+    if not cleaned:
+        return "emoji"
+    if len(cleaned) < 2:
+        return f"{cleaned}_x"
+    return cleaned[:32]
+
+
 def set_emoji_bot(bot: discord.Client) -> None:
     """Register bot/client instance for dynamic custom emoji lookup."""
     global _EMOJI_BOT
@@ -198,11 +208,17 @@ def _parse_emoji_file() -> dict[str, str]:
                 if key and value:
                     # Check if value is already in full format
                     if (value.startswith("<:") or value.startswith("<a:")) and value.endswith(">"):
-                        # Already full format, use as-is
-                        parsed[key] = value
+                        cfg = _parse_custom_emoji_config(value)
+                        if cfg is not None:
+                            cfg_name, emoji_id, animated = cfg
+                            parsed[key] = _build_custom_emoji_code(
+                                _sanitize_emoji_name(cfg_name), emoji_id, animated
+                            )
+                        else:
+                            parsed[key] = value
                     elif value.isdigit():
                         # Just the ID, create full format
-                        parsed[key] = f"<:{name.strip()}:{value}>"
+                        parsed[key] = f"<:{_sanitize_emoji_name(name)}:{value}>"
                     else:
                         # Some other format, try to use as-is
                         parsed[key] = value
@@ -663,7 +679,7 @@ E_DIZZY = "💫"
 E_BOOM = "💥"
 E_ZAP = "⚡"
 E_HEART = "✅"
-E_PURPLE_HEART = "🟢"
+E_PURPLE_HEART = "<:animatedarrowgreen:1477261279428087979>"
 E_BLUE_HEART = "💙"
-E_GREEN_HEART = "💚"
+E_GREEN_HEART = "<:animatedarrowgreen:1477261279428087979>"
 E_YELLOW_HEART = "💛"

bot/i18n.py

@@ -20,7 +20,7 @@ TRANSLATIONS["ar"] = {
     # === Language Commands ===
     "lang.current": "{globe} لغة السيرفر الحالية: **العربية**.",
     "lang.updated": "{ok} تم تغيير لغة البوت إلى **العربية**. استخدم `/menu` لرؤية الأوامر باللغة المحددة.",
-    "lang.invalid": "{no} لغة غير مدعومة. استخدم: `ar`, `en`, `es`, `fr`, `de`, `tr`, `it`, `pt`, `ru`, `hi`, `id`, `ja`, `he`.",
+    "lang.invalid": "{no} لغة غير مدعومة. استخدم: `ar`, `de`, `en`, `es`, `fr`, `he`, `hi`, `id`, `it`, `ja`, `pt`, `ru`, `tr`, `zh`.",
     
     # === Menu System ===
     "menu.title": "{menu} قائمة أوامر البوت",
@@ -629,7 +629,7 @@ TRANSLATIONS["en"] = {
     # === Language Commands ===
     "lang.current": "{globe} Current server language: **English**.",
     "lang.updated": "{ok} Bot language changed to **English**. Use `/menu` to view commands in the selected language.",
-    "lang.invalid": "{no} Unsupported language. Use: `ar`, `en`, `es`, `fr`, `de`, `tr`, `it`, `pt`, `ru`, `hi`, `id`, `ja`, `he`.",
+    "lang.invalid": "{no} Unsupported language. Use: `ar`, `de`, `en`, `es`, `fr`, `he`, `hi`, `id`, `it`, `ja`, `pt`, `ru`, `tr`, `zh`.",
     
     # === Menu System ===
     "menu.title": "{menu} Bot Command Menu",
@@ -1445,6 +1445,19 @@ TRANSLATIONS["he"] = {
     "ping.desc": "זמן תגובה: **{latency}ms**",
 }
 
+# Chinese (fallback pack; missing keys are filled from English below)
+TRANSLATIONS["zh"] = {
+    "lang.current": "{globe} 当前服务器语言: **中文**。",
+    "lang.updated": "{ok} 机器人语言已切换为 **中文**。",
+    "lang.invalid": "{no} 不支持的语言。",
+    "menu.title": "{menu} 命令菜单",
+    "menu.all": "全部",
+    "menu.ai": "AI 面板",
+    "menu.refresh": "刷新",
+    "ping.title": "{ping} Pong",
+    "ping.desc": "延迟: **{latency}ms**",
+}
+
 # ═══════════════════════════════════════════════════════════════════════════════
 # HELPER FUNCTIONS
 # ═══════════════════════════════════════════════════════════════════════════════

bot/locales/ar.json

@@ -89,6 +89,12 @@
     },
     "ai": {
       "header": "『 <:birdmusic:1476278789251268824> 𝔸𝕀 𝕆𝕣𝕒𝕔𝕝𝕖 〣 』"
+    },
+    "ai_architect": {
+      "title": "?? ????? ????? ????? ?????? ?????????",
+      "proposal": "??????? ???????? ???????: {sections}",
+      "analyzing": "???? ????? ??????? ???????...",
+      "success": "????? ????? ????? ?????? ????????? ?????."
     }
   },
   "errors": {
@@ -267,8 +273,163 @@
       "set_banner": "تعيين بنر مخصص لهذا السيرفر",
       "remove_banner": "إزالة البنر المخصص من هذا السيرفر",
       "view_banner": "عرض البنر المخصص الحالي لهذا السيرفر",
-      "banner_help": "تعلم كيفية تعيين بنر مخصص"
-    }
+      "banner_help": "تعلم كيفية تعيين بنر مخصص",
+      "8ball": "8ball",
+      "add_scam_image": "Save scam image signature",
+      "admin_panel": "Open admin control panel",
+      "ai": "Ai",
+      "ai_auto": "Ai auto",
+      "ai_channel": "Ai channel",
+      "ai_model": "Ai model",
+      "ask_image": "Ask image",
+      "avatar": "Avatar",
+      "awesomeroles": "Awesomeroles",
+      "backup_panel": "Open backup management panel",
+      "backupserver": "Backupserver",
+      "balance": "Balance",
+      "ban": "Ban",
+      "banner": "Banner",
+      "board_forfeit": "Board forfeit",
+      "board_move": "Board move",
+      "board_start": "Board start",
+      "boardgames": "Boardgames",
+      "botstats": "Botstats",
+      "buy": "Buy",
+      "chat": "Chat",
+      "checkers": "Checkers",
+      "chess": "Chess",
+      "choose": "Choose",
+      "clearwarn": "Clearwarn",
+      "cloneemoji": "Cloneemoji",
+      "code_gen": "Code gen",
+      "coinflip": "Coinflip",
+      "connect4": "Connect4",
+      "daily": "Daily",
+      "debug": "Debug",
+      "dice": "Dice",
+      "econ_admin": "Manage user economy balances",
+      "economy": "Economy",
+      "economy_deposit": "Economy deposit",
+      "economy_gamble": "Economy gamble",
+      "economy_rob": "Economy rob",
+      "economy_withdraw": "Economy withdraw",
+      "free_games": "Free games",
+      "gamble": "Gamble",
+      "gamehub": "Gamehub",
+      "games_panel": "Games panel",
+      "gaming_news": "Gaming news",
+      "giveaway": "Giveaway command group",
+      "guess": "Guess",
+      "image_gen": "Image gen",
+      "imagine": "Imagine",
+      "inventory": "Inventory",
+      "kick": "Kick",
+      "language": "Language",
+      "languages": "Languages",
+      "leaderboard": "Leaderboard",
+      "level": "Level",
+      "load": "Load",
+      "lock": "Lock",
+      "make_event": "Make event",
+      "mario": "Mario",
+      "meme": "Meme",
+      "menu": "Menu",
+      "music_247": "Music 247",
+      "music_clear": "Music clear",
+      "music_filter": "Music filter",
+      "music_jump": "Music jump",
+      "music_loop": "Music loop",
+      "music_lyrics": "Music lyrics",
+      "music_move": "Music move",
+      "music_nowplaying": "Music nowplaying",
+      "music_panel": "Music panel",
+      "music_pause": "Music pause",
+      "music_play": "Music play",
+      "music_playlist_delete": "Music playlist delete",
+      "music_playlist_rename": "Music playlist rename",
+      "music_playlist_save": "Music playlist save",
+      "music_previous": "Music previous",
+      "music_queue": "Music queue",
+      "music_remove": "Music remove",
+      "music_resume": "Music resume",
+      "music_seek": "Music seek",
+      "music_shuffle": "Music shuffle",
+      "music_skip": "Music skip",
+      "music_stop": "Music stop",
+      "music_volume": "Music volume",
+      "mute": "Mute",
+      "organizechannels": "Organizechannels",
+      "othello": "Othello",
+      "ping": "Ping",
+      "play": "Play",
+      "poll": "Poll",
+      "profile": "Profile",
+      "purge": "Purge",
+      "rank": "Rank",
+      "reload": "Reload",
+      "remind": "Remind",
+      "rob": "Rob",
+      "roll": "Roll",
+      "rps": "Rps",
+      "serverinfo": "Serverinfo",
+      "set": "Set",
+      "set_automod": "Set automod",
+      "set_dailybutton": "Set dailybutton",
+      "set_dailychannel": "Set dailychannel",
+      "set_dailyimage": "Set dailyimage",
+      "set_dailymessage": "Set dailymessage",
+      "set_dailytime": "Set dailytime",
+      "set_dailytitle": "Set dailytitle",
+      "set_dailytoggle": "Set dailytoggle",
+      "set_freegames": "Set freegames",
+      "set_gamenews": "Set gamenews",
+      "set_log": "Set log",
+      "set_pollchannel": "Set pollchannel",
+      "set_suggestions": "Set suggestions",
+      "set_supportai": "Set supportai",
+      "set_welcome": "Set welcome",
+      "set_wisdom": "Set wisdom",
+      "setupserver": "Setupserver",
+      "shield_level": "Set shield sensitivity level",
+      "shield_state": "Show current shield state",
+      "shop": "Shop",
+      "shutdown": "Shutdown",
+      "slots": "Slots",
+      "slowmode": "Slowmode",
+      "speak": "Speak",
+      "summarize": "Summarize",
+      "sync": "Sync",
+      "system_audit": "Show system audit and diagnostics",
+      "ticket": "Ticket command group",
+      "tournament": "Tournament",
+      "tournament_create": "Tournament create",
+      "tournament_end": "Tournament end",
+      "tournament_gamehub": "Tournament gamehub",
+      "tournament_join": "Tournament join",
+      "tournament_lb": "Tournament lb",
+      "tournament_panel": "Tournament panel",
+      "tournament_start": "Tournament start",
+      "transfer": "Transfer",
+      "translate": "Translate",
+      "translate_voice": "Translate voice",
+      "trivia": "Trivia",
+      "tts": "Tts",
+      "unban": "Unban",
+      "unload": "Unload",
+      "unlock": "Unlock",
+      "unmute": "Unmute",
+      "upscale": "Upscale",
+      "userinfo": "Userinfo",
+      "verify": "Verify",
+      "verifysetup": "Verifysetup",
+      "warn": "Warn",
+      "warnings": "Warnings",
+      "wisdom_today": "Wisdom today",
+      "work": "Work",
+      "xo": "Xo",
+      "xp": "Xp"
+    },
+    "quick_ai": "??? ????? ??????? ?????????"
   },
   "gambling": {
     "blackjack": {
@@ -396,5 +557,19 @@
     "trivia_title": "سؤال مسابقة",
     "trivia_correct": "إجابة صحيحة!",
     "trivia_wrong": "إجابة خاطئة!"
+  },
+  "config": {
+    "visuals": {
+      "divider": "<:editprofilewhite:1476278814894981200> ??? ???????? ????????? ??? <:editprofilewhite:1476278814894981200>"
+    }
+  },
+  "ping": {
+    "title": "?? ????",
+    "desc": "??? ?????????: **{latency}ms**"
+  },
+  "roll": "{user} ??? ????? **{value}** (1-{limit}).",
+  "lang": {
+    "current": "Current server language: **English**.",
+    "updated": "Bot language changed successfully."
   }
-}
+}