Upload 94 files

.gitattributes

@@ -40,3 +40,5 @@ 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
+codex[[:space:]]resume[[:space:]]019d6e48-2f09-7771-b4ab-f2399bb70a8d filter=lfs diff=lfs merge=lfs -text
+database.db-wal filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -178,3 +178,6 @@ cookies.txt
 youtube.token.json
 *.token.json
 
+
+.qwen/
+gha-creds-*.json

README.md

@@ -6,68 +6,203 @@ colorTo: purple
 sdk: docker
 sdk_version: "20.10.25"
 python_version: "3.11"
-app_file: main.py
+app_file: bot/main.py
 pinned: false
 ---
-# fitness
 
-## نظرة سريعة على التطبيق
+# 🤖 Ultimate AI & Music Discord Bot
+
+A feature-rich, multi-purpose Discord bot with cyberpunk aesthetics, AI integration, music playback, economy system, and more.
+
+## ✨ Features
+
+### 🎵 Music System
+- Full music playback with Wavelink/Lavalink
+- Queue management, filters, 24/7 mode
+- Playlist support and lyrics display
+- Rich music control panels with buttons
+
+### 🤖 AI Suite
+- OpenRouter & Gemini AI integration
+- Auto-chat mode in dedicated channels
+- Image analysis and prompt generation
+- Multiple AI personalities (Wise, Sarcastic, Technical, Funny)
+
+### 💰 Economy & Engagement
+- Wallet, bank, daily rewards
+- Work, gamble, rob, shop system
+- XP/leveling with rank cards
+- Leaderboards and inventory
+
+### 🎮 Games & Fun
+- Trivia (Gaming, Movies, Series)
+- Arcade games (Mario challenge)
+- Board games (Chess, Checkers, Connect 4, Othello)
+- Classic games (XO, 8ball, Slots, Dice, Coinflip)
+
+### 🛡️ Moderation & Admin
+- Ban, kick, mute, warn, purge
+- Slowmode, lock/unlock channels
+- Server backup and restore
+- Auto-moderation features
+
+### 🌐 Multi-Language Support
+- 14+ languages: Arabic, English, French, Spanish, German, etc.
+- Full i18n with emoji placeholders
+- Per-server language configuration
+
+### 🎫 Community Features
+- Ticket system for support
+- Polls and suggestions
+- Giveaways with auto-winner selection
+- Verification system
+
+### 📊 Configuration
+- Per-server settings panel
+- Custom channels for logs, welcome, daily messages
+- DJ role, premium tiers, music autoplay
+- Game news and free games alerts
+
+## 🚀 Quick Start
+
+### Prerequisites
+- Python 3.11+
+- Discord Bot Token ([Discord Developer Portal](https://discord.com/developers/applications))
+- Optional: OpenRouter API key, Gemini API key
+
+### Installation
+
+1. **Clone the repository**
+```bash
+git clone <your-repo-url>
+cd BOT-
+```
 
-المشروع يحتوي على جزأين رئيسيين:
+2. **Install dependencies**
+```bash
+pip install -r requirements.txt
+```
 
-- `fitness_app`: باك-إند Python باستخدام `FastAPI` مسؤول عن منطق التطبيق، قاعدة البيانات، والتكامل مع الذكاء الاصطناعي.
-- `FitAI_WPF`: واجهة مستخدم سطح مكتب (`C# WPF`) تتصل بواجهة الـ API المحلية.
+3. **Set up environment variables**
+```bash
+cp .env.example .env
+```
 
-## تشغيل الباك-إند (Python)
+Edit `.env` with your configuration:
+```env
+DISCORD_TOKEN=your_bot_token_here
+PREFIX=!
+OWNER_IDS=your_discord_user_id
+OPENROUTER_API_KEY=your_openrouter_key
+GEMINI_API_KEY=your_gemini_key
+```
 
+4. **Run the bot**
 ```bash
-cd fitness_app
-pip install -r requirements.txt
-python main.py
+python -m bot.main
+```
+
+## 🐳 Docker Deployment
+
+```bash
+docker build -t discord-bot .
+docker run -d --env-file .env discord-bot
 ```
 
-عند التشغيل، الخدمة تعمل على:
+## 🌐 Cloud Deployment
 
-- `http://127.0.0.1:8000`
-- فحص الصحة: `GET /health`
+### HuggingFace Spaces
+- Push your code to a HF Space
+- Set environment variables in Space settings
+- The bot will auto-start on deployment
 
-## إعداد مزود الذكاء الاصطناعي عبر `.env`
+### Render
+- Connect your GitHub repository
+- Use the `render.yaml` configuration
+- Add environment variables in Render dashboard
 
-داخل مجلد `fitness_app` انسخ المثال:
+## ⚙️ Configuration
 
-```bash
-cp .env.example .env
+### Required Environment Variables
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `DISCORD_TOKEN` | Your Discord bot token | `MTIz...` |
+| `PREFIX` | Command prefix | `!` or `/` |
+| `OWNER_IDS` | Comma-separated owner user IDs | `123456789,987654321` |
+
+### Optional Environment Variables
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `OPENROUTER_API_KEY` | OpenRouter API key for AI | - |
+| `GEMINI_API_KEY` | Google Gemini API key | - |
+| `OPENROUTER_MODEL` | Default AI model | `meta-llama/llama-3.3-70b-instruct:free` |
+| `DB_PATH` | Custom database path | `database.db` |
+| `HF_TOKEN` | HuggingFace token for DB sync | - |
+| `HF_DB_REPO_ID` | HuggingFace repo for cloud sync | - |
+| `PORT` | Keep-alive server port | `10000` |
+
+## 📁 Project Structure
+
+```
+BOT-/
+├── bot/
+│   ├── cogs/           # Bot modules (cogs)
+│   │   ├── admin.py
+│   │   ├── ai_suite.py
+│   │   ├── media.py
+│   │   ├── community.py
+│   │   └── ...
+│   ├── utils/          # Utility modules
+│   ├── locales/        # Translation files
+│   ├── main.py         # Bot entry point
+│   ├── config.py       # Configuration loader
+│   ├── database.py     # Database layer
+│   ├── emojis.py       # Emoji system
+│   ├── i18n.py         # Translations
+│   └── theme.py        # Styling & colors
+├── requirements.txt
+├── Dockerfile
+├── render.yaml
+├── .env.example
+└── README.md
 ```
 
-ثم عدّل القيم (المزود + API key + الموديل):
+## 🎮 Available Commands
 
-- `FITAI_AI_PROVIDER=google` لتشغيل Gemini مباشرة.
-- `FITAI_AI_PROVIDER=openai_compatible` لأي مزود يدعم OpenAI Chat API (مثل OpenAI/OpenRouter/Groq...).
-- `FITAI_AI_BASE_URL` لعنوان المزود عند استخدام `openai_compatible`.
-- `FITAI_AI_API_KEY` أو مفاتيح منفصلة `FITAI_COACH_API_KEY` / `FITAI_DEV_API_KEY`.
-- `FITAI_AI_MODEL_FAST/SMART/FALLBACK` أو تخصيص لكل role عبر `FITAI_COACH_MODEL_*` و`FITAI_DEV_MODEL_*`.
+Once the bot is running, use `<prefix>menu` or `/menu` to see all available commands organized by category:
 
-## أهم الـ API Endpoints
+- **Music**: play, pause, skip, queue, volume, filters
+- **Admin**: ban, kick, mute, warn, purge, backup
+- **Fun**: 8ball, trivia, meme, roll, mario
+- **AI**: chat, ask_image, imagine, summarize
+- **Economy**: balance, daily, work, gamble, shop
+- **Utility**: serverinfo, userinfo, ping, remind
+- **Configuration**: set, language, setup
 
-- الملف الشخصي: `GET/POST /user/profile`
-- توليد البرنامج: `POST /program/generate` ثم `GET /program/status`
-- الإحصائيات: `POST /stats/body` و `GET /stats/body`
-- الجلسات: `POST /session/start` و `POST /session/{id}/complete`
-- ماء اليوم: `GET /water/today` و `POST /water/log`
-- الداشبورد الموحد: `GET /dashboard`
+## 🛡️ Security Notes
 
-## ملاحظات
+- Never share your `DISCORD_TOKEN` or API keys
+- Use `.env` file for sensitive configuration
+- Set `OWNER_IDS` to restrict admin commands
+- The bot uses SQLite with WAL mode for data integrity
 
-- الاتصال مهيأ محليًا بين WPF والباك-إند عبر `localhost:8000`.
-- يوجد ملف قاعدة بيانات SQLite داخل `fitness_app/fitness.db`.
+## 🤝 Contributing
 
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Submit a pull request
 
-### حل مشكلة عدم اكتشاف backend في نسخة Windows
+## 📝 License
 
-إذا ظهر خطأ `تعذّر تشغيل Python backend` رغم تثبيت Python، حدّد مسار الـ backend يدوياً عبر متغير البيئة:
+This project is provided as-is for educational and community use.
 
-```powershell
-setx FITAI_PYTHON_DIR "D:\path\to\fitness_app"
-```
+## 🆘 Support
+
+- Open an issue on GitHub for bug reports
+- Check the wiki for common problems
+- Use the bot's `/help` command for usage info
+
+---
 
-ثم أغلق التطبيق وافتحه من جديد.
+**Developed with ❤️ by Motaz**

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

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4ac3a481b82aa0aff762d68dd8f262478a5a3f489e08f7b8425530f0fd9298e9
-size 123269
+oid sha256:4e65407e3a0ee2ebbaee76d78967fa971bfa4460c8922ad8f4b67abac8670f4e
+size 125088

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

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

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

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

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

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

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

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1790d4598667f2166132f1c7a8fe1b7456b9636d022b8e17be45d36b6eef022e
-size 110376
+oid sha256:58e4643fd664dcdb77bde357abcf03ef9507fb718cb6a8aa0a575b041c7a7102
+size 141527

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

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a0a9b36f61b4f52cd987d08126f68dce43ae5de6f0cf107f5fc5aeb53a5e6d74
-size 220308
+oid sha256:4a4041ede6a563d0c1605ccde48c9572c66d76bbbaa74f4a7e64abc807651d3a
+size 223657

bot/cogs/admin.py

@@ -19,6 +19,7 @@ from bot.theme import (
     NEON_BLUE, NEON_YELLOW, panel_divider, success_embed, error_embed, warning_embed, info_embed,
     double_line, triple_line, shimmer, pick_neon_color, add_banner_to_embed
 )
+from bot.i18n import get_cmd_desc
 from bot.emojis import (
     ui, E_SHIELD, E_CROWN, E_TROPHY, E_FIRE, E_SPARKLE, E_LOCK, E_KEY,
     E_ARROW_BLUE, E_ARROW_GREEN, E_ARROW_PINK, E_ARROW_PURPLE, E_GEM, E_STAR
@@ -29,7 +30,7 @@ from bot.emojis import (
 # AWESOME ROLES DEFINITIONS
 # ═══════════════════════════════════════════════════════════════════════════════
 
-AWESOME_ROLES = [
+AWESOME_ROLES = [
     {
         "name": "✨ Cyan Legend",
         "color": NEON_CYAN,
@@ -79,25 +80,25 @@ AWESOME_ROLES = [
         "hoist": True,
         "description": "Trusted member with azure power"
     },
-]
-
-PRESENCE_STATUS_MAP: dict[str, discord.Status] = {
-    "online": discord.Status.online,
-    "idle": discord.Status.idle,
-    "dnd": discord.Status.dnd,
-    "invisible": discord.Status.invisible,
-    "offline": discord.Status.invisible,
-}
-
-PRESENCE_ACTIVITY_MAP: dict[str, discord.ActivityType] = {
-    "playing": discord.ActivityType.playing,
-    "watching": discord.ActivityType.watching,
-    "listening": discord.ActivityType.listening,
-    "competing": discord.ActivityType.competing,
-}
-
-
-class AdminMasterPanel(discord.ui.View):
+]
+
+PRESENCE_STATUS_MAP: dict[str, discord.Status] = {
+    "online": discord.Status.online,
+    "idle": discord.Status.idle,
+    "dnd": discord.Status.dnd,
+    "invisible": discord.Status.invisible,
+    "offline": discord.Status.invisible,
+}
+
+PRESENCE_ACTIVITY_MAP: dict[str, discord.ActivityType] = {
+    "playing": discord.ActivityType.playing,
+    "watching": discord.ActivityType.watching,
+    "listening": discord.ActivityType.listening,
+    "competing": discord.ActivityType.competing,
+}
+
+
+class AdminMasterPanel(discord.ui.View):
     def __init__(self, cog: "Admin") -> None:
         super().__init__(timeout=None)
         self.cog = cog
@@ -128,27 +129,34 @@ class AdminMasterPanel(discord.ui.View):
             )
             return
         if choice == "shield":
-            await interaction.response.send_message("Use: `/shield_state` or `/shield_level low|medium|high`", ephemeral=True)
+            events_cog = self.cog.bot.get_cog("Events")
+            if events_cog is None:
+                await interaction.response.send_message("❌ Events cog not loaded.", ephemeral=True)
+                return
+            from bot.cogs.events import ShieldControlPanel
+            panel = ShieldControlPanel(events_cog, interaction.guild.id)
+            embed = await panel._build_embed()
+            await interaction.response.edit_message(embed=embed, view=panel)
+            return
+        if choice == "status":
+            synced = "Enabled" if self.cog.bot.db._hf_sync_enabled else "Disabled"
+            activity_obj = getattr(self.cog.bot, "activity", None)
+            activity_name = getattr(activity_obj, "name", None) or "CYBER // GRID"
+            activity_type = str(getattr(activity_obj, "type", "playing")).replace("ActivityType.", "")
+            status_name = str(getattr(self.cog.bot, "status", "online")).replace("Status.", "")
+            await interaction.response.send_message(
+                (
+                    f"HF DB Sync: **{synced}**\n"
+                    f"Bot Status: **{status_name}**\n"
+                    f"Bot Activity: **{activity_type}** • **{activity_name}**\n\n"
+                    "Owner commands:\n"
+                    "`/set_bot_status <status> <activity_type> <text>`\n"
+                    "`/reset_bot_status`\n"
+                    "`/bot_status`"
+                ),
+                ephemeral=True,
+            )
             return
-        if choice == "status":
-            synced = "Enabled" if self.cog.bot.db._hf_sync_enabled else "Disabled"
-            activity_obj = getattr(self.cog.bot, "activity", None)
-            activity_name = getattr(activity_obj, "name", None) or "CYBER // GRID"
-            activity_type = str(getattr(activity_obj, "type", "playing")).replace("ActivityType.", "")
-            status_name = str(getattr(self.cog.bot, "status", "online")).replace("Status.", "")
-            await interaction.response.send_message(
-                (
-                    f"HF DB Sync: **{synced}**\n"
-                    f"Bot Status: **{status_name}**\n"
-                    f"Bot Activity: **{activity_type}** • **{activity_name}**\n\n"
-                    "Owner commands:\n"
-                    "`/set_bot_status <status> <activity_type> <text>`\n"
-                    "`/reset_bot_status`\n"
-                    "`/bot_status`"
-                ),
-                ephemeral=True,
-            )
-            return
         if choice == "giveaways":
             await interaction.response.send_message(
                 "**Giveaway Commands:**\n"
@@ -411,8 +419,8 @@ class EmojiCloneModal(discord.ui.Modal):
         if not interaction.user.guild_permissions.manage_emojis:
             await interaction.response.send_message("Manage Emojis permission required.", ephemeral=True)
             return
-        source = str(self.source.value).strip()
-        name = str(self.target_name.value).strip() or None
+        source = str(self.source.value).strip()
+        name = str(self.target_name.value).strip() or None
         created, error_text = await self.cog._clone_emoji_to_guild(
             interaction.guild,
             interaction.user,
@@ -583,9 +591,9 @@ class Admin(commands.Cog):
         )
         return before, after
 
-    async def _safe_ctx_send(
-        self,
-        ctx: commands.Context,
+    async def _safe_ctx_send(
+        self,
+        ctx: commands.Context,
         *,
         content: str | None = None,
         embed: discord.Embed | None = None,
@@ -617,82 +625,82 @@ class Admin(commands.Cog):
 
         if ctx.channel:
             channel_kwargs = {k: v for k, v in kwargs.items() if k != "ephemeral"}
-            msg = await ctx.channel.send(**channel_kwargs)
-            if delete_after:
-                await msg.delete(delay=delete_after)
-
-    def _presence_status_label(self, status: discord.Status | str | None) -> str:
-        value = str(status or "online").lower()
-        return {
-            "online": "online",
-            "idle": "idle",
-            "dnd": "dnd",
-            "invisible": "invisible",
-            "offline": "invisible",
-        }.get(value, "online")
-
-    def _presence_activity_label(self, activity_type: discord.ActivityType | str | None) -> str:
-        value = str(activity_type or "playing").lower()
-        return {
-            "playing": "playing",
-            "watching": "watching",
-            "listening": "listening",
-            "competing": "competing",
-        }.get(value, "playing")
-
-    async def _set_bot_presence(
-        self,
-        actor_id: int,
-        *,
-        status_name: str,
-        activity_type_name: str,
-        activity_text: str,
-    ) -> None:
-        resolved_status = PRESENCE_STATUS_MAP.get(status_name, discord.Status.online)
-        resolved_activity_type = PRESENCE_ACTIVITY_MAP.get(activity_type_name, discord.ActivityType.playing)
-        await self.bot.change_presence(
-            status=resolved_status,
-            activity=discord.Activity(type=resolved_activity_type, name=activity_text),
-        )
-        await self.bot.db.execute(
-            "INSERT INTO bot_presence_config(id, status, activity_type, activity_text, updated_by, updated_at) "
-            "VALUES (1, ?, ?, ?, ?, ?) "
-            "ON CONFLICT(id) DO UPDATE SET "
-            "status = excluded.status, "
-            "activity_type = excluded.activity_type, "
-            "activity_text = excluded.activity_text, "
-            "updated_by = excluded.updated_by, "
-            "updated_at = excluded.updated_at",
-            status_name,
-            activity_type_name,
-            activity_text,
-            actor_id,
-            dt.datetime.utcnow().isoformat(),
-        )
-
-    async def _presence_embed(self) -> discord.Embed:
-        current_activity = getattr(self.bot, "activity", None)
-        activity_text = getattr(current_activity, "name", None) or "CYBER // GRID"
-        activity_type_name = self._presence_activity_label(getattr(current_activity, "type", None))
-        status_name = self._presence_status_label(getattr(self.bot, "status", None))
-        row = await self.bot.db.fetchone(
-            "SELECT updated_by, updated_at FROM bot_presence_config WHERE id = 1"
-        )
-        updated_by = f"<@{row[0]}>" if row and row[0] else "Unknown"
-        updated_at = row[1] if row and row[1] else "Not saved yet"
-        embed = info_embed(
-            "Bot Presence",
-            (
-                f"Status: **{status_name}**\n"
-                f"Activity: **{activity_type_name}**\n"
-                f"Text: **{activity_text}**\n\n"
-                f"Updated by: {updated_by}\n"
-                f"Updated at: `{updated_at}`"
-            ),
-        )
-        return embed
-
-    @commands.hybrid_command(name="purge")
+            msg = await ctx.channel.send(**channel_kwargs)
+            if delete_after:
+                await msg.delete(delay=delete_after)
+
+    def _presence_status_label(self, status: discord.Status | str | None) -> str:
+        value = str(status or "online").lower()
+        return {
+            "online": "online",
+            "idle": "idle",
+            "dnd": "dnd",
+            "invisible": "invisible",
+            "offline": "invisible",
+        }.get(value, "online")
+
+    def _presence_activity_label(self, activity_type: discord.ActivityType | str | None) -> str:
+        value = str(activity_type or "playing").lower()
+        return {
+            "playing": "playing",
+            "watching": "watching",
+            "listening": "listening",
+            "competing": "competing",
+        }.get(value, "playing")
+
+    async def _set_bot_presence(
+        self,
+        actor_id: int,
+        *,
+        status_name: str,
+        activity_type_name: str,
+        activity_text: str,
+    ) -> None:
+        resolved_status = PRESENCE_STATUS_MAP.get(status_name, discord.Status.online)
+        resolved_activity_type = PRESENCE_ACTIVITY_MAP.get(activity_type_name, discord.ActivityType.playing)
+        await self.bot.change_presence(
+            status=resolved_status,
+            activity=discord.Activity(type=resolved_activity_type, name=activity_text),
+        )
+        await self.bot.db.execute(
+            "INSERT INTO bot_presence_config(id, status, activity_type, activity_text, updated_by, updated_at) "
+            "VALUES (1, ?, ?, ?, ?, ?) "
+            "ON CONFLICT(id) DO UPDATE SET "
+            "status = excluded.status, "
+            "activity_type = excluded.activity_type, "
+            "activity_text = excluded.activity_text, "
+            "updated_by = excluded.updated_by, "
+            "updated_at = excluded.updated_at",
+            status_name,
+            activity_type_name,
+            activity_text,
+            actor_id,
+            dt.datetime.utcnow().isoformat(),
+        )
+
+    async def _presence_embed(self) -> discord.Embed:
+        current_activity = getattr(self.bot, "activity", None)
+        activity_text = getattr(current_activity, "name", None) or "CYBER // GRID"
+        activity_type_name = self._presence_activity_label(getattr(current_activity, "type", None))
+        status_name = self._presence_status_label(getattr(self.bot, "status", None))
+        row = await self.bot.db.fetchone(
+            "SELECT updated_by, updated_at FROM bot_presence_config WHERE id = 1"
+        )
+        updated_by = f"<@{row[0]}>" if row and row[0] else "Unknown"
+        updated_at = row[1] if row and row[1] else "Not saved yet"
+        embed = info_embed(
+            "Bot Presence",
+            (
+                f"Status: **{status_name}**\n"
+                f"Activity: **{activity_type_name}**\n"
+                f"Text: **{activity_text}**\n\n"
+                f"Updated by: {updated_by}\n"
+                f"Updated at: `{updated_at}`"
+            ),
+        )
+        return embed
+
+    @commands.hybrid_command(name="purge", description=get_cmd_desc("commands.admin.purge_desc"))
     @commands.has_permissions(manage_messages=True)
     async def purge(self, ctx: commands.Context, amount: int) -> None:
         """Delete a number of messages from the channel."""
@@ -712,7 +720,7 @@ class Admin(commands.Cog):
         embed = success_embed("🗑️ Messages Purged", f"{panel_divider('green')}\n{desc}\n{panel_divider('green')}")
         await self._safe_ctx_send(ctx, embed=embed, ephemeral=bool(ctx.interaction), delete_after=5 if not ctx.interaction else None)
 
-    @commands.hybrid_command(name="admin_panel", description="Economy/Shield/Status management panel", with_app_command=False)
+    @commands.hybrid_command(name="admin_panel", description=get_cmd_desc("commands.admin.admin_panel_desc"), with_app_command=False)
     @commands.has_permissions(administrator=True)
     async def admin_panel(self, ctx: commands.Context) -> None:
         if ctx.interaction and not ctx.interaction.response.is_done():
@@ -724,103 +732,103 @@ class Admin(commands.Cog):
             ephemeral=bool(ctx.interaction),
         )
 
-    @commands.hybrid_group(name="admin", fallback="panel", description="Administrative grouped controls")
-    @commands.has_permissions(administrator=True)
-    async def admin_group(self, ctx: commands.Context) -> None:
-        await self.admin_panel(ctx)
-
-    @admin_group.group(name="botstatus", invoke_without_command=True)
-    @commands.is_owner()
-    async def admin_botstatus_group(self, ctx: commands.Context) -> None:
-        embed = await self._presence_embed()
-        await self._safe_ctx_send(ctx, embed=embed, ephemeral=bool(ctx.interaction))
-
-    @admin_botstatus_group.command(name="set")
-    @commands.is_owner()
-    async def admin_botstatus_set(
-        self,
-        ctx: commands.Context,
-        status: str,
-        activity_type: str,
-        *,
-        text: str,
-    ) -> None:
-        status_name = (status or "").strip().lower()
-        activity_type_name = (activity_type or "").strip().lower()
-        activity_text = (text or "").strip()[:128]
-
-        if status_name not in PRESENCE_STATUS_MAP:
-            await self._safe_ctx_send(
-                ctx,
-                content="Invalid status. Use: `online`, `idle`, `dnd`, `invisible`",
-                ephemeral=bool(ctx.interaction),
-            )
-            return
-        if activity_type_name not in PRESENCE_ACTIVITY_MAP:
-            await self._safe_ctx_send(
-                ctx,
-                content="Invalid activity type. Use: `playing`, `watching`, `listening`, `competing`",
-                ephemeral=bool(ctx.interaction),
-            )
-            return
-        if not activity_text:
-            await self._safe_ctx_send(ctx, content="Activity text cannot be empty.", ephemeral=bool(ctx.interaction))
-            return
-
-        await self._set_bot_presence(
-            ctx.author.id,
-            status_name=status_name,
-            activity_type_name=activity_type_name,
-            activity_text=activity_text,
-        )
-        embed = success_embed(
-            "Bot Status Updated",
-            (
-                f"Status: **{status_name}**\n"
-                f"Activity: **{activity_type_name}**\n"
-                f"Text: **{activity_text}**"
-            ),
-        )
-        await self._safe_ctx_send(ctx, embed=embed, ephemeral=bool(ctx.interaction))
-
-    @admin_botstatus_group.command(name="reset")
-    @commands.is_owner()
-    async def admin_botstatus_reset(self, ctx: commands.Context) -> None:
-        await self._set_bot_presence(
-            ctx.author.id,
-            status_name="online",
-            activity_type_name="playing",
-            activity_text="CYBER // GRID",
-        )
-        embed = success_embed("Bot Status Reset", "Restored default presence.")
-        await self._safe_ctx_send(ctx, embed=embed, ephemeral=bool(ctx.interaction))
-
-    @commands.hybrid_command(name="bot_status", description="Show current bot presence", with_app_command=True)
-    @commands.is_owner()
-    async def show_bot_status(self, ctx: commands.Context) -> None:
-        embed = await self._presence_embed()
-        await self._safe_ctx_send(ctx, embed=embed, ephemeral=bool(ctx.interaction))
-
-    @commands.hybrid_command(name="set_bot_status", description="Set bot presence", with_app_command=True)
-    @commands.is_owner()
-    async def update_bot_status(
-        self,
-        ctx: commands.Context,
-        status: str,
-        activity_type: str,
-        *,
-        text: str,
-    ) -> None:
-        await self.admin_botstatus_set(ctx, status, activity_type, text=text)
-
-    @commands.hybrid_command(name="reset_bot_status", description="Reset bot presence to default", with_app_command=True)
-    @commands.is_owner()
-    async def restore_bot_status(self, ctx: commands.Context) -> None:
-        await self.admin_botstatus_reset(ctx)
-
-    @admin_group.group(name="shield", invoke_without_command=True)
-    @commands.has_permissions(administrator=True)
-    async def admin_shield_group(self, ctx: commands.Context) -> None:
+    @commands.hybrid_group(name="admin", fallback="panel", description="Administrative grouped controls")
+    @commands.has_permissions(administrator=True)
+    async def admin_group(self, ctx: commands.Context) -> None:
+        await self.admin_panel(ctx)
+
+    @admin_group.group(name="botstatus", invoke_without_command=True)
+    @commands.is_owner()
+    async def admin_botstatus_group(self, ctx: commands.Context) -> None:
+        embed = await self._presence_embed()
+        await self._safe_ctx_send(ctx, embed=embed, ephemeral=bool(ctx.interaction))
+
+    @admin_botstatus_group.command(name="set")
+    @commands.is_owner()
+    async def admin_botstatus_set(
+        self,
+        ctx: commands.Context,
+        status: str,
+        activity_type: str,
+        *,
+        text: str,
+    ) -> None:
+        status_name = (status or "").strip().lower()
+        activity_type_name = (activity_type or "").strip().lower()
+        activity_text = (text or "").strip()[:128]
+
+        if status_name not in PRESENCE_STATUS_MAP:
+            await self._safe_ctx_send(
+                ctx,
+                content="Invalid status. Use: `online`, `idle`, `dnd`, `invisible`",
+                ephemeral=bool(ctx.interaction),
+            )
+            return
+        if activity_type_name not in PRESENCE_ACTIVITY_MAP:
+            await self._safe_ctx_send(
+                ctx,
+                content="Invalid activity type. Use: `playing`, `watching`, `listening`, `competing`",
+                ephemeral=bool(ctx.interaction),
+            )
+            return
+        if not activity_text:
+            await self._safe_ctx_send(ctx, content="Activity text cannot be empty.", ephemeral=bool(ctx.interaction))
+            return
+
+        await self._set_bot_presence(
+            ctx.author.id,
+            status_name=status_name,
+            activity_type_name=activity_type_name,
+            activity_text=activity_text,
+        )
+        embed = success_embed(
+            "Bot Status Updated",
+            (
+                f"Status: **{status_name}**\n"
+                f"Activity: **{activity_type_name}**\n"
+                f"Text: **{activity_text}**"
+            ),
+        )
+        await self._safe_ctx_send(ctx, embed=embed, ephemeral=bool(ctx.interaction))
+
+    @admin_botstatus_group.command(name="reset")
+    @commands.is_owner()
+    async def admin_botstatus_reset(self, ctx: commands.Context) -> None:
+        await self._set_bot_presence(
+            ctx.author.id,
+            status_name="online",
+            activity_type_name="playing",
+            activity_text="CYBER // GRID",
+        )
+        embed = success_embed("Bot Status Reset", "Restored default presence.")
+        await self._safe_ctx_send(ctx, embed=embed, ephemeral=bool(ctx.interaction))
+
+    @commands.hybrid_command(name="bot_status", description=get_cmd_desc("commands.admin.bot_status_desc"), with_app_command=True)
+    @commands.is_owner()
+    async def show_bot_status(self, ctx: commands.Context) -> None:
+        embed = await self._presence_embed()
+        await self._safe_ctx_send(ctx, embed=embed, ephemeral=bool(ctx.interaction))
+
+    @commands.hybrid_command(name="set_bot_status", description=get_cmd_desc("commands.admin.set_bot_status_desc"), with_app_command=True)
+    @commands.is_owner()
+    async def update_bot_status(
+        self,
+        ctx: commands.Context,
+        status: str,
+        activity_type: str,
+        *,
+        text: str,
+    ) -> None:
+        await self.admin_botstatus_set(ctx, status, activity_type, text=text)
+
+    @commands.hybrid_command(name="reset_bot_status", description=get_cmd_desc("commands.admin.reset_bot_status_desc"), with_app_command=True)
+    @commands.is_owner()
+    async def restore_bot_status(self, ctx: commands.Context) -> None:
+        await self.admin_botstatus_reset(ctx)
+
+    @admin_group.group(name="shield", invoke_without_command=True)
+    @commands.has_permissions(administrator=True)
+    async def admin_shield_group(self, ctx: commands.Context) -> None:
         await self._safe_ctx_send(
             ctx,
             content="Use `/admin shield state`, `/admin shield set_level <low|medium|high>`, or `/admin shield add_image <attachment>`",
@@ -855,7 +863,7 @@ class Admin(commands.Cog):
         )
         await self._safe_ctx_send(ctx, content="✅ Scam image signature saved.", ephemeral=bool(ctx.interaction))
 
-    @commands.hybrid_command(name="shield_level", description="Set AI shield level low|medium|high", hidden=True, with_app_command=False)
+    @commands.hybrid_command(name="shield_level", description=get_cmd_desc("commands.admin.shield_level_desc"), hidden=True, with_app_command=False)
     @commands.has_permissions(administrator=True)
     async def shield_level(self, ctx: commands.Context, level: str) -> None:
         if ctx.interaction and not ctx.interaction.response.is_done():
@@ -871,7 +879,7 @@ class Admin(commands.Cog):
         )
         await self._safe_ctx_send(ctx, content=f"🛡️ Shield level set to `{normalized}`", ephemeral=bool(ctx.interaction))
 
-    @commands.hybrid_command(name="shield_state", description="Show current AI shield state", with_app_command=True)
+    @commands.hybrid_command(name="shield_state", description=get_cmd_desc("commands.admin.shield_state_desc"), with_app_command=True)
     @commands.has_permissions(administrator=True)
     async def shield_state(self, ctx: commands.Context) -> None:
         if not ctx.guild:
@@ -900,7 +908,7 @@ class Admin(commands.Cog):
         )
         await self._safe_ctx_send(ctx, embed=embed, ephemeral=bool(ctx.interaction))
 
-    @commands.hybrid_command(name="econ_admin", description="Add/remove coins from user")
+    @commands.hybrid_command(name="econ_admin", description=get_cmd_desc("commands.admin.econ_admin_desc"))
     @commands.has_permissions(administrator=True)
     async def econ_admin(self, ctx: commands.Context, member: discord.Member, action: str, amount: int) -> None:
         if ctx.interaction and not ctx.interaction.response.is_done():
@@ -922,7 +930,7 @@ class Admin(commands.Cog):
         )
         await self._safe_ctx_send(ctx, content=f"💰 {member.mention} coins: `{coins}` → `{new_coins}`", ephemeral=bool(ctx.interaction))
 
-    @commands.hybrid_command(name="warn")
+    @commands.hybrid_command(name="warn", description=get_cmd_desc("commands.admin.warn_desc"))
     @commands.has_permissions(manage_roles=True)
     async def warn(self, ctx: commands.Context, member: discord.Member, *, reason: str = "No reason provided") -> None:
         """Warn a member."""
@@ -970,7 +978,7 @@ class Admin(commands.Cog):
         except discord.Forbidden:
             pass
 
-    @commands.hybrid_command(name="warnings")
+    @commands.hybrid_command(name="warnings", description=get_cmd_desc("commands.admin.warnings_desc"))
     @commands.has_permissions(manage_roles=True)
     async def warnings(self, ctx: commands.Context, member: discord.Member) -> None:
         """View warnings for a member."""
@@ -1005,7 +1013,7 @@ class Admin(commands.Cog):
         embed.set_thumbnail(url=member.display_avatar.url)
         await ctx.reply(embed=embed)
 
-    @commands.hybrid_command(name="clearwarn")
+    @commands.hybrid_command(name="clearwarn", description=get_cmd_desc("commands.admin.clearwarn_desc"))
     @commands.has_permissions(manage_roles=True)
     async def clearwarn(self, ctx: commands.Context, member: discord.Member) -> None:
         """Clear all warnings for a member."""
@@ -1024,7 +1032,7 @@ class Admin(commands.Cog):
             embed = success_embed("✅ Warnings Cleared", f"🗑️ All warnings for {member.mention} have been removed.")
         await ctx.reply(embed=embed)
 
-    @commands.hybrid_command(name="kick")
+    @commands.hybrid_command(name="kick", description=get_cmd_desc("commands.admin.kick_desc"))
     @commands.has_permissions(kick_members=True)
     async def kick(self, ctx: commands.Context, member: discord.Member, *, reason: str = "No reason provided") -> None:
         """Kick a member from the server."""
@@ -1069,7 +1077,7 @@ class Admin(commands.Cog):
             )
         await ctx.reply(embed=embed)
 
-    @commands.hybrid_command(name="ban")
+    @commands.hybrid_command(name="ban", description=get_cmd_desc("commands.admin.ban_desc"))
     @commands.has_permissions(ban_members=True)
     async def ban(self, ctx: commands.Context, member: discord.Member, *, reason: str = "No reason provided") -> None:
         """Ban a member from the server."""
@@ -1120,7 +1128,7 @@ class Admin(commands.Cog):
             color=discord.Color.red(),
         )
 
-    @commands.hybrid_command(name="unban")
+    @commands.hybrid_command(name="unban", description=get_cmd_desc("commands.admin.unban_desc"))
     @commands.has_permissions(ban_members=True)
     async def unban(self, ctx: commands.Context, user_id: int, *, reason: str = "No reason provided") -> None:
         """Unban a user by their ID."""
@@ -1178,7 +1186,7 @@ class Admin(commands.Cog):
             color=discord.Color.green(),
         )
 
-    @commands.hybrid_command(name="mute")
+    @commands.hybrid_command(name="mute", description=get_cmd_desc("commands.admin.mute_desc"))
     @commands.has_permissions(moderate_members=True)
     async def mute(self, ctx: commands.Context, member: discord.Member, duration: int = 10, *, reason: str = "No reason provided") -> None:
         """Timeout a member for a specified duration in minutes."""
@@ -1225,7 +1233,7 @@ class Admin(commands.Cog):
             color=discord.Color.red(),
         )
 
-    @commands.hybrid_command(name="unmute")
+    @commands.hybrid_command(name="unmute", description=get_cmd_desc("commands.admin.unmute_desc"))
     @commands.has_permissions(moderate_members=True)
     async def unmute(self, ctx: commands.Context, member: discord.Member, *, reason: str = "No reason provided") -> None:
         """Remove timeout from a member."""
@@ -1320,13 +1328,13 @@ class Admin(commands.Cog):
         if not ctx.guild:
             await self._safe_ctx_send(ctx, content="Server only.", ephemeral=bool(ctx.interaction))
             return
-        embed = info_embed(
-            "Emoji Clone Panel",
-            "Quick actions:\n- Clone from tag/ID/URL/name\n- View server emojis\n- Open bot emoji picker",
-        )
+        embed = info_embed(
+            "Emoji Clone Panel",
+            "Quick actions:\n- Clone from tag/ID/URL/name\n- View server emojis\n- Open bot emoji picker",
+        )
         await self._safe_ctx_send(ctx, embed=embed, view=EmojiClonePanelView(self), ephemeral=bool(ctx.interaction))
 
-    @commands.hybrid_command(name="emoji_clone_panel", description="Open the emoji clone panel", with_app_command=True)
+    @commands.hybrid_command(name="emoji_clone_panel", description=get_cmd_desc("commands.admin.emoji_clone_panel_desc"), with_app_command=True)
     @commands.has_permissions(manage_emojis=True)
     async def emoji_clone_panel(self, ctx: commands.Context) -> None:
         await self.admin_emoji_panel(ctx)
@@ -1377,7 +1385,7 @@ class Admin(commands.Cog):
         )
         await self._safe_ctx_send(ctx, embed=embed, ephemeral=bool(ctx.interaction))
 
-    @commands.hybrid_command(name="awesomeroles")
+    @commands.hybrid_command(name="awesomeroles", description=get_cmd_desc("commands.admin.awesomeroles_desc"))
     @commands.has_permissions(manage_roles=True)
     async def awesomeroles(self, ctx: commands.Context) -> None:
         """Create awesome roles for the server with proper permissions."""
@@ -1442,7 +1450,7 @@ class Admin(commands.Cog):
         embed.set_footer(text=f"{E_STAR} Created by {ctx.author.display_name}")
         await ctx.reply(embed=embed)
 
-    @commands.hybrid_command(name="backupserver")
+    @commands.hybrid_command(name="backupserver", description=get_cmd_desc("commands.admin.backupserver_desc"))
     @commands.has_permissions(administrator=True)
     async def backupserver(self, ctx: commands.Context) -> None:
         """Create a backup of server structure."""
@@ -1516,7 +1524,7 @@ class Admin(commands.Cog):
             )
         await ctx.reply(embed=embed)
 
-    @commands.hybrid_command(name="backup_panel", description="Interactive backup management panel")
+    @commands.hybrid_command(name="backup_panel", description=get_cmd_desc("commands.admin.backup_panel_desc"))
     @commands.has_permissions(administrator=True)
     async def backup_panel(self, ctx: commands.Context) -> None:
         """Open the interactive backup management panel."""
@@ -1757,7 +1765,7 @@ class SlowmodeCommandMixin:
     pass
 
 
-    @commands.hybrid_command(name="slowmode")
+    @commands.hybrid_command(name="slowmode", description=get_cmd_desc("commands.admin.slowmode_desc"))
     @commands.has_permissions(manage_channels=True)
     async def slowmode(self, ctx: commands.Context, seconds: int = 0) -> None:
         """Set slowmode for the current channel."""
@@ -1779,7 +1787,7 @@ class SlowmodeCommandMixin:
                 embed = success_embed("⏱️ Slowmode Disabled", f"📺 **Channel:** {ctx.channel.mention}")
         await ctx.reply(embed=embed)
 
-    @commands.hybrid_command(name="lock")
+    @commands.hybrid_command(name="lock", description=get_cmd_desc("commands.admin.lock_desc"))
     @commands.has_permissions(manage_channels=True)
     async def lock(self, ctx: commands.Context, channel: discord.TextChannel | None = None) -> None:
         """Lock a channel to prevent messages."""
@@ -1797,7 +1805,7 @@ class SlowmodeCommandMixin:
             embed = success_embed("🔒 Channel Locked", f"📺 **Channel:** {channel.mention}")
         await ctx.reply(embed=embed)
 
-    @commands.hybrid_command(name="unlock")
+    @commands.hybrid_command(name="unlock", description=get_cmd_desc("commands.admin.unlock_desc"))
     @commands.has_permissions(manage_channels=True)
     async def unlock(self, ctx: commands.Context, channel: discord.TextChannel | None = None) -> None:
         """Unlock a channel to allow messages."""

bot/cogs/ai_admin.py

@@ -3,15 +3,16 @@ 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
+from __future__ import annotations
+
+import datetime as dt
+import json
+from bot.i18n import get_cmd_desc
+import re
+from typing import Any
 
 import discord
-from discord.ext import commands
+from discord.ext import commands, tasks
 
 try:
     import aiohttp
@@ -59,177 +60,246 @@ class IntelligenceLayer:
         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:
+        system_message = """You are a Human-like Discord Server Manager — an expert administrator who understands server structure, member behavior, and aesthetic organization.
+
+You receive natural language requests (Arabic, English, or mixed) and output ONLY a valid JSON array of actions. Do NOT include any other text.
+
+═══════════════════════════════════════════════════════
+YOUR CAPABILITIES
+═══════════════════════════════════════════════════════
 
-1. CREATE ROLE:
+━━━ SERVER ORCHESTRATION ━━━
+1. CREATE_ROLE: Create a role with professional colors
 {
   "action": "create_role",
   "name": "Role Name",
-  "color": "#FF0000",
+  "color": "#800080",
   "hoist": true,
-  "reason": "Why this role is needed"
+  "mentionable": false,
+  "reason": "Professional reason"
 }
 
-2. CREATE CHANNEL:
+2. CREATE_CHANNEL: Create text/voice channels with emojis
 {
   "action": "create_channel",
-  "name": "channel-name",
+  "name": "💬-general-chat",
   "type": "text",
-  "category": "Category Name",
-  "locked_to_roles": ["Role1", "Role2"],
-  "reason": "Why this channel is needed"
+  "category": "Community",
+  "topic": "Channel topic",
+  "locked_to_roles": ["Staff"],
+  "deny_everyone": true,
+  "reason": "Why needed"
 }
 
-3. ANNOUNCE:
+3. CREATE_CATEGORY: Organize server sections
 {
-  "action": "announce",
+  "action": "create_category",
+  "name": "🏆 Competitions",
+  "reason": "Organize competition channels"
+}
+
+4. PERMISSION_SETUP: Full permission architecture
+{
+  "action": "setup_permissions",
   "channel": "channel-name",
-  "title": "Announcement Title",
-  "description": "Announcement content",
-  "color": "#00FFFF"
+  "deny_roles": ["@everyone", "Member"],
+  "allow_roles": ["Staff", "Admin"],
+  "deny_permissions": ["send_messages", "view_channel"],
+  "allow_permissions": ["send_messages", "view_channel", "manage_messages"],
+  "reason": "Staff-only room setup"
 }
 
-4. CREATE GIVEAWAY:
+━━━ COMMUNITY FEATURES ━━━
+5. ANNOUNCE: Rich embed announcement
+{
+  "action": "announce",
+  "channel": "announcements",
+  "title": "📢 Important Update",
+  "description": "Announcement body",
+  "color": "#00FFFF",
+  "fields": [{"name": "Field 1", "value": "Value 1", "inline": true}],
+  "footer": "Footer text"
+}
+
+6. CREATE_GIVEAWAY: Feature setup
 {
   "action": "create_giveaway",
-  "prize": "Prize description",
-  "duration_minutes": 60,
+  "prize": "Discord Nitro",
+  "duration_minutes": 1440,
   "winners": 1,
-  "channel": "channel-name"
+  "channel": "giveaways"
 }
 
-5. CREATE TOURNAMENT:
+7. CREATE_TOURNAMENT: Tournament setup
 {
   "action": "create_tournament",
-  "name": "Tournament Name",
-  "game": "Game name",
+  "name": "Valorant Cup",
+  "game": "Valorant",
   "max_participants": 16,
-  "channel": "channel-name"
+  "channel": "tournaments"
 }
 
-6. CREATE POLL:
+8. CREATE_POLL: Community poll
 {
   "action": "create_poll",
-  "question": "Poll question",
-  "options": ["Option 1", "Option 2", "Option 3"],
-  "duration_minutes": 30
+  "question": "What game should we play?",
+  "options": ["Valorant", "Minecraft", "Fortnite"],
+  "duration_minutes": 60
+}
+
+━━━ MEMBER MANAGEMENT ━━━
+9. TIMEOUT_MEMBER: Temporary timeout
+{
+  "action": "timeout_member",
+  "member": "@user or user_id",
+  "minutes": 30,
+  "reason": "Rule violation"
+}
+
+10. UNTIMEOUT_MEMBER: Remove timeout
+{
+  "action": "untimeout_member",
+  "member": "@user or user_id",
+  "reason": "Timeout removed"
+}
+
+11. ADD_ROLE: Assign role to member
+{
+  "action": "add_role",
+  "member": "@user or user_id",
+  "role": "VIP",
+  "reason": "Reward for contribution"
+}
+
+12. REMOVE_ROLE: Remove role from member
+{
+  "action": "remove_role",
+  "member": "@user or user_id",
+  "role": "Muted",
+  "reason": "Timeout period ended"
+}
+
+━━━ CHANNEL MANAGEMENT ━━━
+13. LOCK_CHANNEL: Restrict channel
+{
+  "action": "lock_channel",
+  "channel": "general",
+  "reason": "Raid prevention"
+}
+
+14. UNLOCK_CHANNEL: Restore access
+{
+  "action": "unlock_channel",
+  "channel": "general",
+  "reason": "Situation resolved"
+}
+
+15. SET_SLOWMODE: Set delay
+{
+  "action": "set_slowmode",
+  "channel": "general",
+  "seconds": 10,
+  "reason": "Reduce spam"
+}
+
+16. PURGE_MESSAGES: Clean channel
+{
+  "action": "purge_messages",
+  "channel": "general",
+  "amount": 50,
+  "reason": "Spam cleanup"
+}
+
+17. DELETE_CHANNEL: Remove channel
+{
+  "action": "delete_channel",
+  "channel": "old-channel",
+  "reason": "No longer needed"
 }
 
-7. RUN COMMAND (for any other bot command):
-{
-  "action": "run_command",
-  "command": "command_name",
-  "args": {"arg1": "value1", "arg2": "value2"}
-}
-
-8. TIMEOUT MEMBER:
-{
-  "action": "timeout_member",
-  "member": "@user or user_id",
-  "minutes": 30,
-  "reason": "Why timeout is needed"
-}
-
-9. UNTIMEOUT MEMBER:
-{
-  "action": "untimeout_member",
-  "member": "@user or user_id",
-  "reason": "Why timeout is removed"
-}
-
-10. ADD ROLE:
-{
-  "action": "add_role",
-  "member": "@user or user_id",
-  "role": "Role Name",
-  "reason": "Why role is added"
-}
-
-11. REMOVE ROLE:
-{
-  "action": "remove_role",
-  "member": "@user or user_id",
-  "role": "Role Name",
-  "reason": "Why role is removed"
-}
-
-12. LOCK CHANNEL:
-{
-  "action": "lock_channel",
-  "channel": "channel-name",
-  "reason": "Why channel is locked"
-}
-
-13. UNLOCK CHANNEL:
-{
-  "action": "unlock_channel",
-  "channel": "channel-name",
-  "reason": "Why channel is unlocked"
-}
-
-14. SLOWMODE:
-{
-  "action": "set_slowmode",
-  "channel": "channel-name",
-  "seconds": 10,
-  "reason": "Why slowmode is set"
-}
-
-15. PURGE MESSAGES:
-{
-  "action": "purge_messages",
-  "channel": "channel-name",
-  "amount": 25,
-  "reason": "Why messages are purged"
-}
-
-16. DELETE CHANNEL:
-{
-  "action": "delete_channel",
-  "channel": "channel-name",
-  "reason": "Why channel is deleted"
-}
-
-17. RENAME CHANNEL:
-{
-  "action": "rename_channel",
-  "channel": "old-channel-name",
-  "new_name": "new-channel-name",
-  "reason": "Why channel is renamed"
-}
-
-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"
-}
-
-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."""
+18. RENAME_CHANNEL: Update name
+{
+  "action": "rename_channel",
+  "channel": "old-name",
+  "new_name": "🎮-new-name",
+  "reason": "Better organization"
+}
+
+19. RENAME_CATEGORY: Update category
+{
+  "action": "rename_category",
+  "category": "Old Category",
+  "new_name": "🎮 New Category",
+  "reason": "Aesthetic update"
+}
+
+20. DELETE_CATEGORY: Remove category
+{
+  "action": "delete_category",
+  "category": "Unused Category",
+  "reason": "Cleanup"
+}
+
+━━━ SCHEDULING & ANALYSIS ━━━
+21. SCHEDULE_TASK: Plan future action
+{
+  "action": "schedule_task",
+  "run_at": "2025-01-15 21:00",
+  "action_to_run": {"action": "unlock_channel", "channel": "events", "reason": "Scheduled opening"},
+  "reason": "Auto-open events channel at 9 PM"
+}
+
+22. ANALYZE_ACTIVITY: Member activity report
+{
+  "action": "analyze_activity",
+  "scope": "all" or "category-name" or "channel-name",
+  "period": "24h" or "7d" or "30d"
+}
+
+23. RUN_COMMAND: Fallback for anything else
+{
+  "action": "run_command",
+  "command": "command_name",
+  "args": {"arg1": "value1"}
+}
+
+═══════════════════════════════════════════════════════
+YOUR BEHAVIOR RULES
+═══════════════════════════════════════════════════════
+
+🎨 AESTHETIC AUTONOMY:
+- Use appropriate emojis in channel names (💬 chat, 🎮 gaming, 📢 announcements, 🎉 events)
+- Choose professional hex colors: #1ABC9C (teal), #9B59B6 (purple), #E74C3C (red), #F1C40F (gold), #2ECC71 (green), #3498DB (blue)
+- For staff roles: use purple (#9B59B6) or gold (#F1C40F)
+- For member roles: use teal (#1ABC9C) or green (#2ECC71)
+
+🏗️ STRATEGIC PLANNING:
+- When asked to "setup X section" (e.g., "جهز قسم المسابقات"), plan multiple steps: create_category → create_roles → create_channels → setup_permissions
+- Always think about the complete structure, not just one action
+
+🔒 PERMISSION ARCHITECTURE:
+- For "staff-only" or "private" channels: use setup_permissions with deny_everyone: true and allow_roles: ["Staff"]
+- Understand hierarchy: @everyone should be denied, specific roles should be allowed
+
+🗣️ HUMAN-LIKE RESPONSES:
+- ALWAYS include "response_to_user" as the FIRST field in the FIRST action
+- Match the user's language (Arabic → Arabic response, English → English)
+- Be professional but conversational — explain your choices
+- For Arabic: use administrative terms (تم إنشاء، تم تعيين، القسم جاهز)
+
+⚠️ RISK ASSESSMENT:
+- For destructive actions (delete, purge): mention impact in response_to_user
+- Example: "سأحذف 50 رسالة من قناة general — هل أنت متأكد؟"
+
+📝 MULTI-ACTION CHAINS:
+- Return ALL actions needed in one response
+- Example: "جهز قسم الألعاب" → create_category → create_role → create_channel (multiple) → setup_permissions
+
+OUTPUT FORMAT: JSON array only. No markdown. No explanation outside the JSON.
+ALWAYS start the FIRST object with "response_to_user" field."""
 
         payload = {
             "model": model,
@@ -238,15 +308,15 @@ IMPORTANT: For any request that involves creating events, giveaways, tournaments
                 {"role": "user", "content": prompt}
             ],
             "temperature": 0.3,
-            "max_tokens": 2000
+            "max_tokens": 3000
         }
-        
+
         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(
@@ -257,7 +327,7 @@ IMPORTANT: For any request that involves creating events, giveaways, tournaments
                 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:
@@ -288,6 +358,9 @@ class ExecutionEngine:
         results = []
         for action in actions:
             action_type = action.get("action", "")
+            # Skip response_to_user — it's metadata, not an action
+            if action_type == "response_to_user":
+                continue
             try:
                 if action_type == "create_role":
                     result = await self._create_role(action, ctx)
@@ -301,101 +374,107 @@ class ExecutionEngine:
                     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
-
-    @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)
+                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)
+                elif action_type == "setup_permissions":
+                    result = await self._setup_permissions(action, ctx)
+                elif action_type == "schedule_task":
+                    result = await self._schedule_task(action, ctx)
+                elif action_type == "analyze_activity":
+                    result = await self._analyze_activity(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
+
+    @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")
@@ -411,11 +490,11 @@ class ExecutionEngine:
         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")
+    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")
@@ -489,214 +568,339 @@ class ExecutionEngine:
         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)
-        
-        cog = self.bot.get_cog("Engagement")
-        if not cog:
-            return "Engagement cog not found."
-
-        # 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"])
-        
-        cog = self.bot.get_cog("Utility")
-        if not cog:
-            return "Utility cog not found."
-        
-        # 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 _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)
+        
+        cog = self.bot.get_cog("Engagement")
+        if not cog:
+            return "Engagement cog not found."
+
+        # 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"])
+        
+        cog = self.bot.get_cog("Utility")
+        if not cog:
+            return "Utility cog not found."
+        
+        # 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", {})
+    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 _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))."
+        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))."
+
+    async def _setup_permissions(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        """Set up complex channel permissions for specific roles."""
+        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."
+
+        deny_roles = action.get("deny_roles", ["@everyone"])
+        allow_roles = action.get("allow_roles", [])
+        deny_perms = action.get("deny_permissions", ["send_messages"])
+        allow_perms = action.get("allow_permissions", ["send_messages"])
+        reason = action.get("reason", "AI Admin permission setup")
+
+        overwrites = {}
+        # Process denied roles
+        for role_name in deny_roles:
+            if role_name.lower() in ("@everyone", "everyone"):
+                role_obj = ctx.guild.default_role
+            else:
+                role_obj = discord.utils.get(ctx.guild.roles, name=role_name)
+            if role_obj:
+                deny_obj = discord.PermissionOverwrite()
+                for perm in deny_perms:
+                    setattr(deny_obj, perm, False)
+                overwrites[role_obj] = deny_obj
+
+        # Process allowed roles
+        for role_name in allow_roles:
+            role_obj = discord.utils.get(ctx.guild.roles, name=role_name)
+            if role_obj:
+                allow_obj = discord.PermissionOverwrite()
+                for perm in allow_perms:
+                    setattr(allow_obj, perm, True)
+                overwrites[role_obj] = allow_obj
+
+        await channel.edit(overwrites=overwrites, reason=reason)
+        denied = ", ".join(deny_roles)
+        allowed = ", ".join(allow_roles) if allow_roles else "none"
+        return f"Permissions set for **{channel.mention}**: denied [{denied}], allowed [{allowed}]."
+
+    async def _schedule_task(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        """Schedule a task for future execution."""
+        run_at = action.get("run_at", "")
+        action_to_run = action.get("action_to_run", {})
+        reason = action.get("reason", "Scheduled task")
+
+        # Parse the datetime
+        try:
+            scheduled_time = dt.datetime.fromisoformat(run_at)
+            if scheduled_time.tzinfo is None:
+                scheduled_time = scheduled_time.replace(tzinfo=dt.timezone.utc)
+        except (ValueError, TypeError):
+            return f"Invalid schedule time: {run_at}. Use ISO format: YYYY-MM-DD HH:MM"
+
+        if scheduled_time <= dt.datetime.now(dt.timezone.utc):
+            return "Scheduled time must be in the future."
+
+        # Store in database
+        await self.bot.db.execute(
+            "INSERT INTO ai_scheduled_tasks(guild_id, run_at, action_json, reason, created_by) VALUES (?, ?, ?, ?, ?)",
+            ctx.guild.id,
+            scheduled_time.isoformat(),
+            json.dumps(action_to_run),
+            reason[:200],
+            ctx.author.id,
+        )
+        time_str = scheduled_time.strftime("%Y-%m-%d %H:%M UTC")
+        return f"⏰ Task scheduled for **{time_str}**: {reason[:100]}"
+
+    async def _analyze_activity(self, action: dict[str, Any], ctx: commands.Context) -> str:
+        """Analyze member activity and return a summary."""
+        scope = action.get("scope", "all")
+        period = action.get("period", "24h")
+
+        # Parse period
+        hours = {"24h": 24, "7d": 168, "30d": 720}.get(period, 24)
+
+        # Get recent messages in scope
+        if scope == "all":
+            channels = ctx.guild.text_channels
+        else:
+            ch = discord.utils.get(ctx.guild.text_channels, name=scope.lower().replace(" ", "-"))
+            cat = discord.utils.get(ctx.guild.categories, name=scope)
+            if ch:
+                channels = [ch]
+            elif cat:
+                channels = cat.text_channels
+            else:
+                channels = ctx.guild.text_channels
+
+        member_counts: dict[int, int] = {}
+        total = 0
+        for ch in channels[:10]:  # Limit to first 10 channels to avoid timeout
+            try:
+                async for msg in ch.history(limit=200):
+                    if msg.author.bot:
+                        continue
+                    age = dt.datetime.now(dt.timezone.utc) - msg.created_at
+                    if age.total_seconds() > hours * 3600:
+                        continue
+                    member_counts[msg.author.id] = member_counts.get(msg.author.id, 0) + 1
+                    total += 1
+            except (discord.Forbidden, discord.HTTPException):
+                continue
+
+        if not member_counts:
+            return f"📊 **Activity Report ({period})**: No recent activity found."
+
+        # Top 5 active
+        sorted_members = sorted(member_counts.items(), key=lambda x: -x[1])[:5]
+        lines = []
+        for rank, (user_id, count) in enumerate(sorted_members, 1):
+            member = ctx.guild.get_member(user_id)
+            name = member.mention if member else f"<@{user_id}>"
+            medal = {1: "🥇", 2: "🥈", 3: "🥉"}.get(rank, f"{rank}.")
+            lines.append(f"{medal} {name}: `{count}` messages")
+
+        unique_users = len(member_counts)
+        return (
+            f"📊 **Activity Report ({period})**\n"
+            f"Total messages: `{total}` | Active users: `{unique_users}`\n\n"
+            f"**Top 5:**\n" + "\n".join(lines)
+        )
     
-class AIAdmin(commands.Cog):
+class AIAdmin(commands.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)
-
-    @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))
+    def __init__(self, bot: commands.Bot) -> None:
+        self.bot = bot
+        self.permission_guard = PermissionGuard()
+        self.intelligence = IntelligenceLayer(bot)
+        self.execution = ExecutionEngine(bot)
+
+    @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:
@@ -712,34 +916,34 @@ class AIAdmin(commands.Cog):
             if match:
                 target = ctx.guild.get_member(int(match.group(1)))
 
-        if lower.startswith("kick ") and target:
+        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 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:
+        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:
@@ -749,128 +953,166 @@ class AIAdmin(commands.Cog):
                 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
-    
+            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
+
+    @commands.Cog.listener()
+    async def on_ready(self) -> None:
+        """Execute any pending scheduled tasks on startup."""
+        await self._check_scheduled_tasks()
+
+    async def _check_scheduled_tasks(self) -> None:
+        """Check and execute any due scheduled tasks."""
+        now = dt.datetime.now(dt.timezone.utc).isoformat()
+        tasks = await self.bot.db.fetchall(
+            "SELECT id, guild_id, action_json, reason FROM ai_scheduled_tasks WHERE executed = 0 AND run_at <= ?",
+            now,
+        )
+        for task_id, guild_id, action_json, reason in tasks:
+            try:
+                action = json.loads(action_json)
+                guild = self.bot.get_guild(guild_id)
+                if not guild:
+                    await self.bot.db.execute("UPDATE ai_scheduled_tasks SET executed = 1 WHERE id = ?", task_id)
+                    continue
+                # Create a fake context for execution
+                class _FakeCtx:
+                    pass
+                fake_ctx = _FakeCtx()
+                fake_ctx.guild = guild
+                fake_ctx.author = guild.me
+                fake_ctx.channel = guild.system_channel
+                fake_ctx.send = lambda *a, **k: None  # type: ignore
+                await self.execution.execute([action], fake_ctx)  # type: ignore
+                await self.bot.db.execute("UPDATE ai_scheduled_tasks SET executed = 1 WHERE id = ?", task_id)
+            except Exception:
+                pass
+
+    @tasks.loop(minutes=5)
+    async def _scheduled_task_checker(self) -> None:
+        """Periodically check for due tasks."""
+        await self._check_scheduled_tasks()
+
     async def cog_unload(self) -> None:
+        self._scheduled_task_checker.cancel()
         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:
-        allowed, deny_reason = self.permission_guard.check(ctx)
-        if not allowed:
-            await ctx.send(deny_reason, ephemeral=True)
-            return
+    @commands.hybrid_command(name="ai_admin", description=get_cmd_desc("commands.ai.ai_admin_desc"))
+    async def ai_admin(self, ctx: commands.Context, *, request: str) -> None:
+        allowed, deny_reason = self.permission_guard.check(ctx)
+        if not allowed:
+            await ctx.send(deny_reason, ephemeral=True)
+            return
 
         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
+        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:
@@ -885,46 +1127,51 @@ class AIAdmin(commands.Cog):
         
         results = await self.execution.execute(actions, ctx)
         
-        if response_text:
-            await ctx.send(response_text)
-        else:
-            await ctx.send("\n".join(results))
+        try:
+            if response_text:
+                await ctx.send(response_text)
+            else:
+                await ctx.send("\n".join(results))
+        except discord.NotFound:
+            # Interaction message may have been deleted
+            try:
+                if ctx.channel:
+                    await ctx.channel.send(response_text or "\n".join(results))
+            except Exception:
+                pass
     
-    @commands.hybrid_command(name="ai_help", description="Show AI Admin capabilities")
+    @commands.hybrid_command(name="ai_help", description=get_cmd_desc("commands.ai.ai_help_desc"))
     async def ai_help(self, ctx: commands.Context) -> None:
         embed = discord.Embed(
-            title="AI Administrator Help",
+            title="🛡️ AI Admin — Server Orchestrator",
             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`\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)
+                "I'm your expert server manager. Ask me in Arabic or English and I'll handle it.\n\n"
+                "**🏗️ Server Setup:**\n"
+                "`/ai_admin جهز قسم البطولات` — Full section with category, channels, roles\n"
+                "`/ai_admin create a staff room with private access` — Locked channel with permissions\n\n"
+                "**📢 Announcements:**\n"
+                "`/ai_admin announce the tournament starts at 9 PM` — Rich embed announcement\n\n"
+                "**👥 Member Management:**\n"
+                "`/ai_admin give VIP role to @user` — Role assignment\n"
+                "`/ai_admin mute @user for 30m` — Timeout with reason\n\n"
+                "**⏰ Scheduling:**\n"
+                "`/ai_admin open events channel at 9 PM tonight` — Scheduled task\n"
+                "`/ai_admin remove temp role after 1 week` — Future action\n\n"
+                "**📊 Activity Analysis:**\n"
+                "`/ai_admin who's most active in gaming?` — Member report\n\n"
+                "**🎨 Direct Moderation Shortcuts:**\n"
+                "`/ai_admin kick @user` | `ban @user` | `mute @user 30m`\n"
+                "`/ai_admin lock #channel` | `unlock #channel`\n"
+                "`/ai_admin purge 50 from #general`"
+            ),
+            color=discord.Color.blue()
+        )
+        embed.set_footer(text="AI Admin v2.0 — Server Orchestrator")
+        try:
+            await ctx.send(embed=embed, ephemeral=True)
+        except discord.NotFound:
+            if ctx.channel:
+                await ctx.channel.send(embed=embed)
 
 
 async def setup(bot: commands.Bot) -> None:

bot/cogs/board_games.py

@@ -1,824 +1,825 @@
-from __future__ import annotations
-
-import random
-from dataclasses import dataclass
-
-import discord
-from discord.ext import commands
-from bot.emojis import ui
-
-FILES = "abcdefgh"
-
-
-@dataclass
-class BoardGameSession:
-    game: str
-    players: tuple[int, int]  # second player can be 0 for bot
-    turn: int
-    board: list[list[str]]
-    tournament_name: str | None = None
-
-
-
-
-class BoardMoveModal(discord.ui.Modal, title="Play Move"):
-    move = discord.ui.TextInput(label="Move", placeholder="e2e4 / d3 / 4", max_length=10)
-
-    def __init__(self, cog: "BoardGames") -> None:
-        super().__init__(timeout=None)
-        self.cog = cog
-
-    async def on_submit(self, interaction: discord.Interaction) -> None:
-        if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
-            await interaction.response.send_message("Server text channels only.", ephemeral=True)
-            return
-        err = await self.cog._play_turn(
-            guild=interaction.guild,
-            channel=interaction.channel,
-            author_id=interaction.user.id,
-            move=str(self.move.value).strip(),
-        )
-        if err:
-            await interaction.response.send_message(err, ephemeral=True)
-        else:
-            await interaction.response.send_message("✅ Move accepted.", ephemeral=True)
-
-
-class BoardActionView(discord.ui.View):
-    def __init__(self, cog: "BoardGames") -> None:
-        super().__init__(timeout=None)
-        self.cog = cog
-
-    @discord.ui.button(label="Play Move", style=discord.ButtonStyle.primary, emoji=ui("controller"), custom_id="board_play")
-    async def play_move(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        await interaction.response.send_modal(BoardMoveModal(self.cog))
-
-    @discord.ui.button(label="Forfeit", style=discord.ButtonStyle.danger, emoji=ui("no"), custom_id="board_forfeit")
-    async def forfeit(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
-            await interaction.response.send_message("Server text channels only.", ephemeral=True)
-            return
-        err = await self.cog._forfeit(
-            guild=interaction.guild,
-            channel=interaction.channel,
-            author_id=interaction.user.id,
-        )
-        if err:
-            await interaction.response.send_message(err, ephemeral=True)
-            return
-        await interaction.response.send_message("🏳️ Forfeit processed.", ephemeral=True)
-
-    @discord.ui.button(label="End Game", style=discord.ButtonStyle.danger, emoji=ui("lock"), custom_id="board_end")
-    async def end_game(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
-            await interaction.response.send_message("Server text channels only.", ephemeral=True)
-            return
-        session = self.cog.sessions.get(interaction.channel.id)
-        if not session:
-            await interaction.response.send_message("No active board game in this channel.", ephemeral=True)
-            return
-        if interaction.user.id not in session.players and not interaction.user.guild_permissions.manage_channels:
-            await interaction.response.send_message("Only players/admins can end this game.", ephemeral=True)
-            return
-        self.cog.sessions.pop(interaction.channel.id, None)
-        await interaction.response.send_message("🔒 Game session ended.", ephemeral=True)
-        if interaction.channel.name.startswith("game-"):
-            try:
-                await interaction.channel.delete(reason=f"Game room closed by {interaction.user}")
-            except Exception:
-                pass
-
-
-class Connect4ActionView(BoardActionView):
-    def __init__(self, cog: "BoardGames") -> None:
-        super().__init__(cog)
-        self.clear_items()
-        for col in range(1, 8):
-            button = discord.ui.Button(label=str(col), style=discord.ButtonStyle.secondary, row=0 if col <= 4 else 1)
-
-            async def _drop(interaction: discord.Interaction, c: int = col) -> None:
-                if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
-                    await interaction.response.send_message("Server text channels only.", ephemeral=True)
-                    return
-                err = await self.cog._play_turn(
-                    guild=interaction.guild,
-                    channel=interaction.channel,
-                    author_id=interaction.user.id,
-                    move=str(c),
-                )
-                if err:
-                    await interaction.response.send_message(err, ephemeral=True)
-                else:
-                    await interaction.response.send_message(f"✅ Dropped in column {c}", ephemeral=True)
-
-            button.callback = _drop
-            self.add_item(button)
-
-        forfeit_btn = discord.ui.Button(label="Forfeit", style=discord.ButtonStyle.danger, emoji=ui("no"), row=2, custom_id="board_forfeit_c4")
-        end_btn = discord.ui.Button(label="End Game", style=discord.ButtonStyle.danger, emoji=ui("lock"), row=2, custom_id="board_end_c4")
-
-        async def _forfeit(interaction: discord.Interaction) -> None:
-            if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
-                await interaction.response.send_message("Server text channels only.", ephemeral=True)
-                return
-            err = await self.cog._forfeit(guild=interaction.guild, channel=interaction.channel, author_id=interaction.user.id)
-            if err:
-                await interaction.response.send_message(err, ephemeral=True)
-                return
-            await interaction.response.send_message("🏳️ Forfeit processed.", ephemeral=True)
-
-        forfeit_btn.callback = _forfeit
-        self.add_item(forfeit_btn)
-
-        async def _end(interaction: discord.Interaction) -> None:
-            if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
-                await interaction.response.send_message("Server text channels only.", ephemeral=True)
-                return
-            session = self.cog.sessions.get(interaction.channel.id)
-            if not session:
-                await interaction.response.send_message("No active board game in this channel.", ephemeral=True)
-                return
-            if interaction.user.id not in session.players and not interaction.user.guild_permissions.manage_channels:
-                await interaction.response.send_message("Only players/admins can end this game.", ephemeral=True)
-                return
-            self.cog.sessions.pop(interaction.channel.id, None)
-            await interaction.response.send_message("🔒 Game session ended.", ephemeral=True)
-            if interaction.channel.name.startswith("game-"):
-                try:
-                    await interaction.channel.delete(reason=f"Game room closed by {interaction.user}")
-                except Exception:
-                    pass
-
-        end_btn.callback = _end
-        self.add_item(end_btn)
-
-
-import random as _random
-
-
-class QuickRPSView(discord.ui.View):
-    def __init__(self) -> None:
-        super().__init__(timeout=60)
-
-    @discord.ui.button(label="Rock 🪨", style=discord.ButtonStyle.primary)
-    async def rock(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        await self._resolve(interaction, "rock")
-
-    @discord.ui.button(label="Paper 📄", style=discord.ButtonStyle.primary)
-    async def paper(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        await self._resolve(interaction, "paper")
-
-    @discord.ui.button(label="Scissors ✂️", style=discord.ButtonStyle.primary)
-    async def scissors(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        await self._resolve(interaction, "scissors")
-
-    async def _resolve(self, interaction: discord.Interaction, choice: str) -> None:
-        bot_choice = _random.choice(["rock", "paper", "scissors"])
-        emoji_map = {"rock": "🪨", "paper": "📄", "scissors": "✂️"}
-        result_map = {("rock", "scissors"): "win", ("paper", "rock"): "win", ("scissors", "paper"): "win"}
-        if choice == bot_choice:
-            result = "🤝 Tie!"
-        elif (choice, bot_choice) in result_map:
-            result = "🎉 You win!"
-        else:
-            result = "💀 You lose!"
-        await interaction.response.send_message(f"You: {emoji_map[choice]} | Bot: {emoji_map[bot_choice]}\n{result}", ephemeral=True)
-        self.stop()
-
-
-class GamePanelView(discord.ui.View):
-    def __init__(self, cog: "BoardGames") -> None:
-        super().__init__(timeout=None)
-        self.cog = cog
-
-    async def _start(self, interaction: discord.Interaction, game: str) -> None:
-        if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
-            await interaction.response.send_message("Server text channels only.", ephemeral=True)
-            return
-        ok = await self.cog.start_game_session_interaction(interaction, game)
-        if ok:
-            await interaction.response.send_message(f"✅ Started **{game}** vs bot.", ephemeral=True)
-
-    @discord.ui.button(label="Chess", style=discord.ButtonStyle.primary, emoji=ui("chess"), row=0, custom_id="board_chess")
-    async def chess(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        await self._start(interaction, "chess")
-
-    @discord.ui.button(label="Checkers", style=discord.ButtonStyle.secondary, emoji=ui("joystick"), row=0, custom_id="board_checkers")
-    async def checkers(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        await self._start(interaction, "checkers")
-
-    @discord.ui.button(label="Connect4", style=discord.ButtonStyle.success, emoji=ui("joystick"), row=0, custom_id="board_connect4")
-    async def connect4(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        await self._start(interaction, "connect4")
-
-    @discord.ui.button(label="Othello", style=discord.ButtonStyle.blurple, emoji=ui("joystick"), row=0, custom_id="board_othello")
-    async def othello(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        await self._start(interaction, "othello")
-
-    @discord.ui.button(label="TicTacToe", style=discord.ButtonStyle.primary, emoji=ui("x"), row=1, custom_id="board_tictactoe")
-    async def tictactoe(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
-            await interaction.response.send_message("Server text channels only.", ephemeral=True)
-            return
-        await interaction.response.send_message(f"❎ **TicTacToe**: {interaction.user.mention} vs 🤖 Bot\nUse `/xo` to play!", ephemeral=True)
-
-    @discord.ui.button(label="Rock Paper Scissors", style=discord.ButtonStyle.secondary, emoji="✂️", row=1, custom_id="board_rps")
-    async def rps(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not interaction.guild:
-            await interaction.response.send_message("Server only.", ephemeral=True)
-            return
-        await interaction.response.send_message(
-            "Choose your move:",
-            view=QuickRPSView(),
-            ephemeral=True,
-        )
-
-
-class BoardGames(commands.Cog):
-    def __init__(self, bot: commands.Bot) -> None:
-        self.bot = bot
-        self.sessions: dict[int, BoardGameSession] = {}
-
-    async def cog_load(self) -> None:
-        self.bot.add_view(GamePanelView(self))
-        self.bot.add_view(BoardActionView(self))
-
-    def _coord(self, token: str) -> tuple[int, int] | None:
-        token = token.strip().lower()
-        if len(token) != 2 or token[0] not in FILES or token[1] not in "12345678":
-            return None
-        x = FILES.index(token[0])
-        y = 8 - int(token[1])
-        return y, x
-
-    def _coord_to_text(self, y: int, x: int) -> str:
-        return f"{FILES[x]}{8-y}"
-
-    def _current_player(self, s: BoardGameSession) -> int:
-        return s.players[s.turn]
-
-    def _render(self, s: BoardGameSession) -> str:
-        if s.game == "connect4":
-            lines = ["1️⃣2️⃣3️⃣4️⃣5️⃣6️⃣7️⃣"]
-            for row in s.board:
-                lines.append("".join(row))
-            return "\n".join(lines)
-        if s.game == "othello":
-            lines = ["⬛🇦🇧🇨🇩🇪🇫🇬🇭"]
-            for y, row in enumerate(s.board):
-                lines.append(f"{8-y}️⃣" + "".join(row))
-            return "\n".join(lines)
-        lines = ["  🇦 🇧 🇨 🇩 🇪 🇫 🇬 🇭"]
-        for y, row in enumerate(s.board):
-            lines.append(f"{8-y} " + " ".join(row))
-        return "\n".join(lines)
-
-    def _make_chess(self) -> list[list[str]]:
-        return [
-            list("♜♞♝♛♚♝♞♜"),
-            list("♟♟♟♟♟♟♟♟"),
-            list("▫▫▫▫▫▫▫▫"),
-            list("▫▫▫▫▫▫▫▫"),
-            list("▫▫▫▫▫▫▫▫"),
-            list("▫▫▫▫▫▫▫▫"),
-            list("♙♙♙♙♙♙♙♙"),
-            list("♖♘♗♕♔♗♘♖"),
-        ]
-
-    def _make_checkers(self) -> list[list[str]]:
-        board = [["▫" for _ in range(8)] for _ in range(8)]
-        for y in range(3):
-            for x in range(8):
-                if (x + y) % 2 == 1:
-                    board[y][x] = "🔴"
-        for y in range(5, 8):
-            for x in range(8):
-                if (x + y) % 2 == 1:
-                    board[y][x] = "⚪"
-        return board
-
-    def _make_connect4(self) -> list[list[str]]:
-        return [["⚫" for _ in range(7)] for _ in range(6)]
-
-    def _make_othello(self) -> list[list[str]]:
-        b = [["🟩" for _ in range(8)] for _ in range(8)]
-        b[3][3] = "⚪"
-        b[3][4] = "⚫"
-        b[4][3] = "⚫"
-        b[4][4] = "⚪"
-        return b
-
-    async def _announce(self, ctx: commands.Context, s: BoardGameSession, text: str) -> None:
-        p1 = f"<@{s.players[0]}>"
-        p2 = "🤖 Bot" if s.players[1] == 0 else f"<@{s.players[1]}>"
-        turn = self._current_player(s)
-        tname = "🤖 Bot" if turn == 0 else f"<@{turn}>"
-        await ctx.send(
-            f"**{s.game.title()}** | {p1} vs {p2}\n{text}\nTurn: {tname}\n{self._render(s)}"
-        )
-
-    async def start_game_session(
-        self,
-        ctx: commands.Context,
-        game: str,
-        opponent: discord.Member | None = None,
-        tournament_name: str | None = None,
-    ) -> bool:
-        game = game.lower().strip()
-        if game not in {"chess", "checkers", "connect4", "othello"}:
-            await ctx.reply("Supported: chess, checkers, connect4, othello")
-            return False
-        if ctx.channel.id in self.sessions:
-            await ctx.reply("There is already an active board game in this channel.")
-            return False
-
-        opponent_id = opponent.id if opponent else 0
-        if opponent_id == ctx.author.id:
-            await ctx.reply("Choose another player or leave opponent empty for bot.")
-            return False
-
-        if game == "chess":
-            board = self._make_chess()
-        elif game == "checkers":
-            board = self._make_checkers()
-        elif game == "connect4":
-            board = self._make_connect4()
-        else:
-            board = self._make_othello()
-
-        s = BoardGameSession(game=game, players=(ctx.author.id, opponent_id), turn=0, board=board, tournament_name=tournament_name)
-        self.sessions[ctx.channel.id] = s
-        await self._announce(ctx.channel, s, "Game started. Use buttons or `/board_move`.")
-        return True
-
-    async def start_game_session_interaction(self, interaction: discord.Interaction, game: str) -> bool:
-        if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
-            return False
-        game = game.lower().strip()
-        if game not in {"chess", "checkers", "connect4", "othello"}:
-            await interaction.followup.send("Supported: chess, checkers, connect4, othello", ephemeral=True)
-            return False
-        if interaction.channel.id in self.sessions:
-            await interaction.followup.send("There is already an active board game in this channel.", ephemeral=True)
-            return False
-
-        if game == "chess":
-            board = self._make_chess()
-        elif game == "checkers":
-            board = self._make_checkers()
-        elif game == "connect4":
-            board = self._make_connect4()
-        else:
-            board = self._make_othello()
-
-        s = BoardGameSession(game=game, players=(interaction.user.id, 0), turn=0, board=board)
-        self.sessions[interaction.channel.id] = s
-        await self._announce(interaction.channel, s, "Game started from panel.")
-        return True
-
-    async def start_tournament_duel(
-        self,
-        ctx: commands.Context,
-        game: str,
-        player1: discord.Member,
-        player2: discord.Member | None,
-        tournament_name: str,
-    ) -> bool:
-        if ctx.channel.id in self.sessions:
-            await ctx.reply("There is already an active board game in this channel.")
-            return False
-        game = game.lower().strip()
-        if game == "chess":
-            board = self._make_chess()
-        elif game == "checkers":
-            board = self._make_checkers()
-        elif game == "connect4":
-            board = self._make_connect4()
-        elif game == "othello":
-            board = self._make_othello()
-        else:
-            await ctx.reply("Supported: chess, checkers, connect4, othello")
-            return False
-
-        s = BoardGameSession(
-            game=game,
-            players=(player1.id, player2.id if player2 else 0),
-            turn=0,
-            board=board,
-            tournament_name=tournament_name,
-        )
-        self.sessions[ctx.channel.id] = s
-        await self._announce(ctx.channel, s, f"Tournament duel: **{tournament_name}**")
-        return True
-
-
-    def _in_bounds(self, y: int, x: int) -> bool:
-        return 0 <= y < 8 and 0 <= x < 8
-
-    def _is_white(self, p: str) -> bool:
-        return p in "♙♖♘♗♕♔"
-
-    def _is_black(self, p: str) -> bool:
-        return p in "♟♜♞♝♛♚"
-
-    def _enemy(self, p: str, white_turn: bool) -> bool:
-        return self._is_black(p) if white_turn else self._is_white(p)
-
-    def _friend(self, p: str, white_turn: bool) -> bool:
-        return self._is_white(p) if white_turn else self._is_black(p)
-
-    def _chess_legal(self, b: list[list[str]], src: tuple[int, int], dst: tuple[int, int], white_turn: bool) -> bool:
-        sy, sx = src
-        dy, dx = dst
-        if not (self._in_bounds(sy, sx) and self._in_bounds(dy, dx)):
-            return False
-        piece = b[sy][sx]
-        if piece == "▫" or not self._friend(piece, white_turn):
-            return False
-        target = b[dy][dx]
-        if target != "▫" and self._friend(target, white_turn):
-            return False
-
-        vy = dy - sy
-        vx = dx - sx
-        ady, adx = abs(vy), abs(vx)
-
-        def clear_line(stepy: int, stepx: int) -> bool:
-            y, x = sy + stepy, sx + stepx
-            while (y, x) != (dy, dx):
-                if b[y][x] != "▫":
-                    return False
-                y += stepy
-                x += stepx
-            return True
-
-        if piece in "♙♟":
-            direction = -1 if piece == "♙" else 1
-            start_row = 6 if piece == "♙" else 1
-            if vx == 0 and target == "▫":
-                if vy == direction:
-                    return True
-                if sy == start_row and vy == 2 * direction and b[sy + direction][sx] == "▫":
-                    return True
-            if adx == 1 and vy == direction and target != "▫" and self._enemy(target, white_turn):
-                return True
-            return False
-        if piece in "♖♜":
-            if sx == dx and clear_line(1 if vy > 0 else -1, 0):
-                return True
-            if sy == dy and clear_line(0, 1 if vx > 0 else -1):
-                return True
-            return False
-        if piece in "♗♝":
-            if adx == ady and clear_line(1 if vy > 0 else -1, 1 if vx > 0 else -1):
-                return True
-            return False
-        if piece in "♕♛":
-            if sx == dx and clear_line(1 if vy > 0 else -1, 0):
-                return True
-            if sy == dy and clear_line(0, 1 if vx > 0 else -1):
-                return True
-            if adx == ady and clear_line(1 if vy > 0 else -1, 1 if vx > 0 else -1):
-                return True
-            return False
-        if piece in "♘♞":
-            return (ady, adx) in {(1, 2), (2, 1)}
-        if piece in "♔♚":
-            return max(ady, adx) == 1
-        return False
-
-    def _checkers_legal(self, b: list[list[str]], src: tuple[int, int], dst: tuple[int, int], white_turn: bool) -> bool:
-        sy, sx = src
-        dy, dx = dst
-        if not (self._in_bounds(sy, sx) and self._in_bounds(dy, dx)):
-            return False
-        me = "⚪" if white_turn else "🔴"
-        enemy = "🔴" if white_turn else "⚪"
-        if b[sy][sx] != me or b[dy][dx] != "▫":
-            return False
-        vy, vx = dy - sy, dx - sx
-        direction = -1 if white_turn else 1
-        if abs(vx) == 1 and vy == direction:
-            return True
-        if abs(vx) == 2 and vy == 2 * direction:
-            my, mx = sy + direction, sx + (1 if vx > 0 else -1)
-            return b[my][mx] == enemy
-        return False
-
-    def _apply_checkers_capture(self, b: list[list[str]], src: tuple[int, int], dst: tuple[int, int], white_turn: bool) -> None:
-        sy, sx = src
-        dy, dx = dst
-        if abs(dy - sy) == 2:
-            my, mx = (sy + dy) // 2, (sx + dx) // 2
-            b[my][mx] = "▫"
-
-    def _connect4_drop(self, b: list[list[str]], col: int, white_turn: bool) -> tuple[int, int] | None:
-        token = "🔵" if white_turn else "🟠"
-        for y in range(len(b) - 1, -1, -1):
-            if b[y][col] == "⚫":
-                b[y][col] = token
-                return y, col
-        return None
-
-    def _has_four(self, b: list[list[str]], y: int, x: int) -> bool:
-        token = b[y][x]
-        if token == "⚫":
-            return False
-        dirs = [(1, 0), (0, 1), (1, 1), (1, -1)]
-        h, w = len(b), len(b[0])
-        for dy, dx in dirs:
-            c = 1
-            for sign in (1, -1):
-                ny, nx = y, x
-                while True:
-                    ny += dy * sign
-                    nx += dx * sign
-                    if not (0 <= ny < h and 0 <= nx < w) or b[ny][nx] != token:
-                        break
-                    c += 1
-            if c >= 4:
-                return True
-        return False
-
-    def _othello_flips(self, b: list[list[str]], y: int, x: int, black_turn: bool) -> list[tuple[int, int]]:
-        me = "⚫" if black_turn else "⚪"
-        enemy = "⚪" if black_turn else "⚫"
-        if not self._in_bounds(y, x) or b[y][x] != "🟩":
-            return []
-        flips: list[tuple[int, int]] = []
-        for dy in (-1, 0, 1):
-            for dx in (-1, 0, 1):
-                if dy == 0 and dx == 0:
-                    continue
-                path: list[tuple[int, int]] = []
-                ny, nx = y + dy, x + dx
-                while self._in_bounds(ny, nx) and b[ny][nx] == enemy:
-                    path.append((ny, nx))
-                    ny += dy
-                    nx += dx
-                if path and self._in_bounds(ny, nx) and b[ny][nx] == me:
-                    flips.extend(path)
-        return flips
-
-    async def _finish(self, ctx: commands.Context, winner_id: int | None, reason: str) -> None:
-        s = self.sessions.pop(ctx.channel.id, None)
-        if not s:
-            return
-        if winner_id is None:
-            await ctx.send(f"🤝 Draw | {reason}")
-            return
-
-        if winner_id == 0:
-            await ctx.send(f"🤖 Bot won | {reason}")
-            return
-
-        await ctx.send(f"🏆 Winner: <@{winner_id}> | {reason}")
-        if s.tournament_name:
-            await self.bot.db.execute(
-                "UPDATE tournaments SET winner_id = ?, status = 'finished' WHERE guild_id = ? AND name = ?",
-                winner_id,
-                ctx.guild.id,
-                s.tournament_name,
-            )
-
-    async def _bot_move(self, ctx: commands.Context) -> None:
-        s = self.sessions.get(ctx.channel.id)
-        if not s or s.players[1] != 0 or self._current_player(s) != 0:
-            return
-        if s.game == "connect4":
-            valid = [c for c in range(7) if s.board[0][c] == "⚫"]
-            col = random.choice(valid)
-            spot = self._connect4_drop(s.board, col, white_turn=False)
-            if spot and self._has_four(s.board, spot[0], spot[1]):
-                await self._announce(ctx.channel, s, f"Bot played column {col + 1}.")
-                await self._finish(ctx, 0, "Four in a row!")
-                return
-            s.turn = 0
-            await self._announce(ctx.channel, s, f"Bot played column {col + 1}.")
-            return
-
-        if s.game == "othello":
-            legal: list[tuple[int, int, list[tuple[int, int]]]] = []
-            for y in range(8):
-                for x in range(8):
-                    flips = self._othello_flips(s.board, y, x, black_turn=False)
-                    if flips:
-                        legal.append((y, x, flips))
-            if not legal:
-                s.turn = 0
-                await self._announce(ctx.channel, s, "Bot has no valid move and passes.")
-                return
-            y, x, flips = random.choice(legal)
-            s.board[y][x] = "⚪"
-            for fy, fx in flips:
-                s.board[fy][fx] = "⚪"
-            s.turn = 0
-            await self._announce(ctx.channel, s, f"Bot played {self._coord_to_text(y, x)}")
-            return
-
-        # chess/checkers bot move: random pseudo legal
-        moves: list[tuple[tuple[int, int], tuple[int, int]]] = []
-        for sy in range(8):
-            for sx in range(8):
-                for dy in range(8):
-                    for dx in range(8):
-                        if s.game == "chess":
-                            if self._chess_legal(s.board, (sy, sx), (dy, dx), white_turn=False):
-                                moves.append(((sy, sx), (dy, dx)))
-                        elif self._checkers_legal(s.board, (sy, sx), (dy, dx), white_turn=False):
-                            moves.append(((sy, sx), (dy, dx)))
-        if not moves:
-            await self._finish(ctx, s.players[0], "Bot has no legal moves.")
-            return
-        src, dst = random.choice(moves)
-        sy, sx = src
-        dy, dx = dst
-        target = s.board[dy][dx]
-        if s.game == "checkers":
-            self._apply_checkers_capture(s.board, src, dst, white_turn=False)
-        s.board[dy][dx] = s.board[sy][sx]
-        s.board[sy][sx] = "▫"
-        s.turn = 0
-        await self._announce(ctx.channel, s, f"Bot played {self._coord_to_text(sy, sx)}{self._coord_to_text(dy, dx)}")
-        if s.game == "chess" and target == "♔":
-            await self._finish(ctx, 0, "White king captured.")
-
-    @commands.hybrid_command(name="boardgames", hidden=True, description="Show supported board games", with_app_command=False)
-    async def boardgames(self, ctx: commands.Context) -> None:
-        embed = discord.Embed(title="Board Games", color=discord.Color.blurple())
-        embed.description = (
-            "• chess\n"
-            "• checkers\n"
-            "• connect4\n"
-            "• othello\n\n"
-            "Use `/board_start <game> [opponent]` then `/board_move`"
-        )
-        await ctx.reply(embed=embed)
-
-    @commands.hybrid_command(name="board_start", hidden=True, description="Start a board game", with_app_command=False)
-    async def board_start(self, ctx: commands.Context, game: str, opponent: discord.Member | None = None) -> None:
-        await self.start_game_session(ctx, game, opponent)
-
-    @commands.hybrid_command(name="chess", hidden=True, description="Start chess with player or bot", with_app_command=False)
-    async def chess(self, ctx: commands.Context, opponent: discord.Member | None = None) -> None:
-        await self.start_game_session(ctx, "chess", opponent)
-
-    @commands.hybrid_command(name="checkers", hidden=True, description="Start checkers with player or bot", with_app_command=False)
-    async def checkers(self, ctx: commands.Context, opponent: discord.Member | None = None) -> None:
-        await self.start_game_session(ctx, "checkers", opponent)
-
-    @commands.hybrid_command(name="connect4", hidden=True, description="Start connect4 with player or bot", with_app_command=False)
-    async def connect4(self, ctx: commands.Context, opponent: discord.Member | None = None) -> None:
-        await self.start_game_session(ctx, "connect4", opponent)
-
-    @commands.hybrid_command(name="othello", hidden=True, description="Start othello with player or bot", with_app_command=False)
-    async def othello(self, ctx: commands.Context, opponent: discord.Member | None = None) -> None:
-        await self.start_game_session(ctx, "othello", opponent)
-
-    async def _play_turn(self, *, guild: discord.Guild, channel: discord.TextChannel, author_id: int, move: str) -> str | None:
-        s = self.sessions.get(channel.id)
-        if not s:
-            return "No active board game in this channel."
-        if self._current_player(s) != author_id:
-            return "Not your turn."
-
-        is_first_player = author_id == s.players[0]
-
-        if s.game == "connect4":
-            try:
-                col = int(move) - 1
-            except ValueError:
-                return "Connect4 move is column number 1-7"
-            if not 0 <= col < 7:
-                return "Column must be 1-7"
-            spot = self._connect4_drop(s.board, col, white_turn=is_first_player)
-            if not spot:
-                return "Column is full."
-            if self._has_four(s.board, spot[0], spot[1]):
-                await self._announce(channel, s, f"Move: {col + 1}")
-                winner = author_id if author_id != 0 else None
-                await self._finish_ctxless(guild, channel, winner, "Four in a row!")
-                return None
-            if all(s.board[0][i] != "⚫" for i in range(7)):
-                await self._announce(channel, s, f"Move: {col + 1}")
-                await self._finish_ctxless(guild, channel, None, "Board full")
-                return None
-            s.turn = 1 - s.turn
-            await self._announce(channel, s, f"Move: {col + 1}")
-            if s.players[1] == 0:
-                await self._bot_move_channel(guild, channel)
-            return None
-
-        if s.game == "othello":
-            c = self._coord(move)
-            if not c:
-                return "Use coordinate like d3"
-            y, x = c
-            black_turn = is_first_player
-            flips = self._othello_flips(s.board, y, x, black_turn=black_turn)
-            if not flips:
-                return "Illegal move."
-            s.board[y][x] = "⚫" if black_turn else "⚪"
-            for fy, fx in flips:
-                s.board[fy][fx] = "⚫" if black_turn else "⚪"
-            s.turn = 1 - s.turn
-            await self._announce(channel, s, f"Move: {move.lower()}")
-            if s.players[1] == 0:
-                await self._bot_move_channel(guild, channel)
-            return None
-
-        if len(move) != 4:
-            return "Use move format like e2e4"
-        src = self._coord(move[:2])
-        dst = self._coord(move[2:])
-        if not src or not dst:
-            return "Invalid coordinates. Example: e2e4"
-
-        legal = self._chess_legal(s.board, src, dst, white_turn=is_first_player) if s.game == "chess" else self._checkers_legal(s.board, src, dst, white_turn=is_first_player)
-        if not legal:
-            return "Illegal move."
-
-        sy, sx = src
-        dy, dx = dst
-        target = s.board[dy][dx]
-        if s.game == "checkers":
-            self._apply_checkers_capture(s.board, src, dst, white_turn=is_first_player)
-        piece = s.board[sy][sx]
-        s.board[dy][dx] = piece
-        s.board[sy][sx] = "▫"
-        if piece == "♙" and dy == 0:
-            s.board[dy][dx] = "♕"
-        if piece == "♟" and dy == 7:
-            s.board[dy][dx] = "♛"
-
-        if s.game == "chess" and target in {"♚", "♔"}:
-            await self._announce(channel, s, f"Move: {move.lower()}")
-            await self._finish_ctxless(guild, channel, author_id, "King captured.")
-            return None
-
-        s.turn = 1 - s.turn
-        await self._announce(channel, s, f"Move: {move.lower()}")
-        if s.players[1] == 0:
-            await self._bot_move_channel(guild, channel)
-        return None
-
-    async def _finish_ctxless(self, guild: discord.Guild, channel: discord.TextChannel, winner_id: int | None, reason: str) -> None:
-        s = self.sessions.pop(channel.id, None)
-        if not s:
-            return
-        if winner_id is None:
-            await channel.send(f"🤝 Draw | {reason}")
-            return
-        if winner_id == 0:
-            await channel.send(f"🤖 Bot won | {reason}")
-            return
-        await channel.send(f"🏆 Winner: <@{winner_id}> | {reason}")
-        if s.tournament_name:
-            await self.bot.db.execute(
-                "UPDATE tournaments SET winner_id = ?, status = 'finished' WHERE guild_id = ? AND name = ?",
-                winner_id,
-                guild.id,
-                s.tournament_name,
-            )
-
-    async def _bot_move_channel(self, guild: discord.Guild, channel: discord.TextChannel) -> None:
-        class Dummy:
-            pass
-        d=Dummy(); d.guild=guild; d.channel=channel
-        await self._bot_move(d)
-
-    async def _forfeit(self, *, guild: discord.Guild, channel: discord.TextChannel, author_id: int) -> str | None:
-        s = self.sessions.get(channel.id)
-        if not s:
-            return "No active board game in this channel."
-        if author_id not in s.players:
-            return "Only players can forfeit."
-        winner = s.players[1] if author_id == s.players[0] else s.players[0]
-        await self._finish_ctxless(guild, channel, None if winner == 0 else winner, "Forfeit")
-        return None
-
-    @commands.hybrid_command(name="board_move", hidden=True, description="Play move in current board game", with_app_command=False)
-    async def board_move(self, ctx: commands.Context, move: str) -> None:
-        if not ctx.guild or not isinstance(ctx.channel, discord.TextChannel):
-            await ctx.reply("Server text channels only.")
-            return
-        err = await self._play_turn(guild=ctx.guild, channel=ctx.channel, author_id=ctx.author.id, move=move)
-        if err:
-            await ctx.reply(err)
-
-    @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("<: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:
-        if not ctx.guild or not isinstance(ctx.channel, discord.TextChannel):
-            await ctx.reply("Server text channels only.")
-            return
-        err = await self._forfeit(guild=ctx.guild, channel=ctx.channel, author_id=ctx.author.id)
-        if err:
-            await ctx.reply(err)
-
-
-async def setup(bot: commands.Bot) -> None:
-    await bot.add_cog(BoardGames(bot))
+from __future__ import annotations
+
+import random
+from dataclasses import dataclass
+
+import discord
+from discord.ext import commands
+from bot.i18n import get_cmd_desc
+from bot.emojis import ui
+
+FILES = "abcdefgh"
+
+
+@dataclass
+class BoardGameSession:
+    game: str
+    players: tuple[int, int]  # second player can be 0 for bot
+    turn: int
+    board: list[list[str]]
+    tournament_name: str | None = None
+
+
+
+
+class BoardMoveModal(discord.ui.Modal, title="Play Move"):
+    move = discord.ui.TextInput(label="Move", placeholder="e2e4 / d3 / 4", max_length=10)
+
+    def __init__(self, cog: "BoardGames") -> None:
+        super().__init__(timeout=None)
+        self.cog = cog
+
+    async def on_submit(self, interaction: discord.Interaction) -> None:
+        if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
+            await interaction.response.send_message("Server text channels only.", ephemeral=True)
+            return
+        err = await self.cog._play_turn(
+            guild=interaction.guild,
+            channel=interaction.channel,
+            author_id=interaction.user.id,
+            move=str(self.move.value).strip(),
+        )
+        if err:
+            await interaction.response.send_message(err, ephemeral=True)
+        else:
+            await interaction.response.send_message("✅ Move accepted.", ephemeral=True)
+
+
+class BoardActionView(discord.ui.View):
+    def __init__(self, cog: "BoardGames") -> None:
+        super().__init__(timeout=None)
+        self.cog = cog
+
+    @discord.ui.button(label="Play Move", style=discord.ButtonStyle.primary, emoji=ui("controller"), custom_id="board_play")
+    async def play_move(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        await interaction.response.send_modal(BoardMoveModal(self.cog))
+
+    @discord.ui.button(label="Forfeit", style=discord.ButtonStyle.danger, emoji=ui("no"), custom_id="board_forfeit")
+    async def forfeit(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
+            await interaction.response.send_message("Server text channels only.", ephemeral=True)
+            return
+        err = await self.cog._forfeit(
+            guild=interaction.guild,
+            channel=interaction.channel,
+            author_id=interaction.user.id,
+        )
+        if err:
+            await interaction.response.send_message(err, ephemeral=True)
+            return
+        await interaction.response.send_message("🏳️ Forfeit processed.", ephemeral=True)
+
+    @discord.ui.button(label="End Game", style=discord.ButtonStyle.danger, emoji=ui("lock"), custom_id="board_end")
+    async def end_game(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
+            await interaction.response.send_message("Server text channels only.", ephemeral=True)
+            return
+        session = self.cog.sessions.get(interaction.channel.id)
+        if not session:
+            await interaction.response.send_message("No active board game in this channel.", ephemeral=True)
+            return
+        if interaction.user.id not in session.players and not interaction.user.guild_permissions.manage_channels:
+            await interaction.response.send_message("Only players/admins can end this game.", ephemeral=True)
+            return
+        self.cog.sessions.pop(interaction.channel.id, None)
+        await interaction.response.send_message("🔒 Game session ended.", ephemeral=True)
+        if interaction.channel.name.startswith("game-"):
+            try:
+                await interaction.channel.delete(reason=f"Game room closed by {interaction.user}")
+            except Exception:
+                pass
+
+
+class Connect4ActionView(BoardActionView):
+    def __init__(self, cog: "BoardGames") -> None:
+        super().__init__(cog)
+        self.clear_items()
+        for col in range(1, 8):
+            button = discord.ui.Button(label=str(col), style=discord.ButtonStyle.secondary, row=0 if col <= 4 else 1)
+
+            async def _drop(interaction: discord.Interaction, c: int = col) -> None:
+                if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
+                    await interaction.response.send_message("Server text channels only.", ephemeral=True)
+                    return
+                err = await self.cog._play_turn(
+                    guild=interaction.guild,
+                    channel=interaction.channel,
+                    author_id=interaction.user.id,
+                    move=str(c),
+                )
+                if err:
+                    await interaction.response.send_message(err, ephemeral=True)
+                else:
+                    await interaction.response.send_message(f"✅ Dropped in column {c}", ephemeral=True)
+
+            button.callback = _drop
+            self.add_item(button)
+
+        forfeit_btn = discord.ui.Button(label="Forfeit", style=discord.ButtonStyle.danger, emoji=ui("no"), row=2, custom_id="board_forfeit_c4")
+        end_btn = discord.ui.Button(label="End Game", style=discord.ButtonStyle.danger, emoji=ui("lock"), row=2, custom_id="board_end_c4")
+
+        async def _forfeit(interaction: discord.Interaction) -> None:
+            if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
+                await interaction.response.send_message("Server text channels only.", ephemeral=True)
+                return
+            err = await self.cog._forfeit(guild=interaction.guild, channel=interaction.channel, author_id=interaction.user.id)
+            if err:
+                await interaction.response.send_message(err, ephemeral=True)
+                return
+            await interaction.response.send_message("🏳️ Forfeit processed.", ephemeral=True)
+
+        forfeit_btn.callback = _forfeit
+        self.add_item(forfeit_btn)
+
+        async def _end(interaction: discord.Interaction) -> None:
+            if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
+                await interaction.response.send_message("Server text channels only.", ephemeral=True)
+                return
+            session = self.cog.sessions.get(interaction.channel.id)
+            if not session:
+                await interaction.response.send_message("No active board game in this channel.", ephemeral=True)
+                return
+            if interaction.user.id not in session.players and not interaction.user.guild_permissions.manage_channels:
+                await interaction.response.send_message("Only players/admins can end this game.", ephemeral=True)
+                return
+            self.cog.sessions.pop(interaction.channel.id, None)
+            await interaction.response.send_message("🔒 Game session ended.", ephemeral=True)
+            if interaction.channel.name.startswith("game-"):
+                try:
+                    await interaction.channel.delete(reason=f"Game room closed by {interaction.user}")
+                except Exception:
+                    pass
+
+        end_btn.callback = _end
+        self.add_item(end_btn)
+
+
+import random as _random
+
+
+class QuickRPSView(discord.ui.View):
+    def __init__(self) -> None:
+        super().__init__(timeout=60)
+
+    @discord.ui.button(label="Rock 🪨", style=discord.ButtonStyle.primary)
+    async def rock(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        await self._resolve(interaction, "rock")
+
+    @discord.ui.button(label="Paper 📄", style=discord.ButtonStyle.primary)
+    async def paper(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        await self._resolve(interaction, "paper")
+
+    @discord.ui.button(label="Scissors ✂️", style=discord.ButtonStyle.primary)
+    async def scissors(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        await self._resolve(interaction, "scissors")
+
+    async def _resolve(self, interaction: discord.Interaction, choice: str) -> None:
+        bot_choice = _random.choice(["rock", "paper", "scissors"])
+        emoji_map = {"rock": "🪨", "paper": "📄", "scissors": "✂️"}
+        result_map = {("rock", "scissors"): "win", ("paper", "rock"): "win", ("scissors", "paper"): "win"}
+        if choice == bot_choice:
+            result = "🤝 Tie!"
+        elif (choice, bot_choice) in result_map:
+            result = "🎉 You win!"
+        else:
+            result = "💀 You lose!"
+        await interaction.response.send_message(f"You: {emoji_map[choice]} | Bot: {emoji_map[bot_choice]}\n{result}", ephemeral=True)
+        self.stop()
+
+
+class GamePanelView(discord.ui.View):
+    def __init__(self, cog: "BoardGames") -> None:
+        super().__init__(timeout=None)
+        self.cog = cog
+
+    async def _start(self, interaction: discord.Interaction, game: str) -> None:
+        if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
+            await interaction.response.send_message("Server text channels only.", ephemeral=True)
+            return
+        ok = await self.cog.start_game_session_interaction(interaction, game)
+        if ok:
+            await interaction.response.send_message(f"✅ Started **{game}** vs bot.", ephemeral=True)
+
+    @discord.ui.button(label="Chess", style=discord.ButtonStyle.primary, emoji=ui("chess"), row=0, custom_id="board_chess")
+    async def chess(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        await self._start(interaction, "chess")
+
+    @discord.ui.button(label="Checkers", style=discord.ButtonStyle.secondary, emoji=ui("joystick"), row=0, custom_id="board_checkers")
+    async def checkers(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        await self._start(interaction, "checkers")
+
+    @discord.ui.button(label="Connect4", style=discord.ButtonStyle.success, emoji=ui("joystick"), row=0, custom_id="board_connect4")
+    async def connect4(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        await self._start(interaction, "connect4")
+
+    @discord.ui.button(label="Othello", style=discord.ButtonStyle.blurple, emoji=ui("joystick"), row=0, custom_id="board_othello")
+    async def othello(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        await self._start(interaction, "othello")
+
+    @discord.ui.button(label="TicTacToe", style=discord.ButtonStyle.primary, emoji=ui("x"), row=1, custom_id="board_tictactoe")
+    async def tictactoe(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
+            await interaction.response.send_message("Server text channels only.", ephemeral=True)
+            return
+        await interaction.response.send_message(f"❎ **TicTacToe**: {interaction.user.mention} vs 🤖 Bot\nUse `/xo` to play!", ephemeral=True)
+
+    @discord.ui.button(label="Rock Paper Scissors", style=discord.ButtonStyle.secondary, emoji="✂️", row=1, custom_id="board_rps")
+    async def rps(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not interaction.guild:
+            await interaction.response.send_message("Server only.", ephemeral=True)
+            return
+        await interaction.response.send_message(
+            "Choose your move:",
+            view=QuickRPSView(),
+            ephemeral=True,
+        )
+
+
+class BoardGames(commands.Cog):
+    def __init__(self, bot: commands.Bot) -> None:
+        self.bot = bot
+        self.sessions: dict[int, BoardGameSession] = {}
+
+    async def cog_load(self) -> None:
+        self.bot.add_view(GamePanelView(self))
+        self.bot.add_view(BoardActionView(self))
+
+    def _coord(self, token: str) -> tuple[int, int] | None:
+        token = token.strip().lower()
+        if len(token) != 2 or token[0] not in FILES or token[1] not in "12345678":
+            return None
+        x = FILES.index(token[0])
+        y = 8 - int(token[1])
+        return y, x
+
+    def _coord_to_text(self, y: int, x: int) -> str:
+        return f"{FILES[x]}{8-y}"
+
+    def _current_player(self, s: BoardGameSession) -> int:
+        return s.players[s.turn]
+
+    def _render(self, s: BoardGameSession) -> str:
+        if s.game == "connect4":
+            lines = ["1️⃣2️⃣3️⃣4️⃣5️⃣6️⃣7️⃣"]
+            for row in s.board:
+                lines.append("".join(row))
+            return "\n".join(lines)
+        if s.game == "othello":
+            lines = ["⬛🇦🇧🇨🇩🇪🇫🇬🇭"]
+            for y, row in enumerate(s.board):
+                lines.append(f"{8-y}️⃣" + "".join(row))
+            return "\n".join(lines)
+        lines = ["  🇦 🇧 🇨 🇩 🇪 🇫 🇬 🇭"]
+        for y, row in enumerate(s.board):
+            lines.append(f"{8-y} " + " ".join(row))
+        return "\n".join(lines)
+
+    def _make_chess(self) -> list[list[str]]:
+        return [
+            list("♜♞♝♛♚♝♞♜"),
+            list("♟♟♟♟♟♟♟♟"),
+            list("▫▫▫▫▫▫▫▫"),
+            list("▫▫▫▫▫▫▫▫"),
+            list("▫▫▫▫▫▫▫▫"),
+            list("▫▫▫▫▫▫▫▫"),
+            list("♙♙♙♙♙♙♙♙"),
+            list("♖♘♗♕♔♗♘♖"),
+        ]
+
+    def _make_checkers(self) -> list[list[str]]:
+        board = [["▫" for _ in range(8)] for _ in range(8)]
+        for y in range(3):
+            for x in range(8):
+                if (x + y) % 2 == 1:
+                    board[y][x] = "🔴"
+        for y in range(5, 8):
+            for x in range(8):
+                if (x + y) % 2 == 1:
+                    board[y][x] = "⚪"
+        return board
+
+    def _make_connect4(self) -> list[list[str]]:
+        return [["⚫" for _ in range(7)] for _ in range(6)]
+
+    def _make_othello(self) -> list[list[str]]:
+        b = [["🟩" for _ in range(8)] for _ in range(8)]
+        b[3][3] = "⚪"
+        b[3][4] = "⚫"
+        b[4][3] = "⚫"
+        b[4][4] = "⚪"
+        return b
+
+    async def _announce(self, ctx: commands.Context, s: BoardGameSession, text: str) -> None:
+        p1 = f"<@{s.players[0]}>"
+        p2 = "🤖 Bot" if s.players[1] == 0 else f"<@{s.players[1]}>"
+        turn = self._current_player(s)
+        tname = "🤖 Bot" if turn == 0 else f"<@{turn}>"
+        await ctx.send(
+            f"**{s.game.title()}** | {p1} vs {p2}\n{text}\nTurn: {tname}\n{self._render(s)}"
+        )
+
+    async def start_game_session(
+        self,
+        ctx: commands.Context,
+        game: str,
+        opponent: discord.Member | None = None,
+        tournament_name: str | None = None,
+    ) -> bool:
+        game = game.lower().strip()
+        if game not in {"chess", "checkers", "connect4", "othello"}:
+            await ctx.reply("Supported: chess, checkers, connect4, othello")
+            return False
+        if ctx.channel.id in self.sessions:
+            await ctx.reply("There is already an active board game in this channel.")
+            return False
+
+        opponent_id = opponent.id if opponent else 0
+        if opponent_id == ctx.author.id:
+            await ctx.reply("Choose another player or leave opponent empty for bot.")
+            return False
+
+        if game == "chess":
+            board = self._make_chess()
+        elif game == "checkers":
+            board = self._make_checkers()
+        elif game == "connect4":
+            board = self._make_connect4()
+        else:
+            board = self._make_othello()
+
+        s = BoardGameSession(game=game, players=(ctx.author.id, opponent_id), turn=0, board=board, tournament_name=tournament_name)
+        self.sessions[ctx.channel.id] = s
+        await self._announce(ctx.channel, s, "Game started. Use buttons or `/board_move`.")
+        return True
+
+    async def start_game_session_interaction(self, interaction: discord.Interaction, game: str) -> bool:
+        if not interaction.guild or not isinstance(interaction.channel, discord.TextChannel):
+            return False
+        game = game.lower().strip()
+        if game not in {"chess", "checkers", "connect4", "othello"}:
+            await interaction.followup.send("Supported: chess, checkers, connect4, othello", ephemeral=True)
+            return False
+        if interaction.channel.id in self.sessions:
+            await interaction.followup.send("There is already an active board game in this channel.", ephemeral=True)
+            return False
+
+        if game == "chess":
+            board = self._make_chess()
+        elif game == "checkers":
+            board = self._make_checkers()
+        elif game == "connect4":
+            board = self._make_connect4()
+        else:
+            board = self._make_othello()
+
+        s = BoardGameSession(game=game, players=(interaction.user.id, 0), turn=0, board=board)
+        self.sessions[interaction.channel.id] = s
+        await self._announce(interaction.channel, s, "Game started from panel.")
+        return True
+
+    async def start_tournament_duel(
+        self,
+        ctx: commands.Context,
+        game: str,
+        player1: discord.Member,
+        player2: discord.Member | None,
+        tournament_name: str,
+    ) -> bool:
+        if ctx.channel.id in self.sessions:
+            await ctx.reply("There is already an active board game in this channel.")
+            return False
+        game = game.lower().strip()
+        if game == "chess":
+            board = self._make_chess()
+        elif game == "checkers":
+            board = self._make_checkers()
+        elif game == "connect4":
+            board = self._make_connect4()
+        elif game == "othello":
+            board = self._make_othello()
+        else:
+            await ctx.reply("Supported: chess, checkers, connect4, othello")
+            return False
+
+        s = BoardGameSession(
+            game=game,
+            players=(player1.id, player2.id if player2 else 0),
+            turn=0,
+            board=board,
+            tournament_name=tournament_name,
+        )
+        self.sessions[ctx.channel.id] = s
+        await self._announce(ctx.channel, s, f"Tournament duel: **{tournament_name}**")
+        return True
+
+
+    def _in_bounds(self, y: int, x: int) -> bool:
+        return 0 <= y < 8 and 0 <= x < 8
+
+    def _is_white(self, p: str) -> bool:
+        return p in "♙♖♘♗♕♔"
+
+    def _is_black(self, p: str) -> bool:
+        return p in "♟♜♞♝♛♚"
+
+    def _enemy(self, p: str, white_turn: bool) -> bool:
+        return self._is_black(p) if white_turn else self._is_white(p)
+
+    def _friend(self, p: str, white_turn: bool) -> bool:
+        return self._is_white(p) if white_turn else self._is_black(p)
+
+    def _chess_legal(self, b: list[list[str]], src: tuple[int, int], dst: tuple[int, int], white_turn: bool) -> bool:
+        sy, sx = src
+        dy, dx = dst
+        if not (self._in_bounds(sy, sx) and self._in_bounds(dy, dx)):
+            return False
+        piece = b[sy][sx]
+        if piece == "▫" or not self._friend(piece, white_turn):
+            return False
+        target = b[dy][dx]
+        if target != "▫" and self._friend(target, white_turn):
+            return False
+
+        vy = dy - sy
+        vx = dx - sx
+        ady, adx = abs(vy), abs(vx)
+
+        def clear_line(stepy: int, stepx: int) -> bool:
+            y, x = sy + stepy, sx + stepx
+            while (y, x) != (dy, dx):
+                if b[y][x] != "▫":
+                    return False
+                y += stepy
+                x += stepx
+            return True
+
+        if piece in "♙♟":
+            direction = -1 if piece == "♙" else 1
+            start_row = 6 if piece == "♙" else 1
+            if vx == 0 and target == "▫":
+                if vy == direction:
+                    return True
+                if sy == start_row and vy == 2 * direction and b[sy + direction][sx] == "▫":
+                    return True
+            if adx == 1 and vy == direction and target != "▫" and self._enemy(target, white_turn):
+                return True
+            return False
+        if piece in "♖♜":
+            if sx == dx and clear_line(1 if vy > 0 else -1, 0):
+                return True
+            if sy == dy and clear_line(0, 1 if vx > 0 else -1):
+                return True
+            return False
+        if piece in "♗♝":
+            if adx == ady and clear_line(1 if vy > 0 else -1, 1 if vx > 0 else -1):
+                return True
+            return False
+        if piece in "♕♛":
+            if sx == dx and clear_line(1 if vy > 0 else -1, 0):
+                return True
+            if sy == dy and clear_line(0, 1 if vx > 0 else -1):
+                return True
+            if adx == ady and clear_line(1 if vy > 0 else -1, 1 if vx > 0 else -1):
+                return True
+            return False
+        if piece in "♘♞":
+            return (ady, adx) in {(1, 2), (2, 1)}
+        if piece in "♔♚":
+            return max(ady, adx) == 1
+        return False
+
+    def _checkers_legal(self, b: list[list[str]], src: tuple[int, int], dst: tuple[int, int], white_turn: bool) -> bool:
+        sy, sx = src
+        dy, dx = dst
+        if not (self._in_bounds(sy, sx) and self._in_bounds(dy, dx)):
+            return False
+        me = "⚪" if white_turn else "🔴"
+        enemy = "🔴" if white_turn else "⚪"
+        if b[sy][sx] != me or b[dy][dx] != "▫":
+            return False
+        vy, vx = dy - sy, dx - sx
+        direction = -1 if white_turn else 1
+        if abs(vx) == 1 and vy == direction:
+            return True
+        if abs(vx) == 2 and vy == 2 * direction:
+            my, mx = sy + direction, sx + (1 if vx > 0 else -1)
+            return b[my][mx] == enemy
+        return False
+
+    def _apply_checkers_capture(self, b: list[list[str]], src: tuple[int, int], dst: tuple[int, int], white_turn: bool) -> None:
+        sy, sx = src
+        dy, dx = dst
+        if abs(dy - sy) == 2:
+            my, mx = (sy + dy) // 2, (sx + dx) // 2
+            b[my][mx] = "▫"
+
+    def _connect4_drop(self, b: list[list[str]], col: int, white_turn: bool) -> tuple[int, int] | None:
+        token = "🔵" if white_turn else "🟠"
+        for y in range(len(b) - 1, -1, -1):
+            if b[y][col] == "⚫":
+                b[y][col] = token
+                return y, col
+        return None
+
+    def _has_four(self, b: list[list[str]], y: int, x: int) -> bool:
+        token = b[y][x]
+        if token == "⚫":
+            return False
+        dirs = [(1, 0), (0, 1), (1, 1), (1, -1)]
+        h, w = len(b), len(b[0])
+        for dy, dx in dirs:
+            c = 1
+            for sign in (1, -1):
+                ny, nx = y, x
+                while True:
+                    ny += dy * sign
+                    nx += dx * sign
+                    if not (0 <= ny < h and 0 <= nx < w) or b[ny][nx] != token:
+                        break
+                    c += 1
+            if c >= 4:
+                return True
+        return False
+
+    def _othello_flips(self, b: list[list[str]], y: int, x: int, black_turn: bool) -> list[tuple[int, int]]:
+        me = "⚫" if black_turn else "⚪"
+        enemy = "⚪" if black_turn else "⚫"
+        if not self._in_bounds(y, x) or b[y][x] != "🟩":
+            return []
+        flips: list[tuple[int, int]] = []
+        for dy in (-1, 0, 1):
+            for dx in (-1, 0, 1):
+                if dy == 0 and dx == 0:
+                    continue
+                path: list[tuple[int, int]] = []
+                ny, nx = y + dy, x + dx
+                while self._in_bounds(ny, nx) and b[ny][nx] == enemy:
+                    path.append((ny, nx))
+                    ny += dy
+                    nx += dx
+                if path and self._in_bounds(ny, nx) and b[ny][nx] == me:
+                    flips.extend(path)
+        return flips
+
+    async def _finish(self, ctx: commands.Context, winner_id: int | None, reason: str) -> None:
+        s = self.sessions.pop(ctx.channel.id, None)
+        if not s:
+            return
+        if winner_id is None:
+            await ctx.send(f"🤝 Draw | {reason}")
+            return
+
+        if winner_id == 0:
+            await ctx.send(f"🤖 Bot won | {reason}")
+            return
+
+        await ctx.send(f"🏆 Winner: <@{winner_id}> | {reason}")
+        if s.tournament_name:
+            await self.bot.db.execute(
+                "UPDATE tournaments SET winner_id = ?, status = 'finished' WHERE guild_id = ? AND name = ?",
+                winner_id,
+                ctx.guild.id,
+                s.tournament_name,
+            )
+
+    async def _bot_move(self, ctx: commands.Context) -> None:
+        s = self.sessions.get(ctx.channel.id)
+        if not s or s.players[1] != 0 or self._current_player(s) != 0:
+            return
+        if s.game == "connect4":
+            valid = [c for c in range(7) if s.board[0][c] == "⚫"]
+            col = random.choice(valid)
+            spot = self._connect4_drop(s.board, col, white_turn=False)
+            if spot and self._has_four(s.board, spot[0], spot[1]):
+                await self._announce(ctx.channel, s, f"Bot played column {col + 1}.")
+                await self._finish(ctx, 0, "Four in a row!")
+                return
+            s.turn = 0
+            await self._announce(ctx.channel, s, f"Bot played column {col + 1}.")
+            return
+
+        if s.game == "othello":
+            legal: list[tuple[int, int, list[tuple[int, int]]]] = []
+            for y in range(8):
+                for x in range(8):
+                    flips = self._othello_flips(s.board, y, x, black_turn=False)
+                    if flips:
+                        legal.append((y, x, flips))
+            if not legal:
+                s.turn = 0
+                await self._announce(ctx.channel, s, "Bot has no valid move and passes.")
+                return
+            y, x, flips = random.choice(legal)
+            s.board[y][x] = "⚪"
+            for fy, fx in flips:
+                s.board[fy][fx] = "⚪"
+            s.turn = 0
+            await self._announce(ctx.channel, s, f"Bot played {self._coord_to_text(y, x)}")
+            return
+
+        # chess/checkers bot move: random pseudo legal
+        moves: list[tuple[tuple[int, int], tuple[int, int]]] = []
+        for sy in range(8):
+            for sx in range(8):
+                for dy in range(8):
+                    for dx in range(8):
+                        if s.game == "chess":
+                            if self._chess_legal(s.board, (sy, sx), (dy, dx), white_turn=False):
+                                moves.append(((sy, sx), (dy, dx)))
+                        elif self._checkers_legal(s.board, (sy, sx), (dy, dx), white_turn=False):
+                            moves.append(((sy, sx), (dy, dx)))
+        if not moves:
+            await self._finish(ctx, s.players[0], "Bot has no legal moves.")
+            return
+        src, dst = random.choice(moves)
+        sy, sx = src
+        dy, dx = dst
+        target = s.board[dy][dx]
+        if s.game == "checkers":
+            self._apply_checkers_capture(s.board, src, dst, white_turn=False)
+        s.board[dy][dx] = s.board[sy][sx]
+        s.board[sy][sx] = "▫"
+        s.turn = 0
+        await self._announce(ctx.channel, s, f"Bot played {self._coord_to_text(sy, sx)}{self._coord_to_text(dy, dx)}")
+        if s.game == "chess" and target == "♔":
+            await self._finish(ctx, 0, "White king captured.")
+
+    @commands.hybrid_command(name="boardgames", hidden=True, description=get_cmd_desc("commands.boardgames.boardgames_desc"), with_app_command=False)
+    async def boardgames(self, ctx: commands.Context) -> None:
+        embed = discord.Embed(title="Board Games", color=discord.Color.blurple())
+        embed.description = (
+            "• chess\n"
+            "• checkers\n"
+            "• connect4\n"
+            "• othello\n\n"
+            "Use `/board_start <game> [opponent]` then `/board_move`"
+        )
+        await ctx.reply(embed=embed)
+
+    @commands.hybrid_command(name="board_start", hidden=True, description=get_cmd_desc("commands.boardgames.board_start_desc"), with_app_command=False)
+    async def board_start(self, ctx: commands.Context, game: str, opponent: discord.Member | None = None) -> None:
+        await self.start_game_session(ctx, game, opponent)
+
+    @commands.hybrid_command(name="chess", hidden=True, description=get_cmd_desc("commands.boardgames.chess_desc"), with_app_command=False)
+    async def chess(self, ctx: commands.Context, opponent: discord.Member | None = None) -> None:
+        await self.start_game_session(ctx, "chess", opponent)
+
+    @commands.hybrid_command(name="checkers", hidden=True, description=get_cmd_desc("commands.boardgames.checkers_desc"), with_app_command=False)
+    async def checkers(self, ctx: commands.Context, opponent: discord.Member | None = None) -> None:
+        await self.start_game_session(ctx, "checkers", opponent)
+
+    @commands.hybrid_command(name="connect4", hidden=True, description=get_cmd_desc("commands.boardgames.connect4_desc"), with_app_command=False)
+    async def connect4(self, ctx: commands.Context, opponent: discord.Member | None = None) -> None:
+        await self.start_game_session(ctx, "connect4", opponent)
+
+    @commands.hybrid_command(name="othello", hidden=True, description=get_cmd_desc("commands.boardgames.othello_desc"), with_app_command=False)
+    async def othello(self, ctx: commands.Context, opponent: discord.Member | None = None) -> None:
+        await self.start_game_session(ctx, "othello", opponent)
+
+    async def _play_turn(self, *, guild: discord.Guild, channel: discord.TextChannel, author_id: int, move: str) -> str | None:
+        s = self.sessions.get(channel.id)
+        if not s:
+            return "No active board game in this channel."
+        if self._current_player(s) != author_id:
+            return "Not your turn."
+
+        is_first_player = author_id == s.players[0]
+
+        if s.game == "connect4":
+            try:
+                col = int(move) - 1
+            except ValueError:
+                return "Connect4 move is column number 1-7"
+            if not 0 <= col < 7:
+                return "Column must be 1-7"
+            spot = self._connect4_drop(s.board, col, white_turn=is_first_player)
+            if not spot:
+                return "Column is full."
+            if self._has_four(s.board, spot[0], spot[1]):
+                await self._announce(channel, s, f"Move: {col + 1}")
+                winner = author_id if author_id != 0 else None
+                await self._finish_ctxless(guild, channel, winner, "Four in a row!")
+                return None
+            if all(s.board[0][i] != "⚫" for i in range(7)):
+                await self._announce(channel, s, f"Move: {col + 1}")
+                await self._finish_ctxless(guild, channel, None, "Board full")
+                return None
+            s.turn = 1 - s.turn
+            await self._announce(channel, s, f"Move: {col + 1}")
+            if s.players[1] == 0:
+                await self._bot_move_channel(guild, channel)
+            return None
+
+        if s.game == "othello":
+            c = self._coord(move)
+            if not c:
+                return "Use coordinate like d3"
+            y, x = c
+            black_turn = is_first_player
+            flips = self._othello_flips(s.board, y, x, black_turn=black_turn)
+            if not flips:
+                return "Illegal move."
+            s.board[y][x] = "⚫" if black_turn else "⚪"
+            for fy, fx in flips:
+                s.board[fy][fx] = "⚫" if black_turn else "⚪"
+            s.turn = 1 - s.turn
+            await self._announce(channel, s, f"Move: {move.lower()}")
+            if s.players[1] == 0:
+                await self._bot_move_channel(guild, channel)
+            return None
+
+        if len(move) != 4:
+            return "Use move format like e2e4"
+        src = self._coord(move[:2])
+        dst = self._coord(move[2:])
+        if not src or not dst:
+            return "Invalid coordinates. Example: e2e4"
+
+        legal = self._chess_legal(s.board, src, dst, white_turn=is_first_player) if s.game == "chess" else self._checkers_legal(s.board, src, dst, white_turn=is_first_player)
+        if not legal:
+            return "Illegal move."
+
+        sy, sx = src
+        dy, dx = dst
+        target = s.board[dy][dx]
+        if s.game == "checkers":
+            self._apply_checkers_capture(s.board, src, dst, white_turn=is_first_player)
+        piece = s.board[sy][sx]
+        s.board[dy][dx] = piece
+        s.board[sy][sx] = "▫"
+        if piece == "♙" and dy == 0:
+            s.board[dy][dx] = "♕"
+        if piece == "♟" and dy == 7:
+            s.board[dy][dx] = "♛"
+
+        if s.game == "chess" and target in {"♚", "♔"}:
+            await self._announce(channel, s, f"Move: {move.lower()}")
+            await self._finish_ctxless(guild, channel, author_id, "King captured.")
+            return None
+
+        s.turn = 1 - s.turn
+        await self._announce(channel, s, f"Move: {move.lower()}")
+        if s.players[1] == 0:
+            await self._bot_move_channel(guild, channel)
+        return None
+
+    async def _finish_ctxless(self, guild: discord.Guild, channel: discord.TextChannel, winner_id: int | None, reason: str) -> None:
+        s = self.sessions.pop(channel.id, None)
+        if not s:
+            return
+        if winner_id is None:
+            await channel.send(f"🤝 Draw | {reason}")
+            return
+        if winner_id == 0:
+            await channel.send(f"🤖 Bot won | {reason}")
+            return
+        await channel.send(f"🏆 Winner: <@{winner_id}> | {reason}")
+        if s.tournament_name:
+            await self.bot.db.execute(
+                "UPDATE tournaments SET winner_id = ?, status = 'finished' WHERE guild_id = ? AND name = ?",
+                winner_id,
+                guild.id,
+                s.tournament_name,
+            )
+
+    async def _bot_move_channel(self, guild: discord.Guild, channel: discord.TextChannel) -> None:
+        class Dummy:
+            pass
+        d=Dummy(); d.guild=guild; d.channel=channel
+        await self._bot_move(d)
+
+    async def _forfeit(self, *, guild: discord.Guild, channel: discord.TextChannel, author_id: int) -> str | None:
+        s = self.sessions.get(channel.id)
+        if not s:
+            return "No active board game in this channel."
+        if author_id not in s.players:
+            return "Only players can forfeit."
+        winner = s.players[1] if author_id == s.players[0] else s.players[0]
+        await self._finish_ctxless(guild, channel, None if winner == 0 else winner, "Forfeit")
+        return None
+
+    @commands.hybrid_command(name="board_move", hidden=True, description=get_cmd_desc("commands.boardgames.board_move_desc"), with_app_command=False)
+    async def board_move(self, ctx: commands.Context, move: str) -> None:
+        if not ctx.guild or not isinstance(ctx.channel, discord.TextChannel):
+            await ctx.reply("Server text channels only.")
+            return
+        err = await self._play_turn(guild=ctx.guild, channel=ctx.channel, author_id=ctx.author.id, move=move)
+        if err:
+            await ctx.reply(err)
+
+    @commands.hybrid_command(name="games_panel", hidden=True, description=get_cmd_desc("commands.boardgames.games_panel_desc"), with_app_command=False)
+    async def games_panel(self, ctx: commands.Context) -> None:
+        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=get_cmd_desc("commands.boardgames.board_forfeit_desc"), with_app_command=False)
+    async def board_forfeit(self, ctx: commands.Context) -> None:
+        if not ctx.guild or not isinstance(ctx.channel, discord.TextChannel):
+            await ctx.reply("Server text channels only.")
+            return
+        err = await self._forfeit(guild=ctx.guild, channel=ctx.channel, author_id=ctx.author.id)
+        if err:
+            await ctx.reply(err)
+
+
+async def setup(bot: commands.Bot) -> None:
+    await bot.add_cog(BoardGames(bot))

bot/cogs/configuration.py

@@ -1,636 +1,637 @@
-from __future__ import annotations
-
-import datetime as dt
-import re
-
-import discord
-from discord.ext import commands
-
-from bot.theme import fancy_header, NEON_CYAN, NEON_PURPLE
-from bot.emojis import ui
-from bot.emojis import ui
-
-
-class ConfigPanelView(discord.ui.View):
-    def __init__(self, cog: "Configuration") -> None:
-        super().__init__(timeout=None)
-        self.cog = cog
-
-    @discord.ui.button(label="Refresh Panel", style=discord.ButtonStyle.blurple, emoji=ui("refresh"), row=3, custom_id="config_refresh")
-    async def refresh(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not interaction.guild:
-            await interaction.response.send_message("This button works only in servers.", ephemeral=True)
-            return
-        embed = await self.cog.build_config_embed(interaction.guild)
-        await interaction.response.edit_message(embed=embed, view=self)
-
-    @discord.ui.button(label="Toggle AutoMod", style=discord.ButtonStyle.danger, emoji="🛡️", row=0, custom_id="config_automod")
-    async def toggle_automod(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not interaction.guild:
-            await interaction.response.send_message("Server only.", ephemeral=True)
-            return
-        if not interaction.user.guild_permissions.manage_guild:
-            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
-            return
-        row = await self.cog.bot.db.fetchone("SELECT automod_enabled FROM guild_config WHERE guild_id = ?", interaction.guild.id)
-        current = row[0] if row else 0
-        new_val = 0 if current else 1
-        await self.cog.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, automod_enabled) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET automod_enabled = excluded.automod_enabled",
-            interaction.guild.id, new_val,
-        )
-        state = "enabled" if new_val else "disabled"
-        await interaction.response.send_message(f"🛡️ AutoMod {state}.", ephemeral=True)
-        embed = await self.cog.build_config_embed(interaction.guild)
-        await interaction.message.edit(embed=embed, view=self)
-
-    @discord.ui.button(label="Toggle Daily", style=discord.ButtonStyle.success, emoji=ui("calendar"), row=0, custom_id="config_daily")
-    async def toggle_daily(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not interaction.guild:
-            await interaction.response.send_message("Server only.", ephemeral=True)
-            return
-        if not interaction.user.guild_permissions.manage_guild:
-            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
-            return
-        row = await self.cog.bot.db.fetchone("SELECT daily_enabled FROM guild_config WHERE guild_id = ?", interaction.guild.id)
-        current = row[0] if row else 0
-        new_val = 0 if current else 1
-        await self.cog.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, daily_enabled) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_enabled = excluded.daily_enabled",
-            interaction.guild.id, new_val,
-        )
-        state = "enabled" if new_val else "disabled"
-        await interaction.response.send_message(f"📅 Daily message {state}.", ephemeral=True)
-        embed = await self.cog.build_config_embed(interaction.guild)
-        await interaction.message.edit(embed=embed, view=self)
-
-    @discord.ui.button(label="Toggle Support AI", style=discord.ButtonStyle.primary, emoji=ui("support"), row=0, custom_id="config_support_ai")
-    async def toggle_support_ai(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not interaction.guild:
-            await interaction.response.send_message("Server only.", ephemeral=True)
-            return
-        if not interaction.user.guild_permissions.manage_guild:
-            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
-            return
-        row = await self.cog.bot.db.fetchone("SELECT support_ai_enabled FROM guild_config WHERE guild_id = ?", interaction.guild.id)
-        current = row[0] if row else 0
-        new_val = 0 if current else 1
-        await self.cog.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, support_ai_enabled) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET support_ai_enabled = excluded.support_ai_enabled",
-            interaction.guild.id, new_val,
-        )
-        state = "enabled" if new_val else "disabled"
-        await interaction.response.send_message(f"🛟 Support AI {state}.", ephemeral=True)
-        embed = await self.cog.build_config_embed(interaction.guild)
-        await interaction.message.edit(embed=embed, view=self)
-
-    @discord.ui.button(label="Toggle Wisdom", style=discord.ButtonStyle.secondary, emoji=ui("brain"), row=0, custom_id="config_wisdom")
-    async def toggle_wisdom(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not interaction.guild:
-            await interaction.response.send_message("Server only.", ephemeral=True)
-            return
-        if not interaction.user.guild_permissions.manage_guild:
-            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
-            return
-        row = await self.cog.bot.db.fetchone("SELECT wisdom_enabled FROM guild_config WHERE guild_id = ?", interaction.guild.id)
-        current = row[0] if row else 0
-        new_val = 0 if current else 1
-        await self.cog.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, wisdom_enabled) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET wisdom_enabled = excluded.wisdom_enabled",
-            interaction.guild.id, new_val,
-        )
-        state = "enabled" if new_val else "disabled"
-        await interaction.response.send_message(f"🧠 Daily wisdom {state}.", ephemeral=True)
-        embed = await self.cog.build_config_embed(interaction.guild)
-        await interaction.message.edit(embed=embed, view=self)
-
-    @discord.ui.button(label="Set Log Channel", style=discord.ButtonStyle.blurple, emoji="📝", row=1, custom_id="config_log")
-    async def set_log(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not interaction.guild:
-            await interaction.response.send_message("Server only.", ephemeral=True)
-            return
-        if not interaction.user.guild_permissions.manage_guild:
-            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
-            return
-        await interaction.response.send_message(
-            "Select a text channel for logging:",
-            view=ChannelSelectModal(self.cog, interaction.guild.id, "log_channel_id", "📝 Log channel set to"),
-            ephemeral=True,
-        )
-
-    @discord.ui.button(label="Set Welcome Channel", style=discord.ButtonStyle.blurple, emoji="👋", row=1, custom_id="config_welcome")
-    async def set_welcome(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not interaction.guild:
-            await interaction.response.send_message("Server only.", ephemeral=True)
-            return
-        if not interaction.user.guild_permissions.manage_guild:
-            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
-            return
-        await interaction.response.send_message(
-            "Select a text channel for welcomes:",
-            view=ChannelSelectModal(self.cog, interaction.guild.id, "welcome_channel_id", "👋 Welcome channel set to"),
-            ephemeral=True,
-        )
-
-    @discord.ui.button(label="Set Daily Channel", style=discord.ButtonStyle.blurple, emoji="📨", row=1, custom_id="config_daily_ch")
-    async def set_daily_ch(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not interaction.guild:
-            await interaction.response.send_message("Server only.", ephemeral=True)
-            return
-        if not interaction.user.guild_permissions.manage_guild:
-            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
-            return
-        await interaction.response.send_message(
-            "Select a text channel for daily messages:",
-            view=ChannelSelectModal(self.cog, interaction.guild.id, "daily_channel_id", "📨 Daily channel set to"),
-            ephemeral=True,
-        )
-
-    @discord.ui.button(label="Set Poll Channel", style=discord.ButtonStyle.blurple, emoji="📊", row=1, custom_id="config_poll_ch")
-    async def set_poll_ch(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not interaction.guild:
-            await interaction.response.send_message("Server only.", ephemeral=True)
-            return
-        if not interaction.user.guild_permissions.manage_guild:
-            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
-            return
-        await interaction.response.send_message(
-            "Select a text channel for polls:",
-            view=ChannelSelectModal(self.cog, interaction.guild.id, "poll_channel_id", "📊 Poll channel set to"),
-            ephemeral=True,
-        )
-
-    @discord.ui.button(label="Set Daily Message", style=discord.ButtonStyle.gray, emoji="✏️", row=2, custom_id="config_daily_msg")
-    async def set_daily_msg(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not interaction.guild:
-            await interaction.response.send_message("Server only.", ephemeral=True)
-            return
-        if not interaction.user.guild_permissions.manage_guild:
-            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
-            return
-        await interaction.response.send_modal(DailyMessageModal(self.cog, interaction.guild.id))
-
-    @discord.ui.button(label="Test Daily", style=discord.ButtonStyle.gray, emoji="🧪", row=2, custom_id="config_test_daily")
-    async def test_daily(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not interaction.guild:
-            await interaction.response.send_message("Server only.", ephemeral=True)
-            return
-        row = await self.cog.bot.db.fetchone(
-            "SELECT daily_channel_id, daily_message, daily_title, daily_image_url, daily_button_label, daily_button_url FROM guild_config WHERE guild_id = ?",
-            interaction.guild.id,
-        )
-        if not row or not row[0]:
-            await interaction.response.send_message("Set a daily channel first.", ephemeral=True)
-            return
-        channel = interaction.guild.get_channel(row[0])
-        if not channel:
-            await interaction.response.send_message("Configured daily channel no longer exists.", ephemeral=True)
-            return
-        embed = self.cog._build_daily_embed(interaction.guild.name, row[2] or "", row[1] or "", row[3])
-        view = None
-        if row[4] and row[5]:
-            view = discord.ui.View()
-            view.add_item(discord.ui.Button(label=row[4], url=row[5]))
-        await channel.send(embed=embed, view=view)
-        await interaction.response.send_message(f"✅ Sent test daily message to {channel.mention}", ephemeral=True)
-
-
-class ChannelSelectModal(discord.ui.View):
-    def __init__(self, cog: "Configuration", guild_id: int, column: str, success_prefix: str) -> None:
-        super().__init__(timeout=300)
-        self.cog = cog
-        self.guild_id = guild_id
-        self.column = column
-        self.success_prefix = success_prefix
-
-        self.channel_select = discord.ui.ChannelSelect(
-            cls=discord.ui.ChannelSelect,
-            channel_types=[discord.ChannelType.text],
-            placeholder="Select a text channel...",
-            min_values=1,
-            max_values=1,
-            custom_id="channel_select_modal",
-        )
-        self.channel_select.callback = self._channel_select_callback
-        self.add_item(self.channel_select)
-
-    async def _channel_select_callback(self, interaction: discord.Interaction) -> None:
-        channel = self.channel_select.values[0]
-        await self.cog.bot.db.execute(
-            f"INSERT INTO guild_config(guild_id, {self.column}) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET {self.column} = excluded.{self.column}",
-            self.guild_id, channel.id,
-        )
-        await interaction.response.send_message(f"{self.success_prefix} {channel.mention}", ephemeral=True)
-
-
-class DailyMessageModal(discord.ui.Modal, title="✏️ Set Daily Message"):
-    message = discord.ui.TextInput(
-        label="Daily Message Text",
-        placeholder="Your daily message here...",
-        required=True,
-        style=discord.TextStyle.paragraph,
-        max_length=500,
-    )
-
-    def __init__(self, cog: "Configuration", guild_id: int) -> None:
-        super().__init__(timeout=None)
-        self.cog = cog
-        self.guild_id = guild_id
-
-    async def on_submit(self, interaction: discord.Interaction) -> None:
-        await self.cog.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, daily_message) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_message = excluded.daily_message",
-            self.guild_id, str(self.message.value),
-        )
-        await interaction.response.send_message("🗓️ Daily message text updated.", ephemeral=True)
-
-
-
-
-class FreeGameSetupView(discord.ui.View):
-    def __init__(self, cog: "Configuration", guild_id: int, channel_id: int, role_id: int | None = None) -> None:
-        super().__init__(timeout=300)
-        self.cog = cog
-        self.guild_id = guild_id
-        self.channel_id = channel_id
-        self.role_id = role_id
-        self.mention_type = "role"
-        self.platforms = {"epic", "steam", "gog"}
-
-    async def _save(self, interaction: discord.Interaction) -> None:
-        await self.cog.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, free_games_channel_id, free_games_role_id, free_games_platforms, free_games_mention_type) VALUES (?, ?, ?, ?, ?) "
-            "ON CONFLICT(guild_id) DO UPDATE SET free_games_channel_id=excluded.free_games_channel_id, free_games_role_id=excluded.free_games_role_id, free_games_platforms=excluded.free_games_platforms, free_games_mention_type=excluded.free_games_mention_type",
-            self.guild_id,
-            self.channel_id,
-            self.role_id,
-            ",".join(sorted(self.platforms)),
-            self.mention_type,
-        )
-
-    @discord.ui.select(
-        placeholder="Choose stores for alerts",
-        min_values=1,
-        max_values=3,
-        options=[
-            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("<:animatedarrowgreen:1477261279428087979> Free games stores updated.", ephemeral=True)
-
-    @discord.ui.select(
-        placeholder="Choose ping role (optional)",
-        min_values=0,
-        max_values=1,
-        cls=discord.ui.RoleSelect,
-    )
-    async def role_select(self, interaction: discord.Interaction, select: discord.ui.RoleSelect) -> None:
-        role = select.values[0] if select.values else None
-        self.role_id = role.id if role else None
-        await self._save(interaction)
-        if role:
-            await interaction.response.send_message(f"✅ Free games role set to {role.mention}", ephemeral=True)
-        else:
-            await interaction.response.send_message("✅ Free games role cleared.", ephemeral=True)
-
-    @discord.ui.select(
-        placeholder="Mention style",
-        min_values=1,
-        max_values=1,
-        options=[
-            discord.SelectOption(label="Role mention", value="role", emoji="🏷️"),
-            discord.SelectOption(label="@everyone", value="everyone", emoji="📢"),
-            discord.SelectOption(label="@here", value="here", emoji="📣"),
-            discord.SelectOption(label="No mention", value="none", emoji="🔕"),
-        ],
-    )
-    async def mention_select(self, interaction: discord.Interaction, select: discord.ui.Select) -> None:
-        self.mention_type = (select.values[0] if select.values else "role").strip().lower()
-        await self._save(interaction)
-        await interaction.response.send_message(f"✅ Mention type set to `{self.mention_type}`", ephemeral=True)
-
-
-class Configuration(commands.Cog):
-    TIME_RE = re.compile(r"^(?:[01]\d|2[0-3]):[0-5]\d$")
-
-    def __init__(self, bot: commands.Bot) -> None:
-        self.bot = bot
-
-    async def cog_load(self) -> None:
-        self.bot.add_view(ConfigPanelView(self))
-
-    async def build_config_embed(self, guild: discord.Guild) -> discord.Embed:
-        row = await self.bot.db.fetchone(
-            "SELECT log_channel_id, welcome_channel_id, suggestion_channel_id, automod_enabled, daily_channel_id, "
-            "daily_enabled, daily_message, daily_time, daily_utc_offset, verify_channel_id, verify_role_id, "
-            "daily_title, daily_image_url, daily_button_label, daily_button_url, poll_channel_id, free_games_channel_id, free_games_role_id, "
-            "support_channel_id, support_ai_enabled, wisdom_channel_id, wisdom_enabled, game_news_channel_id, game_news_role_id "
-            "FROM guild_config WHERE guild_id = ?",
-            guild.id,
-        )
-
-        values = row if row else (None, None, None, 0, None, 0, "Not set", "09:00", 0, None, None, "🌅 Daily Message", None, None, None, None, None, None, None, 0, None, 0, None, None)
-        (
-            log_id,
-            welcome_id,
-            suggestion_id,
-            automod_enabled,
-            daily_channel_id,
-            daily_enabled,
-            daily_message,
-            daily_time,
-            daily_utc_offset,
-            verify_channel_id,
-            verify_role_id,
-            daily_title,
-            daily_image_url,
-            daily_button_label,
-            daily_button_url,
-            poll_channel_id,
-            free_games_channel_id,
-            free_games_role_id,
-            support_channel_id,
-            support_ai_enabled,
-            wisdom_channel_id,
-            wisdom_enabled,
-            game_news_channel_id,
-            game_news_role_id,
-        ) = values
-
-        def mention(channel_id: int | None) -> str:
-            return f"<#{channel_id}>" if channel_id else "Not set"
-
-        embed = discord.Embed(title=fancy_header(f"Settings • {guild.name}"), color=NEON_CYAN)
-        embed.add_field(name="Log Channel", value=mention(log_id), inline=True)
-        embed.add_field(name="Welcome Channel", value=mention(welcome_id), inline=True)
-        embed.add_field(name="Suggestion Channel", value=mention(suggestion_id), inline=True)
-        embed.add_field(name="Verification Channel", value=mention(verify_channel_id), inline=True)
-        embed.add_field(name="Verification Role", value=f"<@&{verify_role_id}>" if verify_role_id else "Not set", inline=True)
-        embed.add_field(name="AutoMod", value="✅ On" if automod_enabled else "❌ Off", inline=True)
-        embed.add_field(name="Daily Channel", value=mention(daily_channel_id), inline=True)
-        embed.add_field(name="Daily Enabled", value="✅ On" if daily_enabled else "❌ Off", inline=True)
-        embed.add_field(name="Daily Time", value=f"`{daily_time or '09:00'}`", inline=True)
-        embed.add_field(name="Daily UTC Offset", value=f"`UTC{daily_utc_offset:+d}`", inline=True)
-        embed.add_field(name="Daily Title", value=(daily_title or "🌅 Daily Message")[:128], inline=False)
-        embed.add_field(name="Daily Message Text", value=(daily_message or "Not set")[:1024], inline=False)
-        embed.add_field(name="Daily Image URL", value=daily_image_url or "Not set", inline=False)
-        embed.add_field(name="Daily Button", value=f"{daily_button_label or 'Not set'} | {daily_button_url or 'Not set'}", inline=False)
-        embed.add_field(name="Poll Channel", value=mention(poll_channel_id), inline=True)
-        embed.add_field(name="Free Games Channel", value=mention(free_games_channel_id), inline=True)
-        embed.add_field(name="Free Games Role", value=f"<@&{free_games_role_id}>" if free_games_role_id else "Not set", inline=True)
-        embed.add_field(name="Support AI Channel", value=mention(support_channel_id), inline=True)
-        embed.add_field(name="Support AI Enabled", value="✅ On" if support_ai_enabled else "❌ Off", inline=True)
-        embed.add_field(name="Wisdom Channel", value=mention(wisdom_channel_id), inline=True)
-        embed.add_field(name="Wisdom Daily", value="✅ On" if wisdom_enabled else "❌ Off", inline=True)
-        embed.add_field(name="Game News Channel", value=mention(game_news_channel_id), inline=True)
-        embed.add_field(name="Game News Role", value=f"<@&{game_news_role_id}>" if game_news_role_id else "Not set", inline=True)
-        embed.set_footer(text="Use /set commands to update • Click Refresh to update panel")
-        return embed
-
-    def _build_daily_embed(self, guild_name: str, title: str, message_text: str, image_url: str | None) -> discord.Embed:
-        today = dt.datetime.utcnow().date().isoformat()
-        embed = discord.Embed(
-            title=title or "🌅 Daily Message",
-            description=message_text or "Have a productive and positive day!",
-            color=discord.Color.gold(),
-        )
-        if image_url:
-            embed.set_image(url=image_url)
-        embed.set_footer(text=f"{guild_name} • {today}")
-        return embed
-
-    @commands.hybrid_group(name="set", fallback="show")
-    @commands.has_permissions(manage_guild=True)
-    async def setgroup(self, ctx: commands.Context) -> None:
-        embed = await self.build_config_embed(ctx.guild)
-        await ctx.reply(embed=embed, view=ConfigPanelView(self))
-
-    @setgroup.command(name="log")
-    async def set_log(self, ctx: commands.Context, channel: discord.TextChannel) -> None:
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, log_channel_id) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET log_channel_id = excluded.log_channel_id",
-            ctx.guild.id,
-            channel.id,
-        )
-        await ctx.reply(f"📝 Log channel set to {channel.mention}")
-
-    @setgroup.command(name="welcome")
-    async def set_welcome(self, ctx: commands.Context, channel: discord.TextChannel) -> None:
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, welcome_channel_id) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET welcome_channel_id = excluded.welcome_channel_id",
-            ctx.guild.id,
-            channel.id,
-        )
-        await ctx.reply(f"👋 Welcome channel set to {channel.mention}")
-
-    @setgroup.command(name="suggestions")
-    async def set_suggestion(self, ctx: commands.Context, channel: discord.TextChannel) -> None:
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, suggestion_channel_id) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET suggestion_channel_id = excluded.suggestion_channel_id",
-            ctx.guild.id,
-            channel.id,
-        )
-        await ctx.reply(f"💡 Suggestion channel set to {channel.mention}")
-
-    @setgroup.command(name="automod")
-    async def set_automod(self, ctx: commands.Context, enabled: bool) -> None:
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, automod_enabled) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET automod_enabled = excluded.automod_enabled",
-            ctx.guild.id,
-            1 if enabled else 0,
-        )
-        await ctx.reply(f"🛡️ AutoMod {'enabled' if enabled else 'disabled'}")
-
-    @setgroup.command(name="dailychannel")
-    async def set_daily_channel(self, ctx: commands.Context, channel: discord.TextChannel) -> None:
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, daily_channel_id) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_channel_id = excluded.daily_channel_id",
-            ctx.guild.id,
-            channel.id,
-        )
-        await ctx.reply(f"📨 Daily message channel set to {channel.mention}")
-
-    @setgroup.command(name="dailymessage")
-    async def set_daily_message(self, ctx: commands.Context, *, text: str) -> None:
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, daily_message) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_message = excluded.daily_message",
-            ctx.guild.id,
-            text,
-        )
-        await ctx.reply("🗓️ Daily message text updated.")
-
-    @setgroup.command(name="dailytitle")
-    async def set_daily_title(self, ctx: commands.Context, *, title: str) -> None:
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, daily_title) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_title = excluded.daily_title",
-            ctx.guild.id,
-            title,
-        )
-        await ctx.reply("🖋️ Daily message title updated.")
-
-    @setgroup.command(name="dailyimage")
-    async def set_daily_image(self, ctx: commands.Context, image_url: str = "") -> None:
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, daily_image_url) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_image_url = excluded.daily_image_url",
-            ctx.guild.id,
-            image_url or None,
-        )
-        await ctx.reply("🖼️ Daily image updated (empty value removes it).")
-
-    @setgroup.command(name="dailybutton")
-    async def set_daily_button(self, ctx: commands.Context, label: str = "", url: str = "") -> None:
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, daily_button_label, daily_button_url) VALUES (?, ?, ?) "
-            "ON CONFLICT(guild_id) DO UPDATE SET daily_button_label = excluded.daily_button_label, daily_button_url = excluded.daily_button_url",
-            ctx.guild.id,
-            label or None,
-            url or None,
-        )
-        await ctx.reply("🔗 Daily button settings updated.")
-
-    @setgroup.command(name="dailytime")
-    async def set_daily_time(self, ctx: commands.Context, hhmm: str) -> None:
-        hhmm = hhmm.strip()
-        if not self.TIME_RE.fullmatch(hhmm):
-            await ctx.reply("Use time in 24h format `HH:MM` (example: `18:30`).")
-            return
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, daily_time) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_time = excluded.daily_time",
-            ctx.guild.id,
-            hhmm,
-        )
-        await ctx.reply(f"⏰ Daily message time set to `{hhmm}`")
-
-    @setgroup.command(name="dailyutc")
-    async def set_daily_utc(self, ctx: commands.Context, offset: int) -> None:
-        if offset < -12 or offset > 14:
-            await ctx.reply("UTC offset must be between `-12` and `+14`.")
-            return
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, daily_utc_offset) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_utc_offset = excluded.daily_utc_offset",
-            ctx.guild.id,
-            offset,
-        )
-        await ctx.reply(f"🌍 Daily timezone set to `UTC{offset:+d}`")
-
-    @setgroup.command(name="dailytest")
-    async def set_daily_test(self, ctx: commands.Context) -> None:
-        row = await self.bot.db.fetchone(
-            "SELECT daily_channel_id, daily_message, daily_title, daily_image_url, daily_button_label, daily_button_url FROM guild_config WHERE guild_id = ?",
-            ctx.guild.id,
-        )
-        if not row or not row[0]:
-            await ctx.reply("Set a daily channel first with `/set dailychannel`.")
-            return
-        channel = ctx.guild.get_channel(row[0])
-        if not channel:
-            await ctx.reply("Configured daily channel no longer exists.")
-            return
-        embed = self._build_daily_embed(ctx.guild.name, row[2] or "", row[1] or "", row[3])
-        view = None
-        if row[4] and row[5]:
-            view = discord.ui.View()
-            view.add_item(discord.ui.Button(label=row[4], url=row[5]))
-        await channel.send(embed=embed, view=view)
-        await ctx.reply(f"✅ Sent test daily message to {channel.mention}")
-
-    @setgroup.command(name="dailytoggle")
-    async def set_daily_toggle(self, ctx: commands.Context, enabled: bool) -> None:
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, daily_enabled) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_enabled = excluded.daily_enabled",
-            ctx.guild.id,
-            1 if enabled else 0,
-        )
-        await ctx.reply(f"📅 Daily message {'enabled' if enabled else 'disabled'}.")
-
-
-    @setgroup.command(name="pollchannel")
-    async def set_poll_channel(self, ctx: commands.Context, channel: discord.TextChannel) -> None:
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, poll_channel_id) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET poll_channel_id = excluded.poll_channel_id",
-            ctx.guild.id,
-            channel.id,
-        )
-        await ctx.reply(f"📊 Poll channel set to {channel.mention}")
-
-    @setgroup.command(name="freegames")
-    async def set_free_games_channel(self, ctx: commands.Context, channel: discord.TextChannel, role: discord.Role | None = None) -> None:
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, free_games_channel_id, free_games_role_id) VALUES (?, ?, ?) "
-            "ON CONFLICT(guild_id) DO UPDATE SET free_games_channel_id = excluded.free_games_channel_id, free_games_role_id = excluded.free_games_role_id",
-            ctx.guild.id,
-            channel.id,
-            role.id if role else None,
-        )
-        mention = f" with role {role.mention}" if role else ""
-        await ctx.reply(f"🎁 Free games alerts channel set to {channel.mention}{mention}")
-
-    @setgroup.command(name="gamenews")
-    async def set_game_news(self, ctx: commands.Context, channel: discord.TextChannel, role: discord.Role | None = None) -> None:
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, game_news_channel_id, game_news_role_id) VALUES (?, ?, ?) "
-            "ON CONFLICT(guild_id) DO UPDATE SET game_news_channel_id = excluded.game_news_channel_id, game_news_role_id = excluded.game_news_role_id",
-            ctx.guild.id,
-            channel.id,
-            role.id if role else None,
-        )
-        mention = f" with role {role.mention}" if role else ""
-        await ctx.reply(f"📰 Game news alerts channel set to {channel.mention}{mention}")
-
-    @setgroup.command(name="supportai")
-    async def set_support_ai(self, ctx: commands.Context, channel: discord.TextChannel, enabled: bool = True) -> None:
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, support_channel_id, support_ai_enabled) VALUES (?, ?, ?) "
-            "ON CONFLICT(guild_id) DO UPDATE SET support_channel_id = excluded.support_channel_id, support_ai_enabled = excluded.support_ai_enabled",
-            ctx.guild.id,
-            channel.id,
-            1 if enabled else 0,
-        )
-        await ctx.reply(f"🛟 Support AI {'enabled' if enabled else 'disabled'} in {channel.mention}")
-
-    @setgroup.command(name="wisdom")
-    async def set_wisdom(self, ctx: commands.Context, channel: discord.TextChannel, enabled: bool = True) -> None:
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, wisdom_channel_id, wisdom_enabled) VALUES (?, ?, ?) "
-            "ON CONFLICT(guild_id) DO UPDATE SET wisdom_channel_id = excluded.wisdom_channel_id, wisdom_enabled = excluded.wisdom_enabled",
-            ctx.guild.id,
-            channel.id,
-            1 if enabled else 0,
-        )
-        await ctx.reply(f"🧠 Daily wisdom {'enabled' if enabled else 'disabled'} in {channel.mention}")
-
-    @setgroup.command(name="freegame")
-    async def set_free_game_alias(self, ctx: commands.Context, channel: discord.TextChannel, role: discord.Role | None = None) -> None:
-        await self.set_free_games_channel(ctx, channel, role)
-
-    @commands.hybrid_command(name="set_freegame", description="Setup free games alerts panel")
-    @commands.has_permissions(administrator=True)
-    async def set_freegame_panel(self, ctx: commands.Context, channel: discord.TextChannel, role: discord.Role | None = None) -> None:
-        await self.bot.db.execute(
-            "INSERT INTO guild_config(guild_id, free_games_channel_id, free_games_role_id) VALUES (?, ?, ?) "
-            "ON CONFLICT(guild_id) DO UPDATE SET free_games_channel_id=excluded.free_games_channel_id, free_games_role_id=excluded.free_games_role_id",
-            ctx.guild.id,
-            channel.id,
-            role.id if role else None,
-        )
-        view = FreeGameSetupView(self, ctx.guild.id, channel.id, role.id if role else None)
-        embed = discord.Embed(
-            title="<:animatedarrowgreen:1477261279428087979> Free Games Setup",
-            description=(
-                f"Channel: {channel.mention}\n"
-                f"Role ping: {role.mention if role else 'None'}\n"
-                "Use menu below to choose stores (Epic/Steam/GOG)."
-            ),
-            color=discord.Color.green(),
-        )
-        await ctx.reply(embed=embed, view=view)
-
-
-
-async def setup(bot: commands.Bot) -> None:
-    await bot.add_cog(Configuration(bot))
+from __future__ import annotations
+
+import datetime as dt
+import re
+
+import discord
+from discord.ext import commands
+
+from bot.theme import fancy_header, NEON_CYAN, NEON_PURPLE
+from bot.i18n import get_cmd_desc
+from bot.emojis import ui
+from bot.emojis import ui
+
+
+class ConfigPanelView(discord.ui.View):
+    def __init__(self, cog: "Configuration") -> None:
+        super().__init__(timeout=None)
+        self.cog = cog
+
+    @discord.ui.button(label="Refresh Panel", style=discord.ButtonStyle.blurple, emoji=ui("refresh"), row=3, custom_id="config_refresh")
+    async def refresh(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not interaction.guild:
+            await interaction.response.send_message("This button works only in servers.", ephemeral=True)
+            return
+        embed = await self.cog.build_config_embed(interaction.guild)
+        await interaction.response.edit_message(embed=embed, view=self)
+
+    @discord.ui.button(label="Toggle AutoMod", style=discord.ButtonStyle.danger, emoji="🛡️", row=0, custom_id="config_automod")
+    async def toggle_automod(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not interaction.guild:
+            await interaction.response.send_message("Server only.", ephemeral=True)
+            return
+        if not interaction.user.guild_permissions.manage_guild:
+            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
+            return
+        row = await self.cog.bot.db.fetchone("SELECT automod_enabled FROM guild_config WHERE guild_id = ?", interaction.guild.id)
+        current = row[0] if row else 0
+        new_val = 0 if current else 1
+        await self.cog.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, automod_enabled) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET automod_enabled = excluded.automod_enabled",
+            interaction.guild.id, new_val,
+        )
+        state = "enabled" if new_val else "disabled"
+        await interaction.response.send_message(f"🛡️ AutoMod {state}.", ephemeral=True)
+        embed = await self.cog.build_config_embed(interaction.guild)
+        await interaction.message.edit(embed=embed, view=self)
+
+    @discord.ui.button(label="Toggle Daily", style=discord.ButtonStyle.success, emoji=ui("calendar"), row=0, custom_id="config_daily")
+    async def toggle_daily(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not interaction.guild:
+            await interaction.response.send_message("Server only.", ephemeral=True)
+            return
+        if not interaction.user.guild_permissions.manage_guild:
+            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
+            return
+        row = await self.cog.bot.db.fetchone("SELECT daily_enabled FROM guild_config WHERE guild_id = ?", interaction.guild.id)
+        current = row[0] if row else 0
+        new_val = 0 if current else 1
+        await self.cog.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, daily_enabled) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_enabled = excluded.daily_enabled",
+            interaction.guild.id, new_val,
+        )
+        state = "enabled" if new_val else "disabled"
+        await interaction.response.send_message(f"📅 Daily message {state}.", ephemeral=True)
+        embed = await self.cog.build_config_embed(interaction.guild)
+        await interaction.message.edit(embed=embed, view=self)
+
+    @discord.ui.button(label="Toggle Support AI", style=discord.ButtonStyle.primary, emoji=ui("support"), row=0, custom_id="config_support_ai")
+    async def toggle_support_ai(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not interaction.guild:
+            await interaction.response.send_message("Server only.", ephemeral=True)
+            return
+        if not interaction.user.guild_permissions.manage_guild:
+            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
+            return
+        row = await self.cog.bot.db.fetchone("SELECT support_ai_enabled FROM guild_config WHERE guild_id = ?", interaction.guild.id)
+        current = row[0] if row else 0
+        new_val = 0 if current else 1
+        await self.cog.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, support_ai_enabled) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET support_ai_enabled = excluded.support_ai_enabled",
+            interaction.guild.id, new_val,
+        )
+        state = "enabled" if new_val else "disabled"
+        await interaction.response.send_message(f"🛟 Support AI {state}.", ephemeral=True)
+        embed = await self.cog.build_config_embed(interaction.guild)
+        await interaction.message.edit(embed=embed, view=self)
+
+    @discord.ui.button(label="Toggle Wisdom", style=discord.ButtonStyle.secondary, emoji=ui("brain"), row=0, custom_id="config_wisdom")
+    async def toggle_wisdom(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not interaction.guild:
+            await interaction.response.send_message("Server only.", ephemeral=True)
+            return
+        if not interaction.user.guild_permissions.manage_guild:
+            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
+            return
+        row = await self.cog.bot.db.fetchone("SELECT wisdom_enabled FROM guild_config WHERE guild_id = ?", interaction.guild.id)
+        current = row[0] if row else 0
+        new_val = 0 if current else 1
+        await self.cog.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, wisdom_enabled) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET wisdom_enabled = excluded.wisdom_enabled",
+            interaction.guild.id, new_val,
+        )
+        state = "enabled" if new_val else "disabled"
+        await interaction.response.send_message(f"🧠 Daily wisdom {state}.", ephemeral=True)
+        embed = await self.cog.build_config_embed(interaction.guild)
+        await interaction.message.edit(embed=embed, view=self)
+
+    @discord.ui.button(label="Set Log Channel", style=discord.ButtonStyle.blurple, emoji="📝", row=1, custom_id="config_log")
+    async def set_log(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not interaction.guild:
+            await interaction.response.send_message("Server only.", ephemeral=True)
+            return
+        if not interaction.user.guild_permissions.manage_guild:
+            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
+            return
+        await interaction.response.send_message(
+            "Select a text channel for logging:",
+            view=ChannelSelectModal(self.cog, interaction.guild.id, "log_channel_id", "📝 Log channel set to"),
+            ephemeral=True,
+        )
+
+    @discord.ui.button(label="Set Welcome Channel", style=discord.ButtonStyle.blurple, emoji="👋", row=1, custom_id="config_welcome")
+    async def set_welcome(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not interaction.guild:
+            await interaction.response.send_message("Server only.", ephemeral=True)
+            return
+        if not interaction.user.guild_permissions.manage_guild:
+            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
+            return
+        await interaction.response.send_message(
+            "Select a text channel for welcomes:",
+            view=ChannelSelectModal(self.cog, interaction.guild.id, "welcome_channel_id", "👋 Welcome channel set to"),
+            ephemeral=True,
+        )
+
+    @discord.ui.button(label="Set Daily Channel", style=discord.ButtonStyle.blurple, emoji="📨", row=1, custom_id="config_daily_ch")
+    async def set_daily_ch(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not interaction.guild:
+            await interaction.response.send_message("Server only.", ephemeral=True)
+            return
+        if not interaction.user.guild_permissions.manage_guild:
+            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
+            return
+        await interaction.response.send_message(
+            "Select a text channel for daily messages:",
+            view=ChannelSelectModal(self.cog, interaction.guild.id, "daily_channel_id", "📨 Daily channel set to"),
+            ephemeral=True,
+        )
+
+    @discord.ui.button(label="Set Poll Channel", style=discord.ButtonStyle.blurple, emoji="📊", row=1, custom_id="config_poll_ch")
+    async def set_poll_ch(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not interaction.guild:
+            await interaction.response.send_message("Server only.", ephemeral=True)
+            return
+        if not interaction.user.guild_permissions.manage_guild:
+            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
+            return
+        await interaction.response.send_message(
+            "Select a text channel for polls:",
+            view=ChannelSelectModal(self.cog, interaction.guild.id, "poll_channel_id", "📊 Poll channel set to"),
+            ephemeral=True,
+        )
+
+    @discord.ui.button(label="Set Daily Message", style=discord.ButtonStyle.gray, emoji="✏️", row=2, custom_id="config_daily_msg")
+    async def set_daily_msg(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not interaction.guild:
+            await interaction.response.send_message("Server only.", ephemeral=True)
+            return
+        if not interaction.user.guild_permissions.manage_guild:
+            await interaction.response.send_message("Manage Server permission required.", ephemeral=True)
+            return
+        await interaction.response.send_modal(DailyMessageModal(self.cog, interaction.guild.id))
+
+    @discord.ui.button(label="Test Daily", style=discord.ButtonStyle.gray, emoji="🧪", row=2, custom_id="config_test_daily")
+    async def test_daily(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not interaction.guild:
+            await interaction.response.send_message("Server only.", ephemeral=True)
+            return
+        row = await self.cog.bot.db.fetchone(
+            "SELECT daily_channel_id, daily_message, daily_title, daily_image_url, daily_button_label, daily_button_url FROM guild_config WHERE guild_id = ?",
+            interaction.guild.id,
+        )
+        if not row or not row[0]:
+            await interaction.response.send_message("Set a daily channel first.", ephemeral=True)
+            return
+        channel = interaction.guild.get_channel(row[0])
+        if not channel:
+            await interaction.response.send_message("Configured daily channel no longer exists.", ephemeral=True)
+            return
+        embed = self.cog._build_daily_embed(interaction.guild.name, row[2] or "", row[1] or "", row[3])
+        view = None
+        if row[4] and row[5]:
+            view = discord.ui.View()
+            view.add_item(discord.ui.Button(label=row[4], url=row[5]))
+        await channel.send(embed=embed, view=view)
+        await interaction.response.send_message(f"✅ Sent test daily message to {channel.mention}", ephemeral=True)
+
+
+class ChannelSelectModal(discord.ui.View):
+    def __init__(self, cog: "Configuration", guild_id: int, column: str, success_prefix: str) -> None:
+        super().__init__(timeout=300)
+        self.cog = cog
+        self.guild_id = guild_id
+        self.column = column
+        self.success_prefix = success_prefix
+
+        self.channel_select = discord.ui.ChannelSelect(
+            cls=discord.ui.ChannelSelect,
+            channel_types=[discord.ChannelType.text],
+            placeholder="Select a text channel...",
+            min_values=1,
+            max_values=1,
+            custom_id="channel_select_modal",
+        )
+        self.channel_select.callback = self._channel_select_callback
+        self.add_item(self.channel_select)
+
+    async def _channel_select_callback(self, interaction: discord.Interaction) -> None:
+        channel = self.channel_select.values[0]
+        await self.cog.bot.db.execute(
+            f"INSERT INTO guild_config(guild_id, {self.column}) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET {self.column} = excluded.{self.column}",
+            self.guild_id, channel.id,
+        )
+        await interaction.response.send_message(f"{self.success_prefix} {channel.mention}", ephemeral=True)
+
+
+class DailyMessageModal(discord.ui.Modal, title="✏️ Set Daily Message"):
+    message = discord.ui.TextInput(
+        label="Daily Message Text",
+        placeholder="Your daily message here...",
+        required=True,
+        style=discord.TextStyle.paragraph,
+        max_length=500,
+    )
+
+    def __init__(self, cog: "Configuration", guild_id: int) -> None:
+        super().__init__(timeout=None)
+        self.cog = cog
+        self.guild_id = guild_id
+
+    async def on_submit(self, interaction: discord.Interaction) -> None:
+        await self.cog.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, daily_message) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_message = excluded.daily_message",
+            self.guild_id, str(self.message.value),
+        )
+        await interaction.response.send_message("🗓️ Daily message text updated.", ephemeral=True)
+
+
+
+
+class FreeGameSetupView(discord.ui.View):
+    def __init__(self, cog: "Configuration", guild_id: int, channel_id: int, role_id: int | None = None) -> None:
+        super().__init__(timeout=300)
+        self.cog = cog
+        self.guild_id = guild_id
+        self.channel_id = channel_id
+        self.role_id = role_id
+        self.mention_type = "role"
+        self.platforms = {"epic", "steam", "gog"}
+
+    async def _save(self, interaction: discord.Interaction) -> None:
+        await self.cog.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, free_games_channel_id, free_games_role_id, free_games_platforms, free_games_mention_type) VALUES (?, ?, ?, ?, ?) "
+            "ON CONFLICT(guild_id) DO UPDATE SET free_games_channel_id=excluded.free_games_channel_id, free_games_role_id=excluded.free_games_role_id, free_games_platforms=excluded.free_games_platforms, free_games_mention_type=excluded.free_games_mention_type",
+            self.guild_id,
+            self.channel_id,
+            self.role_id,
+            ",".join(sorted(self.platforms)),
+            self.mention_type,
+        )
+
+    @discord.ui.select(
+        placeholder="Choose stores for alerts",
+        min_values=1,
+        max_values=3,
+        options=[
+            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("<:animatedarrowgreen:1477261279428087979> Free games stores updated.", ephemeral=True)
+
+    @discord.ui.select(
+        placeholder="Choose ping role (optional)",
+        min_values=0,
+        max_values=1,
+        cls=discord.ui.RoleSelect,
+    )
+    async def role_select(self, interaction: discord.Interaction, select: discord.ui.RoleSelect) -> None:
+        role = select.values[0] if select.values else None
+        self.role_id = role.id if role else None
+        await self._save(interaction)
+        if role:
+            await interaction.response.send_message(f"✅ Free games role set to {role.mention}", ephemeral=True)
+        else:
+            await interaction.response.send_message("✅ Free games role cleared.", ephemeral=True)
+
+    @discord.ui.select(
+        placeholder="Mention style",
+        min_values=1,
+        max_values=1,
+        options=[
+            discord.SelectOption(label="Role mention", value="role", emoji="🏷️"),
+            discord.SelectOption(label="@everyone", value="everyone", emoji="📢"),
+            discord.SelectOption(label="@here", value="here", emoji="📣"),
+            discord.SelectOption(label="No mention", value="none", emoji="🔕"),
+        ],
+    )
+    async def mention_select(self, interaction: discord.Interaction, select: discord.ui.Select) -> None:
+        self.mention_type = (select.values[0] if select.values else "role").strip().lower()
+        await self._save(interaction)
+        await interaction.response.send_message(f"✅ Mention type set to `{self.mention_type}`", ephemeral=True)
+
+
+class Configuration(commands.Cog):
+    TIME_RE = re.compile(r"^(?:[01]\d|2[0-3]):[0-5]\d$")
+
+    def __init__(self, bot: commands.Bot) -> None:
+        self.bot = bot
+
+    async def cog_load(self) -> None:
+        self.bot.add_view(ConfigPanelView(self))
+
+    async def build_config_embed(self, guild: discord.Guild) -> discord.Embed:
+        row = await self.bot.db.fetchone(
+            "SELECT log_channel_id, welcome_channel_id, suggestion_channel_id, automod_enabled, daily_channel_id, "
+            "daily_enabled, daily_message, daily_time, daily_utc_offset, verify_channel_id, verify_role_id, "
+            "daily_title, daily_image_url, daily_button_label, daily_button_url, poll_channel_id, free_games_channel_id, free_games_role_id, "
+            "support_channel_id, support_ai_enabled, wisdom_channel_id, wisdom_enabled, game_news_channel_id, game_news_role_id "
+            "FROM guild_config WHERE guild_id = ?",
+            guild.id,
+        )
+
+        values = row if row else (None, None, None, 0, None, 0, "Not set", "09:00", 0, None, None, "🌅 Daily Message", None, None, None, None, None, None, None, 0, None, 0, None, None)
+        (
+            log_id,
+            welcome_id,
+            suggestion_id,
+            automod_enabled,
+            daily_channel_id,
+            daily_enabled,
+            daily_message,
+            daily_time,
+            daily_utc_offset,
+            verify_channel_id,
+            verify_role_id,
+            daily_title,
+            daily_image_url,
+            daily_button_label,
+            daily_button_url,
+            poll_channel_id,
+            free_games_channel_id,
+            free_games_role_id,
+            support_channel_id,
+            support_ai_enabled,
+            wisdom_channel_id,
+            wisdom_enabled,
+            game_news_channel_id,
+            game_news_role_id,
+        ) = values
+
+        def mention(channel_id: int | None) -> str:
+            return f"<#{channel_id}>" if channel_id else "Not set"
+
+        embed = discord.Embed(title=fancy_header(f"Settings • {guild.name}"), color=NEON_CYAN)
+        embed.add_field(name="Log Channel", value=mention(log_id), inline=True)
+        embed.add_field(name="Welcome Channel", value=mention(welcome_id), inline=True)
+        embed.add_field(name="Suggestion Channel", value=mention(suggestion_id), inline=True)
+        embed.add_field(name="Verification Channel", value=mention(verify_channel_id), inline=True)
+        embed.add_field(name="Verification Role", value=f"<@&{verify_role_id}>" if verify_role_id else "Not set", inline=True)
+        embed.add_field(name="AutoMod", value="✅ On" if automod_enabled else "❌ Off", inline=True)
+        embed.add_field(name="Daily Channel", value=mention(daily_channel_id), inline=True)
+        embed.add_field(name="Daily Enabled", value="✅ On" if daily_enabled else "❌ Off", inline=True)
+        embed.add_field(name="Daily Time", value=f"`{daily_time or '09:00'}`", inline=True)
+        embed.add_field(name="Daily UTC Offset", value=f"`UTC{daily_utc_offset:+d}`", inline=True)
+        embed.add_field(name="Daily Title", value=(daily_title or "🌅 Daily Message")[:128], inline=False)
+        embed.add_field(name="Daily Message Text", value=(daily_message or "Not set")[:1024], inline=False)
+        embed.add_field(name="Daily Image URL", value=daily_image_url or "Not set", inline=False)
+        embed.add_field(name="Daily Button", value=f"{daily_button_label or 'Not set'} | {daily_button_url or 'Not set'}", inline=False)
+        embed.add_field(name="Poll Channel", value=mention(poll_channel_id), inline=True)
+        embed.add_field(name="Free Games Channel", value=mention(free_games_channel_id), inline=True)
+        embed.add_field(name="Free Games Role", value=f"<@&{free_games_role_id}>" if free_games_role_id else "Not set", inline=True)
+        embed.add_field(name="Support AI Channel", value=mention(support_channel_id), inline=True)
+        embed.add_field(name="Support AI Enabled", value="✅ On" if support_ai_enabled else "❌ Off", inline=True)
+        embed.add_field(name="Wisdom Channel", value=mention(wisdom_channel_id), inline=True)
+        embed.add_field(name="Wisdom Daily", value="✅ On" if wisdom_enabled else "❌ Off", inline=True)
+        embed.add_field(name="Game News Channel", value=mention(game_news_channel_id), inline=True)
+        embed.add_field(name="Game News Role", value=f"<@&{game_news_role_id}>" if game_news_role_id else "Not set", inline=True)
+        embed.set_footer(text="Use /set commands to update • Click Refresh to update panel")
+        return embed
+
+    def _build_daily_embed(self, guild_name: str, title: str, message_text: str, image_url: str | None) -> discord.Embed:
+        today = dt.datetime.utcnow().date().isoformat()
+        embed = discord.Embed(
+            title=title or "🌅 Daily Message",
+            description=message_text or "Have a productive and positive day!",
+            color=discord.Color.gold(),
+        )
+        if image_url:
+            embed.set_image(url=image_url)
+        embed.set_footer(text=f"{guild_name} • {today}")
+        return embed
+
+    @commands.hybrid_group(name="set", fallback="show")
+    @commands.has_permissions(manage_guild=True)
+    async def setgroup(self, ctx: commands.Context) -> None:
+        embed = await self.build_config_embed(ctx.guild)
+        await ctx.reply(embed=embed, view=ConfigPanelView(self))
+
+    @setgroup.command(name="log")
+    async def set_log(self, ctx: commands.Context, channel: discord.TextChannel) -> None:
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, log_channel_id) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET log_channel_id = excluded.log_channel_id",
+            ctx.guild.id,
+            channel.id,
+        )
+        await ctx.reply(f"📝 Log channel set to {channel.mention}")
+
+    @setgroup.command(name="welcome")
+    async def set_welcome(self, ctx: commands.Context, channel: discord.TextChannel) -> None:
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, welcome_channel_id) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET welcome_channel_id = excluded.welcome_channel_id",
+            ctx.guild.id,
+            channel.id,
+        )
+        await ctx.reply(f"👋 Welcome channel set to {channel.mention}")
+
+    @setgroup.command(name="suggestions")
+    async def set_suggestion(self, ctx: commands.Context, channel: discord.TextChannel) -> None:
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, suggestion_channel_id) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET suggestion_channel_id = excluded.suggestion_channel_id",
+            ctx.guild.id,
+            channel.id,
+        )
+        await ctx.reply(f"💡 Suggestion channel set to {channel.mention}")
+
+    @setgroup.command(name="automod")
+    async def set_automod(self, ctx: commands.Context, enabled: bool) -> None:
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, automod_enabled) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET automod_enabled = excluded.automod_enabled",
+            ctx.guild.id,
+            1 if enabled else 0,
+        )
+        await ctx.reply(f"🛡️ AutoMod {'enabled' if enabled else 'disabled'}")
+
+    @setgroup.command(name="dailychannel")
+    async def set_daily_channel(self, ctx: commands.Context, channel: discord.TextChannel) -> None:
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, daily_channel_id) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_channel_id = excluded.daily_channel_id",
+            ctx.guild.id,
+            channel.id,
+        )
+        await ctx.reply(f"📨 Daily message channel set to {channel.mention}")
+
+    @setgroup.command(name="dailymessage")
+    async def set_daily_message(self, ctx: commands.Context, *, text: str) -> None:
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, daily_message) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_message = excluded.daily_message",
+            ctx.guild.id,
+            text,
+        )
+        await ctx.reply("🗓️ Daily message text updated.")
+
+    @setgroup.command(name="dailytitle")
+    async def set_daily_title(self, ctx: commands.Context, *, title: str) -> None:
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, daily_title) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_title = excluded.daily_title",
+            ctx.guild.id,
+            title,
+        )
+        await ctx.reply("🖋️ Daily message title updated.")
+
+    @setgroup.command(name="dailyimage")
+    async def set_daily_image(self, ctx: commands.Context, image_url: str = "") -> None:
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, daily_image_url) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_image_url = excluded.daily_image_url",
+            ctx.guild.id,
+            image_url or None,
+        )
+        await ctx.reply("🖼️ Daily image updated (empty value removes it).")
+
+    @setgroup.command(name="dailybutton")
+    async def set_daily_button(self, ctx: commands.Context, label: str = "", url: str = "") -> None:
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, daily_button_label, daily_button_url) VALUES (?, ?, ?) "
+            "ON CONFLICT(guild_id) DO UPDATE SET daily_button_label = excluded.daily_button_label, daily_button_url = excluded.daily_button_url",
+            ctx.guild.id,
+            label or None,
+            url or None,
+        )
+        await ctx.reply("🔗 Daily button settings updated.")
+
+    @setgroup.command(name="dailytime")
+    async def set_daily_time(self, ctx: commands.Context, hhmm: str) -> None:
+        hhmm = hhmm.strip()
+        if not self.TIME_RE.fullmatch(hhmm):
+            await ctx.reply("Use time in 24h format `HH:MM` (example: `18:30`).")
+            return
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, daily_time) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_time = excluded.daily_time",
+            ctx.guild.id,
+            hhmm,
+        )
+        await ctx.reply(f"⏰ Daily message time set to `{hhmm}`")
+
+    @setgroup.command(name="dailyutc")
+    async def set_daily_utc(self, ctx: commands.Context, offset: int) -> None:
+        if offset < -12 or offset > 14:
+            await ctx.reply("UTC offset must be between `-12` and `+14`.")
+            return
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, daily_utc_offset) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_utc_offset = excluded.daily_utc_offset",
+            ctx.guild.id,
+            offset,
+        )
+        await ctx.reply(f"🌍 Daily timezone set to `UTC{offset:+d}`")
+
+    @setgroup.command(name="dailytest")
+    async def set_daily_test(self, ctx: commands.Context) -> None:
+        row = await self.bot.db.fetchone(
+            "SELECT daily_channel_id, daily_message, daily_title, daily_image_url, daily_button_label, daily_button_url FROM guild_config WHERE guild_id = ?",
+            ctx.guild.id,
+        )
+        if not row or not row[0]:
+            await ctx.reply("Set a daily channel first with `/set dailychannel`.")
+            return
+        channel = ctx.guild.get_channel(row[0])
+        if not channel:
+            await ctx.reply("Configured daily channel no longer exists.")
+            return
+        embed = self._build_daily_embed(ctx.guild.name, row[2] or "", row[1] or "", row[3])
+        view = None
+        if row[4] and row[5]:
+            view = discord.ui.View()
+            view.add_item(discord.ui.Button(label=row[4], url=row[5]))
+        await channel.send(embed=embed, view=view)
+        await ctx.reply(f"✅ Sent test daily message to {channel.mention}")
+
+    @setgroup.command(name="dailytoggle")
+    async def set_daily_toggle(self, ctx: commands.Context, enabled: bool) -> None:
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, daily_enabled) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET daily_enabled = excluded.daily_enabled",
+            ctx.guild.id,
+            1 if enabled else 0,
+        )
+        await ctx.reply(f"📅 Daily message {'enabled' if enabled else 'disabled'}.")
+
+
+    @setgroup.command(name="pollchannel")
+    async def set_poll_channel(self, ctx: commands.Context, channel: discord.TextChannel) -> None:
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, poll_channel_id) VALUES (?, ?) ON CONFLICT(guild_id) DO UPDATE SET poll_channel_id = excluded.poll_channel_id",
+            ctx.guild.id,
+            channel.id,
+        )
+        await ctx.reply(f"📊 Poll channel set to {channel.mention}")
+
+    @setgroup.command(name="freegames")
+    async def set_free_games_channel(self, ctx: commands.Context, channel: discord.TextChannel, role: discord.Role | None = None) -> None:
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, free_games_channel_id, free_games_role_id) VALUES (?, ?, ?) "
+            "ON CONFLICT(guild_id) DO UPDATE SET free_games_channel_id = excluded.free_games_channel_id, free_games_role_id = excluded.free_games_role_id",
+            ctx.guild.id,
+            channel.id,
+            role.id if role else None,
+        )
+        mention = f" with role {role.mention}" if role else ""
+        await ctx.reply(f"🎁 Free games alerts channel set to {channel.mention}{mention}")
+
+    @setgroup.command(name="gamenews")
+    async def set_game_news(self, ctx: commands.Context, channel: discord.TextChannel, role: discord.Role | None = None) -> None:
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, game_news_channel_id, game_news_role_id) VALUES (?, ?, ?) "
+            "ON CONFLICT(guild_id) DO UPDATE SET game_news_channel_id = excluded.game_news_channel_id, game_news_role_id = excluded.game_news_role_id",
+            ctx.guild.id,
+            channel.id,
+            role.id if role else None,
+        )
+        mention = f" with role {role.mention}" if role else ""
+        await ctx.reply(f"📰 Game news alerts channel set to {channel.mention}{mention}")
+
+    @setgroup.command(name="supportai")
+    async def set_support_ai(self, ctx: commands.Context, channel: discord.TextChannel, enabled: bool = True) -> None:
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, support_channel_id, support_ai_enabled) VALUES (?, ?, ?) "
+            "ON CONFLICT(guild_id) DO UPDATE SET support_channel_id = excluded.support_channel_id, support_ai_enabled = excluded.support_ai_enabled",
+            ctx.guild.id,
+            channel.id,
+            1 if enabled else 0,
+        )
+        await ctx.reply(f"🛟 Support AI {'enabled' if enabled else 'disabled'} in {channel.mention}")
+
+    @setgroup.command(name="wisdom")
+    async def set_wisdom(self, ctx: commands.Context, channel: discord.TextChannel, enabled: bool = True) -> None:
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, wisdom_channel_id, wisdom_enabled) VALUES (?, ?, ?) "
+            "ON CONFLICT(guild_id) DO UPDATE SET wisdom_channel_id = excluded.wisdom_channel_id, wisdom_enabled = excluded.wisdom_enabled",
+            ctx.guild.id,
+            channel.id,
+            1 if enabled else 0,
+        )
+        await ctx.reply(f"🧠 Daily wisdom {'enabled' if enabled else 'disabled'} in {channel.mention}")
+
+    @setgroup.command(name="freegame")
+    async def set_free_game_alias(self, ctx: commands.Context, channel: discord.TextChannel, role: discord.Role | None = None) -> None:
+        await self.set_free_games_channel(ctx, channel, role)
+
+    @commands.hybrid_command(name="set_freegame", description=get_cmd_desc("commands.tools.set_freegame_desc"))
+    @commands.has_permissions(administrator=True)
+    async def set_freegame_panel(self, ctx: commands.Context, channel: discord.TextChannel, role: discord.Role | None = None) -> None:
+        await self.bot.db.execute(
+            "INSERT INTO guild_config(guild_id, free_games_channel_id, free_games_role_id) VALUES (?, ?, ?) "
+            "ON CONFLICT(guild_id) DO UPDATE SET free_games_channel_id=excluded.free_games_channel_id, free_games_role_id=excluded.free_games_role_id",
+            ctx.guild.id,
+            channel.id,
+            role.id if role else None,
+        )
+        view = FreeGameSetupView(self, ctx.guild.id, channel.id, role.id if role else None)
+        embed = discord.Embed(
+            title="<:animatedarrowgreen:1477261279428087979> Free Games Setup",
+            description=(
+                f"Channel: {channel.mention}\n"
+                f"Role ping: {role.mention if role else 'None'}\n"
+                "Use menu below to choose stores (Epic/Steam/GOG)."
+            ),
+            color=discord.Color.green(),
+        )
+        await ctx.reply(embed=embed, view=view)
+
+
+
+async def setup(bot: commands.Bot) -> None:
+    await bot.add_cog(Configuration(bot))

bot/cogs/developer.py

@@ -1,10 +1,16 @@
 from __future__ import annotations
 
+import re
 import traceback
 
 import discord
 from discord.ext import commands
 
+from bot.emojis import (
+    CUSTOM_EMOJIS, _UI_ALIASES, FALLBACK_EMOJIS, _EMOJI_BOT,
+    _EMOJI_ID_RE, _normalize_key
+)
+
 
 class Developer(commands.Cog):
     def __init__(self, bot: commands.Bot) -> None:
@@ -13,43 +19,140 @@ class Developer(commands.Cog):
     async def cog_check(self, ctx: commands.Context) -> bool:
         return await self.bot.is_owner(ctx.author)
 
-    @commands.command(name="load", help="Load a cog extension by dotted path.")
-    async def load(self, ctx: commands.Context, extension: str) -> None:
+    @commands.command(name="load", help="Load a cog extension by dotted path.")
+    async def load(self, ctx: commands.Context, extension: str) -> None:
         await self.bot.load_extension(extension)
         await ctx.reply(f"Loaded {extension}")
 
-    @commands.command(name="unload", help="Unload a cog extension by dotted path.")
-    async def unload(self, ctx: commands.Context, extension: str) -> None:
+    @commands.command(name="unload", help="Unload a cog extension by dotted path.")
+    async def unload(self, ctx: commands.Context, extension: str) -> None:
         await self.bot.unload_extension(extension)
         await ctx.reply(f"Unloaded {extension}")
 
-    @commands.command(name="reload", help="Reload a cog extension by dotted path.")
-    async def reload(self, ctx: commands.Context, extension: str) -> None:
+    @commands.command(name="reload", help="Reload a cog extension by dotted path.")
+    async def reload(self, ctx: commands.Context, extension: str) -> None:
         await self.bot.reload_extension(extension)
         await ctx.reply(f"Reloaded {extension}")
 
-    @commands.command(name="sync", help="Sync global slash commands to Discord.")
-    async def sync(self, ctx: commands.Context) -> None:
+    @commands.command(name="sync", help="Sync global slash commands to Discord.")
+    async def sync(self, ctx: commands.Context) -> None:
         synced = await self.bot.tree.sync()
         await ctx.reply(f"Synced {len(synced)} app commands")
 
-    @commands.command(name="shutdown", help="Gracefully shut down the bot process.")
-    async def shutdown(self, ctx: commands.Context) -> None:
+    @commands.command(name="shutdown", help="Gracefully shut down the bot process.")
+    async def shutdown(self, ctx: commands.Context) -> None:
         await ctx.reply("Shutting down...")
         await self.bot.close()
 
+    @commands.hybrid_command(name="emoji_scan", description="Show broken/unresolved custom emojis")
+    async def emoji_scan(self, ctx: commands.Context) -> None:
+        """Scan all configured custom emojis and show which ones are broken."""
+        if not self.bot.is_ready() or not self.bot.user:
+            await ctx.reply("⏳ Bot is not ready yet.", ephemeral=True)
+            return
+
+        bot_emojis = {e.id: e for e in self.bot.emojis}
+        broken: list[tuple[str, str, str]] = []
+        working: list[tuple[str, str]] = []
+        total = 0
+
+        # Scan CUSTOM_EMOJIS from emojies.txt
+        for key, value in CUSTOM_EMOJIS.items():
+            total += 1
+            emoji_id = self._extract_id(value)
+            if emoji_id and emoji_id not in bot_emojis:
+                broken.append((key, value, "emoji not in bot cache"))
+            elif not emoji_id:
+                broken.append((key, value, "no valid emoji ID found"))
+            else:
+                working.append((key, value))
+
+        # Scan _UI_ALIASES — check if any alias resolves
+        checked_aliases: set[str] = set()
+        for ui_key, aliases in _UI_ALIASES.items():
+            for alias in aliases:
+                norm = _normalize_key(alias)
+                if norm in checked_aliases:
+                    continue
+                checked_aliases.add(norm)
+                total += 1
+                alias_value = CUSTOM_EMOJIS.get(norm, "")
+                if not alias_value:
+                    # Alias doesn't map to any configured emoji
+                    broken.append((f"ui:{ui_key}→{alias}", alias_value or "(none)", "alias has no configured emoji"))
+                    continue
+                aid = self._extract_id(alias_value)
+                if aid and aid not in bot_emojis:
+                    broken.append((f"ui:{ui_key}→{alias}", alias_value, "aliased emoji not in cache"))
+
+        # Deduplicate broken list by key
+        seen_keys: set[str] = set()
+        unique_broken: list[tuple[str, str, str]] = []
+        for key, value, reason in broken:
+            if key not in seen_keys:
+                seen_keys.add(key)
+                unique_broken.append((key, value, reason))
+        broken = unique_broken
+
+        # Build embed
+        color = discord.Color.red() if broken else discord.Color.green()
+        embed = discord.Embed(
+            title="🔍 Bot Emoji Health Check",
+            description=(
+                f"**Total configured:** `{total}`\n"
+                f"**✅ Working:** `{len(working) + len(checked_aliases) - len(broken)}`\n"
+                f"**❌ Broken:** `{len(broken)}`\n"
+                f"**Bot cache size:** `{len(bot_emojis)}`"
+            ),
+            color=color,
+        )
+
+        if broken:
+            # Group by reason
+            by_reason: dict[str, list[tuple[str, str]]] = {}
+            for key, value, reason in broken:
+                by_reason.setdefault(reason, []).append((key, value))
+
+            for reason, items in list(by_reason.items())[:10]:  # Limit display
+                names = ", ".join(f"`{k}`" for k, v in items[:15])
+                if len(items) > 15:
+                    names += f" (+{len(items) - 15} more)"
+                embed.add_field(
+                    name=f"❌ {reason} ({len(items)})",
+                    value=names[:1000],
+                    inline=False,
+                )
+
+        embed.set_footer(text="Run this after the bot joins new servers to refresh emoji cache")
+
+        if ctx.interaction:
+            await ctx.interaction.response.send_message(embed=embed, ephemeral=True)
+        else:
+            await ctx.reply(embed=embed, ephemeral=True)
+
+    @staticmethod
+    def _extract_id(value: str) -> int | None:
+        """Extract numeric emoji ID from a custom emoji tag."""
+        if not value:
+            return None
+        m = _EMOJI_ID_RE.search(value)
+        if m:
+            return int(m.group(0))
+        if value.strip().isdigit():
+            return int(value.strip())
+        return None
 
-    async def _safe_reply(self, ctx: commands.Context, message: str) -> None:
-        try:
-            await ctx.reply(message)
-        except (discord.NotFound, discord.InteractionResponded):
-            if ctx.channel:
-                await ctx.channel.send(message)
-        except discord.HTTPException as exc:
-            if exc.code not in {10062, 40060}:
-                raise
-            if ctx.channel:
-                await ctx.channel.send(message)
+    async def _safe_reply(self, ctx: commands.Context, message: str) -> None:
+        try:
+            await ctx.reply(message)
+        except (discord.NotFound, discord.InteractionResponded):
+            if ctx.channel:
+                await ctx.channel.send(message)
+        except discord.HTTPException as exc:
+            if exc.code not in {10062, 40060}:
+                raise
+            if ctx.channel:
+                await ctx.channel.send(message)
 
     @commands.Cog.listener()
     async def on_command_error(self, ctx: commands.Context, error: Exception) -> None:

bot/cogs/fun.py

@@ -1,980 +1,981 @@
-"""
-Fun cog: Games, trivia, memes, and entertainment commands.
-Enhanced with rich emoji decorations, beautiful formatting, and multi-language support.
-"""
-
-import html
-import random
-
-import aiohttp
-import discord
-from discord.ext import commands
-
-from bot.cogs.ai_suite import ImperialMotaz
-from bot.theme import (
-    fancy_header, NEON_CYAN, NEON_PINK, NEON_PURPLE, NEON_LIME, NEON_ORANGE, NEON_BLUE,
-    panel_divider, gaming_embed, success_embed, error_embed, info_embed,
-    double_line, triple_line, shimmer, pick_neon_color
-)
-from bot.emojis import (
-    ui, E_GAMEHUB, E_ARROW_PINK, E_ARROW_GREEN, E_ARROW_PURPLE, E_STAR,
-    E_TROPHY, E_FIRE, E_SPARKLE, E_DIZZY, E_BOOM, E_ZAP, E_DIAMOND, E_CROWN, E_GEM
-)
-from bot.utils.shared import fetch_gaming_news, fetch_free_games, store_icon, FreeGameClaimView
-
-
-TRIVIA_BANK: dict[str, dict[str, list[dict[str, object]]]] = {
-    "en": {
-        "gaming": [
-            {"q": "Which studio created The Witcher 3?", "c": ["CD Projekt Red", "Rockstar", "Ubisoft", "Bethesda"], "a": 0},
-            {"q": "What is the default block in Minecraft?", "c": ["Stone", "Dirt", "Grass Block", "Sand"], "a": 2},
-            {"q": "In which game would you find Master Chief?", "c": ["Halo", "Destiny", "Call of Duty", "Gears of War"], "a": 0},
-            {"q": "What year was Fortnite released?", "c": ["2015", "2017", "2018", "2019"], "a": 1},
-            {"q": "Which company makes the PlayStation?", "c": ["Microsoft", "Nintendo", "Sony", "Sega"], "a": 2},
-        ],
-        "movies": [
-            {"q": "Who directed Inception?", "c": ["Christopher Nolan", "James Cameron", "Denis Villeneuve", "Ridley Scott"], "a": 0},
-            {"q": "In the MCU, who is Peter Parker?", "c": ["Iron Man", "Spider-Man", "Doctor Strange", "Hawkeye"], "a": 1},
-            {"q": "What is the highest-grossing film of all time?", "c": ["Avengers: Endgame", "Avatar", "Titanic", "Star Wars"], "a": 1},
-            {"q": "Who played the Joker in The Dark Knight?", "c": ["Joaquin Phoenix", "Jack Nicholson", "Heath Ledger", "Jared Leto"], "a": 2},
-        ],
-        "series": [
-            {"q": "Which series features Walter White?", "c": ["Narcos", "Breaking Bad", "Dark", "Sherlock"], "a": 1},
-            {"q": "In Game of Thrones, what is Jon Snow's house at first?", "c": ["Lannister", "Baratheon", "Stark", "Targaryen"], "a": 2},
-            {"q": "What is the name of the coffee shop in Friends?", "c": ["Central Park", "Central Perk", "Coffee House", "The Brew"], "a": 1},
-            {"q": "How many seasons does Stranger Things have?", "c": ["3", "4", "5", "6"], "a": 2},
-        ],
-    },
-    "ar": {
-        "gaming": [
-            {"q": "أي شركة طورت لعبة The Witcher 3؟", "c": ["CD Projekt Red", "Rockstar", "Ubisoft", "Bethesda"], "a": 0},
-            {"q": "ما هو البلوك الافتراضي في Minecraft؟", "c": ["Stone", "Dirt", "Grass Block", "Sand"], "a": 2},
-            {"q": "في أي لعبة تجد Master Chief؟", "c": ["Halo", "Destiny", "Call of Duty", "Gears of War"], "a": 0},
-            {"q": "متى صدرت Fortnite؟", "c": ["2015", "2017", "2018", "2019"], "a": 1},
-        ],
-        "movies": [
-            {"q": "من مخرج فيلم Inception؟", "c": ["كريستوفر نولان", "جيمس كاميرون", "دينيس فيلنوف", "ريدلي سكوت"], "a": 0},
-            {"q": "في عالم مارفل، بيتر باركر هو؟", "c": ["Iron Man", "Spider-Man", "Doctor Strange", "Hawkeye"], "a": 1},
-            {"q": "ما هو أعلى فيلم إيرادات في التاريخ؟", "c": ["Avengers: Endgame", "Avatar", "Titanic", "Star Wars"], "a": 1},
-        ],
-        "series": [
-            {"q": "أي مسلسل يظهر فيه Walter White؟", "c": ["Narcos", "Breaking Bad", "Dark", "Sherlock"], "a": 1},
-            {"q": "في Game of Thrones، جون سنو كان ضمن أي بيت بالبداية؟", "c": ["Lannister", "Baratheon", "Stark", "Targaryen"], "a": 2},
-        ],
-    },
-}
-
-
-class TriviaAnswerButton(discord.ui.Button["TriviaView"]):
-    def __init__(self, label: str, index: int) -> None:
-        super().__init__(label=label[:80], style=discord.ButtonStyle.secondary)
-        self.index = index
-
-    async def callback(self, interaction: discord.Interaction) -> None:
-        await self.view.on_answer(interaction, self.index)
-
-
-class FreeGameClaimView(discord.ui.View):
-    def __init__(self, url: str) -> None:
-        super().__init__(timeout=None)
-        self.add_item(
-            discord.ui.Button(
-                label=f"{ui('gift')} Claim Your Prize {ui('gift')}",
-                style=discord.ButtonStyle.link,
-                url=url,
-            )
-        )
-
-
-class TriviaView(discord.ui.View):
-    def __init__(self, owner_id: int, correct_index: int, lang: str, cog: "Fun", guild_id: int | None) -> None:
-        super().__init__(timeout=None)
-        self.owner_id = owner_id
-        self.correct_index = correct_index
-        self.lang = lang
-        self.answered = False
-        self.cog = cog
-        self.guild_id = guild_id
-
-    async def on_answer(self, interaction: discord.Interaction, picked_index: int) -> None:
-        if interaction.user.id != self.owner_id:
-            msg = "❌ هذا السؤال لصاحب الأمر فقط." if self.lang == "ar" else "❌ This question is for the command author only."
-            await interaction.response.send_message(msg, ephemeral=True)
-            return
-        if self.answered:
-            msg = "⚠️ تمت الإجابة بالفعل." if self.lang == "ar" else "⚠️ Already answered."
-            await interaction.response.send_message(msg, ephemeral=True)
-            return
-
-        self.answered = True
-        is_correct = picked_index == self.correct_index
-        for idx, child in enumerate(self.children):
-            if isinstance(child, discord.ui.Button):
-                child.disabled = True
-                if idx == self.correct_index:
-                    child.style = discord.ButtonStyle.success
-                elif idx == picked_index and not is_correct:
-                    child.style = discord.ButtonStyle.danger
-
-        if is_correct:
-            msg = f"✅ إجابة صحيحة! {E_STAR}" if self.lang == "ar" else f"✅ Correct answer! {E_STAR}"
-        else:
-            msg = "❌ إجابة خاطئة." if self.lang == "ar" else "❌ Wrong answer."
-
-        await interaction.response.edit_message(view=self)
-        if is_correct and interaction.guild and self.guild_id:
-            reward = random.randint(20, 45)
-            await self.cog.bot.db.execute(
-                "INSERT INTO user_balance(guild_id, user_id, wallet, bank) VALUES (?, ?, ?, 0) "
-                "ON CONFLICT(guild_id, user_id) DO UPDATE SET wallet = wallet + excluded.wallet",
-                self.guild_id,
-                interaction.user.id,
-                reward,
-            )
-            if self.lang == "ar":
-                msg += f" 💰 **+{reward}** عملة!"
-            else:
-                msg += f" 💰 **+{reward}** coins!"
-        await interaction.followup.send(msg, ephemeral=True)
-
-
-GAME_HUB_GAMES = [
-    {"id": "chess", "name": "Chess", "emoji": "♟️", "description": "Strategic board game"},
-    {"id": "checkers", "name": "Checkers", "emoji": "🔴", "description": "Classic draughts game"},
-    {"id": "connect4", "name": "Connect 4", "emoji": "🔴", "description": "Drop and connect"},
-    {"id": "othello", "name": "Othello", "emoji": "⚪", "description": "Reversi strategy"},
-    {"id": "tictactoe", "name": "TicTacToe", "emoji": "❎", "description": "X and O battle"},
-    {"id": "rps", "name": "Rock Paper Scissors", "emoji": "✂️", "description": "Quick decision game"},
-    {"id": "trivia", "name": "Trivia Challenge", "emoji": "🧠", "description": "Knowledge contest"},
-    {"id": "guess", "name": "Number Guess", "emoji": "🔢", "description": "Guess 1-10"},
-]
-
-
-class GameHubSelect(discord.ui.Select):
-    def __init__(self, cog: "Fun", invitee_id: int | None, lang: str = "en") -> None:
-        self.cog = cog
-        self.invitee_id = invitee_id
-        self.lang = lang
-        
-        options = []
-        for game in GAME_HUB_GAMES:
-            if lang == "ar":
-                desc = game["description"]
-            else:
-                desc = game["description"]
-            options.append(
-                discord.SelectOption(
-                    label=game["name"],
-                    value=game["id"],
-                    description=desc,
-                    emoji=game["emoji"]
-                )
-            )
-        super().__init__(
-            placeholder="🎮 Choose a game",
-            min_values=1,
-            max_values=1,
-            options=options,
-            custom_id="gamehub_select",
-        )
-
-    async def callback(self, interaction: discord.Interaction) -> None:
-        if not interaction.guild:
-            await interaction.response.send_message("Server only.", ephemeral=True)
-            return
-        
-        guild = interaction.guild
-        game_id = self.values[0]
-        invitee = guild.get_member(self.invitee_id) if self.invitee_id else None
-        guild_id = guild.id
-        lang = await self.cog.bot.get_guild_language(guild_id)
-
-        category = discord.utils.get(guild.categories, name="🕹️ Game Rooms")
-        if category is None:
-            category = await guild.create_category("🕹️ Game Rooms", reason="GameHub temporary rooms")
-
-        overwrites = {
-            guild.default_role: discord.PermissionOverwrite(view_channel=False),
-            interaction.user: discord.PermissionOverwrite(view_channel=True, send_messages=True, read_message_history=True),
-        }
-        if invitee:
-            overwrites[invitee] = discord.PermissionOverwrite(view_channel=True, send_messages=True, read_message_history=True)
-        if guild.me:
-            overwrites[guild.me] = discord.PermissionOverwrite(view_channel=True, send_messages=True, manage_channels=True)
-
-        room = await guild.create_text_channel(
-            name=f"game-{game_id}-{interaction.user.name[:8].lower()}",
-            category=category,
-            overwrites=overwrites,
-            reason=f"GameHub room for {interaction.user}",
-        )
-
-        board_cog = self.cog.bot.get_cog("BoardGames")
-        try:
-            if game_id == "tictactoe":
-                view = TicTacToeView(interaction.user, invitee)
-                first = interaction.user.mention
-                second = invitee.mention if invitee else "🤖 Bot"
-                if lang == "ar":
-                    msg = await room.send(f"❎ تيك تاك تو: {first} (X) ضد {second} (O)\n🎮 الدور: {interaction.user.mention}", view=view)
-                else:
-                    msg = await room.send(f"❎ TicTacToe: {first} (X) vs {second} (O)\n🎮 Turn: {interaction.user.mention}", view=view)
-                if invitee is None:
-                    await view._maybe_bot(msg)
-            elif game_id == "trivia":
-                # Start trivia game
-                item = random.choice(TRIVIA_BANK.get(lang, TRIVIA_BANK["en"])["gaming"])
-                view = TriviaView(owner_id=interaction.user.id, correct_index=int(item["a"]), lang=lang, cog=self.cog, guild_id=guild_id)
-                for idx, choice in enumerate(item["c"]):
-                    view.add_item(TriviaAnswerButton(str(choice), idx))
-                
-                if lang == "ar":
-                    q_title = "🧠 سؤال تراڤيا!"
-                else:
-                    q_title = "🧠 Trivia Time!"
-                    
-                embed = discord.Embed(
-                    title=q_title,
-                    description=f"{panel_divider('blue')}\n❓ {str(item['q'])}\n{panel_divider('blue')}",
-                    color=NEON_CYAN,
-                )
-                await room.send(embed=embed, view=view)
-            elif game_id == "rps":
-                # RPS game in channel
-                if lang == "ar":
-                    await room.send(f"✂️ حجر ورقة مقص!\nاستخدم `rps rock/paper/scissors` للعب!")
-                else:
-                    await room.send(f"✂️ Rock Paper Scissors!\nUse `rps rock/paper/scissors` to play!")
-            elif game_id == "guess":
-                # Number guessing game
-                secret = random.randint(1, 10)
-                if lang == "ar":
-                    await room.send(f"🔢 خمن الرقم من 1 إلى 10!\nاستخدم `/guess <رقم>` للعب!")
-                else:
-                    await room.send(f"🔢 Guess a number from 1 to 10!\nUse `/guess <number>` to play!")
-            elif board_cog and game_id in {"chess", "checkers", "connect4", "othello"}:
-                fake_ctx = type("_Ctx", (), {"guild": guild, "channel": room, "author": interaction.user, "reply": room.send})
-                opponent = invitee
-                ok = await board_cog.start_game_session(fake_ctx, game_id, opponent)
-                if not ok:
-                    if lang == "ar":
-                        await room.send("⚠️ تعذر تشغيل اللعبة. اختر لعبة أخرى.")
-                    else:
-                        await room.send("⚠️ Could not initialize selected board game. Choose another one.")
-            else:
-                game_name = next((g["name"] for g in GAME_HUB_GAMES if g["id"] == game_id), game_id.title())
-                if lang == "ar":
-                    await room.send(f"🎮 **{game_name}** الغرفة جاهزة. العب الآن! {E_FIRE}")
-                else:
-                    await room.send(f"🎮 **{game_name}** room is ready. Play now! {E_FIRE}")
-        except Exception:
-            if lang == "ar":
-                await room.send("⚠️ تعذر تشغيل هذه اللعبة. جرب إنشاء غرفة أخرى.")
-            else:
-                await room.send("⚠️ Could not start this game. Try creating another room.")
-
-        if lang == "ar":
-            invite_text = (
-                f"🎮 **{game_id.title()}** الغرفة جاهزة!\n"
-                f"{panel_divider('purple')}\n"
-                f"👤 **المضيف:** {interaction.user.mention}"
-            )
-            close_text = "🔒 أغلق الغرفة عند الانتهاء 👇"
-        else:
-            invite_text = (
-                f"🎮 **{game_id.title()}** Room Ready!\n"
-                f"{panel_divider('purple')}\n"
-                f"👤 **Host:** {interaction.user.mention}"
-            )
-            close_text = "🔒 Close the room when done 👇"
-            
-        if invitee:
-            if lang == "ar":
-                invite_text += f"\n🎯 **مدعو:** {invitee.mention}"
-            else:
-                invite_text += f"\n🎯 **Invited:** {invitee.mention}"
-        invite_text += f"\n\n{close_text}"
-        await room.send(invite_text, view=RoomControlView(interaction.user.id))
-        
-        if lang == "ar":
-            response_msg = f"✅ تم إنشاء الغرفة: {room.mention} 🎮"
-            if invitee:
-                response_msg += f" | تمت دعوة {invitee.mention}"
-        else:
-            response_msg = f"✅ Room created: {room.mention} 🎮"
-            if invitee:
-                response_msg += f" | Invited {invitee.mention}"
-        await interaction.response.send_message(response_msg, ephemeral=True)
-
-
-class GameHubView(discord.ui.View):
-    def __init__(self, cog: "Fun", invitee_id: int | None = None, lang: str = "en") -> None:
-        super().__init__(timeout=None)
-        self.add_item(GameHubSelect(cog, invitee_id, lang))
-
-
-class RoomControlView(discord.ui.View):
-    def __init__(self, owner_id: int) -> None:
-        super().__init__(timeout=None)
-        self.owner_id = owner_id
-
-    @discord.ui.button(label="End Game & Close Room", style=discord.ButtonStyle.danger, emoji=ui("lock"), custom_id="room_close")
-    async def close_room(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not isinstance(interaction.channel, discord.TextChannel):
-            await interaction.response.send_message("Text channel only.", ephemeral=True)
-            return
-        if interaction.user.id != self.owner_id and not interaction.user.guild_permissions.manage_channels:
-            await interaction.response.send_message("❌ Only room owner or admins can close this room.", ephemeral=True)
-            return
-        await interaction.response.send_message("🔒 Closing room...", ephemeral=True)
-        try:
-            await interaction.channel.delete(reason=f"Game room closed by {interaction.user}")
-        except Exception:
-            pass
-
-    @discord.ui.button(label="Invite Friend", style=discord.ButtonStyle.success, emoji=ui("plus"), custom_id="room_invite")
-    async def invite_friend(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if interaction.user.id != self.owner_id:
-            await interaction.response.send_message("❌ Only room owner can invite.", ephemeral=True)
-            return
-        await interaction.response.send_message("➕ Use `/gamehub @user` to invite someone to a new game room!", ephemeral=True)
-
-
-class TicTacToeButton(discord.ui.Button["TicTacToeView"]):
-    def __init__(self, index: int) -> None:
-        super().__init__(label=" ", style=discord.ButtonStyle.secondary, row=index // 3)
-        self.index = index
-
-    async def callback(self, interaction: discord.Interaction) -> None:
-        if self.view:
-            await self.view.play(interaction, self.index)
-
-
-class TicTacToeView(discord.ui.View):
-    def __init__(self, player_x: discord.Member, player_o: discord.Member | None) -> None:
-        super().__init__(timeout=None)
-        self.player_x = player_x
-        self.player_o = player_o
-        self.turn_x = True
-        self.board = ["" for _ in range(9)]
-        for i in range(9):
-            self.add_item(TicTacToeButton(i))
-
-    def _check(self, mark: str) -> bool:
-        lines = [(0,1,2),(3,4,5),(6,7,8),(0,3,6),(1,4,7),(2,5,8),(0,4,8),(2,4,6)]
-        return any(self.board[a]==self.board[b]==self.board[c]==mark for a,b,c in lines)
-
-    def _free(self) -> list[int]:
-        return [i for i,v in enumerate(self.board) if not v]
-
-    async def _maybe_bot(self, message: discord.Message) -> None:
-        if self.player_o is not None or not self._free() or not self.turn_x:
-            return
-        move = random.choice(self._free())
-        self.board[move] = "O"
-        btn = self.children[move]
-        if isinstance(btn, discord.ui.Button):
-            btn.label = "O"
-            btn.style = discord.ButtonStyle.danger
-            btn.disabled = True
-        self.turn_x = True
-        if self._check("O"):
-            for child in self.children:
-                if isinstance(child, discord.ui.Button):
-                    child.disabled = True
-            await message.edit(content=f"🤖 Bot won TicTacToe! {E_BOOM}", view=self)
-            return
-        if not self._free():
-            await message.edit(content="🤝 TicTacToe draw!", view=self)
-            return
-        await message.edit(content=f"❎ Turn: {self.player_x.mention}", view=self)
-
-    async def play(self, interaction: discord.Interaction, index: int) -> None:
-        if self.board[index]:
-            await interaction.response.send_message("This cell is already used.", ephemeral=True)
-            return
-        current = self.player_x if self.turn_x else self.player_o
-        if self.turn_x and interaction.user.id != self.player_x.id:
-            await interaction.response.send_message("It is X player's turn.", ephemeral=True)
-            return
-        if not self.turn_x and self.player_o and interaction.user.id != self.player_o.id:
-            await interaction.response.send_message("It is O player's turn.", ephemeral=True)
-            return
-        mark = "X" if self.turn_x else "O"
-        self.board[index] = mark
-        btn = self.children[index]
-        if isinstance(btn, discord.ui.Button):
-            btn.label = mark
-            btn.style = discord.ButtonStyle.success if mark == "X" else discord.ButtonStyle.danger
-            btn.disabled = True
-
-        if self._check(mark):
-            for child in self.children:
-                if isinstance(child, discord.ui.Button):
-                    child.disabled = True
-            winner = interaction.user.mention if self.player_o else (self.player_x.mention if mark == "X" else "🤖 Bot")
-            await interaction.response.edit_message(content=f"🏆 TicTacToe Winner: {winner}! {E_TROPHY}", view=self)
-            return
-
-        if not self._free():
-            await interaction.response.edit_message(content="🤝 TicTacToe draw!", view=self)
-            return
-
-        self.turn_x = not self.turn_x
-        nxt = self.player_x.mention if self.turn_x else (self.player_o.mention if self.player_o else "🤖 Bot")
-        await interaction.response.edit_message(content=f"🎮 Turn: {nxt}", view=self)
-        if not self.turn_x and self.player_o is None and interaction.message:
-            await self._maybe_bot(interaction.message)
-
-
-class Fun(commands.Cog):
-    """Games and entertainment 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(GameHubView(self))
-
-    async def _fetch_trivia_api(self) -> dict[str, object] | None:
-        url = "https://opentdb.com/api.php?amount=50"
-        async with aiohttp.ClientSession() as session:
-            async with session.get(url, timeout=15) as response:
-                data = await response.json(content_type=None)
-        results = data.get("results") if isinstance(data, dict) else None
-        if not isinstance(results, list) or not results:
-            return None
-        item = random.choice(results)
-        question = html.unescape(str(item.get("question", "")).strip())
-        correct = html.unescape(str(item.get("correct_answer", "")).strip())
-        wrong = [html.unescape(str(c).strip()) for c in item.get("incorrect_answers", []) if str(c).strip()]
-        if not question or not correct or not wrong:
-            return None
-        choices = wrong[:]
-        choices.append(correct)
-        random.shuffle(choices)
-        answer_index = choices.index(correct)
-        return {"q": question, "c": choices[:4], "a": answer_index}
-
-    @commands.hybrid_command(name="8ball")
-    async def eightball(self, ctx: commands.Context, *, question: str) -> None:
-        guild_id = ctx.guild.id if ctx.guild else None
-        lang = await self.bot.get_guild_language(guild_id)
-        
-        if lang == "ar":
-            answers = [
-                "نعم! ✅", "لا ❌", "ربما 🤔", "بالتأكيد! 💯", 
-                "ليس الآن ⏰", "اسأل لاحقاً 🔮", "100% نعم! 🔥", "غير واضح 🌫️"
-            ]
-            embed = discord.Embed(
-                title="🎱 الكرة السحرية",
-                description=(
-                    f"{panel_divider('pink')}\n"
-                    f"❓ **السؤال:** {question}\n"
-                    f"🎱 **الجواب:** {random.choice(answers)}\n"
-                    f"{panel_divider('pink')}"
-                ),
-                color=NEON_PINK,
-            )
-        else:
-            answers = [
-                "Yes! ✅", "No ❌", "Maybe 🤔", "Definitely! 💯", 
-                "Not now ⏰", "Ask later 🔮", "100% Yes! 🔥", "Unclear 🌫️"
-            ]
-            embed = discord.Embed(
-                title="🎱 Magic 8 Ball",
-                description=(
-                    f"{panel_divider('pink')}\n"
-                    f"❓ **Question:** {question}\n"
-                    f"🎱 **Answer:** {random.choice(answers)}\n"
-                    f"{panel_divider('pink')}"
-                ),
-                color=NEON_PINK,
-            )
-        await ctx.reply(embed=embed)
-
-    @commands.hybrid_command(name="meme")
-    async def meme(self, ctx: commands.Context) -> None:
-        guild_id = ctx.guild.id if ctx.guild else None
-        lang = await self.bot.get_guild_language(guild_id)
-        
-        url = "https://meme-api.com/gimme"
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(url, timeout=10) as response:
-                    data = await response.json()
-        except Exception:
-            if lang == "ar":
-                await ctx.reply("⚠️ تعذر تحميل الميم الآن. جرب مرة أخرى! 🔄")
-            else:
-                await ctx.reply("⚠️ Could not load meme right now. Try again in a minute! 🔄")
-            return
-
-        embed = discord.Embed(
-            title=f"😂 {data.get('title', 'Random Meme')}",
-            color=NEON_CYAN, 
-            url=data.get("postLink")
-        )
-        if data.get("url"):
-            embed.set_image(url=data["url"])
-        embed.set_footer(text=f"👍 {data.get('ups', 0)} | r/{data.get('subreddit', 'meme')}")
-        await ctx.reply(embed=embed)
-
-    @commands.hybrid_command(name="trivia", description="Gaming/Movies/Series trivia | تراڤيا", hidden=True, with_app_command=False)
-    async def trivia(self, ctx: commands.Context, category: str = "", source: str = "local") -> None:
-        guild_id = ctx.guild.id if ctx.guild else None
-        lang = await self.bot.get_guild_language(guild_id)
-
-        normalized_source = source.strip().lower() or "local"
-        if normalized_source not in {"local", "api"}:
-            if lang == "ar":
-                await ctx.reply("❌ المصدر يجب أن يكون `local` أو `api`")
-            else:
-                await ctx.reply("❌ Source must be `local` or `api`")
-            return
-
-        normalized = category.strip().lower()
-        item: dict[str, object] | None = None
-        if lang == "ar":
-            topic_text = "الألعاب • الأفلام • المسلسلات"
-        else:
-            topic_text = "Gaming • Movies • Series"
-
-        if normalized_source == "api":
-            try:
-                item = await self._fetch_trivia_api()
-                topic_text = "OpenTDB (50 questions pool)"
-            except Exception:
-                item = None
-
-        if item is None:
-            aliases = {
-                "gaming": "gaming", "games": "gaming", "game": "gaming", "قيمز": "gaming", "العاب": "gaming",
-                "movies": "movies", "movie": "movies", "افلام": "movies", "أفلام": "movies",
-                "series": "series", "show": "series", "shows": "series", "مسلسلات": "series",
-            }
-            normalized = aliases.get(normalized, normalized) if normalized else random.choice(["gaming", "movies", "series"])
-            if normalized not in {"gaming", "movies", "series"}:
-                if lang == "ar":
-                    await ctx.reply("❌ قسم غير مدعوم. استخدم: gaming أو movies أو series")
-                else:
-                    await ctx.reply("❌ Unsupported category. Use: gaming, movies, or series")
-                return
-            
-            # Get trivia from appropriate language bank
-            trivia_bank = TRIVIA_BANK.get(lang, TRIVIA_BANK["en"])
-            if normalized not in trivia_bank:
-                trivia_bank = TRIVIA_BANK["en"]
-            item = random.choice(trivia_bank[normalized])
-
-        view = TriviaView(owner_id=ctx.author.id, correct_index=int(item["a"]), lang=lang, cog=self, guild_id=guild_id)
-        for idx, choice in enumerate(item["c"]):
-            view.add_item(TriviaAnswerButton(str(choice), idx))
-
-        if lang == "ar":
-            title = "🧠 سؤال تراڤيا!"
-            cat_label = "📁 القسم"
-            topics_label = "📚 المواضيع"
-        else:
-            title = "🧠 Trivia Time!"
-            cat_label = "📁 Category"
-            topics_label = "📚 Topics"
-            
-        embed = discord.Embed(
-            title=title,
-            description=f"{panel_divider('blue')}\n❓ {str(item['q'])}\n{panel_divider('blue')}",
-            color=NEON_CYAN,
-        )
-        cat_value = normalized.title() if normalized else ("General" if normalized_source == "api" else "Random")
-        embed.add_field(name=cat_label, value=cat_value, inline=True)
-        embed.add_field(name=topics_label, value=topic_text, inline=True)
-        await ctx.reply(embed=embed, view=view)
-
-    async def _fetch_gaming_news(self) -> list[dict[str, str]]:
-        return await fetch_gaming_news()
-
-    async def _fetch_free_games(self) -> list[dict[str, str]]:
-        return await fetch_free_games()
-
-    @staticmethod
-    def _store_icon(platform: str) -> str:
-        return store_icon(platform)
-
-    def _free_game_embed(self, item: dict[str, str]) -> tuple[discord.Embed, discord.ui.View]:
-        title = item["title"][:120]
-        link = item["link"]
-        embed = ImperialMotaz.craft_embed(
-            title=f"[FREE GAME] | {title}",
-            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", "")))
-        return embed, FreeGameClaimView(link)
-
-    @commands.hybrid_command(name="gaming_news", description="Latest gaming news worldwide | آخر أخبار الألعاب")
-    async def gaming_news(self, ctx: commands.Context) -> None:
-        guild_id = ctx.guild.id if ctx.guild else None
-        lang = await self.bot.get_guild_language(guild_id)
-        
-        try:
-            items = await self._fetch_gaming_news()
-        except Exception:
-            if lang == "ar":
-                await ctx.reply("❌ تعذر جلب أخبار الألعاب الآن.")
-            else:
-                await ctx.reply("❌ Could not fetch gaming news right now.")
-            return
-
-        if not items:
-            if lang == "ar":
-                await ctx.reply("لا توجد أخبار متاحة الآن.")
-            else:
-                await ctx.reply("No gaming news available right now.")
-            return
-
-        if lang == "ar":
-            title = "🕹️ آخر أخبار الألعاب عالميًا"
-        else:
-            title = "🕹️ Latest Gaming News Worldwide"
-            
-        embed = discord.Embed(
-            title=title,
-            description=f"{panel_divider('green')}",
-            color=NEON_CYAN,
-        )
-        for item in items:
-            date_hint = f"\n🗓️ {item['pub_date'][:16]}" if item.get("pub_date") else ""
-            if lang == "ar":
-                embed.add_field(name=item["title"][:256], value=f"📰 [اقرأ المقال]({item['link']}){date_hint}", inline=False)
-            else:
-                embed.add_field(name=item["title"][:256], value=f"📰 [Read Article]({item['link']}){date_hint}", inline=False)
-        await ctx.reply(embed=embed)
-
-    @commands.hybrid_command(name="freegames", description="List active free games on Epic/Steam/GOG", with_app_command=False)
-    async def freegames(self, ctx: commands.Context) -> None:
-        guild_id = ctx.guild.id if ctx.guild else None
-        lang = await self.bot.get_guild_language(guild_id)
-        
-        try:
-            items = await self._fetch_free_games()
-        except Exception:
-            if lang == "ar":
-                await ctx.reply("❌ تعذر جلب العروض الآن.")
-            else:
-                await ctx.reply("❌ Could not fetch free game offers right now.")
-            return
-
-        if not items:
-            if lang == "ar":
-                await ctx.reply("لا توجد عروض مجانية نشطة الآن.")
-            else:
-                await ctx.reply("No active free game offers right now.")
-            return
-
-        for item in items:
-            embed, view = self._free_game_embed(item)
-            await ctx.reply(embed=embed, view=view)
-
-    @commands.hybrid_command(name="free_games", description="Temporary free game offers | عروض الألعاب المجانية")
-    async def free_games(self, ctx: commands.Context) -> None:
-        await self.freegames(ctx)
-
-    @commands.hybrid_group(name="gamehub", fallback="panel", description="Interactive game hub with temporary private rooms")
-    async def gamehub(self, ctx: commands.Context, invite: discord.Member | None = None) -> None:
-        if not ctx.guild:
-            await ctx.reply("Server only.")
-            return
-        
-        guild_id = ctx.guild.id
-        lang = await self.bot.get_guild_language(guild_id)
-        
-        if invite and invite.bot:
-            if lang == "ar":
-                await ctx.reply("❌ ادعُ عضواً حقيقياً، ليس بوت.")
-            else:
-                await ctx.reply("❌ Invite a real member, not a bot.")
-            return
-        if invite and invite.id == ctx.author.id:
-            if lang == "ar":
-                await ctx.reply("❌ ادعُ عضواً آخر.")
-            else:
-                await ctx.reply("❌ Invite another member.")
-            return
-
-        games_list = " • ".join([f"{g['emoji']} {g['name']}" for g in GAME_HUB_GAMES])
-        
-        if lang == "ar":
-            title = "🎮 مركز الألعاب"
-            desc = (
-                f"{panel_divider('pink')}\n"
-                f"🕹️ اختر لعبة أدناه لإنشاء **غرفة خاصة**.\n"
-                f"👥 ادعُ صديقاً أو العب ضد البوت.\n"
-                f"🗑️ الغرفة تُحذف تلقائياً عند إغلاقها.\n"
-                f"{panel_divider('pink')}\n\n"
-                f"**الألعاب:** {games_list}"
-            )
-            invited_label = "🎯 العضو المدعو"
-        else:
-            title = "🎮 Game Hub"
-            desc = (
-                f"{panel_divider('pink')}\n"
-                f"🕹️ Select a game below to create a **private room**.\n"
-                f"👥 Invite a friend or play solo vs the bot.\n"
-                f"🗑️ The room auto-deletes when you close it.\n"
-                f"{panel_divider('pink')}\n\n"
-                f"**Games:** {games_list}"
-            )
-            invited_label = "🎯 Invited Member"
-            
-        embed = discord.Embed(
-            title=title,
-            description=desc,
-            color=NEON_CYAN,
-        )
-        if invite:
-            embed.add_field(name=invited_label, value=invite.mention, inline=False)
-        await ctx.reply(embed=embed, view=GameHubView(self, invite.id if invite else None, lang))
-
-    @gamehub.command(name="xo", description="TicTacToe vs member or bot")
-    async def gamehub_xo(self, ctx: commands.Context, opponent: discord.Member | None = None) -> None:
-        await self.xo(ctx, opponent=opponent)
-
-    @gamehub.command(name="mario", description="Mario/Pac-Man arcade challenge")
-    async def gamehub_mario(self, ctx: commands.Context) -> None:
-        await self.mario(ctx)
-
-    @gamehub.command(name="dice", description="Roll dice")
-    async def gamehub_dice(self, ctx: commands.Context, sides: int = 6) -> None:
-        await self.dice(ctx, sides=sides)
-
-    @gamehub.command(name="slots", description="Slot machine game")
-    async def gamehub_slots(self, ctx: commands.Context, bet: int = 50) -> None:
-        await self.slots(ctx, bet=bet)
-
-    @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)
-
-    @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:
-        guild_id = ctx.guild.id if ctx.guild else None
-        lang = await self.bot.get_guild_language(guild_id)
-        
-        if opponent and opponent.bot:
-            opponent = None
-        view = TicTacToeView(ctx.author, opponent)
-        second = opponent.mention if opponent else "🤖 Bot"
-        
-        if lang == "ar":
-            msg = await ctx.reply(
-                f"❎ تيك تاك تو: {ctx.author.mention} (X) ضد {second} (O)\n"
-                f"🎮 الدور: {ctx.author.mention}", 
-                view=view
-            )
-        else:
-            msg = await ctx.reply(
-                f"❎ TicTacToe: {ctx.author.mention} (X) vs {second} (O)\n"
-                f"🎮 Turn: {ctx.author.mention}", 
-                view=view
-            )
-        if opponent is None:
-            await view._maybe_bot(msg)
-
-    @commands.hybrid_command(name="choose", hidden=True, with_app_command=False)
-    async def choose(self, ctx: commands.Context, *, options: str) -> None:
-        guild_id = ctx.guild.id if ctx.guild else None
-        lang = await self.bot.get_guild_language(guild_id)
-        
-        parts = [p.strip() for p in options.split(",") if p.strip()]
-        if len(parts) < 2:
-            if lang == "ar":
-                await ctx.reply("❌ أدخل خيارين على الأقل مفصولين بفواصل.")
-            else:
-                await ctx.reply("❌ Provide at least 2 options separated by commas.")
-            return
-            
-        choice = random.choice(parts)
-        
-        if lang == "ar":
-            embed = discord.Embed(
-                title="🎲 اختيار عشوائي",
-                description=(
-                    f"{panel_divider('purple')}\n"
-                    f"📝 الخيارات: {', '.join(parts)}\n"
-                    f"🎯 **المختار:** {choice}\n"
-                    f"{panel_divider('purple')}"
-                ),
-                color=NEON_PINK,
-            )
-        else:
-            embed = discord.Embed(
-                title="🎲 Random Choice",
-                description=(
-                    f"{panel_divider('purple')}\n"
-                    f"📝 Options: {', '.join(parts)}\n"
-                    f"🎯 **Selected:** {choice}\n"
-                    f"{panel_divider('purple')}"
-                ),
-                color=NEON_PINK,
-            )
-        await ctx.reply(embed=embed)
-
-    @commands.hybrid_command(name="mario", description="Mario/Pac-Man arcade challenge", hidden=True, with_app_command=False)
-    async def mario(self, ctx: commands.Context) -> None:
-        guild_id = ctx.guild.id if ctx.guild else None
-        lang = await self.bot.get_guild_language(guild_id)
-        
-        coins = random.randint(5, 120)
-        level = random.randint(1, 8)
-        
-        if lang == "ar":
-            embed = discord.Embed(
-                title="🍄 تحدي الآركيد",
-                description=(
-                    f"{panel_divider('orange')}\n"
-                    f"🍄 {ctx.author.mention} جمع **{coins}** عملة!\n"
-                    f"✅ تجاوز المرحلة **{level}**!\n"
-                    f"{panel_divider('orange')}"
-                ),
-                color=NEON_ORANGE,
-            )
-            embed.add_field(name="🎁 مكافأة", value="تم فتح combo باك مان! <:animatedarrowyellow:1477261257592668271>", inline=False)
-        else:
-            embed = discord.Embed(
-                title="🍄 Arcade Challenge",
-                description=(
-                    f"{panel_divider('orange')}\n"
-                    f"🍄 {ctx.author.mention} collected **{coins}** coins!\n"
-                    f"✅ Cleared level **{level}**!\n"
-                    f"{panel_divider('orange')}"
-                ),
-                color=NEON_ORANGE,
-            )
-            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)
-
-    @commands.hybrid_command(name="dice", description="Roll dice", hidden=True, with_app_command=False)
-    async def dice(self, ctx: commands.Context, sides: int = 6) -> None:
-        """Roll a dice with specified sides."""
-        guild_id = ctx.guild.id if ctx.guild else None
-        lang = await self.bot.get_guild_language(guild_id)
-        
-        sides = max(2, min(sides, 100))
-        result = random.randint(1, sides)
-        
-        if lang == "ar":
-            embed = gaming_embed(
-                "🎲 رمي النرد",
-                f"🎲 رميت نرد بـ **{sides}** أوجه\n🎯 النتيجة: **{result}**"
-            )
-        else:
-            embed = gaming_embed(
-                "🎲 Dice Roll",
-                f"🎲 Rolled a **{sides}**-sided dice\n🎯 Result: **{result}**"
-            )
-        await ctx.reply(embed=embed)
-
-    @commands.hybrid_command(name="slots", description="Slot machine game", hidden=True, with_app_command=False)
-    async def slots(self, ctx: commands.Context, bet: int = 10) -> None:
-        """Play a slot machine game."""
-        guild_id = ctx.guild.id if ctx.guild else None
-        lang = await self.bot.get_guild_language(guild_id)
-        
-        bet = max(10, bet)
-        
-        # Check balance
-        row = await self.bot.db.fetchone(
-            "SELECT wallet FROM user_balance WHERE guild_id = ? AND user_id = ?",
-            guild_id,
-            ctx.author.id,
-        )
-        wallet = row[0] if row else 0
-        
-        if wallet < bet:
-            if lang == "ar":
-                await ctx.reply(f"❌ ليس لديك رصيد كافي. محفظتك: **{wallet}** عملة")
-            else:
-                await ctx.reply(f"❌ Insufficient balance. Your wallet: **{wallet}** coins")
-            return
-        
-        # Slot symbols
-        symbols = ["🍒", "🍋", "🍊", "🍇", "✅", "💎", "7️⃣"]
-        weights = [25, 20, 18, 15, 12, 7, 3]  # Weighted probabilities
-        
-        # Spin
-        results = random.choices(symbols, weights=weights, k=3)
-        
-        # Calculate winnings
-        if results[0] == results[1] == results[2]:
-            # Jackpot!
-            if results[0] == "7️⃣":
-                multiplier = 10
-            elif results[0] == "💎":
-                multiplier = 7
-            elif results[0] == "✅":
-                multiplier = 5
-            else:
-                multiplier = 3
-            winnings = bet * multiplier
-        elif results[0] == results[1] or results[1] == results[2] or results[0] == results[2]:
-            winnings = bet * 2
-        else:
-            winnings = 0
-        
-        # Update balance
-        if winnings > 0:
-            await self._add_coins(guild_id, ctx.author.id, winnings - bet)
-        else:
-            await self._add_coins(guild_id, ctx.author.id, -bet)
-        
-        # Build display
-        slot_display = " | ".join(results)
-        
-        if winnings >= bet * 5:
-            result_text = f"🎰 **{'جائزة كبرى!' if lang == 'ar' else 'JACKPOT!'}** {E_FIRE}"
-        elif winnings > 0:
-            result_text = f"✅ **{'فزت!' if lang == 'ar' else 'You won!'}**"
-        else:
-            result_text = f"❌ **{'حظ أوفر' if lang == 'ar' else 'Better luck next time'}**"
-        
-        if lang == "ar":
-            embed = gaming_embed(
-                "🎰 ماكينة القمار",
-                f"┌───────┐\n│ {slot_display} │\n└───────┘\n\n{result_text}\n💰 **الرابح:** {winnings} عملة"
-            )
-        else:
-            embed = gaming_embed(
-                "🎰 Slot Machine",
-                f"┌───────┐\n│ {slot_display} │\n└───────┘\n\n{result_text}\n💰 **Won:** {winnings} coins"
-            )
-        await ctx.reply(embed=embed)
-    
-    async def _add_coins(self, guild_id: int, user_id: int, amount: int) -> None:
-        """Helper to add/remove coins from user balance."""
-        if amount == 0:
-            return
-        await self.bot.db.execute(
-            "INSERT INTO user_balance(guild_id, user_id, wallet, bank) VALUES (?, ?, ?, 0) "
-            "ON CONFLICT(guild_id, user_id) DO UPDATE SET wallet = wallet + ?",
-            guild_id,
-            user_id,
-            amount if amount > 0 else 0,
-            amount,
-        )
-
-
-async def setup(bot: commands.Bot) -> None:
-    await bot.add_cog(Fun(bot))
+"""
+Fun cog: Games, trivia, memes, and entertainment commands.
+Enhanced with rich emoji decorations, beautiful formatting, and multi-language support.
+"""
+
+import html
+import random
+
+import aiohttp
+import discord
+from discord.ext import commands
+
+from bot.cogs.ai_suite import ImperialMotaz
+from bot.theme import (
+    fancy_header, NEON_CYAN, NEON_PINK, NEON_PURPLE, NEON_LIME, NEON_ORANGE, NEON_BLUE,
+    panel_divider, gaming_embed, success_embed, error_embed, info_embed,
+    double_line, triple_line, shimmer, pick_neon_color
+)
+from bot.i18n import get_cmd_desc
+from bot.emojis import (
+    ui, E_GAMEHUB, E_ARROW_PINK, E_ARROW_GREEN, E_ARROW_PURPLE, E_STAR,
+    E_TROPHY, E_FIRE, E_SPARKLE, E_DIZZY, E_BOOM, E_ZAP, E_DIAMOND, E_CROWN, E_GEM
+)
+from bot.utils.shared import fetch_gaming_news, fetch_free_games, store_icon, FreeGameClaimView
+
+
+TRIVIA_BANK: dict[str, dict[str, list[dict[str, object]]]] = {
+    "en": {
+        "gaming": [
+            {"q": "Which studio created The Witcher 3?", "c": ["CD Projekt Red", "Rockstar", "Ubisoft", "Bethesda"], "a": 0},
+            {"q": "What is the default block in Minecraft?", "c": ["Stone", "Dirt", "Grass Block", "Sand"], "a": 2},
+            {"q": "In which game would you find Master Chief?", "c": ["Halo", "Destiny", "Call of Duty", "Gears of War"], "a": 0},
+            {"q": "What year was Fortnite released?", "c": ["2015", "2017", "2018", "2019"], "a": 1},
+            {"q": "Which company makes the PlayStation?", "c": ["Microsoft", "Nintendo", "Sony", "Sega"], "a": 2},
+        ],
+        "movies": [
+            {"q": "Who directed Inception?", "c": ["Christopher Nolan", "James Cameron", "Denis Villeneuve", "Ridley Scott"], "a": 0},
+            {"q": "In the MCU, who is Peter Parker?", "c": ["Iron Man", "Spider-Man", "Doctor Strange", "Hawkeye"], "a": 1},
+            {"q": "What is the highest-grossing film of all time?", "c": ["Avengers: Endgame", "Avatar", "Titanic", "Star Wars"], "a": 1},
+            {"q": "Who played the Joker in The Dark Knight?", "c": ["Joaquin Phoenix", "Jack Nicholson", "Heath Ledger", "Jared Leto"], "a": 2},
+        ],
+        "series": [
+            {"q": "Which series features Walter White?", "c": ["Narcos", "Breaking Bad", "Dark", "Sherlock"], "a": 1},
+            {"q": "In Game of Thrones, what is Jon Snow's house at first?", "c": ["Lannister", "Baratheon", "Stark", "Targaryen"], "a": 2},
+            {"q": "What is the name of the coffee shop in Friends?", "c": ["Central Park", "Central Perk", "Coffee House", "The Brew"], "a": 1},
+            {"q": "How many seasons does Stranger Things have?", "c": ["3", "4", "5", "6"], "a": 2},
+        ],
+    },
+    "ar": {
+        "gaming": [
+            {"q": "أي شركة طورت لعبة The Witcher 3؟", "c": ["CD Projekt Red", "Rockstar", "Ubisoft", "Bethesda"], "a": 0},
+            {"q": "ما هو البلوك الافتراضي في Minecraft؟", "c": ["Stone", "Dirt", "Grass Block", "Sand"], "a": 2},
+            {"q": "في أي لعبة تجد Master Chief؟", "c": ["Halo", "Destiny", "Call of Duty", "Gears of War"], "a": 0},
+            {"q": "متى صدرت Fortnite؟", "c": ["2015", "2017", "2018", "2019"], "a": 1},
+        ],
+        "movies": [
+            {"q": "من مخرج فيلم Inception؟", "c": ["كريستوفر نولان", "جيمس كاميرون", "دينيس فيلنوف", "ريدلي سكوت"], "a": 0},
+            {"q": "في عالم مارفل، بيتر باركر هو؟", "c": ["Iron Man", "Spider-Man", "Doctor Strange", "Hawkeye"], "a": 1},
+            {"q": "ما هو أعلى فيلم إيرادات في التاريخ؟", "c": ["Avengers: Endgame", "Avatar", "Titanic", "Star Wars"], "a": 1},
+        ],
+        "series": [
+            {"q": "أي مسلسل يظهر فيه Walter White؟", "c": ["Narcos", "Breaking Bad", "Dark", "Sherlock"], "a": 1},
+            {"q": "في Game of Thrones، جون سنو كان ضمن أي بيت بالبداية؟", "c": ["Lannister", "Baratheon", "Stark", "Targaryen"], "a": 2},
+        ],
+    },
+}
+
+
+class TriviaAnswerButton(discord.ui.Button["TriviaView"]):
+    def __init__(self, label: str, index: int) -> None:
+        super().__init__(label=label[:80], style=discord.ButtonStyle.secondary)
+        self.index = index
+
+    async def callback(self, interaction: discord.Interaction) -> None:
+        await self.view.on_answer(interaction, self.index)
+
+
+class FreeGameClaimView(discord.ui.View):
+    def __init__(self, url: str) -> None:
+        super().__init__(timeout=None)
+        self.add_item(
+            discord.ui.Button(
+                label=f"{ui('gift')} Claim Your Prize {ui('gift')}",
+                style=discord.ButtonStyle.link,
+                url=url,
+            )
+        )
+
+
+class TriviaView(discord.ui.View):
+    def __init__(self, owner_id: int, correct_index: int, lang: str, cog: "Fun", guild_id: int | None) -> None:
+        super().__init__(timeout=None)
+        self.owner_id = owner_id
+        self.correct_index = correct_index
+        self.lang = lang
+        self.answered = False
+        self.cog = cog
+        self.guild_id = guild_id
+
+    async def on_answer(self, interaction: discord.Interaction, picked_index: int) -> None:
+        if interaction.user.id != self.owner_id:
+            msg = "❌ هذا السؤال لصاحب الأمر فقط." if self.lang == "ar" else "❌ This question is for the command author only."
+            await interaction.response.send_message(msg, ephemeral=True)
+            return
+        if self.answered:
+            msg = "⚠️ تمت الإجابة بالفعل." if self.lang == "ar" else "⚠️ Already answered."
+            await interaction.response.send_message(msg, ephemeral=True)
+            return
+
+        self.answered = True
+        is_correct = picked_index == self.correct_index
+        for idx, child in enumerate(self.children):
+            if isinstance(child, discord.ui.Button):
+                child.disabled = True
+                if idx == self.correct_index:
+                    child.style = discord.ButtonStyle.success
+                elif idx == picked_index and not is_correct:
+                    child.style = discord.ButtonStyle.danger
+
+        if is_correct:
+            msg = f"✅ إجابة صحيحة! {E_STAR}" if self.lang == "ar" else f"✅ Correct answer! {E_STAR}"
+        else:
+            msg = "❌ إجابة خاطئة." if self.lang == "ar" else "❌ Wrong answer."
+
+        await interaction.response.edit_message(view=self)
+        if is_correct and interaction.guild and self.guild_id:
+            reward = random.randint(20, 45)
+            await self.cog.bot.db.execute(
+                "INSERT INTO user_balance(guild_id, user_id, wallet, bank) VALUES (?, ?, ?, 0) "
+                "ON CONFLICT(guild_id, user_id) DO UPDATE SET wallet = wallet + excluded.wallet",
+                self.guild_id,
+                interaction.user.id,
+                reward,
+            )
+            if self.lang == "ar":
+                msg += f" 💰 **+{reward}** عملة!"
+            else:
+                msg += f" 💰 **+{reward}** coins!"
+        await interaction.followup.send(msg, ephemeral=True)
+
+
+GAME_HUB_GAMES = [
+    {"id": "chess", "name": "Chess", "emoji": "♟️", "description": "Strategic board game"},
+    {"id": "checkers", "name": "Checkers", "emoji": "🔴", "description": "Classic draughts game"},
+    {"id": "connect4", "name": "Connect 4", "emoji": "🔴", "description": "Drop and connect"},
+    {"id": "othello", "name": "Othello", "emoji": "⚪", "description": "Reversi strategy"},
+    {"id": "tictactoe", "name": "TicTacToe", "emoji": "❎", "description": "X and O battle"},
+    {"id": "rps", "name": "Rock Paper Scissors", "emoji": "✂️", "description": "Quick decision game"},
+    {"id": "trivia", "name": "Trivia Challenge", "emoji": "🧠", "description": "Knowledge contest"},
+    {"id": "guess", "name": "Number Guess", "emoji": "🔢", "description": "Guess 1-10"},
+]
+
+
+class GameHubSelect(discord.ui.Select):
+    def __init__(self, cog: "Fun", invitee_id: int | None, lang: str = "en") -> None:
+        self.cog = cog
+        self.invitee_id = invitee_id
+        self.lang = lang
+        
+        options = []
+        for game in GAME_HUB_GAMES:
+            if lang == "ar":
+                desc = game["description"]
+            else:
+                desc = game["description"]
+            options.append(
+                discord.SelectOption(
+                    label=game["name"],
+                    value=game["id"],
+                    description=desc,
+                    emoji=game["emoji"]
+                )
+            )
+        super().__init__(
+            placeholder="🎮 Choose a game",
+            min_values=1,
+            max_values=1,
+            options=options,
+            custom_id="gamehub_select",
+        )
+
+    async def callback(self, interaction: discord.Interaction) -> None:
+        if not interaction.guild:
+            await interaction.response.send_message("Server only.", ephemeral=True)
+            return
+        
+        guild = interaction.guild
+        game_id = self.values[0]
+        invitee = guild.get_member(self.invitee_id) if self.invitee_id else None
+        guild_id = guild.id
+        lang = await self.cog.bot.get_guild_language(guild_id)
+
+        category = discord.utils.get(guild.categories, name="🕹️ Game Rooms")
+        if category is None:
+            category = await guild.create_category("🕹️ Game Rooms", reason="GameHub temporary rooms")
+
+        overwrites = {
+            guild.default_role: discord.PermissionOverwrite(view_channel=False),
+            interaction.user: discord.PermissionOverwrite(view_channel=True, send_messages=True, read_message_history=True),
+        }
+        if invitee:
+            overwrites[invitee] = discord.PermissionOverwrite(view_channel=True, send_messages=True, read_message_history=True)
+        if guild.me:
+            overwrites[guild.me] = discord.PermissionOverwrite(view_channel=True, send_messages=True, manage_channels=True)
+
+        room = await guild.create_text_channel(
+            name=f"game-{game_id}-{interaction.user.name[:8].lower()}",
+            category=category,
+            overwrites=overwrites,
+            reason=f"GameHub room for {interaction.user}",
+        )
+
+        board_cog = self.cog.bot.get_cog("BoardGames")
+        try:
+            if game_id == "tictactoe":
+                view = TicTacToeView(interaction.user, invitee)
+                first = interaction.user.mention
+                second = invitee.mention if invitee else "🤖 Bot"
+                if lang == "ar":
+                    msg = await room.send(f"❎ تيك تاك تو: {first} (X) ضد {second} (O)\n🎮 الدور: {interaction.user.mention}", view=view)
+                else:
+                    msg = await room.send(f"❎ TicTacToe: {first} (X) vs {second} (O)\n🎮 Turn: {interaction.user.mention}", view=view)
+                if invitee is None:
+                    await view._maybe_bot(msg)
+            elif game_id == "trivia":
+                # Start trivia game
+                item = random.choice(TRIVIA_BANK.get(lang, TRIVIA_BANK["en"])["gaming"])
+                view = TriviaView(owner_id=interaction.user.id, correct_index=int(item["a"]), lang=lang, cog=self.cog, guild_id=guild_id)
+                for idx, choice in enumerate(item["c"]):
+                    view.add_item(TriviaAnswerButton(str(choice), idx))
+                
+                if lang == "ar":
+                    q_title = "🧠 سؤال تراڤيا!"
+                else:
+                    q_title = "🧠 Trivia Time!"
+                    
+                embed = discord.Embed(
+                    title=q_title,
+                    description=f"{panel_divider('blue')}\n❓ {str(item['q'])}\n{panel_divider('blue')}",
+                    color=NEON_CYAN,
+                )
+                await room.send(embed=embed, view=view)
+            elif game_id == "rps":
+                # RPS game in channel
+                if lang == "ar":
+                    await room.send(f"✂️ حجر ورقة مقص!\nاستخدم `rps rock/paper/scissors` للعب!")
+                else:
+                    await room.send(f"✂️ Rock Paper Scissors!\nUse `rps rock/paper/scissors` to play!")
+            elif game_id == "guess":
+                # Number guessing game
+                secret = random.randint(1, 10)
+                if lang == "ar":
+                    await room.send(f"🔢 خمن الرقم من 1 إلى 10!\nاستخدم `/guess <رقم>` للعب!")
+                else:
+                    await room.send(f"🔢 Guess a number from 1 to 10!\nUse `/guess <number>` to play!")
+            elif board_cog and game_id in {"chess", "checkers", "connect4", "othello"}:
+                fake_ctx = type("_Ctx", (), {"guild": guild, "channel": room, "author": interaction.user, "reply": room.send})
+                opponent = invitee
+                ok = await board_cog.start_game_session(fake_ctx, game_id, opponent)
+                if not ok:
+                    if lang == "ar":
+                        await room.send("⚠️ تعذر تشغيل اللعبة. اختر لعبة أخرى.")
+                    else:
+                        await room.send("⚠️ Could not initialize selected board game. Choose another one.")
+            else:
+                game_name = next((g["name"] for g in GAME_HUB_GAMES if g["id"] == game_id), game_id.title())
+                if lang == "ar":
+                    await room.send(f"🎮 **{game_name}** الغرفة جاهزة. العب الآن! {E_FIRE}")
+                else:
+                    await room.send(f"🎮 **{game_name}** room is ready. Play now! {E_FIRE}")
+        except Exception:
+            if lang == "ar":
+                await room.send("⚠️ تعذر تشغيل هذه اللعبة. جرب إنشاء غرفة أخرى.")
+            else:
+                await room.send("⚠️ Could not start this game. Try creating another room.")
+
+        if lang == "ar":
+            invite_text = (
+                f"🎮 **{game_id.title()}** الغرفة جاهزة!\n"
+                f"{panel_divider('purple')}\n"
+                f"👤 **المضيف:** {interaction.user.mention}"
+            )
+            close_text = "🔒 أغلق الغرفة عند الانتهاء 👇"
+        else:
+            invite_text = (
+                f"🎮 **{game_id.title()}** Room Ready!\n"
+                f"{panel_divider('purple')}\n"
+                f"👤 **Host:** {interaction.user.mention}"
+            )
+            close_text = "🔒 Close the room when done 👇"
+            
+        if invitee:
+            if lang == "ar":
+                invite_text += f"\n🎯 **مدعو:** {invitee.mention}"
+            else:
+                invite_text += f"\n🎯 **Invited:** {invitee.mention}"
+        invite_text += f"\n\n{close_text}"
+        await room.send(invite_text, view=RoomControlView(interaction.user.id))
+        
+        if lang == "ar":
+            response_msg = f"✅ تم إنشاء الغرفة: {room.mention} 🎮"
+            if invitee:
+                response_msg += f" | تمت دعوة {invitee.mention}"
+        else:
+            response_msg = f"✅ Room created: {room.mention} 🎮"
+            if invitee:
+                response_msg += f" | Invited {invitee.mention}"
+        await interaction.response.send_message(response_msg, ephemeral=True)
+
+
+class GameHubView(discord.ui.View):
+    def __init__(self, cog: "Fun", invitee_id: int | None = None, lang: str = "en") -> None:
+        super().__init__(timeout=None)
+        self.add_item(GameHubSelect(cog, invitee_id, lang))
+
+
+class RoomControlView(discord.ui.View):
+    def __init__(self, owner_id: int) -> None:
+        super().__init__(timeout=None)
+        self.owner_id = owner_id
+
+    @discord.ui.button(label="End Game & Close Room", style=discord.ButtonStyle.danger, emoji=ui("lock"), custom_id="room_close")
+    async def close_room(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not isinstance(interaction.channel, discord.TextChannel):
+            await interaction.response.send_message("Text channel only.", ephemeral=True)
+            return
+        if interaction.user.id != self.owner_id and not interaction.user.guild_permissions.manage_channels:
+            await interaction.response.send_message("❌ Only room owner or admins can close this room.", ephemeral=True)
+            return
+        await interaction.response.send_message("🔒 Closing room...", ephemeral=True)
+        try:
+            await interaction.channel.delete(reason=f"Game room closed by {interaction.user}")
+        except Exception:
+            pass
+
+    @discord.ui.button(label="Invite Friend", style=discord.ButtonStyle.success, emoji=ui("plus"), custom_id="room_invite")
+    async def invite_friend(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if interaction.user.id != self.owner_id:
+            await interaction.response.send_message("❌ Only room owner can invite.", ephemeral=True)
+            return
+        await interaction.response.send_message("➕ Use `/gamehub @user` to invite someone to a new game room!", ephemeral=True)
+
+
+class TicTacToeButton(discord.ui.Button["TicTacToeView"]):
+    def __init__(self, index: int) -> None:
+        super().__init__(label=" ", style=discord.ButtonStyle.secondary, row=index // 3)
+        self.index = index
+
+    async def callback(self, interaction: discord.Interaction) -> None:
+        if self.view:
+            await self.view.play(interaction, self.index)
+
+
+class TicTacToeView(discord.ui.View):
+    def __init__(self, player_x: discord.Member, player_o: discord.Member | None) -> None:
+        super().__init__(timeout=None)
+        self.player_x = player_x
+        self.player_o = player_o
+        self.turn_x = True
+        self.board = ["" for _ in range(9)]
+        for i in range(9):
+            self.add_item(TicTacToeButton(i))
+
+    def _check(self, mark: str) -> bool:
+        lines = [(0,1,2),(3,4,5),(6,7,8),(0,3,6),(1,4,7),(2,5,8),(0,4,8),(2,4,6)]
+        return any(self.board[a]==self.board[b]==self.board[c]==mark for a,b,c in lines)
+
+    def _free(self) -> list[int]:
+        return [i for i,v in enumerate(self.board) if not v]
+
+    async def _maybe_bot(self, message: discord.Message) -> None:
+        if self.player_o is not None or not self._free() or not self.turn_x:
+            return
+        move = random.choice(self._free())
+        self.board[move] = "O"
+        btn = self.children[move]
+        if isinstance(btn, discord.ui.Button):
+            btn.label = "O"
+            btn.style = discord.ButtonStyle.danger
+            btn.disabled = True
+        self.turn_x = True
+        if self._check("O"):
+            for child in self.children:
+                if isinstance(child, discord.ui.Button):
+                    child.disabled = True
+            await message.edit(content=f"🤖 Bot won TicTacToe! {E_BOOM}", view=self)
+            return
+        if not self._free():
+            await message.edit(content="🤝 TicTacToe draw!", view=self)
+            return
+        await message.edit(content=f"❎ Turn: {self.player_x.mention}", view=self)
+
+    async def play(self, interaction: discord.Interaction, index: int) -> None:
+        if self.board[index]:
+            await interaction.response.send_message("This cell is already used.", ephemeral=True)
+            return
+        current = self.player_x if self.turn_x else self.player_o
+        if self.turn_x and interaction.user.id != self.player_x.id:
+            await interaction.response.send_message("It is X player's turn.", ephemeral=True)
+            return
+        if not self.turn_x and self.player_o and interaction.user.id != self.player_o.id:
+            await interaction.response.send_message("It is O player's turn.", ephemeral=True)
+            return
+        mark = "X" if self.turn_x else "O"
+        self.board[index] = mark
+        btn = self.children[index]
+        if isinstance(btn, discord.ui.Button):
+            btn.label = mark
+            btn.style = discord.ButtonStyle.success if mark == "X" else discord.ButtonStyle.danger
+            btn.disabled = True
+
+        if self._check(mark):
+            for child in self.children:
+                if isinstance(child, discord.ui.Button):
+                    child.disabled = True
+            winner = interaction.user.mention if self.player_o else (self.player_x.mention if mark == "X" else "🤖 Bot")
+            await interaction.response.edit_message(content=f"🏆 TicTacToe Winner: {winner}! {E_TROPHY}", view=self)
+            return
+
+        if not self._free():
+            await interaction.response.edit_message(content="🤝 TicTacToe draw!", view=self)
+            return
+
+        self.turn_x = not self.turn_x
+        nxt = self.player_x.mention if self.turn_x else (self.player_o.mention if self.player_o else "🤖 Bot")
+        await interaction.response.edit_message(content=f"🎮 Turn: {nxt}", view=self)
+        if not self.turn_x and self.player_o is None and interaction.message:
+            await self._maybe_bot(interaction.message)
+
+
+class Fun(commands.Cog):
+    """Games and entertainment 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(GameHubView(self))
+
+    async def _fetch_trivia_api(self) -> dict[str, object] | None:
+        url = "https://opentdb.com/api.php?amount=50"
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, timeout=15) as response:
+                data = await response.json(content_type=None)
+        results = data.get("results") if isinstance(data, dict) else None
+        if not isinstance(results, list) or not results:
+            return None
+        item = random.choice(results)
+        question = html.unescape(str(item.get("question", "")).strip())
+        correct = html.unescape(str(item.get("correct_answer", "")).strip())
+        wrong = [html.unescape(str(c).strip()) for c in item.get("incorrect_answers", []) if str(c).strip()]
+        if not question or not correct or not wrong:
+            return None
+        choices = wrong[:]
+        choices.append(correct)
+        random.shuffle(choices)
+        answer_index = choices.index(correct)
+        return {"q": question, "c": choices[:4], "a": answer_index}
+
+    @commands.hybrid_command(name="8ball", description=get_cmd_desc("commands.tools.8ball_desc"))
+    async def eightball(self, ctx: commands.Context, *, question: str) -> None:
+        guild_id = ctx.guild.id if ctx.guild else None
+        lang = await self.bot.get_guild_language(guild_id)
+        
+        if lang == "ar":
+            answers = [
+                "نعم! ✅", "لا ❌", "ربما 🤔", "بالتأكيد! 💯", 
+                "ليس الآن ⏰", "اسأل لاحقاً 🔮", "100% نعم! 🔥", "غير واضح 🌫️"
+            ]
+            embed = discord.Embed(
+                title="🎱 الكرة السحرية",
+                description=(
+                    f"{panel_divider('pink')}\n"
+                    f"❓ **السؤال:** {question}\n"
+                    f"🎱 **الجواب:** {random.choice(answers)}\n"
+                    f"{panel_divider('pink')}"
+                ),
+                color=NEON_PINK,
+            )
+        else:
+            answers = [
+                "Yes! ✅", "No ❌", "Maybe 🤔", "Definitely! 💯", 
+                "Not now ⏰", "Ask later 🔮", "100% Yes! 🔥", "Unclear 🌫️"
+            ]
+            embed = discord.Embed(
+                title="🎱 Magic 8 Ball",
+                description=(
+                    f"{panel_divider('pink')}\n"
+                    f"❓ **Question:** {question}\n"
+                    f"🎱 **Answer:** {random.choice(answers)}\n"
+                    f"{panel_divider('pink')}"
+                ),
+                color=NEON_PINK,
+            )
+        await ctx.reply(embed=embed)
+
+    @commands.hybrid_command(name="meme", description=get_cmd_desc("commands.tools.meme_desc"))
+    async def meme(self, ctx: commands.Context) -> None:
+        guild_id = ctx.guild.id if ctx.guild else None
+        lang = await self.bot.get_guild_language(guild_id)
+        
+        url = "https://meme-api.com/gimme"
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, timeout=10) as response:
+                    data = await response.json()
+        except Exception:
+            if lang == "ar":
+                await ctx.reply("⚠️ تعذر تحميل الميم الآن. جرب مرة أخرى! 🔄")
+            else:
+                await ctx.reply("⚠️ Could not load meme right now. Try again in a minute! 🔄")
+            return
+
+        embed = discord.Embed(
+            title=f"😂 {data.get('title', 'Random Meme')}",
+            color=NEON_CYAN, 
+            url=data.get("postLink")
+        )
+        if data.get("url"):
+            embed.set_image(url=data["url"])
+        embed.set_footer(text=f"👍 {data.get('ups', 0)} | r/{data.get('subreddit', 'meme')}")
+        await ctx.reply(embed=embed)
+
+    @commands.hybrid_command(name="trivia", description=get_cmd_desc("commands.tools.trivia_desc"), hidden=True, with_app_command=False)
+    async def trivia(self, ctx: commands.Context, category: str = "", source: str = "local") -> None:
+        guild_id = ctx.guild.id if ctx.guild else None
+        lang = await self.bot.get_guild_language(guild_id)
+
+        normalized_source = source.strip().lower() or "local"
+        if normalized_source not in {"local", "api"}:
+            if lang == "ar":
+                await ctx.reply("❌ المصدر يجب أن يكون `local` أو `api`")
+            else:
+                await ctx.reply("❌ Source must be `local` or `api`")
+            return
+
+        normalized = category.strip().lower()
+        item: dict[str, object] | None = None
+        if lang == "ar":
+            topic_text = "الألعاب • الأفلام • المسلسلات"
+        else:
+            topic_text = "Gaming • Movies • Series"
+
+        if normalized_source == "api":
+            try:
+                item = await self._fetch_trivia_api()
+                topic_text = "OpenTDB (50 questions pool)"
+            except Exception:
+                item = None
+
+        if item is None:
+            aliases = {
+                "gaming": "gaming", "games": "gaming", "game": "gaming", "قيمز": "gaming", "العاب": "gaming",
+                "movies": "movies", "movie": "movies", "افلام": "movies", "أفلام": "movies",
+                "series": "series", "show": "series", "shows": "series", "مسلسلات": "series",
+            }
+            normalized = aliases.get(normalized, normalized) if normalized else random.choice(["gaming", "movies", "series"])
+            if normalized not in {"gaming", "movies", "series"}:
+                if lang == "ar":
+                    await ctx.reply("❌ قسم غير مدعوم. استخدم: gaming أو movies أو series")
+                else:
+                    await ctx.reply("❌ Unsupported category. Use: gaming, movies, or series")
+                return
+            
+            # Get trivia from appropriate language bank
+            trivia_bank = TRIVIA_BANK.get(lang, TRIVIA_BANK["en"])
+            if normalized not in trivia_bank:
+                trivia_bank = TRIVIA_BANK["en"]
+            item = random.choice(trivia_bank[normalized])
+
+        view = TriviaView(owner_id=ctx.author.id, correct_index=int(item["a"]), lang=lang, cog=self, guild_id=guild_id)
+        for idx, choice in enumerate(item["c"]):
+            view.add_item(TriviaAnswerButton(str(choice), idx))
+
+        if lang == "ar":
+            title = "🧠 سؤال تراڤيا!"
+            cat_label = "📁 القسم"
+            topics_label = "📚 المواضيع"
+        else:
+            title = "🧠 Trivia Time!"
+            cat_label = "📁 Category"
+            topics_label = "📚 Topics"
+            
+        embed = discord.Embed(
+            title=title,
+            description=f"{panel_divider('blue')}\n❓ {str(item['q'])}\n{panel_divider('blue')}",
+            color=NEON_CYAN,
+        )
+        cat_value = normalized.title() if normalized else ("General" if normalized_source == "api" else "Random")
+        embed.add_field(name=cat_label, value=cat_value, inline=True)
+        embed.add_field(name=topics_label, value=topic_text, inline=True)
+        await ctx.reply(embed=embed, view=view)
+
+    async def _fetch_gaming_news(self) -> list[dict[str, str]]:
+        return await fetch_gaming_news()
+
+    async def _fetch_free_games(self) -> list[dict[str, str]]:
+        return await fetch_free_games()
+
+    @staticmethod
+    def _store_icon(platform: str) -> str:
+        return store_icon(platform)
+
+    def _free_game_embed(self, item: dict[str, str]) -> tuple[discord.Embed, discord.ui.View]:
+        title = item["title"][:120]
+        link = item["link"]
+        embed = ImperialMotaz.craft_embed(
+            title=f"[FREE GAME] | {title}",
+            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", "")))
+        return embed, FreeGameClaimView(link)
+
+    @commands.hybrid_command(name="gaming_news", description=get_cmd_desc("commands.tools.gaming_news_desc"))
+    async def gaming_news(self, ctx: commands.Context) -> None:
+        guild_id = ctx.guild.id if ctx.guild else None
+        lang = await self.bot.get_guild_language(guild_id)
+        
+        try:
+            items = await self._fetch_gaming_news()
+        except Exception:
+            if lang == "ar":
+                await ctx.reply("❌ تعذر جلب أخبار الألعاب الآن.")
+            else:
+                await ctx.reply("❌ Could not fetch gaming news right now.")
+            return
+
+        if not items:
+            if lang == "ar":
+                await ctx.reply("لا توجد أخبار متاحة الآن.")
+            else:
+                await ctx.reply("No gaming news available right now.")
+            return
+
+        if lang == "ar":
+            title = "🕹️ آخر أخبار الألعاب عالميًا"
+        else:
+            title = "🕹️ Latest Gaming News Worldwide"
+            
+        embed = discord.Embed(
+            title=title,
+            description=f"{panel_divider('green')}",
+            color=NEON_CYAN,
+        )
+        for item in items:
+            date_hint = f"\n🗓️ {item['pub_date'][:16]}" if item.get("pub_date") else ""
+            if lang == "ar":
+                embed.add_field(name=item["title"][:256], value=f"📰 [اقرأ المقال]({item['link']}){date_hint}", inline=False)
+            else:
+                embed.add_field(name=item["title"][:256], value=f"📰 [Read Article]({item['link']}){date_hint}", inline=False)
+        await ctx.reply(embed=embed)
+
+    @commands.hybrid_command(name="freegames", description=get_cmd_desc("commands.tools.freegames_desc"), with_app_command=False)
+    async def freegames(self, ctx: commands.Context) -> None:
+        guild_id = ctx.guild.id if ctx.guild else None
+        lang = await self.bot.get_guild_language(guild_id)
+        
+        try:
+            items = await self._fetch_free_games()
+        except Exception:
+            if lang == "ar":
+                await ctx.reply("❌ تعذر جلب العروض الآن.")
+            else:
+                await ctx.reply("❌ Could not fetch free game offers right now.")
+            return
+
+        if not items:
+            if lang == "ar":
+                await ctx.reply("لا توجد عروض مجانية نشطة الآن.")
+            else:
+                await ctx.reply("No active free game offers right now.")
+            return
+
+        for item in items:
+            embed, view = self._free_game_embed(item)
+            await ctx.reply(embed=embed, view=view)
+
+    @commands.hybrid_command(name="free_games", description=get_cmd_desc("commands.tools.free_games_desc"))
+    async def free_games(self, ctx: commands.Context) -> None:
+        await self.freegames(ctx)
+
+    @commands.hybrid_group(name="gamehub", fallback="panel", description="Interactive game hub with temporary private rooms")
+    async def gamehub(self, ctx: commands.Context, invite: discord.Member | None = None) -> None:
+        if not ctx.guild:
+            await ctx.reply("Server only.")
+            return
+        
+        guild_id = ctx.guild.id
+        lang = await self.bot.get_guild_language(guild_id)
+        
+        if invite and invite.bot:
+            if lang == "ar":
+                await ctx.reply("❌ ادعُ عضواً حقيقياً، ليس بوت.")
+            else:
+                await ctx.reply("❌ Invite a real member, not a bot.")
+            return
+        if invite and invite.id == ctx.author.id:
+            if lang == "ar":
+                await ctx.reply("❌ ادعُ عضواً آخر.")
+            else:
+                await ctx.reply("❌ Invite another member.")
+            return
+
+        games_list = " • ".join([f"{g['emoji']} {g['name']}" for g in GAME_HUB_GAMES])
+        
+        if lang == "ar":
+            title = "🎮 مركز الألعاب"
+            desc = (
+                f"{panel_divider('pink')}\n"
+                f"🕹️ اختر لعبة أدناه لإنشاء **غرفة خاصة**.\n"
+                f"👥 ادعُ صديقاً أو العب ضد البوت.\n"
+                f"🗑️ الغرفة تُحذف تلقائياً عند إغلاقها.\n"
+                f"{panel_divider('pink')}\n\n"
+                f"**الألعاب:** {games_list}"
+            )
+            invited_label = "🎯 العضو المدعو"
+        else:
+            title = "🎮 Game Hub"
+            desc = (
+                f"{panel_divider('pink')}\n"
+                f"🕹️ Select a game below to create a **private room**.\n"
+                f"👥 Invite a friend or play solo vs the bot.\n"
+                f"🗑️ The room auto-deletes when you close it.\n"
+                f"{panel_divider('pink')}\n\n"
+                f"**Games:** {games_list}"
+            )
+            invited_label = "🎯 Invited Member"
+            
+        embed = discord.Embed(
+            title=title,
+            description=desc,
+            color=NEON_CYAN,
+        )
+        if invite:
+            embed.add_field(name=invited_label, value=invite.mention, inline=False)
+        await ctx.reply(embed=embed, view=GameHubView(self, invite.id if invite else None, lang))
+
+    @gamehub.command(name="xo", description="TicTacToe vs member or bot")
+    async def gamehub_xo(self, ctx: commands.Context, opponent: discord.Member | None = None) -> None:
+        await self.xo(ctx, opponent=opponent)
+
+    @gamehub.command(name="mario", description="Mario/Pac-Man arcade challenge")
+    async def gamehub_mario(self, ctx: commands.Context) -> None:
+        await self.mario(ctx)
+
+    @gamehub.command(name="dice", description="Roll dice")
+    async def gamehub_dice(self, ctx: commands.Context, sides: int = 6) -> None:
+        await self.dice(ctx, sides=sides)
+
+    @gamehub.command(name="slots", description="Slot machine game")
+    async def gamehub_slots(self, ctx: commands.Context, bet: int = 50) -> None:
+        await self.slots(ctx, bet=bet)
+
+    @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)
+
+    @commands.hybrid_command(name="xo", description=get_cmd_desc("commands.tools.xo_desc"), hidden=True, with_app_command=False)
+    async def xo(self, ctx: commands.Context, opponent: discord.Member | None = None) -> None:
+        guild_id = ctx.guild.id if ctx.guild else None
+        lang = await self.bot.get_guild_language(guild_id)
+        
+        if opponent and opponent.bot:
+            opponent = None
+        view = TicTacToeView(ctx.author, opponent)
+        second = opponent.mention if opponent else "🤖 Bot"
+        
+        if lang == "ar":
+            msg = await ctx.reply(
+                f"❎ تيك تاك تو: {ctx.author.mention} (X) ضد {second} (O)\n"
+                f"🎮 الدور: {ctx.author.mention}", 
+                view=view
+            )
+        else:
+            msg = await ctx.reply(
+                f"❎ TicTacToe: {ctx.author.mention} (X) vs {second} (O)\n"
+                f"🎮 Turn: {ctx.author.mention}", 
+                view=view
+            )
+        if opponent is None:
+            await view._maybe_bot(msg)
+
+    @commands.hybrid_command(name="choose", hidden=True, with_app_command=False, description=get_cmd_desc("commands.tools.choose_desc"))
+    async def choose(self, ctx: commands.Context, *, options: str) -> None:
+        guild_id = ctx.guild.id if ctx.guild else None
+        lang = await self.bot.get_guild_language(guild_id)
+        
+        parts = [p.strip() for p in options.split(",") if p.strip()]
+        if len(parts) < 2:
+            if lang == "ar":
+                await ctx.reply("❌ أدخل خيارين على الأقل مفصولين بفواصل.")
+            else:
+                await ctx.reply("❌ Provide at least 2 options separated by commas.")
+            return
+            
+        choice = random.choice(parts)
+        
+        if lang == "ar":
+            embed = discord.Embed(
+                title="🎲 اختيار عشوائي",
+                description=(
+                    f"{panel_divider('purple')}\n"
+                    f"📝 الخيارات: {', '.join(parts)}\n"
+                    f"🎯 **المختار:** {choice}\n"
+                    f"{panel_divider('purple')}"
+                ),
+                color=NEON_PINK,
+            )
+        else:
+            embed = discord.Embed(
+                title="🎲 Random Choice",
+                description=(
+                    f"{panel_divider('purple')}\n"
+                    f"📝 Options: {', '.join(parts)}\n"
+                    f"🎯 **Selected:** {choice}\n"
+                    f"{panel_divider('purple')}"
+                ),
+                color=NEON_PINK,
+            )
+        await ctx.reply(embed=embed)
+
+    @commands.hybrid_command(name="mario", description=get_cmd_desc("commands.tools.mario_desc"), hidden=True, with_app_command=False)
+    async def mario(self, ctx: commands.Context) -> None:
+        guild_id = ctx.guild.id if ctx.guild else None
+        lang = await self.bot.get_guild_language(guild_id)
+        
+        coins = random.randint(5, 120)
+        level = random.randint(1, 8)
+        
+        if lang == "ar":
+            embed = discord.Embed(
+                title="🍄 تحدي الآركيد",
+                description=(
+                    f"{panel_divider('orange')}\n"
+                    f"🍄 {ctx.author.mention} جمع **{coins}** عملة!\n"
+                    f"✅ تجاوز المرحلة **{level}**!\n"
+                    f"{panel_divider('orange')}"
+                ),
+                color=NEON_ORANGE,
+            )
+            embed.add_field(name="🎁 مكافأة", value="تم فتح combo باك مان! <:animatedarrowyellow:1477261257592668271>", inline=False)
+        else:
+            embed = discord.Embed(
+                title="🍄 Arcade Challenge",
+                description=(
+                    f"{panel_divider('orange')}\n"
+                    f"🍄 {ctx.author.mention} collected **{coins}** coins!\n"
+                    f"✅ Cleared level **{level}**!\n"
+                    f"{panel_divider('orange')}"
+                ),
+                color=NEON_ORANGE,
+            )
+            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)
+
+    @commands.hybrid_command(name="dice", description=get_cmd_desc("commands.tools.dice_desc"), hidden=True, with_app_command=False)
+    async def dice(self, ctx: commands.Context, sides: int = 6) -> None:
+        """Roll a dice with specified sides."""
+        guild_id = ctx.guild.id if ctx.guild else None
+        lang = await self.bot.get_guild_language(guild_id)
+        
+        sides = max(2, min(sides, 100))
+        result = random.randint(1, sides)
+        
+        if lang == "ar":
+            embed = gaming_embed(
+                "🎲 رمي النرد",
+                f"🎲 رميت نرد بـ **{sides}** أوجه\n🎯 النتيجة: **{result}**"
+            )
+        else:
+            embed = gaming_embed(
+                "🎲 Dice Roll",
+                f"🎲 Rolled a **{sides}**-sided dice\n🎯 Result: **{result}**"
+            )
+        await ctx.reply(embed=embed)
+
+    @commands.hybrid_command(name="slots", description=get_cmd_desc("commands.tools.slots_desc"), hidden=True, with_app_command=False)
+    async def slots(self, ctx: commands.Context, bet: int = 10) -> None:
+        """Play a slot machine game."""
+        guild_id = ctx.guild.id if ctx.guild else None
+        lang = await self.bot.get_guild_language(guild_id)
+        
+        bet = max(10, bet)
+        
+        # Check balance
+        row = await self.bot.db.fetchone(
+            "SELECT wallet FROM user_balance WHERE guild_id = ? AND user_id = ?",
+            guild_id,
+            ctx.author.id,
+        )
+        wallet = row[0] if row else 0
+        
+        if wallet < bet:
+            if lang == "ar":
+                await ctx.reply(f"❌ ليس لديك رصيد كافي. محفظتك: **{wallet}** عملة")
+            else:
+                await ctx.reply(f"❌ Insufficient balance. Your wallet: **{wallet}** coins")
+            return
+        
+        # Slot symbols
+        symbols = ["🍒", "🍋", "🍊", "🍇", "✅", "💎", "7️⃣"]
+        weights = [25, 20, 18, 15, 12, 7, 3]  # Weighted probabilities
+        
+        # Spin
+        results = random.choices(symbols, weights=weights, k=3)
+        
+        # Calculate winnings
+        if results[0] == results[1] == results[2]:
+            # Jackpot!
+            if results[0] == "7️⃣":
+                multiplier = 10
+            elif results[0] == "💎":
+                multiplier = 7
+            elif results[0] == "✅":
+                multiplier = 5
+            else:
+                multiplier = 3
+            winnings = bet * multiplier
+        elif results[0] == results[1] or results[1] == results[2] or results[0] == results[2]:
+            winnings = bet * 2
+        else:
+            winnings = 0
+        
+        # Update balance
+        if winnings > 0:
+            await self._add_coins(guild_id, ctx.author.id, winnings - bet)
+        else:
+            await self._add_coins(guild_id, ctx.author.id, -bet)
+        
+        # Build display
+        slot_display = " | ".join(results)
+        
+        if winnings >= bet * 5:
+            result_text = f"🎰 **{'جائزة كبرى!' if lang == 'ar' else 'JACKPOT!'}** {E_FIRE}"
+        elif winnings > 0:
+            result_text = f"✅ **{'فزت!' if lang == 'ar' else 'You won!'}**"
+        else:
+            result_text = f"❌ **{'حظ أوفر' if lang == 'ar' else 'Better luck next time'}**"
+        
+        if lang == "ar":
+            embed = gaming_embed(
+                "🎰 ماكينة القمار",
+                f"┌───────┐\n│ {slot_display} │\n└───────┘\n\n{result_text}\n💰 **الرابح:** {winnings} عملة"
+            )
+        else:
+            embed = gaming_embed(
+                "🎰 Slot Machine",
+                f"┌───────┐\n│ {slot_display} │\n└───────┘\n\n{result_text}\n💰 **Won:** {winnings} coins"
+            )
+        await ctx.reply(embed=embed)
+    
+    async def _add_coins(self, guild_id: int, user_id: int, amount: int) -> None:
+        """Helper to add/remove coins from user balance."""
+        if amount == 0:
+            return
+        await self.bot.db.execute(
+            "INSERT INTO user_balance(guild_id, user_id, wallet, bank) VALUES (?, ?, ?, 0) "
+            "ON CONFLICT(guild_id, user_id) DO UPDATE SET wallet = wallet + ?",
+            guild_id,
+            user_id,
+            amount if amount > 0 else 0,
+            amount,
+        )
+
+
+async def setup(bot: commands.Bot) -> None:
+    await bot.add_cog(Fun(bot))

bot/cogs/gambling.py

@@ -12,6 +12,7 @@ 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.i18n import get_cmd_desc
 from bot.emojis import ui
 
 
@@ -282,7 +283,7 @@ class RouletteGameView(discord.ui.View):
         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:
+        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))
 
@@ -386,7 +387,7 @@ class RPGView(discord.ui.View):
     
     @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:
+        if self.user_id and interaction.user.id != self.user_id:
             return
         
         engagement_cog = interaction.client.get_cog("Engagement")
@@ -443,7 +444,7 @@ class RPGView(discord.ui.View):
     
     @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:
+        if self.user_id and interaction.user.id != self.user_id:
             return
         
         engagement_cog = interaction.client.get_cog("Engagement")
@@ -620,11 +621,11 @@ class BlackjackBetModal(discord.ui.Modal, title="🃏 Place Your Bet"):
         await interaction.response.send_message("✅ Blackjack game started!", ephemeral=True)
 
 
-class Gambling(commands.Cog):
+class Gambling(commands.Cog):
     def __init__(self, bot: commands.Bot) -> None:
         self.bot = bot
     
-    @commands.hybrid_command(name="blackjack", description="Play interactive Blackjack")
+    @commands.hybrid_command(name="blackjack", description=get_cmd_desc("commands.economy.blackjack_desc"))
     async def blackjack(self, ctx: commands.Context, bet: int) -> None:
         if bet < 10:
             await ctx.send("❌ Minimum bet is 10 coins.", ephemeral=True)
@@ -650,13 +651,13 @@ class Gambling(commands.Cog):
         message = await ctx.send(embed=embed, view=view)
         view.message = message
     
-    @commands.hybrid_command(name="roulette", description="Play interactive Roulette")
+    @commands.hybrid_command(name="roulette", description=get_cmd_desc("commands.economy.roulette_desc"))
     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")
+    @commands.hybrid_command(name="rpg", description=get_cmd_desc("commands.economy.rpg_desc"))
     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(
@@ -666,7 +667,7 @@ class Gambling(commands.Cog):
         )
         await ctx.send(embed=embed, view=view, ephemeral=True)
     
-    @commands.hybrid_command(name="gambling_panel", description="Open the gambling panel")
+    @commands.hybrid_command(name="gambling_panel", description=get_cmd_desc("commands.economy.gambling_panel_desc"))
     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(

bot/cogs/language.py

@@ -1,187 +1,188 @@
-"""
-Language cog: Multi-language support for the bot.
-Provides a beautiful panel for changing server language.
-"""
-
-import discord
-from discord.ext import commands
-
-from bot.i18n import SUPPORTED_LANGUAGES, translate
-from bot.theme import NEON_CYAN, NEON_LIME, panel_divider, success_embed, shimmer
-
-LANGUAGE_META: dict[str, tuple[str, str]] = {
-    "ar": ("العربية", "🇸🇦"),
-    "en": ("English", "🇬🇧"),
-    "es": ("Español", "🇪🇸"),
-    "fr": ("Français", "🇫🇷"),
-    "de": ("Deutsch", "🇩🇪"),
-    "tr": ("Türkçe", "🇹🇷"),
-    "it": ("Italiano", "🇮🇹"),
-    "pt": ("Português", "🇵🇹"),
-    "ru": ("Русский", "🇷🇺"),
-    "hi": ("हिन्दी", "🇮🇳"),
-    "id": ("Indonesia", "🇮🇩"),
-    "ja": ("日本語", "🇯🇵"),
-    "zh": ("中文", "🇨🇳"),
-    "he": ("עברית", "🇮🇱"),
-}
-
-
-class LanguageSelect(discord.ui.Select):
-    def __init__(self, cog: "Language", guild_id: int, current_code: str) -> None:
-        self.cog = cog
-        self.guild_id = guild_id
-
-        options: list[discord.SelectOption] = []
-        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(
-                    label=label,
-                    value=code,
-                    emoji=emoji,
-                    description=f"{code.upper()} language",
-                    default=code == current_code,
-                )
-            )
-
-        super().__init__(
-            placeholder="Choose server language",
-            min_values=1,
-            max_values=1,
-            options=options[:25],
-            custom_id="lang:select",
-        )
-
-    async def callback(self, interaction: discord.Interaction) -> None:
-        if not interaction.guild:
-            await interaction.response.send_message(translate("en", "common.server_only"), ephemeral=True)
-            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",
-            interaction.guild.id,
-            selected,
-        )
-
-        for option in self.options:
-            option.default = option.value == selected
-
-        embed = await self.cog._language_embed(interaction.guild.id, selected)
-        await interaction.response.edit_message(embed=embed, view=self.view)
-        
-        # Send follow-up with hint to open /menu
-        lang_name = LANGUAGE_META.get(selected, (selected.upper(), "🌐"))[0]
-        hint_msg = translate(selected, "lang.updated")
-        
-        followup_embed = discord.Embed(
-            title=f"✅ Language Changed!",
-            description=f"{panel_divider('lime')}\n{hint_msg}\n\n💡 Use `/menu` to see all commands in your selected language!\n{panel_divider('lime')}",
-            color=NEON_LIME,
-        )
-        await interaction.followup.send(embed=followup_embed, ephemeral=True)
-
-
-class LanguagePanelView(discord.ui.View):
-    def __init__(self, cog: "Language", guild_id: int, current_code: str) -> None:
-        super().__init__(timeout=None)
-        self.add_item(LanguageSelect(cog, guild_id, current_code))
-
-
-class Language(commands.Cog):
-    def __init__(self, bot: commands.Bot) -> None:
-        self.bot = bot
-
-    async def cog_load(self) -> None:
-        self.bot.add_view(LanguagePanelView(self, 0, "ar"))
-
-    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)
-        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 = []
-        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})`")
-
-        # Get translated content
-        title = translate(current_code, "lang.current").replace("{globe}", "🌍")
-        
-        embed = discord.Embed(
-            title="🌍 Language Control Panel",
-            description=(
-                f"{shimmer('Current Language')}: **{current_emoji} {current_name}** (`{current_code}`)\n"
-                f"{panel_divider('cyan')}\n"
-                f"Pick your server language from the dropdown below.\n"
-                f"All bot messages and panels will use the selected language!"
-            ),
-            color=NEON_CYAN,
-        )
-        embed.add_field(name="🌐 Supported Languages", value="\n".join(lines[:20]), inline=False)
-        embed.add_field(
-            name="💡 Tips",
-            value=(
-                "• Language changes apply instantly\n"
-                "• Use `/menu` to see commands in your language\n"
-                "• Available full locales: Arabic, English, Spanish, French, German"
-            ),
-            inline=False
-        )
-        embed.set_footer(text="Changes apply instantly across bot messages and panels")
-        return embed
-
-    @commands.hybrid_command(name="language", description="Open language panel for this server")
-    @commands.has_permissions(manage_guild=True)
-    async def language(self, ctx: commands.Context) -> None:
-        if not ctx.guild:
-            await ctx.reply(translate("en", "common.server_only"))
-            return
-
-        current_code = await self._current_code(ctx.guild.id)
-        embed = await self._language_embed(ctx.guild.id, current_code)
-        view = LanguagePanelView(self, ctx.guild.id, current_code)
-        await ctx.reply(embed=embed, view=view)
-
-    @commands.hybrid_command(name="languages", description="List supported bot languages", hidden=True, with_app_command=False)
-    async def languages(self, ctx: commands.Context) -> None:
-        guild_id = ctx.guild.id if ctx.guild else None
-        lang = await self.bot.get_guild_language(guild_id)
-        
-        pretty = [f"{LANGUAGE_META.get(code, (code.upper(), '🌐'))[1]} **{LANGUAGE_META.get(code, (code.upper(), '🌐'))[0]}** (`{code}`)" for code in LANGUAGE_META]
-        
-        embed = discord.Embed(
-            title="🌍 Supported Languages",
-            description=f"{panel_divider('cyan')}\n" + "\n".join(pretty) + f"\n{panel_divider('cyan')}",
-            color=NEON_CYAN,
-        )
-        embed.set_footer(text=f"Current: {LANGUAGE_META.get(lang, (lang.upper(), '🌐'))[0]}")
-        await ctx.reply(embed=embed)
-
-
-async def setup(bot: commands.Bot) -> None:
-    await bot.add_cog(Language(bot))
+from bot.i18n import get_cmd_desc
+"""
+Language cog: Multi-language support for the bot.
+Provides a beautiful panel for changing server language.
+"""
+
+import discord
+from discord.ext import commands
+
+from bot.i18n import SUPPORTED_LANGUAGES, translate
+from bot.theme import NEON_CYAN, NEON_LIME, panel_divider, success_embed, shimmer
+
+LANGUAGE_META: dict[str, tuple[str, str]] = {
+    "ar": ("العربية", "🇸🇦"),
+    "en": ("English", "🇬🇧"),
+    "es": ("Español", "🇪🇸"),
+    "fr": ("Français", "🇫🇷"),
+    "de": ("Deutsch", "🇩🇪"),
+    "tr": ("Türkçe", "🇹🇷"),
+    "it": ("Italiano", "🇮🇹"),
+    "pt": ("Português", "🇵🇹"),
+    "ru": ("Русский", "🇷🇺"),
+    "hi": ("हिन्दी", "🇮🇳"),
+    "id": ("Indonesia", "🇮🇩"),
+    "ja": ("日本語", "🇯🇵"),
+    "zh": ("中文", "🇨🇳"),
+    "he": ("עברית", "🇮🇱"),
+}
+
+
+class LanguageSelect(discord.ui.Select):
+    def __init__(self, cog: "Language", guild_id: int, current_code: str) -> None:
+        self.cog = cog
+        self.guild_id = guild_id
+
+        options: list[discord.SelectOption] = []
+        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(
+                    label=label,
+                    value=code,
+                    emoji=emoji,
+                    description=f"{code.upper()} language",
+                    default=code == current_code,
+                )
+            )
+
+        super().__init__(
+            placeholder="Choose server language",
+            min_values=1,
+            max_values=1,
+            options=options[:25],
+            custom_id="lang:select",
+        )
+
+    async def callback(self, interaction: discord.Interaction) -> None:
+        if not interaction.guild:
+            await interaction.response.send_message(translate("en", "common.server_only"), ephemeral=True)
+            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",
+            interaction.guild.id,
+            selected,
+        )
+
+        for option in self.options:
+            option.default = option.value == selected
+
+        embed = await self.cog._language_embed(interaction.guild.id, selected)
+        await interaction.response.edit_message(embed=embed, view=self.view)
+        
+        # Send follow-up with hint to open /menu
+        lang_name = LANGUAGE_META.get(selected, (selected.upper(), "🌐"))[0]
+        hint_msg = translate(selected, "lang.updated")
+        
+        followup_embed = discord.Embed(
+            title=f"✅ Language Changed!",
+            description=f"{panel_divider('lime')}\n{hint_msg}\n\n💡 Use `/menu` to see all commands in your selected language!\n{panel_divider('lime')}",
+            color=NEON_LIME,
+        )
+        await interaction.followup.send(embed=followup_embed, ephemeral=True)
+
+
+class LanguagePanelView(discord.ui.View):
+    def __init__(self, cog: "Language", guild_id: int, current_code: str) -> None:
+        super().__init__(timeout=None)
+        self.add_item(LanguageSelect(cog, guild_id, current_code))
+
+
+class Language(commands.Cog):
+    def __init__(self, bot: commands.Bot) -> None:
+        self.bot = bot
+
+    async def cog_load(self) -> None:
+        self.bot.add_view(LanguagePanelView(self, 0, "ar"))
+
+    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)
+        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 = []
+        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})`")
+
+        # Get translated content
+        title = translate(current_code, "lang.current").replace("{globe}", "🌍")
+        
+        embed = discord.Embed(
+            title="🌍 Language Control Panel",
+            description=(
+                f"{shimmer('Current Language')}: **{current_emoji} {current_name}** (`{current_code}`)\n"
+                f"{panel_divider('cyan')}\n"
+                f"Pick your server language from the dropdown below.\n"
+                f"All bot messages and panels will use the selected language!"
+            ),
+            color=NEON_CYAN,
+        )
+        embed.add_field(name="🌐 Supported Languages", value="\n".join(lines[:20]), inline=False)
+        embed.add_field(
+            name="💡 Tips",
+            value=(
+                "• Language changes apply instantly\n"
+                "• Use `/menu` to see commands in your language\n"
+                "• Available full locales: Arabic, English, Spanish, French, German"
+            ),
+            inline=False
+        )
+        embed.set_footer(text="Changes apply instantly across bot messages and panels")
+        return embed
+
+    @commands.hybrid_command(name="language", description=get_cmd_desc("commands.tools.language_desc"))
+    @commands.has_permissions(manage_guild=True)
+    async def language(self, ctx: commands.Context) -> None:
+        if not ctx.guild:
+            await ctx.reply(translate("en", "common.server_only"))
+            return
+
+        current_code = await self._current_code(ctx.guild.id)
+        embed = await self._language_embed(ctx.guild.id, current_code)
+        view = LanguagePanelView(self, ctx.guild.id, current_code)
+        await ctx.reply(embed=embed, view=view)
+
+    @commands.hybrid_command(name="languages", description=get_cmd_desc("commands.tools.languages_desc"), hidden=True, with_app_command=False)
+    async def languages(self, ctx: commands.Context) -> None:
+        guild_id = ctx.guild.id if ctx.guild else None
+        lang = await self.bot.get_guild_language(guild_id)
+        
+        pretty = [f"{LANGUAGE_META.get(code, (code.upper(), '🌐'))[1]} **{LANGUAGE_META.get(code, (code.upper(), '🌐'))[0]}** (`{code}`)" for code in LANGUAGE_META]
+        
+        embed = discord.Embed(
+            title="🌍 Supported Languages",
+            description=f"{panel_divider('cyan')}\n" + "\n".join(pretty) + f"\n{panel_divider('cyan')}",
+            color=NEON_CYAN,
+        )
+        embed.set_footer(text=f"Current: {LANGUAGE_META.get(lang, (lang.upper(), '🌐'))[0]}")
+        await ctx.reply(embed=embed)
+
+
+async def setup(bot: commands.Bot) -> None:
+    await bot.add_cog(Language(bot))

bot/cogs/media_helpers.py

@@ -362,9 +362,9 @@ class AutoRefreshMixin:
 
 class FiltersPanelView(discord.ui.View, AutoRefreshMixin):
     """Separate Filters Panel with auto-refresh."""
-    
+
     def __init__(self, cog: "Media", guild_id: int) -> None:
-        discord.ui.View.__init__(self, timeout=300)
+        discord.ui.View.__init__(self, timeout=None)
         AutoRefreshMixin.__init__(self)
         self.cog = cog
         self.guild_id = guild_id
@@ -747,10 +747,15 @@ class MusicPanelView(discord.ui.View, AutoRefreshMixin):
     async def _build_refresh_embed(self) -> discord.Embed:
         """Build refresh embed."""
         return await self.cog._music_panel_embed(self.guild_id)
-    
+
     def _build_refresh_view(self) -> None:
-        """Rebuild view for refresh."""
-        self._build_view()
+        """Skip rebuilding view on auto-refresh to prevent 'unknown view' errors.
+
+        The buttons are static and don't need rebuilding during auto-refresh.
+        Rebuilding clears items and creates new button instances which breaks
+        Discord's view caching and causes 'interaction referencing unknown view'.
+        """
+        pass
     
     @safe_interaction
     async def _join(self, interaction: discord.Interaction) -> None:

bot/cogs/menu.py

@@ -9,6 +9,7 @@ import discord
 from discord.ext import commands
 
 from bot.cogs.ai_suite import ImperialMotaz
+from bot.i18n import get_cmd_desc
 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,
@@ -20,78 +21,93 @@ from bot.theme import (
 
 
 # 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_EMOJIS: dict[str, str] = {
+    "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_DESCRIPTIONS: dict[str, str] = {
+    "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 | التحقق",
+    "__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}")
+    return _CATEGORY_BILINGUAL.get(name, f"📂 {name} | {name}")
+
+
+def _safe_emoji(value: str) -> "discord.Emoji | discord.PartialEmoji | str | None":
+    """Safely resolve an emoji value for use in Discord SelectOptions."""
+    if not value:
+        return None
+    value = value.strip()
+    if not value:
+        return None
+    if value.startswith("<") and value.endswith(">"):
+        try:
+            return discord.PartialEmoji.from_str(value)
+        except Exception:
+            return None
+    return value
 
 
 class CommandsMenuSelect(discord.ui.Select):
     """Beautiful dropdown menu for selecting command categories."""
-    
+
     def __init__(
         self,
         cog_names: list[str],
@@ -121,23 +137,25 @@ class CommandsMenuSelect(discord.ui.Select):
                 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"))
+            raw_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]
+            # Safely resolve emoji - use PartialEmoji for custom emoji strings
+            resolved_emoji = _safe_emoji(raw_emoji)
             options.append(
                 discord.SelectOption(
                     label=_bilingual_category(name)[:100],
                     description=desc,
-                    emoji=emoji,
+                    emoji=resolved_emoji,
                     value=name,
                     default=selected_cog == name,
                 )
             )
-        
+
         super().__init__(
             placeholder=placeholder,
             min_values=1,
@@ -184,7 +202,7 @@ class CommandsMenuView(discord.ui.View):
             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")
+                desc = _CATEGORY_DESCRIPTIONS.get(name, f"📂 {name} commands")
             cog_desc_map[name] = desc
         self.clear_items()
         self.add_item(
@@ -203,13 +221,13 @@ class CommandsMenuView(discord.ui.View):
         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))
+        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):
@@ -348,6 +366,8 @@ class CommandsMenuView(discord.ui.View):
             "reload": "menu.cmd.reload",
             "sync": "menu.cmd.sync",
             "shutdown": "menu.cmd.shutdown",
+            "bot_emojis": "menu.cmd.emoji_scan",
+            "emoji_scan": "menu.cmd.emoji_scan",
             
             # Verification commands
             "verify": "menu.cmd.verify",
@@ -400,55 +420,55 @@ class CommandsMenuView(discord.ui.View):
             "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",
-        }
+            # 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:
@@ -471,13 +491,13 @@ class CommandsMenuView(discord.ui.View):
 
             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 "-"
+                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]}"
+            line = f"- {invoke} - {desc[:78]}"
             projected = used + len(line) + (1 if lines else 0)
 
             if projected > max_chars:
@@ -488,12 +508,12 @@ class CommandsMenuView(discord.ui.View):
             if len(lines) >= max_lines:
                 break
 
-        if len(lines) < len([c for c in cmds if not c.hidden]):
-            suffix = "\n- ------------"
-            if used + len(suffix) <= max_chars:
-                lines.append("- ------------")
-
-        return "\n".join(lines)
+        if len(lines) < len([c for c in cmds if not c.hidden]):
+            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)
@@ -527,16 +547,16 @@ class CommandsMenuView(discord.ui.View):
         
         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, "📁")
+            badge = {1: "🥇", 2: "🥈", 3: "🥉"}.get(index, f"#{index}")
+            emoji = _CATEGORY_EMOJIS.get(name, "📂")
             
             if lang == "ar":
-                lines.append(f"{badge} {emoji} **{name}** — `{count}` أمر")
+                lines.append(f"{badge} {emoji} **{name}** — `{count}` أمر")
             else:
-                lines.append(f"{badge} {emoji} **{name}** — `{count}` cmds")
+                lines.append(f"{badge} {emoji} **{name}** — `{count}` cmds")
         
         if len(stats) > 8:
-            lines.append("✦ ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈")
+            lines.append("✦ ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈")
         
         return "\n".join(lines)
 
@@ -553,17 +573,17 @@ class CommandsMenuView(discord.ui.View):
         
         if lang == "ar":
             pieces = [
-                f"📊 **إجمالي الأوامر:** `{total_commands}`",
-                f"📁 **الفئات:** `{category_count}`",
-                f"✨ **المحدد:** {selection_label} (`{visible_commands}` أمر)",
-                f"📈 {progress_bar(visible_commands, total_commands, size=14)}",
+                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)}",
+                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)
 
@@ -622,21 +642,21 @@ class CommandsMenuView(discord.ui.View):
             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` - {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` - {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'}"
-        )
-        footer = "Powered by BOT- AI Suite"
+        quick = (
+            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` - {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'}"
+        )
+        footer = "Powered by BOT- AI Suite"
 
         top_divider = panel_divider("cyan")
         mid_divider = panel_divider("purple")
@@ -662,10 +682,10 @@ class CommandsMenuView(discord.ui.View):
         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"),
+                ("Guilds", str(total_guilds), "G"),
+                ("Members", f"{total_members:,}", "M"),
+                ("Latency", latency_ms, "L"),
+                ("Slash", slash_budget, "S"),
             ],
             columns=2,
         )
@@ -677,7 +697,7 @@ class CommandsMenuView(discord.ui.View):
             inline=True,
         )
 
-        emoji = _CATEGORY_EMOJIS.get(selected_cog, "C")
+        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}",
@@ -690,7 +710,7 @@ class CommandsMenuView(discord.ui.View):
         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}"
+        embed.description = f"{embed.description}\n\nPage {self.page + 1}/{total_pages}"
         return embed
 
 
@@ -724,8 +744,8 @@ class RefreshButton(discord.ui.Button):
 
     async def callback(self, interaction: discord.Interaction) -> None:
         await interaction.response.defer()
-        guild_id = interaction.guild.id if interaction.guild else None
-        self.label = await self.parent_view.bot.get_text(guild_id, "menu.refresh")
+        guild_id = interaction.guild.id if interaction.guild else None
+        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)
@@ -757,7 +777,7 @@ class PageButton(discord.ui.Button):
         self.parent_view = parent
         self.direction = direction
         label = "Previous" if direction == "prev" else "Next"
-        emoji = "⬅️" if direction == "prev" else "➡️"
+        emoji = "⬅️" if direction == "prev" else "➡️"
         super().__init__(label=label, emoji=emoji, style=discord.ButtonStyle.secondary)
 
     async def callback(self, interaction: discord.Interaction) -> None:
@@ -778,10 +798,10 @@ class Menu(commands.Cog):
     def __init__(self, bot: commands.Bot) -> None:
         self.bot = bot
 
-    async def cog_load(self) -> None:
-        self.bot.add_view(CommandsMenuView(self.bot))
+    async def cog_load(self) -> None:
+        self.bot.add_view(CommandsMenuView(self.bot))
 
-    @commands.hybrid_command(name="menu", description="Bot menu | قائمة أوامر واضحة")
+    @commands.hybrid_command(name="menu", description=get_cmd_desc("commands.tools.menu_desc"))
     async def menu(self, ctx: commands.Context) -> None:
         """Display the beautiful command menu."""
         if ctx.interaction and not ctx.interaction.response.is_done():
@@ -795,16 +815,16 @@ class Menu(commands.Cog):
         else:
             await ctx.reply(embed=embed, view=view)
 
-    @commands.hybrid_command(name="start", description="Start menu | القائمة الرئيسية", with_app_command=False)
+    @commands.hybrid_command(name="start", description=get_cmd_desc("commands.tools.start_desc"), 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]} 」",
+            title="⚠️ Command Error | خطأ في الأمر",
+            description=f"「 {str(error)[:1000]} 」",
             color=discord.Color(0x2B2D31),
-            footer="🏮 Powered by BOT- AI Suite 🏮",
+            footer="🏮 Powered by BOT- AI Suite 🏮",
         )
         try:
             await ctx.reply(embed=embed)

bot/cogs/observability.py

@@ -1,16 +1,17 @@
-from __future__ import annotations
-
-import difflib
-import json
-import traceback
-from pathlib import Path
-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
+
+from bot.i18n import get_cmd_desc
 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
 
@@ -46,17 +47,17 @@ class Observability(commands.Cog):
         names = sorted({c.qualified_name for c in self.bot.commands} | {c.name for c in self.bot.commands})
         return difflib.get_close_matches(name, names, n=5, cutoff=0.4)
 
-    async def _safe_reply(self, ctx: commands.Context, message: str) -> None:
-        try:
-            await ctx.reply(message)
-        except (discord.NotFound, discord.InteractionResponded):
-            if ctx.channel:
-                await ctx.channel.send(message)
-        except discord.HTTPException as exc:
-            if exc.code not in {10062, 40060}:
-                raise
-            if ctx.channel:
-                await ctx.channel.send(message)
+    async def _safe_reply(self, ctx: commands.Context, message: str) -> None:
+        try:
+            await ctx.reply(message)
+        except (discord.NotFound, discord.InteractionResponded):
+            if ctx.channel:
+                await ctx.channel.send(message)
+        except discord.HTTPException as exc:
+            if exc.code not in {10062, 40060}:
+                raise
+            if ctx.channel:
+                await ctx.channel.send(message)
 
     @commands.Cog.listener()
     async def on_command_error(self, ctx: commands.Context, error: Exception) -> None:
@@ -124,8 +125,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=get_cmd_desc("commands.tools.command_fill_desc"))
+    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())
@@ -143,70 +144,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)
-
-    @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)
+        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=get_cmd_desc("commands.tools.system_audit_desc"))
+    @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/cogs/server_manager.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import discord
 from discord.ext import commands
 
+from bot.i18n import get_cmd_desc
+
 
 class ServerManager(commands.Cog):
     def __init__(self, bot: commands.Bot) -> None:
@@ -30,10 +32,10 @@ class ServerManager(commands.Cog):
             await channel.edit(category=category)
         return channel
 
-    @commands.hybrid_command(name="setupserver", description="Create an organized professional gaming server structure")
-    @commands.has_permissions(administrator=True)
-    async def setupserver_cmd(self, ctx: commands.Context) -> None:
-        guild = ctx.guild
+    @commands.hybrid_command(name="setupserver", description=get_cmd_desc("commands.tools.setupserver_desc"))
+    @commands.has_permissions(administrator=True)
+    async def setupserver_cmd(self, ctx: commands.Context) -> None:
+        guild = ctx.guild
 
         category_general = await self.ensure_category(guild, "📌・الإدارة")
         category_community = await self.ensure_category(guild, "💬・المجتمع")
@@ -98,7 +100,7 @@ class ServerManager(commands.Cog):
         embed.add_field(name="Core", value=f"{welcome.mention} | {logs.mention} | {daily.mention} | {suggestions.mention}", inline=False)
         await ctx.reply(embed=embed)
 
-    @commands.hybrid_command(name="organizechannels", description="Move current channels under suitable categories")
+    @commands.hybrid_command(name="organizechannels", description=get_cmd_desc("commands.tools.organizechannels_desc"))
     @commands.has_permissions(administrator=True)
     async def organize_channels(self, ctx: commands.Context) -> None:
         guild = ctx.guild

bot/cogs/utility.py

@@ -1,358 +1,556 @@
-from __future__ import annotations
-
-import asyncio
-import time
-
-import discord
-import psutil
-from discord.ext import commands
-
-from bot.theme import NEON_CYAN, NEON_PINK, NEON_PURPLE, progress_bar, add_banner_to_embed
-from bot.emojis import ui
-from bot.emojis import ui
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# AUTO REFRESH MIXIN - ميزة التحديث التلقائي
-# ═══════════════════════════════════════════════════════════════════════════════
-
-class AutoRefreshMixin:
-    """Mixin class for auto-refresh functionality."""
-    
-    _refresh_interval: int = 4
-    _refresh_task: asyncio.Task = None
-    _message: discord.Message = None
-    _stopped: bool = False
-    _consecutive_failures: int = 0
-    
-    async def start_auto_refresh(self, message: discord.Message) -> None:
-        """Start auto-refresh task."""
-        self._message = message
-        self._stopped = False
-        self._refresh_task = asyncio.create_task(self._auto_refresh_loop())
-    
-    async def _auto_refresh_loop(self) -> None:
-        """Auto refresh loop."""
-        while not self._stopped:
-            try:
-                await asyncio.sleep(self._refresh_interval)
-                if self._stopped or not self._message:
-                    break
-                # Build new embed
-                embed = await self._build_refresh_embed()
-                await self._message.edit(embed=embed, view=self)
-                self._consecutive_failures = 0
-            except discord.NotFound:
-                break
-            except discord.HTTPException:
-                self._consecutive_failures += 1
-                if self._consecutive_failures >= 5:
-                    break
-                await asyncio.sleep(2)
-                continue
-            except asyncio.CancelledError:
-                break
-            except Exception:
-                self._consecutive_failures += 1
-                if self._consecutive_failures >= 5:
-                    break
-                await asyncio.sleep(2)
-    
-    def stop_refresh(self) -> None:
-        """Stop auto-refresh."""
-        self._stopped = True
-        if self._refresh_task and not self._refresh_task.done():
-            self._refresh_task.cancel()
-    
-    async def _build_refresh_embed(self) -> discord.Embed:
-        """Override this method to build refresh embed."""
-        raise NotImplementedError
-
-
-class ServerInfoView(discord.ui.View, AutoRefreshMixin):
-    def __init__(self, cog: "Utility") -> None:
-        discord.ui.View.__init__(self, timeout=None)
-        AutoRefreshMixin.__init__(self)
-        self.cog = cog
-
-    @discord.ui.button(label="Refresh", emoji=ui("refresh"), style=discord.ButtonStyle.blurple, custom_id="utility:serverinfo:refresh")
-    async def refresh(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not interaction.guild:
-            await interaction.response.send_message("Server only.", ephemeral=True)
-            return
-        self._message = interaction.message
-        self.refresh.label = await self.cog.bot.tr(interaction.guild.id, "utility.refresh")
-        embed = await self.cog.build_serverinfo_embed(interaction.guild)
-        try:
-            await interaction.response.edit_message(embed=embed, view=self)
-        except (discord.NotFound, discord.InteractionResponded):
-            if interaction.message:
-                await interaction.message.edit(embed=embed, view=self)
-        except discord.HTTPException:
-            if interaction.message:
-                await interaction.message.edit(embed=embed, view=self)
-    
-    async def _build_refresh_embed(self) -> discord.Embed:
-        if self._message and self._message.guild:
-            return await self.cog.build_serverinfo_embed(self._message.guild)
-        return discord.Embed(title="Server Info", description="Server panel is ready.")
-
-
-class UserInfoView(discord.ui.View):
-    def __init__(self, cog: "Utility", member_id: int) -> None:
-        super().__init__(timeout=None)
-        self.cog = cog
-        self.member_id = member_id
-
-    @discord.ui.button(label="Refresh", emoji=ui("refresh"), style=discord.ButtonStyle.blurple)
-    async def refresh(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        if not interaction.guild:
-            await interaction.response.send_message("Server only.", ephemeral=True)
-            return
-        member = interaction.guild.get_member(self.member_id)
-        if not member:
-            await interaction.response.send_message("Member not found.", ephemeral=True)
-            return
-        self.refresh.label = await self.cog.bot.tr(interaction.guild.id, "utility.refresh")
-        embed = await self.cog.build_userinfo_embed(interaction.guild.id, member)
-        await interaction.response.edit_message(embed=embed, view=self)
-
-
-
-
-class BotStatsView(discord.ui.View, AutoRefreshMixin):
-    def __init__(self, cog: "Utility", guild_id: int | None = None) -> None:
-        discord.ui.View.__init__(self, timeout=None)
-        AutoRefreshMixin.__init__(self)
-        self.cog = cog
-        self.guild_id = guild_id
-
-    @discord.ui.button(label="Refresh", emoji="⛩️", style=discord.ButtonStyle.blurple, custom_id="utility:botstats:refresh")
-    async def refresh(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        guild_id = interaction.guild.id if interaction.guild else None
-        self.refresh.label = await self.cog.bot.tr(guild_id, "utility.refresh")
-        self.guild_id = guild_id
-        embed = await self._build_refresh_embed()
-        try:
-            await interaction.response.edit_message(embed=embed, view=self)
-        except (discord.NotFound, discord.InteractionResponded):
-            if interaction.message:
-                await interaction.message.edit(embed=embed, view=self)
-        except discord.HTTPException:
-            if interaction.message:
-                await interaction.message.edit(embed=embed, view=self)
-    
-    async def _build_refresh_embed(self) -> discord.Embed:
-        return await self.cog.build_botstats_embed(self.guild_id)
-
-
-
-
-class UtilityPollVoteView(discord.ui.View):
-    def __init__(self, *, question: str, options: list[str], author_id: int) -> None:
-        super().__init__(timeout=None)
-        self.question = question
-        self.options = options
-        self.author_id = author_id
-        self.voters: dict[int, int] = {}
-        for idx, option in enumerate(options):
-            btn = discord.ui.Button(label=option[:80], style=discord.ButtonStyle.secondary, custom_id=f"poll:{idx}")
-
-            async def _callback(interaction: discord.Interaction, i: int = idx) -> None:
-                self.voters[interaction.user.id] = i
-                await interaction.response.send_message(f"✅ Vote saved: **{self.options[i]}**", ephemeral=True)
-                if self.message:
-                    await self.message.edit(embed=self._build_embed(), view=self)
-
-            btn.callback = _callback
-            self.add_item(btn)
-        self.message: discord.Message | None = None
-
-    def _build_embed(self) -> discord.Embed:
-        total = len(self.voters)
-        embed = discord.Embed(title="🗳️ Community Poll", description=f"### {self.question}", color=NEON_CYAN)
-        for idx, option in enumerate(self.options):
-            count = sum(1 for choice in self.voters.values() if choice == idx)
-            ratio = 0 if total == 0 else int((count / total) * 100)
-            bar = "█" * max(1, ratio // 10) if total else "-"
-            embed.add_field(name=option, value=f"{count} votes • {ratio}%\n`{bar}`", inline=False)
-        embed.set_footer(text=f"Total voters: {total} • Poll by <@{self.author_id}> • You can change your vote any time")
-        return embed
-
-class Utility(commands.Cog):
-    def __init__(self, bot: commands.Bot) -> None:
-        self.bot = bot
-        self.started_at = time.time()
-
-    async def cog_load(self) -> None:
-        # Register persistent views for static panels.
-        self.bot.add_view(ServerInfoView(self))
-        self.bot.add_view(BotStatsView(self))
-
-    async def build_serverinfo_embed(self, guild: discord.Guild) -> discord.Embed:
-        text_channels = len(guild.text_channels)
-        voice_channels = len(guild.voice_channels)
-        categories = len(guild.categories)
-        bots = sum(1 for m in guild.members if m.bot)
-        humans = (guild.member_count or 0) - bots
-        owner = guild.owner.mention if guild.owner else "Unknown"
-        created = f"<t:{int(guild.created_at.timestamp())}:F>\n<t:{int(guild.created_at.timestamp())}:R>"
-
-        embed = discord.Embed(
-            title=f"╔════╗ {await self.bot.tr(guild.id, 'utility.serverinfo.title')} ╗════",
-            description=f"**{guild.name}**\nOwner: {owner}",
-            color=NEON_CYAN,
-        )
-        embed.add_field(name=await self.bot.tr(guild.id, "utility.serverinfo.members"), value=f"Total: {guild.member_count}\nHumans: {humans}\nBots: {bots}", inline=True)
-        embed.add_field(name=await self.bot.tr(guild.id, "utility.serverinfo.channels"), value=f"Total: {len(guild.channels)}\nText: {text_channels}\nVoice: {voice_channels}\nCategories: {categories}", inline=True)
-        embed.add_field(name=await self.bot.tr(guild.id, "utility.serverinfo.roles"), value=str(len(guild.roles)), inline=True)
-        embed.add_field(name=await self.bot.tr(guild.id, "utility.serverinfo.boost"), value=f"Tier {guild.premium_tier}\nBoosts: {guild.premium_subscription_count or 0}", inline=True)
-        embed.add_field(name="Created", value=created, inline=False)
-        embed.add_field(name="Server ID", value=str(guild.id), inline=False)
-        
-        # Add server banner if available
-        if guild.banner:
-            embed.set_image(url=guild.banner.url)
-        
-        if guild.icon:
-            embed.set_thumbnail(url=guild.icon.url)
-        embed.timestamp = discord.utils.utcnow()
-        return embed
-
-    async def build_userinfo_embed(self, guild_id: int | None, member: discord.Member) -> discord.Embed:
-        embed = discord.Embed(title=await self.bot.tr(guild_id, "utility.userinfo.title"), color=NEON_PINK)
-        embed.add_field(name=await self.bot.tr(guild_id, "utility.userinfo.id"), value=str(member.id), inline=False)
-        embed.add_field(name=await self.bot.tr(guild_id, "utility.userinfo.joined"), value=str(member.joined_at), inline=False)
-        embed.add_field(name=await self.bot.tr(guild_id, "utility.userinfo.created"), value=str(member.created_at), inline=False)
-        if guild_id:
-            row = await self.bot.db.fetchone(
-                "SELECT xp, level FROM user_xp WHERE guild_id = ? AND user_id = ?",
-                guild_id,
-                member.id,
-            )
-            xp, level = row if row else (0, 1)
-            target = max(1, level * 150)
-            remaining = max(0, target - xp)
-            embed.add_field(name="Level", value=str(level), inline=True)
-            embed.add_field(name="XP", value=f"{xp}/{target}", inline=True)
-            embed.add_field(name="XP Progress", value=progress_bar(xp, target), inline=False)
-            embed.add_field(name="XP to next level", value=str(remaining), inline=True)
-        embed.set_thumbnail(url=member.display_avatar.url)
-        embed.timestamp = discord.utils.utcnow()
-        return embed
-
-    async def build_botstats_embed(self, guild_id: int | None) -> discord.Embed:
-        process = psutil.Process()
-        mem = process.memory_info().rss / (1024 * 1024)
-        uptime_seconds = int(time.time() - self.started_at)
-        days, rem = divmod(uptime_seconds, 86400)
-        hours, rem = divmod(rem, 3600)
-        minutes, seconds = divmod(rem, 60)
-        uptime = f"{days}d {hours}h {minutes}m {seconds}s"
-        latency_ms = round(self.bot.latency * 1000)
-
-        embed = discord.Embed(
-            title=f"BOT- AI System\n╔════╗ {await self.bot.tr(guild_id, 'botstats.title')} ╗════",
-            color=NEON_PURPLE,
-        )
-        embed.add_field(name=await self.bot.tr(guild_id, "botstats.servers"), value=str(len(self.bot.guilds)), inline=True)
-        embed.add_field(name=await self.bot.tr(guild_id, "botstats.users"), value=str(len(self.bot.users)), inline=True)
-        embed.add_field(name=await self.bot.tr(guild_id, "botstats.latency"), value=f"{latency_ms}ms", inline=True)
-        embed.add_field(name=await self.bot.tr(guild_id, "botstats.cpu"), value=f"{psutil.cpu_percent()}%", inline=True)
-        embed.add_field(name=await self.bot.tr(guild_id, "botstats.ram"), value=f"{mem:.1f}MB", inline=True)
-        embed.add_field(name=await self.bot.tr(guild_id, "botstats.uptime"), value=uptime, inline=True)
-        embed.timestamp = discord.utils.utcnow()
-        return embed
-
-    @commands.hybrid_command(name="serverinfo", description="Server info panel | لوحة معلومات السيرفر")
-    async def serverinfo(self, ctx: commands.Context) -> None:
-        g = ctx.guild
-        if not g:
-            await ctx.reply("Server only.")
-            return
-        embed = await self.build_serverinfo_embed(g)
-        view = ServerInfoView(self)
-        view.refresh.label = await self.bot.tr(g.id, "utility.refresh")
-        msg = await ctx.reply(embed=embed, view=view)
-        if msg is None and ctx.interaction:
-            try:
-                msg = await ctx.interaction.original_response()
-            except Exception:
-                msg = None
-        view._message = msg
-        if msg:
-            await view.start_auto_refresh(msg)
-
-    @commands.hybrid_command(name="userinfo", description="User info panel | لوحة معلومات العضو")
-    async def userinfo(self, ctx: commands.Context, member: discord.Member | None = None) -> None:
-        member = member or ctx.author
-        embed = await self.build_userinfo_embed(ctx.guild.id if ctx.guild else None, member)
-        view = UserInfoView(self, member.id)
-        if ctx.guild:
-            view.refresh.label = await self.bot.tr(ctx.guild.id, "utility.refresh")
-        await ctx.reply(embed=embed, view=view)
-
-    @commands.hybrid_command(name="poll_legacy", description="Create poll | إنشاء تصويت", hidden=True, with_app_command=False)
-    async def poll(self, ctx: commands.Context, question: str, options: str = "") -> None:
-        parts = [p.strip() for p in options.split("|") if p.strip()]
-        if not parts:
-            parts = ["Yes", "No", "Maybe", "Skip", "Later"]
-        if len(parts) == 1:
-            parts.extend(["Option 2", "Option 3", "Option 4"])
-        elif len(parts) == 2:
-            parts.extend(["Option 3", "Option 4", "Option 5"])
-        parts = parts[:10]
-        row = await self.bot.db.fetchone("SELECT poll_channel_id FROM guild_config WHERE guild_id = ?", ctx.guild.id) if ctx.guild else None
-        channel = ctx.guild.get_channel(row[0]) if (ctx.guild and row and row[0]) else ctx.channel
-        view = PollVoteView(question=question, options=parts, author_id=ctx.author.id)
-        msg = await channel.send(embed=view._build_embed(), view=view)
-        view.message = msg
-        await ctx.reply(f"✅ Poll published in {channel.mention} with {len(parts)} options by {ctx.author.mention}.")
-
-    @commands.hybrid_command(name="remind", description="Set reminder | تعيين تذكير")
-    async def remind(self, ctx: commands.Context, seconds: int, *, text: str) -> None:
-        seconds = max(5, min(seconds, 604800))
-        due = int(time.time()) + seconds
-        await self.bot.db.execute(
-            "INSERT INTO reminders(user_id, channel_id, message, due_unix) VALUES (?, ?, ?, ?)",
-            ctx.author.id,
-            ctx.channel.id,
-            text,
-            due,
-        )
-        await ctx.reply(f"⏰ Reminder set in {seconds} seconds.")
-
-    @commands.Cog.listener()
-    async def on_message(self, message: discord.Message) -> None:
-        if message.author.bot:
-            return
-        now = int(time.time())
-        due_rows = await self.bot.db.fetchall(
-            "SELECT id, user_id, channel_id, message FROM reminders WHERE due_unix <= ? LIMIT 20",
-            now,
-        )
-        for rid, user_id, channel_id, msg in due_rows:
-            channel = self.bot.get_channel(channel_id)
-            if channel:
-                await channel.send(f"⏰ <@{user_id}> reminder: {msg}")
-            await self.bot.db.execute("DELETE FROM reminders WHERE id = ?", rid)
-
-    @commands.hybrid_command(name="botstats", description="Bot stats | إحصائيات البوت")
-    async def botstats(self, ctx: commands.Context) -> None:
-        guild_id = ctx.guild.id if ctx.guild else None
-        embed = await self.build_botstats_embed(guild_id)
-        view = BotStatsView(self, guild_id)
-        view.refresh.label = await self.bot.tr(guild_id, "utility.refresh")
-        msg = await ctx.reply(embed=embed, view=view)
-        if msg is None and ctx.interaction:
-            try:
-                msg = await ctx.interaction.original_response()
-            except Exception:
-                msg = None
-        view._message = msg
-        if msg:
-            await view.start_auto_refresh(msg)
-
-
-async def setup(bot: commands.Bot) -> None:
-    await bot.add_cog(Utility(bot))
+from __future__ import annotations
+
+import asyncio
+import time
+
+import discord
+import psutil
+from discord.ext import commands
+
+from bot.theme import NEON_CYAN, NEON_PINK, NEON_PURPLE, progress_bar, add_banner_to_embed
+from bot.i18n import get_cmd_desc
+from bot.emojis import ui
+from bot.emojis import ui
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# AUTO REFRESH MIXIN - ميزة التحديث التلقائي
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class AutoRefreshMixin:
+    """Mixin class for auto-refresh functionality."""
+    
+    _refresh_interval: int = 4
+    _refresh_task: asyncio.Task = None
+    _message: discord.Message = None
+    _stopped: bool = False
+    _consecutive_failures: int = 0
+    
+    async def start_auto_refresh(self, message: discord.Message) -> None:
+        """Start auto-refresh task."""
+        self._message = message
+        self._stopped = False
+        self._refresh_task = asyncio.create_task(self._auto_refresh_loop())
+    
+    async def _auto_refresh_loop(self) -> None:
+        """Auto refresh loop."""
+        while not self._stopped:
+            try:
+                await asyncio.sleep(self._refresh_interval)
+                if self._stopped or not self._message:
+                    break
+                # Build new embed
+                embed = await self._build_refresh_embed()
+                await self._message.edit(embed=embed, view=self)
+                self._consecutive_failures = 0
+            except discord.NotFound:
+                break
+            except discord.HTTPException:
+                self._consecutive_failures += 1
+                if self._consecutive_failures >= 5:
+                    break
+                await asyncio.sleep(2)
+                continue
+            except asyncio.CancelledError:
+                break
+            except Exception:
+                self._consecutive_failures += 1
+                if self._consecutive_failures >= 5:
+                    break
+                await asyncio.sleep(2)
+    
+    def stop_refresh(self) -> None:
+        """Stop auto-refresh."""
+        self._stopped = True
+        if self._refresh_task and not self._refresh_task.done():
+            self._refresh_task.cancel()
+    
+    async def _build_refresh_embed(self) -> discord.Embed:
+        """Override this method to build refresh embed."""
+        raise NotImplementedError
+
+
+class ServerInfoView(discord.ui.View, AutoRefreshMixin):
+    def __init__(self, cog: "Utility") -> None:
+        discord.ui.View.__init__(self, timeout=None)
+        AutoRefreshMixin.__init__(self)
+        self.cog = cog
+
+    @discord.ui.button(label="Refresh", emoji=ui("refresh"), style=discord.ButtonStyle.blurple, custom_id="utility:serverinfo:refresh")
+    async def refresh(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not interaction.guild:
+            await interaction.response.send_message("Server only.", ephemeral=True)
+            return
+        self._message = interaction.message
+        self.refresh.label = await self.cog.bot.tr(interaction.guild.id, "utility.refresh")
+        embed = await self.cog.build_serverinfo_embed(interaction.guild)
+        try:
+            await interaction.response.edit_message(embed=embed, view=self)
+        except (discord.NotFound, discord.InteractionResponded):
+            if interaction.message:
+                await interaction.message.edit(embed=embed, view=self)
+        except discord.HTTPException:
+            if interaction.message:
+                await interaction.message.edit(embed=embed, view=self)
+    
+    async def _build_refresh_embed(self) -> discord.Embed:
+        if self._message and self._message.guild:
+            return await self.cog.build_serverinfo_embed(self._message.guild)
+        return discord.Embed(title="Server Info", description="Server panel is ready.")
+
+
+class UserInfoView(discord.ui.View):
+    def __init__(self, cog: "Utility", member_id: int) -> None:
+        super().__init__(timeout=None)
+        self.cog = cog
+        self.member_id = member_id
+
+    @discord.ui.button(label="Refresh", emoji=ui("refresh"), style=discord.ButtonStyle.blurple)
+    async def refresh(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        if not interaction.guild:
+            await interaction.response.send_message("Server only.", ephemeral=True)
+            return
+        member = interaction.guild.get_member(self.member_id)
+        if not member:
+            await interaction.response.send_message("Member not found.", ephemeral=True)
+            return
+        self.refresh.label = await self.cog.bot.tr(interaction.guild.id, "utility.refresh")
+        embed = await self.cog.build_userinfo_embed(interaction.guild.id, member)
+        await interaction.response.edit_message(embed=embed, view=self)
+
+
+
+
+class BotStatsView(discord.ui.View, AutoRefreshMixin):
+    def __init__(self, cog: "Utility", guild_id: int | None = None) -> None:
+        discord.ui.View.__init__(self, timeout=None)
+        AutoRefreshMixin.__init__(self)
+        self.cog = cog
+        self.guild_id = guild_id
+
+    @discord.ui.button(label="Refresh", emoji="⛩️", style=discord.ButtonStyle.blurple, custom_id="utility:botstats:refresh")
+    async def refresh(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        guild_id = interaction.guild.id if interaction.guild else None
+        self.refresh.label = await self.cog.bot.tr(guild_id, "utility.refresh")
+        self.guild_id = guild_id
+        embed = await self._build_refresh_embed()
+        try:
+            await interaction.response.edit_message(embed=embed, view=self)
+        except (discord.NotFound, discord.InteractionResponded):
+            if interaction.message:
+                await interaction.message.edit(embed=embed, view=self)
+        except discord.HTTPException:
+            if interaction.message:
+                await interaction.message.edit(embed=embed, view=self)
+    
+    async def _build_refresh_embed(self) -> discord.Embed:
+        return await self.cog.build_botstats_embed(self.guild_id)
+
+
+
+
+class UtilityPollVoteView(discord.ui.View):
+    def __init__(self, *, question: str, options: list[str], author_id: int) -> None:
+        super().__init__(timeout=None)
+        self.question = question
+        self.options = options
+        self.author_id = author_id
+        self.voters: dict[int, int] = {}
+        for idx, option in enumerate(options):
+            btn = discord.ui.Button(label=option[:80], style=discord.ButtonStyle.secondary, custom_id=f"poll:{idx}")
+
+            async def _callback(interaction: discord.Interaction, i: int = idx) -> None:
+                self.voters[interaction.user.id] = i
+                await interaction.response.send_message(f"✅ Vote saved: **{self.options[i]}**", ephemeral=True)
+                if self.message:
+                    await self.message.edit(embed=self._build_embed(), view=self)
+
+            btn.callback = _callback
+            self.add_item(btn)
+        self.message: discord.Message | None = None
+
+    def _build_embed(self) -> discord.Embed:
+        total = len(self.voters)
+        embed = discord.Embed(title="🗳️ Community Poll", description=f"### {self.question}", color=NEON_CYAN)
+        for idx, option in enumerate(self.options):
+            count = sum(1 for choice in self.voters.values() if choice == idx)
+            ratio = 0 if total == 0 else int((count / total) * 100)
+            bar = "█" * max(1, ratio // 10) if total else "-"
+            embed.add_field(name=option, value=f"{count} votes • {ratio}%\n`{bar}`", inline=False)
+        embed.set_footer(text=f"Total voters: {total} • Poll by <@{self.author_id}> • You can change your vote any time")
+        return embed
+
+class Utility(commands.Cog):
+    def __init__(self, bot: commands.Bot) -> None:
+        self.bot = bot
+        self.started_at = time.time()
+
+    async def cog_load(self) -> None:
+        # Register persistent views for static panels.
+        self.bot.add_view(ServerInfoView(self))
+        self.bot.add_view(BotStatsView(self))
+
+    async def build_serverinfo_embed(self, guild: discord.Guild) -> discord.Embed:
+        text_channels = len(guild.text_channels)
+        voice_channels = len(guild.voice_channels)
+        categories = len(guild.categories)
+        bots = sum(1 for m in guild.members if m.bot)
+        humans = (guild.member_count or 0) - bots
+        owner = guild.owner.mention if guild.owner else "Unknown"
+        created = f"<t:{int(guild.created_at.timestamp())}:F>\n<t:{int(guild.created_at.timestamp())}:R>"
+
+        embed = discord.Embed(
+            title=f"╔════╗ {await self.bot.tr(guild.id, 'utility.serverinfo.title')} ╗════",
+            description=f"**{guild.name}**\nOwner: {owner}",
+            color=NEON_CYAN,
+        )
+        embed.add_field(name=await self.bot.tr(guild.id, "utility.serverinfo.members"), value=f"Total: {guild.member_count}\nHumans: {humans}\nBots: {bots}", inline=True)
+        embed.add_field(name=await self.bot.tr(guild.id, "utility.serverinfo.channels"), value=f"Total: {len(guild.channels)}\nText: {text_channels}\nVoice: {voice_channels}\nCategories: {categories}", inline=True)
+        embed.add_field(name=await self.bot.tr(guild.id, "utility.serverinfo.roles"), value=str(len(guild.roles)), inline=True)
+        embed.add_field(name=await self.bot.tr(guild.id, "utility.serverinfo.boost"), value=f"Tier {guild.premium_tier}\nBoosts: {guild.premium_subscription_count or 0}", inline=True)
+        embed.add_field(name="Created", value=created, inline=False)
+        embed.add_field(name="Server ID", value=str(guild.id), inline=False)
+        
+        # Add server banner if available
+        if guild.banner:
+            embed.set_image(url=guild.banner.url)
+        
+        if guild.icon:
+            embed.set_thumbnail(url=guild.icon.url)
+        embed.timestamp = discord.utils.utcnow()
+        return embed
+
+    async def build_userinfo_embed(self, guild_id: int | None, member: discord.Member) -> discord.Embed:
+        embed = discord.Embed(title=await self.bot.tr(guild_id, "utility.userinfo.title"), color=NEON_PINK)
+        embed.add_field(name=await self.bot.tr(guild_id, "utility.userinfo.id"), value=str(member.id), inline=False)
+        embed.add_field(name=await self.bot.tr(guild_id, "utility.userinfo.joined"), value=str(member.joined_at), inline=False)
+        embed.add_field(name=await self.bot.tr(guild_id, "utility.userinfo.created"), value=str(member.created_at), inline=False)
+        if guild_id:
+            row = await self.bot.db.fetchone(
+                "SELECT xp, level FROM user_xp WHERE guild_id = ? AND user_id = ?",
+                guild_id,
+                member.id,
+            )
+            xp, level = row if row else (0, 1)
+            target = max(1, level * 150)
+            remaining = max(0, target - xp)
+            embed.add_field(name="Level", value=str(level), inline=True)
+            embed.add_field(name="XP", value=f"{xp}/{target}", inline=True)
+            embed.add_field(name="XP Progress", value=progress_bar(xp, target), inline=False)
+            embed.add_field(name="XP to next level", value=str(remaining), inline=True)
+        embed.set_thumbnail(url=member.display_avatar.url)
+        embed.timestamp = discord.utils.utcnow()
+        return embed
+
+    async def build_botstats_embed(self, guild_id: int | None) -> discord.Embed:
+        process = psutil.Process()
+        mem = process.memory_info().rss / (1024 * 1024)
+        uptime_seconds = int(time.time() - self.started_at)
+        days, rem = divmod(uptime_seconds, 86400)
+        hours, rem = divmod(rem, 3600)
+        minutes, seconds = divmod(rem, 60)
+        uptime = f"{days}d {hours}h {minutes}m {seconds}s"
+        latency_ms = round(self.bot.latency * 1000)
+
+        embed = discord.Embed(
+            title=f"BOT- AI System\n╔════╗ {await self.bot.tr(guild_id, 'botstats.title')} ╗════",
+            color=NEON_PURPLE,
+        )
+        embed.add_field(name=await self.bot.tr(guild_id, "botstats.servers"), value=str(len(self.bot.guilds)), inline=True)
+        embed.add_field(name=await self.bot.tr(guild_id, "botstats.users"), value=str(len(self.bot.users)), inline=True)
+        embed.add_field(name=await self.bot.tr(guild_id, "botstats.latency"), value=f"{latency_ms}ms", inline=True)
+        embed.add_field(name=await self.bot.tr(guild_id, "botstats.cpu"), value=f"{psutil.cpu_percent()}%", inline=True)
+        embed.add_field(name=await self.bot.tr(guild_id, "botstats.ram"), value=f"{mem:.1f}MB", inline=True)
+        embed.add_field(name=await self.bot.tr(guild_id, "botstats.uptime"), value=uptime, inline=True)
+        embed.timestamp = discord.utils.utcnow()
+        return embed
+
+    @commands.hybrid_command(name="serverinfo", description=get_cmd_desc("commands.tools.serverinfo_desc"))
+    async def serverinfo(self, ctx: commands.Context) -> None:
+        g = ctx.guild
+        if not g:
+            await ctx.reply("Server only.")
+            return
+        embed = await self.build_serverinfo_embed(g)
+        view = ServerInfoView(self)
+        view.refresh.label = await self.bot.tr(g.id, "utility.refresh")
+        msg = await ctx.reply(embed=embed, view=view)
+        if msg is None and ctx.interaction:
+            try:
+                msg = await ctx.interaction.original_response()
+            except Exception:
+                msg = None
+        view._message = msg
+        if msg:
+            await view.start_auto_refresh(msg)
+
+    @commands.hybrid_command(name="userinfo", description=get_cmd_desc("commands.tools.userinfo_desc"))
+    async def userinfo(self, ctx: commands.Context, member: discord.Member | None = None) -> None:
+        member = member or ctx.author
+        embed = await self.build_userinfo_embed(ctx.guild.id if ctx.guild else None, member)
+        view = UserInfoView(self, member.id)
+        if ctx.guild:
+            view.refresh.label = await self.bot.tr(ctx.guild.id, "utility.refresh")
+        await ctx.reply(embed=embed, view=view)
+
+    @commands.hybrid_command(name="poll_legacy", description=get_cmd_desc("commands.tools.poll_legacy_desc"), hidden=True, with_app_command=False)
+    async def poll(self, ctx: commands.Context, question: str, options: str = "") -> None:
+        parts = [p.strip() for p in options.split("|") if p.strip()]
+        if not parts:
+            parts = ["Yes", "No", "Maybe", "Skip", "Later"]
+        if len(parts) == 1:
+            parts.extend(["Option 2", "Option 3", "Option 4"])
+        elif len(parts) == 2:
+            parts.extend(["Option 3", "Option 4", "Option 5"])
+        parts = parts[:10]
+        row = await self.bot.db.fetchone("SELECT poll_channel_id FROM guild_config WHERE guild_id = ?", ctx.guild.id) if ctx.guild else None
+        channel = ctx.guild.get_channel(row[0]) if (ctx.guild and row and row[0]) else ctx.channel
+        view = PollVoteView(question=question, options=parts, author_id=ctx.author.id)
+        msg = await channel.send(embed=view._build_embed(), view=view)
+        view.message = msg
+        await ctx.reply(f"✅ Poll published in {channel.mention} with {len(parts)} options by {ctx.author.mention}.")
+
+    @commands.hybrid_command(name="remind", description=get_cmd_desc("commands.tools.remind_desc"))
+    async def remind(self, ctx: commands.Context, seconds: int, *, text: str) -> None:
+        seconds = max(5, min(seconds, 604800))
+        due = int(time.time()) + seconds
+        await self.bot.db.execute(
+            "INSERT INTO reminders(user_id, channel_id, message, due_unix) VALUES (?, ?, ?, ?)",
+            ctx.author.id,
+            ctx.channel.id,
+            text,
+            due,
+        )
+        await ctx.reply(f"⏰ Reminder set in {seconds} seconds.")
+
+    @commands.Cog.listener()
+    async def on_message(self, message: discord.Message) -> None:
+        if message.author.bot:
+            return
+        now = int(time.time())
+        due_rows = await self.bot.db.fetchall(
+            "SELECT id, user_id, channel_id, message FROM reminders WHERE due_unix <= ? LIMIT 20",
+            now,
+        )
+        for rid, user_id, channel_id, msg in due_rows:
+            channel = self.bot.get_channel(channel_id)
+            if channel:
+                await channel.send(f"⏰ <@{user_id}> reminder: {msg}")
+            await self.bot.db.execute("DELETE FROM reminders WHERE id = ?", rid)
+
+    @commands.hybrid_command(name="search", description=get_cmd_desc("commands.tools.search_desc"))
+    @discord.app_commands.describe(query="Search query | بحث")
+    async def search(self, ctx: commands.Context, query: str) -> None:
+        """Search YouTube and show results with preview."""
+        if ctx.interaction and not ctx.interaction.response.is_done():
+            await ctx.interaction.response.defer()
+
+        loading_embed = discord.Embed(
+            title="🔎 Searching YouTube...",
+            description=f"🔍 **{query}**\n⏳ Please wait...",
+            color=discord.Color.orange(),
+        )
+        loading_msg = await ctx.send(embed=loading_embed)
+
+        results = await _yt_search(query, max_results=25)
+
+        if not results:
+            error_embed = discord.Embed(
+                title="❌ No Results Found",
+                description=f"No videos found for **{query}**.\nTry a different search term.",
+                color=discord.Color.red(),
+            )
+            try:
+                await loading_msg.edit(embed=error_embed, view=None)
+            except discord.NotFound:
+                await ctx.send(embed=error_embed)
+            return
+
+        view = SearchView(self, results, query)
+        first = results[0]
+        preview_embed = discord.Embed(
+            title=f"📺 {first.get('title', 'Untitled')}",
+            description=(
+                f"**📺 Channel:** {first.get('channel', 'Unknown')}\n"
+                f"**👁️ Views:** {first.get('views', 'N/A')}\n"
+                f"**⏱️ Duration:** {first.get('duration', 'N/A')}\n\n"
+                f"🔗 **[Watch Video]({first.get('url', '')})**\n\n"
+                f"📋 **{len(results)}** results found — select one below:"
+            ),
+            url=first.get("url", ""),
+            color=discord.Color.red(),
+        )
+        thumbnail = first.get("thumbnail")
+        if thumbnail:
+            preview_embed.set_image(url=thumbnail)
+        preview_embed.set_footer(text=f"YouTube Search | صفحة 1 من {min(len(results), 25)}")
+
+        try:
+            await loading_msg.edit(embed=preview_embed, view=view)
+        except discord.NotFound:
+            await ctx.send(embed=preview_embed, view=view)
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# YOUTUBE SEARCH COMMAND
+# ═══════════════════════════════════════════════════════════════════════════════
+
+_YT_AUTOCOMPLETE_CACHE: dict[str, list[str]] = {}
+
+
+class SearchSelect(discord.ui.Select):
+    """Select a YouTube video from search results."""
+
+    def __init__(self, cog, results: list, query: str) -> None:
+        self.cog = cog
+        self.results = results
+        self.query = query
+        options = []
+        for i, vid in enumerate(results[:25]):
+            title = vid.get("title", "Untitled")[:100]
+            channel = vid.get("channel", "")[:50]
+            label = f"{title}"
+            desc = f"📺 {channel}" if channel else None
+            options.append(discord.SelectOption(label=label, description=desc, value=str(i), emoji="▶️"))
+        super().__init__(
+            placeholder="🔎 Select a video to preview...",
+            options=options,
+        )
+
+    async def callback(self, interaction: discord.Interaction) -> None:
+        idx = int(self.values[0])
+        vid = self.results[idx]
+        embed = discord.Embed(
+            title=f"📺 {vid.get('title', 'Untitled')}",
+            description=f"**Channel:** {vid.get('channel', 'Unknown')}\n**Views:** {vid.get('views', 'N/A')}\n**Duration:** {vid.get('duration', 'N/A')}\n\n🔗 **Link:** {vid.get('url', '')}",
+            url=vid.get("url", ""),
+            color=discord.Color.red(),
+        )
+        thumbnail = vid.get("thumbnail")
+        if thumbnail:
+            embed.set_image(url=thumbnail)
+        embed.set_footer(text="YouTube Search | ابحث في يوتيوب")
+        await interaction.response.send_message(embed=embed)
+
+
+class SearchView(discord.ui.View):
+    def __init__(self, cog, results: list, query: str) -> None:
+        super().__init__(timeout=120)
+        self.add_item(SearchSelect(cog, results, query))
+
+
+class YouTubeAutocomplete(discord.app_commands.Transformer):
+    """Transformer that provides YouTube search suggestions."""
+
+    async def transform(self, interaction: discord.Interaction, value: str) -> str:
+        return value
+
+    async def autocomplete(self, interaction: discord.Interaction, current: str) -> list[discord.app_commands.Choice[str]]:
+        if not current or len(current) < 2:
+            return [discord.app_commands.Choice(name="🔎 Type to search YouTube...", value="")]
+        cache_key = current.lower()[:50]
+        if cache_key in _YT_AUTOCOMPLETE_CACHE:
+            suggestions = _YT_AUTOCOMPLETE_CACHE[cache_key]
+        else:
+            suggestions = await _yt_autocomplete_fetch(cache_key)
+            _YT_AUTOCOMPLETE_CACHE[cache_key] = suggestions
+        choices = []
+        for s in suggestions[:25]:
+            name = s[:100]
+            if len(s) > 100:
+                name = s[:97] + "..."
+            choices.append(discord.app_commands.Choice(name=name, value=s))
+        if not choices:
+            choices.append(discord.app_commands.Choice(name=f"🔎 Search: {current}", value=current))
+        return choices
+
+
+async def _yt_autocomplete_fetch(query: str) -> list[str]:
+    """Fetch YouTube search suggestions using the suggest endpoint."""
+    import aiohttp
+    url = f"http://suggestqueries.google.com/complete/search?client=firefox&ds=yt&q={query}"
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, timeout=aiohttp.ClientTimeout(total=5)) as resp:
+                if resp.status == 200:
+                    data = await resp.json()
+                    if len(data) >= 2:
+                        return [str(s) for s in data[1] if isinstance(s, str)]
+    except Exception:
+        pass
+    return []
+
+
+async def _yt_search(query: str, max_results: int = 25) -> list[dict]:
+    """Search YouTube and return video results."""
+    import aiohttp
+    import json
+    import re
+    from urllib.parse import quote
+
+    results = []
+    search_url = f"https://www.youtube.com/results?search_query={quote(query)}&hl=en"
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(search_url, timeout=aiohttp.ClientTimeout(total=10)) as resp:
+                if resp.status == 200:
+                    html = await resp.text()
+                    match = re.search(r'var ytInitialData\s*=\s*(\{.*?\});', html, re.DOTALL)
+                    if match:
+                        data = json.loads(match.group(1))
+                        contents = data.get("contents", {}).get("twoColumnSearchResultsRenderer", {}).get(
+                            "primaryContents", {}).get("sectionListRenderer", {}).get("contents", [{}])[0].get(
+                            "itemSectionRenderer", {}).get("contents", [])
+                        for item in contents:
+                            vr = item.get("videoRenderer", {})
+                            if not vr:
+                                continue
+                            video_id = vr.get("videoId", "")
+                            title_runs = vr.get("title", {}).get("runs", [])
+                            title = title_runs[0].get("text", "Untitled") if title_runs else "Untitled"
+                            channel_runs = vr.get("ownerText", {}).get("runs", [])
+                            channel = channel_runs[0].get("text", "Unknown") if channel_runs else "Unknown"
+                            view_text = vr.get("viewCountText", {}).get("simpleText", "")
+                            length_text = vr.get("lengthText", {}).get("simpleText", "")
+                            thumbnails = vr.get("thumbnail", {}).get("thumbnails", [])
+                            thumbnail = thumbnails[-1].get("url", "") if thumbnails else ""
+                            results.append({
+                                "title": title,
+                                "channel": channel,
+                                "views": view_text,
+                                "duration": length_text,
+                                "url": f"https://www.youtube.com/watch?v={video_id}",
+                                "thumbnail": thumbnail,
+                                "video_id": video_id,
+                            })
+                            if len(results) >= max_results:
+                                break
+    except Exception:
+        pass
+    return results
+
+
+class Utility(commands.Cog):
+    """Utility commands including YouTube search."""
+
+    def __init__(self, bot: commands.Bot) -> None:
+        self.bot = bot
+
+    @commands.hybrid_command(name="botstats", description=get_cmd_desc("commands.tools.botstats_desc"))
+    async def botstats(self, ctx: commands.Context) -> None:
+        guild_id = ctx.guild.id if ctx.guild else None
+        embed = await self.build_botstats_embed(guild_id)
+        view = BotStatsView(self, guild_id)
+        view.refresh.label = await self.bot.tr(guild_id, "utility.refresh")
+        msg = await ctx.reply(embed=embed, view=view)
+        if msg is None and ctx.interaction:
+            try:
+                msg = await ctx.interaction.original_response()
+            except Exception:
+                msg = None
+        view._message = msg
+        if msg:
+            await view.start_auto_refresh(msg)
+
+
+async def setup(bot: commands.Bot) -> None:
+    await bot.add_cog(Utility(bot))

bot/cogs/verification.py

@@ -1,177 +1,178 @@
-from __future__ import annotations
-
-import discord
-from discord.ext import commands
-from bot.emojis import ui
-from bot.emojis import ui
-
-
-class VerifyView(discord.ui.View):
-    def __init__(self, bot: commands.Bot) -> None:
-        super().__init__(timeout=None)
-        self.bot = bot
-
-    @discord.ui.button(label="Verify", emoji=ui("lock"), style=discord.ButtonStyle.success, custom_id="verify:member")
-    async def verify_member(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
-        guild_id = interaction.guild.id if interaction.guild else None
-        if not interaction.response.is_done():
-            try:
-                await interaction.response.defer(ephemeral=True, thinking=False)
-            except (discord.NotFound, discord.HTTPException, discord.InteractionResponded):
-                return
-        if not interaction.guild:
-            await interaction.followup.send(await self.bot.get_text(guild_id, "common.server_only"), ephemeral=True)
-            return
-
-        row = await self.bot.db.fetchone(
-            "SELECT verify_role_id, welcome_channel_id FROM guild_config WHERE guild_id = ?",
-            interaction.guild.id,
-        )
-        if not row or not row[0]:
-            await interaction.followup.send(await self.bot.get_text(guild_id, "welcome.verify_role_missing"), ephemeral=True)
-            return
-
-        role = interaction.guild.get_role(row[0])
-        if not role:
-            await interaction.followup.send(await self.bot.get_text(guild_id, "welcome.verify_role_deleted"), ephemeral=True)
-            return
-
-        member = interaction.user if isinstance(interaction.user, discord.Member) else interaction.guild.get_member(interaction.user.id)
-        if not member:
-            await interaction.followup.send(await self.bot.get_text(guild_id, "welcome.verify_member_missing"), ephemeral=True)
-            return
-
-        if role in member.roles:
-            await interaction.followup.send(await self.bot.get_text(guild_id, "welcome.verify_already_done"), ephemeral=True)
-            return
-
-        await member.add_roles(role, reason="Member completed verification")
-        await interaction.followup.send(await self.bot.get_text(guild_id, "welcome.verify_success"), ephemeral=True)
-
-        await self.bot.log_to_guild(
-            interaction.guild,
-            await self.bot.get_text(guild_id, "welcome.verify_log_title"),
-            await self.bot.get_text(guild_id, "welcome.verify_log_desc", member=member.mention, role=role.mention),
-            color=discord.Color.green(),
-        )
-
-    async def localize(self, guild_id: int | None) -> "VerifyView":
-        for item in self.children:
-            if isinstance(item, discord.ui.Button) and item.custom_id == "verify:member":
-                item.label = await self.bot.get_text(guild_id, "welcome.verify_button")
-                item.emoji = self.bot.get_custom_emoji("admin", fallback="🔐")
-        return self
-
-
-class Verification(commands.Cog):
-    def __init__(self, bot: commands.Bot) -> None:
-        self.bot = bot
-
-    async def cog_load(self) -> None:
-        self.bot.add_view(VerifyView(self))
-
-    @commands.hybrid_command(name="verify", description="Open the verification panel")
-    async def verify(self, ctx: commands.Context) -> None:
-        await self.verify_config(ctx)
-
-    @commands.hybrid_group(name="verify_config", fallback="panel", description="Verification system controls")
-    async def verify_config(self, ctx: commands.Context) -> None:
-        """Open the verification panel."""
-        if not ctx.guild:
-            await ctx.reply(await self.bot.get_text(None, "common.server_only"))
-            return
-        embed = await self._build_verify_panel(ctx.guild.id)
-        await ctx.reply(embed=embed, view=await VerifyView(self.bot).localize(ctx.guild.id))
-
-    @verify_config.command(name="setup", description="Configure verification system and lock channels")
-    @commands.has_permissions(administrator=True)
-    async def verify_setup(
-        self,
-        ctx: commands.Context,
-        role: discord.Role,
-        verify_channel: discord.TextChannel,
-        welcome_channel: discord.TextChannel,
-    ) -> None:
-        guild = ctx.guild
-
-        await self.bot.db.execute(
-            """
-            INSERT INTO guild_config(guild_id, verify_role_id, verify_channel_id, welcome_channel_id)
-            VALUES (?, ?, ?, ?)
-            ON CONFLICT(guild_id) DO UPDATE SET
-                verify_role_id = excluded.verify_role_id,
-                verify_channel_id = excluded.verify_channel_id,
-                welcome_channel_id = excluded.welcome_channel_id
-            """,
-            guild.id,
-            role.id,
-            verify_channel.id,
-            welcome_channel.id,
-        )
-
-        everyone = guild.default_role
-        for channel in guild.channels:
-            if channel.id == verify_channel.id:
-                await channel.set_permissions(everyone, view_channel=True, send_messages=False)
-                await channel.set_permissions(role, view_channel=True, send_messages=False)
-            else:
-                await channel.set_permissions(everyone, view_channel=False)
-                await channel.set_permissions(role, view_channel=True)
-
-        embed = discord.Embed(
-            title="🔐 Verification Enabled",
-            description=(
-                "تم تفعيل نظام التحقق الاحترافي.\n"
-                f"- قناة التحقق: {verify_channel.mention}\n"
-                f"- قناة الترحيب: {welcome_channel.mention}\n"
-                f"- رتبة التحقق: {role.mention}\n"
-                "كل القنوات أصبحت مخفية حتى يقوم العضو بالتحقق."
-            ),
-            color=discord.Color.blurple(),
-        )
-        panel = discord.Embed(
-            title=await self.bot.get_text(guild.id, "welcome.verify_title"),
-            description=await self.bot.get_text(guild.id, "welcome.verify_body"),
-            color=discord.Color.green(),
-        )
-        panel.add_field(name=await self.bot.get_text(guild.id, "welcome.verify_benefits_title"), value=await self.bot.get_text(guild.id, "welcome.verify_benefits_body"), inline=False)
-        panel.set_footer(text=await self.bot.get_text(guild.id, "welcome.verify_footer"))
-        await verify_channel.send(embed=panel, view=await VerifyView(self.bot).localize(guild.id))
-        await ctx.reply(embed=embed)
-
-    @commands.hybrid_command(name="verifysetup", description="Configure verification system and lock channels", with_app_command=False)
-    @commands.has_permissions(administrator=True)
-    async def verify_setup_legacy(
-        self,
-        ctx: commands.Context,
-        role: discord.Role,
-        verify_channel: discord.TextChannel,
-        welcome_channel: discord.TextChannel,
-    ) -> None:
-        await self.verify_setup(
-            ctx,
-            role=role,
-            verify_channel=verify_channel,
-            welcome_channel=welcome_channel,
-        )
-
-    async def _build_verify_panel(self, guild_id: int) -> discord.Embed:
-        lock = self.bot.get_custom_emoji("admin", fallback="🔐")
-        unlock = self.bot.get_custom_emoji("admin", fallback="🔓")
-        divider = "⛩️ ━━━ 🏮 ━━━ ⛩️"
-        embed = discord.Embed(
-            title=f"{lock} {await self.bot.get_text(guild_id, 'welcome.verify_title')}",
-            description=f"{divider}\n{await self.bot.get_text(guild_id, 'welcome.verify_body')}\n{divider}",
-            color=discord.Color.green(),
-        )
-        embed.add_field(
-            name=f"{unlock} {await self.bot.get_text(guild_id, 'welcome.verify_benefits_title')}",
-            value=await self.bot.get_text(guild_id, "welcome.verify_benefits_body"),
-            inline=False,
-        )
-        embed.set_footer(text=await self.bot.get_text(guild_id, "welcome.verify_footer"))
-        return embed
-
-
-async def setup(bot: commands.Bot) -> None:
-    await bot.add_cog(Verification(bot))
+from __future__ import annotations
+
+import discord
+from discord.ext import commands
+from bot.i18n import get_cmd_desc
+from bot.emojis import ui
+from bot.emojis import ui
+
+
+class VerifyView(discord.ui.View):
+    def __init__(self, bot: commands.Bot) -> None:
+        super().__init__(timeout=None)
+        self.bot = bot
+
+    @discord.ui.button(label="Verify", emoji=ui("lock"), style=discord.ButtonStyle.success, custom_id="verify:member")
+    async def verify_member(self, interaction: discord.Interaction, _: discord.ui.Button) -> None:
+        guild_id = interaction.guild.id if interaction.guild else None
+        if not interaction.response.is_done():
+            try:
+                await interaction.response.defer(ephemeral=True, thinking=False)
+            except (discord.NotFound, discord.HTTPException, discord.InteractionResponded):
+                return
+        if not interaction.guild:
+            await interaction.followup.send(await self.bot.get_text(guild_id, "common.server_only"), ephemeral=True)
+            return
+
+        row = await self.bot.db.fetchone(
+            "SELECT verify_role_id, welcome_channel_id FROM guild_config WHERE guild_id = ?",
+            interaction.guild.id,
+        )
+        if not row or not row[0]:
+            await interaction.followup.send(await self.bot.get_text(guild_id, "welcome.verify_role_missing"), ephemeral=True)
+            return
+
+        role = interaction.guild.get_role(row[0])
+        if not role:
+            await interaction.followup.send(await self.bot.get_text(guild_id, "welcome.verify_role_deleted"), ephemeral=True)
+            return
+
+        member = interaction.user if isinstance(interaction.user, discord.Member) else interaction.guild.get_member(interaction.user.id)
+        if not member:
+            await interaction.followup.send(await self.bot.get_text(guild_id, "welcome.verify_member_missing"), ephemeral=True)
+            return
+
+        if role in member.roles:
+            await interaction.followup.send(await self.bot.get_text(guild_id, "welcome.verify_already_done"), ephemeral=True)
+            return
+
+        await member.add_roles(role, reason="Member completed verification")
+        await interaction.followup.send(await self.bot.get_text(guild_id, "welcome.verify_success"), ephemeral=True)
+
+        await self.bot.log_to_guild(
+            interaction.guild,
+            await self.bot.get_text(guild_id, "welcome.verify_log_title"),
+            await self.bot.get_text(guild_id, "welcome.verify_log_desc", member=member.mention, role=role.mention),
+            color=discord.Color.green(),
+        )
+
+    async def localize(self, guild_id: int | None) -> "VerifyView":
+        for item in self.children:
+            if isinstance(item, discord.ui.Button) and item.custom_id == "verify:member":
+                item.label = await self.bot.get_text(guild_id, "welcome.verify_button")
+                item.emoji = self.bot.get_custom_emoji("admin", fallback="🔐")
+        return self
+
+
+class Verification(commands.Cog):
+    def __init__(self, bot: commands.Bot) -> None:
+        self.bot = bot
+
+    async def cog_load(self) -> None:
+        self.bot.add_view(VerifyView(self))
+
+    @commands.hybrid_command(name="verify", description=get_cmd_desc("commands.tools.verify_desc"))
+    async def verify(self, ctx: commands.Context) -> None:
+        await self.verify_config(ctx)
+
+    @commands.hybrid_group(name="verify_config", fallback="panel", description="Verification system controls")
+    async def verify_config(self, ctx: commands.Context) -> None:
+        """Open the verification panel."""
+        if not ctx.guild:
+            await ctx.reply(await self.bot.get_text(None, "common.server_only"))
+            return
+        embed = await self._build_verify_panel(ctx.guild.id)
+        await ctx.reply(embed=embed, view=await VerifyView(self.bot).localize(ctx.guild.id))
+
+    @verify_config.command(name="setup", description="Configure verification system and lock channels")
+    @commands.has_permissions(administrator=True)
+    async def verify_setup(
+        self,
+        ctx: commands.Context,
+        role: discord.Role,
+        verify_channel: discord.TextChannel,
+        welcome_channel: discord.TextChannel,
+    ) -> None:
+        guild = ctx.guild
+
+        await self.bot.db.execute(
+            """
+            INSERT INTO guild_config(guild_id, verify_role_id, verify_channel_id, welcome_channel_id)
+            VALUES (?, ?, ?, ?)
+            ON CONFLICT(guild_id) DO UPDATE SET
+                verify_role_id = excluded.verify_role_id,
+                verify_channel_id = excluded.verify_channel_id,
+                welcome_channel_id = excluded.welcome_channel_id
+            """,
+            guild.id,
+            role.id,
+            verify_channel.id,
+            welcome_channel.id,
+        )
+
+        everyone = guild.default_role
+        for channel in guild.channels:
+            if channel.id == verify_channel.id:
+                await channel.set_permissions(everyone, view_channel=True, send_messages=False)
+                await channel.set_permissions(role, view_channel=True, send_messages=False)
+            else:
+                await channel.set_permissions(everyone, view_channel=False)
+                await channel.set_permissions(role, view_channel=True)
+
+        embed = discord.Embed(
+            title="🔐 Verification Enabled",
+            description=(
+                "تم تفعيل نظام التحقق الاحترافي.\n"
+                f"- قناة التحقق: {verify_channel.mention}\n"
+                f"- قناة الترحيب: {welcome_channel.mention}\n"
+                f"- رتبة التحقق: {role.mention}\n"
+                "كل القنوات أصبحت مخفية حتى يقوم العضو بالتحقق."
+            ),
+            color=discord.Color.blurple(),
+        )
+        panel = discord.Embed(
+            title=await self.bot.get_text(guild.id, "welcome.verify_title"),
+            description=await self.bot.get_text(guild.id, "welcome.verify_body"),
+            color=discord.Color.green(),
+        )
+        panel.add_field(name=await self.bot.get_text(guild.id, "welcome.verify_benefits_title"), value=await self.bot.get_text(guild.id, "welcome.verify_benefits_body"), inline=False)
+        panel.set_footer(text=await self.bot.get_text(guild.id, "welcome.verify_footer"))
+        await verify_channel.send(embed=panel, view=await VerifyView(self.bot).localize(guild.id))
+        await ctx.reply(embed=embed)
+
+    @commands.hybrid_command(name="verifysetup", description=get_cmd_desc("commands.tools.verifysetup_desc"), with_app_command=False)
+    @commands.has_permissions(administrator=True)
+    async def verify_setup_legacy(
+        self,
+        ctx: commands.Context,
+        role: discord.Role,
+        verify_channel: discord.TextChannel,
+        welcome_channel: discord.TextChannel,
+    ) -> None:
+        await self.verify_setup(
+            ctx,
+            role=role,
+            verify_channel=verify_channel,
+            welcome_channel=welcome_channel,
+        )
+
+    async def _build_verify_panel(self, guild_id: int) -> discord.Embed:
+        lock = self.bot.get_custom_emoji("admin", fallback="🔐")
+        unlock = self.bot.get_custom_emoji("admin", fallback="🔓")
+        divider = "⛩️ ━━━ 🏮 ━━━ ⛩️"
+        embed = discord.Embed(
+            title=f"{lock} {await self.bot.get_text(guild_id, 'welcome.verify_title')}",
+            description=f"{divider}\n{await self.bot.get_text(guild_id, 'welcome.verify_body')}\n{divider}",
+            color=discord.Color.green(),
+        )
+        embed.add_field(
+            name=f"{unlock} {await self.bot.get_text(guild_id, 'welcome.verify_benefits_title')}",
+            value=await self.bot.get_text(guild_id, "welcome.verify_benefits_body"),
+            inline=False,
+        )
+        embed.set_footer(text=await self.bot.get_text(guild_id, "welcome.verify_footer"))
+        return embed
+
+
+async def setup(bot: commands.Bot) -> None:
+    await bot.add_cog(Verification(bot))

bot/config.py

@@ -1,10 +1,14 @@
 from __future__ import annotations
 
+import logging
 import os
 from dataclasses import dataclass
 from dotenv import load_dotenv
 
 
+logger = logging.getLogger("mega-bot.config")
+
+
 @dataclass(slots=True)
 class Settings:
     token: str
@@ -16,16 +20,44 @@ class Settings:
     gemini_api_key: str = ""
 
 
+def _parse_owner_ids(raw: str) -> set[int]:
+    """Parse and validate OWNER_IDS from environment variable."""
+    if not raw or not raw.strip():
+        logger.warning("OWNER_IDS is empty. No owners configured.")
+        return set()
+
+    owner_ids: set[int] = set()
+    for part in raw.split(","):
+        cleaned = part.strip()
+        if not cleaned:
+            continue
+        if not cleaned.isdigit():
+            logger.warning("Invalid OWNER_IDS value skipped: %r", cleaned)
+            continue
+        value = int(cleaned)
+        # Discord snowflake IDs are positive integers, typically 17-19 digits
+        if value <= 0:
+            logger.warning("Invalid OWNER_IDS value (non-positive): %d", value)
+            continue
+        if value > 9_999_999_999_999_999_999:
+            logger.warning("Suspiciously large OWNER_IDS value: %d", value)
+            continue
+        owner_ids.add(value)
+
+    if not owner_ids:
+        logger.warning("No valid OWNER_IDS found after validation.")
+    else:
+        logger.info("Loaded %d owner ID(s).", len(owner_ids))
+
+    return owner_ids
+
+
 def load_settings() -> Settings:
     load_dotenv()
     token = os.getenv("DISCORD_TOKEN", "").strip()
     prefix = os.getenv("PREFIX", "!").strip() or "!"
     raw_owners = os.getenv("OWNER_IDS", "")
-    owner_ids: set[int] = {
-        int(owner.strip())
-        for owner in raw_owners.split(",")
-        if owner.strip().isdigit()
-    }
+    owner_ids = _parse_owner_ids(raw_owners)
     raw_db_path = os.getenv("DB_PATH", "").strip()
     if raw_db_path:
         db_path = raw_db_path

bot/database.py

@@ -6,6 +6,7 @@ Provides async SQLite operations with schema migrations and persistent connectio
 import asyncio
 import os
 import shutil
+import time
 from pathlib import Path
 
 import aiosqlite
@@ -17,6 +18,10 @@ except Exception:  # pragma: no cover
     hf_hub_download = None
 
 
+# Minimum seconds between HuggingFace DB sync pushes to avoid rate limits
+_HF_SYNC_INTERVAL_SECONDS = 60
+
+
 class Database:
     def __init__(self, path: str = "database.db") -> None:
         self.path = path
@@ -37,6 +42,7 @@ class Database:
             and HfApi
             and hf_hub_download
         )
+        self._last_hf_push: float = 0.0
 
     def _prepare_path(self) -> None:
         """Ensure the sqlite parent directory exists when a directory is provided."""
@@ -66,6 +72,11 @@ class Database:
     async def _push_remote_db(self) -> None:
         if not self._hf_sync_enabled:
             return
+        # Rate limit: avoid pushing too frequently
+        now = time.monotonic()
+        elapsed = now - self._last_hf_push
+        if elapsed < _HF_SYNC_INTERVAL_SECONDS:
+            return
         try:
             api = HfApi(token=self._hf_token)
             await asyncio.to_thread(
@@ -76,6 +87,7 @@ class Database:
                 repo_type=self._hf_repo_type,
                 commit_message="Bot DB sync",
             )
+            self._last_hf_push = time.monotonic()
         except Exception:
             # Disable further sync attempts to avoid repeated noisy auth/network failures.
             self._hf_sync_enabled = False
@@ -350,6 +362,17 @@ class Database:
                 updated_by INTEGER,
                 updated_at TEXT DEFAULT CURRENT_TIMESTAMP
             );
+
+            CREATE TABLE IF NOT EXISTS ai_scheduled_tasks (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                guild_id INTEGER,
+                run_at TEXT,
+                action_json TEXT,
+                reason TEXT,
+                created_by INTEGER,
+                executed INTEGER DEFAULT 0,
+                created_at TEXT DEFAULT CURRENT_TIMESTAMP
+            );
             """
         )
 

bot/emojis.py

@@ -3,6 +3,7 @@ Enhanced Emoji system for the bot.
 Loads custom emojis from emojies.txt and provides UI emoji aliases with rich decorations.
 """
 
+import os
 from pathlib import Path
 import re
 
@@ -79,8 +80,9 @@ FALLBACK_EMOJIS: dict[str, str] = {
 _EMOJI_FILES = (
     Path("emojies.txt"),
     Path("bot/emojies.txt"),
-    Path("/home/z/my-project/discord-bot/emojies.txt"),
+    Path(os.getenv("EMOJI_FILE_PATH", "/opt/bot/emojies.txt")) if os.getenv("EMOJI_FILE_PATH") else None,
 )
+_EMOJI_FILES = tuple(p for p in _EMOJI_FILES if p is not None)
 _EMOJI_ID_RE = re.compile(r"\d{6,}")
 _EMOJI_TAG_RE = re.compile(r"^<(a?):([\w~]+):(\d{6,})>$")
 _EMOJI_BOT: discord.Client | None = None
@@ -139,7 +141,11 @@ def _ensure_unescaped_emoji(value: str) -> str:
 
 
 def resolve_emoji_value(value: str, fallback: str = "✨", *, bot: discord.Client | None = None) -> str:
-    """Resolve emoji config with a hybrid resolver (cache first, then manual tag build)."""
+    """Resolve emoji config with a hybrid resolver (cache first, then fallback to unicode).
+
+    If the custom emoji is available in the bot's cache, it returns the full tag.
+    Otherwise it falls back to the unicode fallback to avoid showing raw :name: text.
+    """
     parsed = _parse_custom_emoji_config(value)
     if parsed is not None:
         config_name, emoji_id, animated = parsed
@@ -148,7 +154,8 @@ def resolve_emoji_value(value: str, fallback: str = "✨", *, bot: discord.Clien
             resolved = active_bot.get_emoji(emoji_id)
             if resolved is not None:
                 return _ensure_unescaped_emoji(_format_custom_emoji(resolved))
-        return _ensure_unescaped_emoji(_build_custom_emoji_code(config_name, emoji_id, animated))
+        # Emoji not in cache — return fallback unicode to avoid raw :name: display
+        return fallback
 
     emoji_id = _extract_emoji_id(value)
     active_bot = bot or _EMOJI_BOT
@@ -156,6 +163,8 @@ def resolve_emoji_value(value: str, fallback: str = "✨", *, bot: discord.Clien
         resolved = active_bot.get_emoji(emoji_id)
         if resolved is not None:
             return _ensure_unescaped_emoji(_format_custom_emoji(resolved))
+        return fallback
+    # Value might be a plain unicode emoji or already-resolved string
     return _ensure_unescaped_emoji(value or fallback)
 
 
@@ -488,7 +497,6 @@ COMMAND_EMOJIS: dict[str, str] = {
     "seek": "⏩",
     "rewind": "⏪",
     "forward": "⏩",
-    "rewind": "⏪",
     "filter": "🎛️",
     "clear": ui("trash"),
     "remove": ui("spotify_remove"),