From 063b68fdc12a13bbc1445c919d569dd7fdde9c86 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sat, 30 May 2026 16:00:48 +1000
Subject: [PATCH 01/32] 279-Bug fix quest progress counting in restricted
 channels

---
 features/quests.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/features/quests.py b/features/quests.py
index dc467a0..dd27883 100644
--- a/features/quests.py
+++ b/features/quests.py
@@ -2,6 +2,9 @@
 from discord import app_commands
 from discord.ext import commands
 
+# Import Config
+from features.config import BOTS_CATEGORY_ID, PASSIVE_REWARD_EXCLUDED_CHANNEL_IDS
+
 # Import Database Helpers
 from database.mongo import (
     init_default_quests,
@@ -115,6 +118,13 @@ async def process_quest_update(self, user_id, channel, action_type="message"):
     async def on_message(self, message: discord.Message):
         if message.author.bot:
             return
+
+        # Skip quest progress in restricted channels (same rules as token earning)
+        if message.channel.category and message.channel.category.id == BOTS_CATEGORY_ID:
+            return
+        if message.channel.id in PASSIVE_REWARD_EXCLUDED_CHANNEL_IDS:
+            return
+
         # Trigger message quest updates
         await self.process_quest_update(
             str(message.author.id), message.channel, "message"

From 0e1a15af9096afbcb3b7d4b1fee6ee2188d6fec5 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sat, 30 May 2026 16:13:19 +1000
Subject: [PATCH 02/32] 285-Enhancement add budget reset date to check-budget
 command embed

---
 features/economy.py | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/features/economy.py b/features/economy.py
index d83e1d7..89e39b7 100644
--- a/features/economy.py
+++ b/features/economy.py
@@ -2,7 +2,7 @@
 import discord
 from discord import app_commands
 from discord.ext import commands, tasks
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 import random
 from typing import Optional
 import asyncio
@@ -1175,11 +1175,19 @@ async def check_budget(self, interaction: discord.Interaction):
         int(await get_setting("nitro_redeemed_count", "0"))
         int(await get_setting("pin_redeemed_count", "0"))
 
+        now = datetime.now(timezone.utc)
+        if now.month == 12:
+            reset_date = datetime(now.year + 1, 1, 1, tzinfo=timezone.utc)
+        else:
+            reset_date = datetime(now.year, now.month + 1, 1, tzinfo=timezone.utc)
+        reset_timestamp = int(reset_date.timestamp())
+
         embed = discord.Embed(title="💰 **Budget Status**", color=discord.Color.blue())
         embed.description = (
             f"**Total Monthly Budget:** ${total_budget:.2f}\n"
             f"**Total Spent on Redemptions:** ${total_spent:.2f}\n"
-            f"**Remaining Budget:** ${remaining:.2f}"
+            f"**Remaining Budget:** ${remaining:.2f}\n"
+            f"**Budget Resets:** <t:{reset_timestamp}:R> (<t:{reset_timestamp}:F>)"
         )
         await interaction.response.send_message(embed=embed, ephemeral=True)
 

From 1d687a873b21472173468c25f368be677e2d2c4b Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sat, 30 May 2026 19:48:28 +1000
Subject: [PATCH 03/32] 277-Feature add /version slash command with embed
 display

---
 features/general.py | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/features/general.py b/features/general.py
index 1b52347..57050a0 100644
--- a/features/general.py
+++ b/features/general.py
@@ -194,6 +194,14 @@ async def admin_help(self, interaction: discord.Interaction):
         "BRT": "America/Sao_Paulo",
     }
 
+    @app_commands.command(name="version", description="View the bot's current version.")
+    async def version(self, interaction: discord.Interaction):
+        embed = discord.Embed(
+            description=f"🤖 R7 Bot is running\n# {BOT_VERSION}",
+            color=discord.Color.blurple(),
+        )
+        await interaction.response.send_message(embed=embed)
+
     @app_commands.command(
         name="convert-time",
         description="Convert a date and time to all Discord timestamp formats.",

From 62b8acea2fbcc01225fde2d63409d00993d77a90 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sat, 30 May 2026 19:54:31 +1000
Subject: [PATCH 04/32] 278-Enhancement restrict !starttourney and !endtourney
 to tourney admin channel

---
 features/tourney/tourney_commands.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/features/tourney/tourney_commands.py b/features/tourney/tourney_commands.py
index ebfd4f6..2c2fcc1 100644
--- a/features/tourney/tourney_commands.py
+++ b/features/tourney/tourney_commands.py
@@ -1316,6 +1316,12 @@ async def start_tourney_command(ctx: commands.Context, region: str = None):
             await ctx.reply("You don't have permission to start the tourney.")
             return
 
+        if ctx.channel.id != TOURNEY_ADMIN_CHANNEL_ID:
+            await ctx.reply(
+                f"This command can only be used in <#{TOURNEY_ADMIN_CHANNEL_ID}>."
+            )
+            return
+
         guild = ctx.guild
         if not guild:
             return
@@ -1549,6 +1555,12 @@ async def end_tourney_command(ctx: commands.Context):
             await ctx.reply("You don't have permission to end the tourney.")
             return
 
+        if ctx.channel.id != TOURNEY_ADMIN_CHANNEL_ID:
+            await ctx.reply(
+                f"This command can only be used in <#{TOURNEY_ADMIN_CHANNEL_ID}>."
+            )
+            return
+
         guild = ctx.guild
         if guild is None:
             return

From a4d1036c2bd2cef4584941ee384d20e303641ad8 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sat, 30 May 2026 20:22:41 +1000
Subject: [PATCH 05/32] 265-Enhancement add response time duration to hacked
 user flag embed

---
 features/security.py | 26 ++++++++++++++++++++++++--
 1 file changed, 24 insertions(+), 2 deletions(-)

diff --git a/features/security.py b/features/security.py
index f74c215..e9dc065 100644
--- a/features/security.py
+++ b/features/security.py
@@ -1,7 +1,7 @@
 import discord
 from discord import app_commands
 from discord.ext import commands
-from datetime import timedelta, datetime
+from datetime import timedelta, datetime, timezone
 from math import ceil
 import asyncio
 
@@ -70,6 +70,7 @@ async def _execute_hacked_action(self, guild, target_user, moderator):
         cutoff_date = datetime.utcnow() - timedelta(hours=12)
         total_deleted = 0
         channels_checked = 0
+        earliest_message_time = None
 
         # COMBINE LISTS: Convert all to list() first to avoid SequenceProxy errors
         all_channels = (
@@ -91,13 +92,29 @@ async def _execute_hacked_action(self, guild, target_user, moderator):
                 )
                 if len(deleted) > 0:
                     total_deleted += len(deleted)
+                    channel_earliest = min(msg.created_at for msg in deleted)
+                    if (
+                        earliest_message_time is None
+                        or channel_earliest < earliest_message_time
+                    ):
+                        earliest_message_time = channel_earliest
             except Exception:
                 pass
 
             channels_checked += 1
             await asyncio.sleep(0.1)
 
-        # 6. Build Result Embed
+        # 6. Calculate response time
+        if earliest_message_time is not None:
+            response_delta = datetime.now(timezone.utc) - earliest_message_time
+            total_seconds = int(response_delta.total_seconds())
+            hours, remainder = divmod(total_seconds, 3600)
+            minutes = remainder // 60
+            response_time_str = f"{hours:02d}:{minutes:02d}"
+        else:
+            response_time_str = "N/A (no messages found)"
+
+        # 7. Build Result Embed
         embed = discord.Embed(
             title="🚨 User Flagged as Hacked",
             description=f"**Target:** {target_user.mention} (`{target_user.id}`)\n**Action:** 7-Day Timeout & Message Purge",
@@ -109,6 +126,11 @@ async def _execute_hacked_action(self, guild, target_user, moderator):
             value=f"🗑️ Deleted **{total_deleted} messages** across **{channels_checked} channels** (Past 12 hours).",
             inline=False,
         )
+        embed.add_field(
+            name="Response Time",
+            value=f"⏱️ {response_time_str}",
+            inline=False,
+        )
         embed.add_field(
             name="Next Step",
             value="User added to Hacked Database. Use `/unhacked` when recovered.",

From 38292ff165e2344081789d7df9d46639345b2fe4 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sat, 30 May 2026 20:46:24 +1000
Subject: [PATCH 06/32] 251-Enhancement add moderator identity to hacked
 command embed

---
 features/security.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/features/security.py b/features/security.py
index e9dc065..6c4df32 100644
--- a/features/security.py
+++ b/features/security.py
@@ -117,7 +117,11 @@ async def _execute_hacked_action(self, guild, target_user, moderator):
         # 7. Build Result Embed
         embed = discord.Embed(
             title="🚨 User Flagged as Hacked",
-            description=f"**Target:** {target_user.mention} (`{target_user.id}`)\n**Action:** 7-Day Timeout & Message Purge",
+            description=(
+                f"**Target:** {target_user.mention} (`{target_user.id}`)\n"
+                f"**Moderator:** {moderator.mention}\n"
+                f"**Action:** 7-Day Timeout & Message Purge"
+            ),
             color=discord.Color.dark_red(),
         )
         embed.add_field(name="Status", value=timeout_status, inline=False)

From 9106e1589bca851d455890621c2c2c524f45fc8c Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sun, 31 May 2026 21:55:34 +1000
Subject: [PATCH 07/32] 292-Enhancement update README and help commands with
 accurate documentation

---
 README.md                            | 21 +++++++++++++++++----
 features/general.py                  |  3 ++-
 features/tourney/tourney_commands.py |  2 ++
 3 files changed, 21 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 4b36a9a..5921e7b 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 ## Overview
 **Name:** Remaining7 Discord Bot
-**Version:** v1.7.5
+**Version:** v1.9.2
 **Contributors:** remainingdelta, nightwarrior5
 **Objective:** A feature-rich Discord bot for the Remaining7 community server (16k+ members). Handles an R7 Token economy, leveling, quests, a Brawl Stars collection minigame, tournament management with Matcherino integration, support tickets, event operations, a security protocol, and multi-language translation.
 **Server Link:** https://discord.gg/6MzrjS2X8k
@@ -15,6 +15,7 @@
 - **Database:** MongoDB Atlas via `motor` (async)
 - **Translation:** `deep-translator` + `langdetect`
 - **External API:** Matcherino (tournament brackets, payouts)
+- **AI Integration:** Gemini API (GitHub issue generation)
 - **Linting:** Ruff (`ruff check .` / `ruff format .`)
 
 ---
@@ -23,7 +24,10 @@
 ```
 Remaining7-Discord-Bot/
 ├── main.py                          # Entry point — loads cogs, syncs commands
+├── pyproject.toml                   # Project metadata and version
 ├── requirements.txt
+├── Makefile
+├── LICENSE
 ├── .env.example
 ├── .gitignore
 ├── CLAUDE.md
@@ -36,9 +40,10 @@ Remaining7-Discord-Bot/
 │   ├── quests.py                    # Daily & weekly quest system
 │   ├── security.py                  # Hacked protocol (timeout, purge, flag)
 │   ├── event.py                     # Event channel cleanup & reward payouts
-│   ├── general.py                   # /help, /mod-help, /admin-help, /convert-time
+│   ├── general.py                   # /help, /mod-help, /admin-help, /version, /convert-time
 │   ├── translation.py               # !t prefix & /translate slash command (55 languages)
 │   ├── support_tickets.py           # General support tickets (issues, support, apps, partnership)
+│   ├── github_tickets.py           # AI-powered GitHub issue creation from tickets (Gemini)
 │   ├── ticket_command_router.py     # Shared routing for tourney & support ticket commands
 │   ├── brawl/
 │   │   ├── brawlers.json            # Brawler data (name, rarity, gadgets, star powers, hypercharges)
@@ -64,7 +69,7 @@ Remaining7-Discord-Bot/
 ## Core Features
 
 ### R7 Token Economy
-- **Passive Income:** Users earn 2–5 R7 Tokens per message (20-second cooldown). Server Boosters get a 2% average bonus.
+- **Passive Income:** Users earn 2–5 R7 Tokens per message (20-second cooldown). Server Boosters get a 5% increase in tokens on average.
 - **Daily Rewards:** `/daily` grants 80–160 tokens (scaled by level). Requires 5 messages sent since last claim and a 24-hour cooldown.
 - **Supply Drop:** `/drop <amount>` (Admin) to force a token drop in general chat.
 - **Balance & Ranking:** `/balance [user]`, `/leaderboard [page]`.
@@ -150,6 +155,11 @@ Remaining7-Discord-Bot/
 - Staff can close, reopen, and delete tickets with transcript generation.
 - Transcripts DM'd to the opener and archived in a log channel.
 
+### GitHub Ticket Integration
+- AI-powered GitHub issue creation from support tickets using Gemini.
+- Automatically generates structured bug reports, feature requests, and enhancement issues from ticket conversations.
+- Requires `GEMINI_TOKEN` and `GITHUB_TOKEN` environment variables.
+
 ### Event Management
 - **Automated Monitoring:** Daily background task at 12:00 AM ET scans event channels.
 - **Smart Alerts:** Alert sent when messages are 7+ days old (prevents exceeding Discord's 14-day bulk-delete limit).
@@ -170,6 +180,7 @@ Remaining7-Discord-Bot/
 
 ### Utility
 - `/convert-time <date> <time> <timezone>` — convert a date and time to all Discord timestamp formats. Supports 20+ timezone aliases (EST, PT, GMT, etc.) and IANA names.
+- `/version` — view the bot's current version.
 
 ### Help Commands
 - `/help` — user command directory.
@@ -206,10 +217,12 @@ This bot requires **Python 3.10+** and a **MongoDB Atlas** database.
     PROD_TOKEN=             # Production bot token (used when BOT_MODE=PROD)
     DEV_TOKEN=              # Dev/test bot token (used when BOT_MODE=DEV)
     MONGO_URI=              # MongoDB Atlas connection string
+    GEMINI_TOKEN=           # Gemini API key for AI-powered GitHub issue creation
+    GITHUB_TOKEN=           # GitHub PAT with 'repo' scope for issue creation
     ```
 
 4. **Update Configuration**
-    Verify and update IDs in `features/config.py` (channels, roles, categories, emojis) for your server. Both `REAL` and `TEST` branches must be maintained.
+    Verify and update IDs in `features/config.py` (channels, roles, categories, emojis) for your server. Both `PROD` and `DEV` branches must be maintained.
 
 5. **Run the Bot**
     ```bash
diff --git a/features/general.py b/features/general.py
index 57050a0..6a434ac 100644
--- a/features/general.py
+++ b/features/general.py
@@ -63,7 +63,8 @@ async def help_command(self, interaction: discord.Interaction):
         embed.add_field(name="🌐 Translation", value=translation_text, inline=False)
 
         utility_text = (
-            "`/convert-time` - Convert a date and time to Discord timestamp formats"
+            "`/convert-time` - Convert a date and time to Discord timestamp formats\n"
+            "`/version` - View the bot's current version"
         )
         embed.add_field(name="🔧 Utility", value=utility_text, inline=False)
 
diff --git a/features/tourney/tourney_commands.py b/features/tourney/tourney_commands.py
index 2c2fcc1..adaad80 100644
--- a/features/tourney/tourney_commands.py
+++ b/features/tourney/tourney_commands.py
@@ -2414,6 +2414,8 @@ async def tourney_admin_help(interaction: discord.Interaction):
         session_text = (
             "`!starttourney [region]` - Wipes old tickets, locks general support, and posts the live panel. Use `!starttourney SA` for South America mode.\n"
             "`!endtourney` - Closes all active tickets, generates staff stats, posts the Pre-Tourney panel, and unlocks general support.\n"
+            "`/tourney-panel` - Post the live tourney support button.\n"
+            "`/pre-tourney-panel` - Post the pre-tourney support button.\n"
             "`!lock` / `!unlock` - Manually close or open the general server support channel.\n"
             "`/tourney-test-mode` - Toggle 100-ticket limit and 0.1s cooldown for testing."
         )

From 538b1fac10d2fa1cd8b05dffd0ac5ee8d742b204 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Wed, 3 Jun 2026 17:57:04 +1000
Subject: [PATCH 08/32] 294-Feature add poll rewards command for distributing
 tokens to poll voters

---
 database/mongo.py  |  43 +++++++++
 features/config.py |   2 +
 features/event.py  | 228 ++++++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 271 insertions(+), 2 deletions(-)

diff --git a/database/mongo.py b/database/mongo.py
index 4b152a1..287eea8 100644
--- a/database/mongo.py
+++ b/database/mongo.py
@@ -79,6 +79,49 @@ async def update_user_balance(user_id: str, amount: int):
     )
 
 
+async def increment_user_balance(user_id: str, amount: int):
+    """Atomically increments a user's balance using $inc."""
+    if db is None:
+        return
+    await db.users.update_one(
+        {"_id": str(user_id)}, {"$inc": {"balance": amount}}, upsert=True
+    )
+
+
+# --- POLL REWARD HELPERS ---
+
+
+async def is_poll_reward_processed(message_id: str) -> bool:
+    """Checks if a poll reward has already been distributed for this message."""
+    if db is None:
+        return False
+    doc = await db.processed_poll_rewards.find_one({"_id": str(message_id)})
+    return doc is not None
+
+
+async def mark_poll_reward_processed(
+    message_id: str,
+    admin_id: str,
+    answer_text: str,
+    amount: int,
+    voter_count: int,
+):
+    """Records that poll rewards were distributed for this message."""
+    if db is None:
+        return
+    await db.processed_poll_rewards.insert_one(
+        {
+            "_id": str(message_id),
+            "admin_id": str(admin_id),
+            "answer_text": answer_text,
+            "amount_per_user": amount,
+            "voter_count": voter_count,
+            "total_distributed": amount * voter_count,
+            "processed_at": datetime.utcnow(),
+        }
+    )
+
+
 # --- LEVELING HELPERS ---
 
 
diff --git a/features/config.py b/features/config.py
index bd82137..fe9c1d6 100644
--- a/features/config.py
+++ b/features/config.py
@@ -55,6 +55,7 @@
     GREEN_EVENT_CHANNEL_ID = 1419791220053643384
     EVENT_STAFF_CHANNEL_ID = 811497227531845642
     EVENT_ANNOUNCEMENTS_CHANNEL_ID = 863649858120450088
+    POLLS_CHANNEL_ID = 753118356743389194
 
     EVENT_STAFF_ROLE_ID = 811495204346789938
 
@@ -232,6 +233,7 @@
     GREEN_EVENT_CHANNEL_ID = 1450350503467815034
     EVENT_STAFF_CHANNEL_ID = 1450350534279036979
     EVENT_ANNOUNCEMENTS_CHANNEL_ID = 1450923458342162677
+    POLLS_CHANNEL_ID = 1510921417036927098
 
     EVENT_STAFF_ROLE_ID = 1450350588209533019
 
diff --git a/features/event.py b/features/event.py
index 8ebc2d1..dd7f881 100644
--- a/features/event.py
+++ b/features/event.py
@@ -4,7 +4,13 @@
 from datetime import datetime, time
 import zoneinfo
 import re
-from database.mongo import get_user_balance, update_user_balance
+from database.mongo import (
+    get_user_balance,
+    increment_user_balance,
+    is_poll_reward_processed,
+    mark_poll_reward_processed,
+    update_user_balance,
+)
 
 from features.config import (
     ADMIN_ROLE_ID,
@@ -13,6 +19,7 @@
     BLUE_EVENT_CHANNEL_ID,
     GREEN_EVENT_CHANNEL_ID,
     EVENT_STAFF_CHANNEL_ID,
+    POLLS_CHANNEL_ID,
     EVENT_ANNOUNCEMENTS_CHANNEL_ID,
     BOT_VERSION,
 )
@@ -195,6 +202,97 @@ async def cancel(self, interaction: discord.Interaction, button: discord.ui.Butt
         await interaction.response.edit_message(embed=embed, view=self)
 
 
+class PollPayoutConfirmView(discord.ui.View):
+    def __init__(self, original_msg, voters, amount, answer_text, interaction_user):
+        super().__init__(timeout=60)
+        self.original_msg = original_msg
+        self.voters = voters
+        self.amount = amount
+        self.answer_text = answer_text
+        self.interaction_user = interaction_user
+        self.processed = False
+
+    async def interaction_check(self, interaction: discord.Interaction) -> bool:
+        if interaction.user.id != self.interaction_user.id:
+            await interaction.response.send_message(
+                "❌ This is not your command.", ephemeral=True
+            )
+            return False
+        return True
+
+    @discord.ui.button(
+        label="Confirm Payout", style=discord.ButtonStyle.green, emoji="✅"
+    )
+    async def confirm(
+        self, interaction: discord.Interaction, button: discord.ui.Button
+    ):
+        if self.processed:
+            return
+        self.processed = True
+        await interaction.response.defer()
+
+        # Double-check idempotency before distributing
+        if await is_poll_reward_processed(str(self.original_msg.id)):
+            embed = interaction.message.embeds[0]
+            embed.title = "❌ Already Processed"
+            embed.color = discord.Color.red()
+            embed.description = "This poll has already been processed."
+            embed.clear_fields()
+            for child in self.children:
+                child.disabled = True
+            await interaction.edit_original_response(embed=embed, view=self)
+            return
+
+        # Distribute tokens atomically
+        for voter in self.voters:
+            await increment_user_balance(str(voter.id), self.amount)
+
+        # Record in DB
+        await mark_poll_reward_processed(
+            message_id=str(self.original_msg.id),
+            admin_id=str(interaction.user.id),
+            answer_text=self.answer_text,
+            amount=self.amount,
+            voter_count=len(self.voters),
+        )
+
+        # Mark original poll message with checkmark
+        try:
+            await self.original_msg.add_reaction("✅")
+        except Exception:
+            pass
+
+        # Update confirmation embed
+        total = self.amount * len(self.voters)
+        embed = interaction.message.embeds[0]
+        embed.title = "✅ Poll Rewards Complete"
+        embed.color = discord.Color.green()
+        embed.clear_fields()
+        embed.add_field(
+            name="Summary",
+            value=(
+                f"Distributed **{total}** tokens to **{len(self.voters)}** voters.\n"
+                f"(**{self.amount}** tokens each for option: *{self.answer_text}*)"
+            ),
+            inline=False,
+        )
+        for child in self.children:
+            child.disabled = True
+        await interaction.edit_original_response(embed=embed, view=self)
+
+    @discord.ui.button(label="Cancel", style=discord.ButtonStyle.red, emoji="✖️")
+    async def cancel(self, interaction: discord.Interaction, button: discord.ui.Button):
+        self.processed = True
+        embed = interaction.message.embeds[0]
+        embed.title = "❌ Poll Rewards Cancelled"
+        embed.color = discord.Color.red()
+        embed.description = "No tokens were distributed."
+        embed.clear_fields()
+        for child in self.children:
+            child.disabled = True
+        await interaction.response.edit_message(embed=embed, view=self)
+
+
 class Events(commands.Cog):
     def __init__(self, bot):
         self.bot = bot
@@ -405,6 +503,130 @@ async def event_rewards(self, interaction: discord.Interaction, message_id: str)
         view = PayoutConfirmView(target_message, matches, interaction.user)
         await interaction.followup.send(embed=embed, view=view)
 
+    @app_commands.command(
+        name="poll-rewards",
+        description="ADMIN ONLY: Distribute tokens to voters of a poll option.",
+    )
+    @app_commands.describe(
+        message_id="The ID of the poll message in #polls",
+        answer="The poll option text to reward (case-insensitive match)",
+        amount="Flat token amount to give each voter",
+    )
+    async def poll_rewards(
+        self,
+        interaction: discord.Interaction,
+        message_id: str,
+        answer: str,
+        amount: int,
+    ):
+        # 1. Permission Check - Admin only
+        if not interaction.user.get_role(ADMIN_ROLE_ID):
+            await interaction.response.send_message(
+                "❌ Permission Denied: Only Admins can process poll rewards.",
+                ephemeral=True,
+            )
+            return
+
+        # 2. Channel Check
+        if interaction.channel_id != EVENT_STAFF_CHANNEL_ID:
+            await interaction.response.send_message(
+                f"❌ Please use this command in <#{EVENT_STAFF_CHANNEL_ID}>.",
+                ephemeral=True,
+            )
+            return
+
+        # 3. Validate amount
+        if amount <= 0:
+            await interaction.response.send_message(
+                "❌ Amount must be a positive number.", ephemeral=True
+            )
+            return
+
+        await interaction.response.defer()
+
+        # 4. Check idempotency (DB-backed)
+        if await is_poll_reward_processed(message_id):
+            await interaction.followup.send(
+                "⚠️ This poll message has already been processed for rewards."
+            )
+            return
+
+        # 5. Fetch message from polls channel
+        polls_channel = self.bot.get_channel(POLLS_CHANNEL_ID)
+        if not polls_channel:
+            await interaction.followup.send("❌ Config Error: Polls channel not found.")
+            return
+
+        try:
+            target_message = await polls_channel.fetch_message(int(message_id))
+        except Exception:
+            await interaction.followup.send(
+                "❌ Could not find that message ID in the polls channel."
+            )
+            return
+
+        # 6. Validate poll exists
+        if not target_message.poll:
+            await interaction.followup.send("❌ That message does not contain a poll.")
+            return
+
+        poll = target_message.poll
+
+        # 7. Check poll is finalized
+        if not poll.is_finalized():
+            await interaction.followup.send(
+                "⚠️ This poll has not ended yet. Please wait for it to close."
+            )
+            return
+
+        # 8. Match answer text (case-insensitive)
+        matched_answer = None
+        for poll_answer in poll.answers:
+            if poll_answer.text and poll_answer.text.lower() == answer.lower():
+                matched_answer = poll_answer
+                break
+
+        if not matched_answer:
+            available = ", ".join(f'"{a.text}"' for a in poll.answers if a.text)
+            await interaction.followup.send(
+                f'❌ No poll option matches "{answer}".\nAvailable options: {available}'
+            )
+            return
+
+        # 9. Fetch all voters via async iterator
+        voters = []
+        async for voter in matched_answer.voters(limit=None):
+            voters.append(voter)
+
+        if not voters:
+            await interaction.followup.send(
+                f'⚠️ No voters found for option "{matched_answer.text}".'
+            )
+            return
+
+        # 10. Build confirmation embed
+        total = amount * len(voters)
+        embed = discord.Embed(
+            title="⚠️ Confirm Poll Rewards?",
+            description=(
+                f"**Poll Option:** {matched_answer.text}\n"
+                f"**Voters:** {len(voters)}\n"
+                f"**Amount Per Voter:** {amount} tokens\n"
+                f"**Total Payout:** {total} tokens"
+            ),
+            color=discord.Color.orange(),
+        )
+
+        voter_preview = ", ".join(f"<@{v.id}>" for v in voters[:20])
+        if len(voters) > 20:
+            voter_preview += f"\n... and {len(voters) - 20} more"
+        embed.add_field(name="Voters", value=voter_preview, inline=False)
+
+        view = PollPayoutConfirmView(
+            target_message, voters, amount, matched_answer.text, interaction.user
+        )
+        await interaction.followup.send(embed=embed, view=view)
+
     @app_commands.command(
         name="event-staff-help",
         description="STAFF ONLY: Guide for managing event channels.",
@@ -436,7 +658,9 @@ async def event_staff_help(self, interaction: discord.Interaction):
         # --- Reward Distribution ---
         reward_text = (
             "`/event-rewards <message_id>` - Process token distribution from an announcement message.\n"
-            "*(Message must use `@User 500` format. Admin only.)*"
+            "*(Message must use `@User 500` format. Admin only.)*\n\n"
+            "`/poll-rewards <message_id> <answer> <amount>` - Distribute tokens to all voters of a poll option.\n"
+            "*(Poll must be finalized. Case-insensitive option match. Admin only.)*"
         )
         embed.add_field(name="🏆 Reward Distribution", value=reward_text, inline=False)
 

From 3860976a9b777d344134ff72c39c01fabcf31a41 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Fri, 12 Jun 2026 01:21:40 -0400
Subject: [PATCH 09/32] 301-Enhancement restrict passive token earning, quest
 progress, and daily message tracking to general chat only

---
 README.md           |  4 ++--
 features/economy.py | 58 ++++++++++++++++++++++-----------------------
 features/quests.py  | 10 ++++++--
 3 files changed, 39 insertions(+), 33 deletions(-)

diff --git a/README.md b/README.md
index 5921e7b..68664f2 100644
--- a/README.md
+++ b/README.md
@@ -257,8 +257,8 @@ Uses MongoDB database `r7_bot_db` with the following collections:
 
 | Task | Schedule | Description |
 |---|---|---|
-| Message listener | On every message | Passive token + XP generation (20s cooldown) |
-| Quest tracker | On every message | Track quest progress, auto-complete and reward |
+| Message listener | On every message | XP generation; passive token earning restricted to general chat (20s cooldown) |
+| Quest tracker | On every message in general chat | Track quest progress, auto-complete and reward |
 | Event cleanup | Daily at 12:00 AM ET | Scan event channels for stale messages |
 | Queue dashboard | Every 15 seconds | Update tourney queue embed during live tournaments |
 | Supply drop | Every 6 hours | Random token drop in general chat |
diff --git a/features/economy.py b/features/economy.py
index 89e39b7..ef8d6a4 100644
--- a/features/economy.py
+++ b/features/economy.py
@@ -653,9 +653,9 @@ async def on_message(self, message: discord.Message):
         current_timestamp = time.time()
         datetime.utcnow().strftime("%Y-%m-%d")
 
-        # --- TRACK DAILY MESSAGE COUNT (tied to /daily cooldown window) ---
-        # Format: "LAST_DAILY_TIMESTAMP:COUNT" — resets when user claims /daily
-        if message.channel.id not in PASSIVE_REWARD_EXCLUDED_CHANNEL_IDS:
+        if message.channel.id == GENERAL_CHANNEL_ID:
+            # --- TRACK DAILY MESSAGE COUNT (tied to /daily cooldown window) ---
+            # Format: "LAST_DAILY_TIMESTAMP:COUNT" — resets when user claims /daily
             last_daily_str = await get_setting(f"daily_{user_id}")
             window_key = last_daily_str if last_daily_str else "0"
 
@@ -671,37 +671,37 @@ async def on_message(self, message: discord.Message):
 
             await set_setting(f"daily_msg_count_{user_id}", f"{window_key}:{new_count}")
 
-        # --- PART 1: TOKENS (ON 1 MINUTE COOLDOWN) ---
-        last_message_str = await get_setting(f"last_message_{user_id}")
-        should_award_tokens = False
+            # --- PART 1: TOKENS (ON 20s COOLDOWN) ---
+            last_message_str = await get_setting(f"last_message_{user_id}")
+            should_award_tokens = False
 
-        if last_message_str:
-            try:
-                last_message_ts = float(last_message_str)
-                time_diff = current_timestamp - last_message_ts
+            if last_message_str:
+                try:
+                    last_message_ts = float(last_message_str)
+                    time_diff = current_timestamp - last_message_ts
 
-                # Check for 20s cooldown OR bugged negative timestamps
-                if time_diff >= 20 or time_diff < -3600:
+                    # Check for 20s cooldown OR bugged negative timestamps
+                    if time_diff >= 20 or time_diff < -3600:
+                        should_award_tokens = True
+                except ValueError:
                     should_award_tokens = True
-            except ValueError:
+            else:
                 should_award_tokens = True
-        else:
-            should_award_tokens = True
 
-        if should_award_tokens:
-            earned_tokens = random.randint(2, 5)
+            if should_award_tokens:
+                earned_tokens = random.randint(2, 5)
 
-            # Booster Bonus: 17.5% Chance (Avg 5% increase)
-            SERVER_BOOSTER_ROLE_ID = 647685778255642626
-            if message.guild:
-                booster_role = message.guild.get_role(SERVER_BOOSTER_ROLE_ID)
-                if booster_role and booster_role in message.author.roles:
-                    if random.random() < 0.175:
-                        earned_tokens += 1
+                # Booster Bonus: 17.5% Chance (Avg 5% increase)
+                SERVER_BOOSTER_ROLE_ID = 647685778255642626
+                if message.guild:
+                    booster_role = message.guild.get_role(SERVER_BOOSTER_ROLE_ID)
+                    if booster_role and booster_role in message.author.roles:
+                        if random.random() < 0.175:
+                            earned_tokens += 1
 
-            current_balance = await get_user_balance(user_id)
-            await update_user_balance(user_id, current_balance + earned_tokens)
-            await set_setting(f"last_message_{user_id}", str(current_timestamp))
+                current_balance = await get_user_balance(user_id)
+                await update_user_balance(user_id, current_balance + earned_tokens)
+                await set_setting(f"last_message_{user_id}", str(current_timestamp))
 
         # --- PART 2: XP & LEVELING (EVERY MESSAGE) ---
         EXP_PER_MESSAGE = 10
@@ -1354,9 +1354,9 @@ async def economy_help(self, interaction: discord.Interaction):
             color=discord.Color.gold(),
         )
         earn_text = (
-            f"💬 **Chatting:** Earn **2-5 Tokens** every message in **any channel** across the server! (20s cooldown)\n"
+            f"💬 **Chatting:** Earn **2-5 Tokens** every message in {general_ch}! (20s cooldown)\n"
             "📅 **Daily Rewards:** Use `/daily` to claim tokens every 24h. "
-            "*Requires 5 messages sent since your last `/daily` claim.*\n"
+            f"*Requires 5 messages sent in {general_ch} since your last `/daily` claim.*\n"
             f"🪂 **Supply Drops:** Random crates appear in {general_ch}! Click the button to claim.\n"
             f"🏆 **Events:** Earn massive token rewards in {event_ch}.\n"
             "🚀 **Booster Bonus:** Server Boosters receive a **5% increase** in coins on average."
diff --git a/features/quests.py b/features/quests.py
index dd27883..7a8405e 100644
--- a/features/quests.py
+++ b/features/quests.py
@@ -3,7 +3,11 @@
 from discord.ext import commands
 
 # Import Config
-from features.config import BOTS_CATEGORY_ID, PASSIVE_REWARD_EXCLUDED_CHANNEL_IDS
+from features.config import (
+    BOTS_CATEGORY_ID,
+    GENERAL_CHANNEL_ID,
+    PASSIVE_REWARD_EXCLUDED_CHANNEL_IDS,
+)
 
 # Import Database Helpers
 from database.mongo import (
@@ -119,11 +123,13 @@ async def on_message(self, message: discord.Message):
         if message.author.bot:
             return
 
-        # Skip quest progress in restricted channels (same rules as token earning)
+        # Skip quest progress outside general chat and restricted channels
         if message.channel.category and message.channel.category.id == BOTS_CATEGORY_ID:
             return
         if message.channel.id in PASSIVE_REWARD_EXCLUDED_CHANNEL_IDS:
             return
+        if message.channel.id != GENERAL_CHANNEL_ID:
+            return
 
         # Trigger message quest updates
         await self.process_quest_update(

From 1d014849e3bdffd18e2b97d727d8f522fc4b3278 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Fri, 12 Jun 2026 01:25:54 -0400
Subject: [PATCH 10/32] 300-Bug fix handle Gemini API failure in GitHub issue
 creation confirm button

---
 features/github_tickets.py | 43 ++++++++++++++++++++++++++++----------
 1 file changed, 32 insertions(+), 11 deletions(-)

diff --git a/features/github_tickets.py b/features/github_tickets.py
index 4b7dbfa..32ee334 100644
--- a/features/github_tickets.py
+++ b/features/github_tickets.py
@@ -269,21 +269,42 @@ async def confirm(
             content="Creating GitHub issue...", view=None
         )
 
-        ticket = await call_gemini(self.raw_text)
+        try:
+            ticket = await call_gemini(self.raw_text)
 
-        label_map = {"bug": "Bug", "enhancement": "Enhancement", "feature": "Feature"}
-        label = label_map[ticket["type"]]
+            label_map = {
+                "bug": "Bug",
+                "enhancement": "Enhancement",
+                "feature": "Feature",
+            }
+            label = label_map[ticket["type"]]
 
-        issue = await create_github_issue(ticket["title"], ticket["body"], label)
+            issue = await create_github_issue(ticket["title"], ticket["body"], label)
 
-        branch = f"{issue['number']}-{label}"
-        updated_body = ticket["body"].replace(f"-{label}", branch)
-        await update_github_issue(issue["number"], updated_body)
+            branch = f"{issue['number']}-{label}"
+            updated_body = ticket["body"].replace(f"-{label}", branch)
+            await update_github_issue(issue["number"], updated_body)
 
-        await interaction.edit_original_response(
-            content=f"Created issue #{issue['number']}: <{issue['html_url']}>\nBranch: `{branch}`",
-            view=None,
-        )
+            await interaction.edit_original_response(
+                content=f"Created issue #{issue['number']}: <{issue['html_url']}>\nBranch: `{branch}`",
+            )
+        except Exception as e:
+            error_str = str(e)
+            if "503" in error_str or "UNAVAILABLE" in error_str:
+                user_msg = "The AI service is currently experiencing high demand. Please try again later."
+            elif "429" in error_str:
+                user_msg = "The AI service rate limit has been reached. Please try again later."
+            elif "Gemini" in error_str:
+                user_msg = (
+                    "The AI service returned an unexpected response. Please try again."
+                )
+            elif "GitHub" in error_str:
+                user_msg = "Failed to create the GitHub issue via GitHub API. Please try again."
+            else:
+                user_msg = "An unexpected error occurred. Please try again."
+            await interaction.edit_original_response(
+                content=f"Failed to create GitHub issue: {user_msg}",
+            )
 
     @discord.ui.button(label="No", style=discord.ButtonStyle.red)
     async def cancel(self, interaction: discord.Interaction, button: discord.ui.Button):

From 043c4d05e7d2b14a36100b97f07fe55501c4c332 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Fri, 12 Jun 2026 01:34:07 -0400
Subject: [PATCH 11/32] 299-Bug fix floating-point display in redemption ticket
 balance fields

---
 features/economy.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/features/economy.py b/features/economy.py
index ef8d6a4..ee295c9 100644
--- a/features/economy.py
+++ b/features/economy.py
@@ -991,11 +991,13 @@ async def redeem(self, interaction: discord.Interaction, item: str):
             )
             ticket_embed.add_field(
                 name="Balance Before",
-                value=f"{balance_display_before:,} R7 tokens",
+                value=f"{int(round(balance_display_before)):,} R7 tokens",
                 inline=True,
             )
             ticket_embed.add_field(
-                name="Balance After", value=f"{balance_after:,} R7 tokens", inline=True
+                name="Balance After",
+                value=f"{int(round(balance_after)):,} R7 tokens",
+                inline=True,
             )
             await ch.send(embed=ticket_embed)
 

From 0920f05fab10b0e3f7a8cbbfeffdac30365f5f30 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Fri, 12 Jun 2026 01:51:51 -0400
Subject: [PATCH 12/32] 298-Bug fix command failing for users who have left the
 server

---
 features/security.py | 35 +++++++++++++++++++----------------
 1 file changed, 19 insertions(+), 16 deletions(-)

diff --git a/features/security.py b/features/security.py
index 6c4df32..a7504c0 100644
--- a/features/security.py
+++ b/features/security.py
@@ -31,22 +31,26 @@ async def _execute_hacked_action(self, guild, target_user, moderator):
         """
         Shared logic that performs the timeout, DB update, and message purge.
         """
-        # 1. Prevent targetting admins/mods or self
-        if target_user.top_role >= moderator.top_role:
-            return discord.Embed(
-                description="❌ You cannot target someone with equal or higher roles.",
-                color=discord.Color.red(),
-            )
+        # 1. Prevent targetting admins/mods or self (only possible if user is still in server)
+        if isinstance(target_user, discord.Member):
+            if target_user.top_role >= moderator.top_role:
+                return discord.Embed(
+                    description="❌ You cannot target someone with equal or higher roles.",
+                    color=discord.Color.red(),
+                )
 
         # 2. Timeout the User (7 Days)
-        try:
-            duration = timedelta(days=7)
-            await target_user.timeout(
-                duration, reason="Security: User Compromised/Hacked"
-            )
-            timeout_status = "✅ User Timed Out (7 Days)"
-        except Exception as e:
-            timeout_status = f"⚠️ Failed to Timeout: {e}"
+        if isinstance(target_user, discord.Member):
+            try:
+                duration = timedelta(days=7)
+                await target_user.timeout(
+                    duration, reason="Security: User Compromised/Hacked"
+                )
+                timeout_status = "✅ User Timed Out (7 Days)"
+            except Exception as e:
+                timeout_status = f"⚠️ Failed to Timeout: {e}"
+        else:
+            timeout_status = "⚠️ User Not in Server — Timeout Skipped"
 
         # 3. Add to Database
         await add_hacked_user(str(target_user.id))
@@ -201,8 +205,7 @@ async def hacked_text(self, ctx):
             try:
                 target_user = await ctx.guild.fetch_member(target_user.id)
             except Exception:
-                await ctx.send("❌ User is no longer in the server.")
-                return
+                pass  # User left — proceed with discord.User to still purge messages and tag DB
 
         status_msg = await ctx.send("⏳ Processing Hacked Protocol...")
         result_embed = await self._execute_hacked_action(

From 12a16d33c494ca8ad4727c936c2f93c14cfa73c0 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Fri, 12 Jun 2026 02:10:00 -0400
Subject: [PATCH 13/32] 297-Feature add sticky messages feature with debounced
 repost and per-channel MongoDB storage

---
 database/mongo.py  |  43 ++++++++++++-
 features/sticky.py | 154 +++++++++++++++++++++++++++++++++++++++++++++
 main.py            |   3 +
 3 files changed, 199 insertions(+), 1 deletion(-)
 create mode 100644 features/sticky.py

diff --git a/database/mongo.py b/database/mongo.py
index 287eea8..6ce36a6 100644
--- a/database/mongo.py
+++ b/database/mongo.py
@@ -998,4 +998,45 @@ async def get_next_support_ticket_number(counter_key: str) -> int:
         return int(doc.get("value", 1))
     except Exception as e:
         print(f"⚠️ DB Error (Support Counter): {e}")
-        return 1
+
+
+# --- STICKY MESSAGES ---
+
+
+async def get_sticky(channel_id: int):
+    if db is None:
+        return None
+    return await db.sticky_messages.find_one({"_id": str(channel_id)})
+
+
+async def set_sticky(
+    channel_id: int, content: str, attachments: list, bot_message_id: int
+):
+    if db is None:
+        return
+    await db.sticky_messages.update_one(
+        {"_id": str(channel_id)},
+        {
+            "$set": {
+                "content": content,
+                "attachments": attachments,
+                "bot_message_id": bot_message_id,
+            }
+        },
+        upsert=True,
+    )
+
+
+async def update_sticky_message_id(channel_id: int, bot_message_id: int):
+    if db is None:
+        return
+    await db.sticky_messages.update_one(
+        {"_id": str(channel_id)},
+        {"$set": {"bot_message_id": bot_message_id}},
+    )
+
+
+async def delete_sticky(channel_id: int):
+    if db is None:
+        return
+    await db.sticky_messages.delete_one({"_id": str(channel_id)})
diff --git a/features/sticky.py b/features/sticky.py
new file mode 100644
index 0000000..15b2f58
--- /dev/null
+++ b/features/sticky.py
@@ -0,0 +1,154 @@
+import asyncio
+import io
+
+import discord
+from discord.ext import commands
+
+from database.mongo import (
+    delete_sticky,
+    get_sticky,
+    set_sticky,
+    update_sticky_message_id,
+)
+
+
+DEBOUNCE_SECONDS = 1.5
+
+
+class StickyMessages(commands.Cog):
+    def __init__(self, bot):
+        self.bot = bot
+        self._pending: dict[int, asyncio.Task] = {}
+
+    async def _post_sticky(
+        self, channel: discord.TextChannel, sticky_doc: dict
+    ) -> discord.Message:
+        content = sticky_doc.get("content") or ""
+        attachments = sticky_doc.get("attachments", [])
+        files = [
+            discord.File(io.BytesIO(bytes(a["data"])), filename=a["filename"])
+            for a in attachments
+        ]
+        return await channel.send(content=content or None, files=files)
+
+    async def _delete_bot_message(self, channel: discord.TextChannel, message_id: int):
+        try:
+            msg = await channel.fetch_message(message_id)
+            await msg.delete()
+        except (discord.NotFound, discord.HTTPException):
+            pass
+
+    @commands.command(name="sticky")
+    async def sticky(self, ctx: commands.Context):
+        if not ctx.author.guild_permissions.administrator:
+            await ctx.send(
+                "❌ You need Administrator permissions to use this command.",
+                delete_after=5,
+            )
+            return
+
+        if ctx.message.reference is None:
+            await ctx.send(
+                "❌ Please reply to a message to make it sticky.", delete_after=5
+            )
+            return
+
+        try:
+            ref_message = await ctx.channel.fetch_message(
+                ctx.message.reference.message_id
+            )
+        except discord.NotFound:
+            await ctx.send("❌ Could not find the referenced message.", delete_after=5)
+            return
+
+        content = ref_message.content or ""
+        attachments = []
+        for attachment in ref_message.attachments:
+            data = await attachment.read()
+            attachments.append({"filename": attachment.filename, "data": data})
+
+        if not content and not attachments:
+            await ctx.send(
+                "❌ The referenced message has no content or attachments.",
+                delete_after=5,
+            )
+            return
+
+        # Remove any existing sticky bot message
+        existing = await get_sticky(ctx.channel.id)
+        if existing and existing.get("bot_message_id"):
+            await self._delete_bot_message(ctx.channel, existing["bot_message_id"])
+
+        sticky_msg = await self._post_sticky(
+            ctx.channel,
+            {"content": content, "attachments": attachments},
+        )
+        await set_sticky(ctx.channel.id, content, attachments, sticky_msg.id)
+
+        try:
+            await ctx.message.delete()
+        except discord.HTTPException:
+            pass
+
+    @commands.command(name="unsticky")
+    async def unsticky(self, ctx: commands.Context):
+        if not ctx.author.guild_permissions.administrator:
+            await ctx.send(
+                "❌ You need Administrator permissions to use this command.",
+                delete_after=5,
+            )
+            return
+
+        existing = await get_sticky(ctx.channel.id)
+        if not existing:
+            await ctx.send(
+                "❌ There is no sticky message in this channel.", delete_after=5
+            )
+            return
+
+        if existing.get("bot_message_id"):
+            await self._delete_bot_message(ctx.channel, existing["bot_message_id"])
+
+        await delete_sticky(ctx.channel.id)
+        pending = self._pending.pop(ctx.channel.id, None)
+        if pending:
+            pending.cancel()
+
+        await ctx.send("✅ Sticky message removed.")
+
+    async def _repost_sticky(self, channel: discord.TextChannel):
+        await asyncio.sleep(DEBOUNCE_SECONDS)
+        self._pending.pop(channel.id, None)
+
+        sticky_doc = await get_sticky(channel.id)
+        if not sticky_doc:
+            return
+
+        if sticky_doc.get("bot_message_id"):
+            await self._delete_bot_message(channel, sticky_doc["bot_message_id"])
+
+        new_msg = await self._post_sticky(channel, sticky_doc)
+        await update_sticky_message_id(channel.id, new_msg.id)
+
+    @commands.Cog.listener()
+    async def on_message(self, message: discord.Message):
+        if message.author.bot:
+            return
+        if not message.guild:
+            return
+
+        sticky_doc = await get_sticky(message.channel.id)
+        if not sticky_doc:
+            return
+
+        pending = self._pending.pop(message.channel.id, None)
+        if pending:
+            pending.cancel()
+
+        self._pending[message.channel.id] = asyncio.create_task(
+            self._repost_sticky(message.channel)
+        )
+
+
+async def setup(bot):
+    await bot.add_cog(StickyMessages(bot))
diff --git a/main.py b/main.py
index f0f82a3..5fb17ea 100644
--- a/main.py
+++ b/main.py
@@ -70,6 +70,9 @@ async def on_ready():
         await bot.load_extension("features.github_tickets")
         print("✅ Loaded Feature: GitHub Tickets")
 
+        await bot.load_extension("features.sticky")
+        print("✅ Loaded Feature: Sticky Messages")
+
     except Exception as e:
         print(f"❌ Error loading features: {e}")
 

From 9b03eab4667b169666d989c9def75ba253573c5b Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Fri, 12 Jun 2026 02:23:49 -0400
Subject: [PATCH 14/32] 296-Bug fix redeem ticket channel not pinging the
 redeeming user

---
 features/economy.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/features/economy.py b/features/economy.py
index ee295c9..f468377 100644
--- a/features/economy.py
+++ b/features/economy.py
@@ -999,7 +999,7 @@ async def redeem(self, interaction: discord.Interaction, item: str):
                 value=f"{int(round(balance_after)):,} R7 tokens",
                 inline=True,
             )
-            await ch.send(embed=ticket_embed)
+            await ch.send(content=interaction.user.mention, embed=ticket_embed)
 
         except Exception as e:
             await add_item_token(user_id, item, quantity=1)

From 3a3de484666cdd343cc4cd6556563e088ee4865d Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Fri, 12 Jun 2026 03:01:03 -0400
Subject: [PATCH 15/32] 220-Feature add counting game feature with sequential
 validation and set-count command

---
 database/mongo.py    | 30 +++++++++++++++
 features/config.py   |  2 +
 features/counting.py | 89 ++++++++++++++++++++++++++++++++++++++++++++
 main.py              |  3 ++
 4 files changed, 124 insertions(+)
 create mode 100644 features/counting.py

diff --git a/database/mongo.py b/database/mongo.py
index 6ce36a6..574e568 100644
--- a/database/mongo.py
+++ b/database/mongo.py
@@ -179,6 +179,36 @@ async def set_setting(key: str, value: str):
     await db.settings.update_one({"_id": key}, {"$set": {"value": value}}, upsert=True)
 
 
+# --- COUNTING HELPERS ---
+
+
+async def get_counting_state() -> dict:
+    if db is None:
+        return {"current_count": 0, "last_user_id": None}
+    doc = await db.counting.find_one({"_id": "state"})
+    if not doc:
+        return {"current_count": 0, "last_user_id": None}
+    return {
+        "current_count": doc.get("current_count", 0),
+        "last_user_id": doc.get("last_user_id"),
+    }
+
+
+async def update_counting_state(current_count: int, last_user_id: int | None):
+    if db is None:
+        return
+    await db.counting.update_one(
+        {"_id": "state"},
+        {
+            "$set": {
+                "current_count": current_count,
+                "last_user_id": last_user_id,
+            }
+        },
+        upsert=True,
+    )
+
+
 # --- LEADERBOARD HELPERS ---
 
 
diff --git a/features/config.py b/features/config.py
index fe9c1d6..f3a9456 100644
--- a/features/config.py
+++ b/features/config.py
@@ -61,6 +61,7 @@
 
     ECONOMY_COMMANDS_CHANNEL_ID = 1352841132735860746
     BOT_COMMANDS_CHANNEL_ID = 546405233736155151
+    COUNTING_CHANNEL_ID = 909853678863790092
 
     EMOJIS_CURRENCY = {
         "coins": "<:bs_coin:1454305320015888516>",
@@ -239,6 +240,7 @@
 
     ECONOMY_COMMANDS_CHANNEL_ID = 1484768262649675776
     BOT_COMMANDS_CHANNEL_ID = 1484768347756167228
+    COUNTING_CHANNEL_ID = 1513450829707874354
 
     EMOJIS_CURRENCY = {
         "coins": "<:bs_coin:1454290949780934678>",
diff --git a/features/counting.py b/features/counting.py
new file mode 100644
index 0000000..06135f2
--- /dev/null
+++ b/features/counting.py
@@ -0,0 +1,89 @@
+import discord
+from discord import app_commands
+from discord.ext import commands
+
+from database.mongo import get_counting_state, update_counting_state
+from features.config import (
+    ADMIN_ROLE_ID,
+    COUNTING_CHANNEL_ID,
+    FOUNDER_ROLE_ID,
+    MODERATOR_ROLE_ID,
+)
+
+COUNTING_MOD_ROLES = {MODERATOR_ROLE_ID, ADMIN_ROLE_ID, FOUNDER_ROLE_ID}
+
+
+class Counting(commands.Cog):
+    def __init__(self, bot):
+        self.bot = bot
+
+    @commands.Cog.listener()
+    async def on_message(self, message: discord.Message):
+        if message.author.bot:
+            return
+        if not message.guild:
+            return
+        if message.channel.id != COUNTING_CHANNEL_ID:
+            return
+
+        state = await get_counting_state()
+        current_count = state["current_count"]
+        last_user_id = state["last_user_id"]
+        expected = current_count + 1
+
+        if message.author.id == last_user_id:
+            await message.delete()
+            await message.channel.send(
+                f"{message.author.mention} You can't count twice in a row!",
+                delete_after=5,
+            )
+            return
+
+        try:
+            number = int(message.content.strip())
+        except ValueError:
+            await message.delete()
+            await message.channel.send(
+                f"{message.author.mention} That's not a number! Next number is **{expected}**.",
+                delete_after=5,
+            )
+            return
+
+        if number != expected:
+            await message.delete()
+            await message.channel.send(
+                f"{message.author.mention} Wrong number! Next number is **{expected}**.",
+                delete_after=5,
+            )
+            return
+
+        await update_counting_state(number, message.author.id)
+
+    @app_commands.command(
+        name="set-count", description="Set the current count (staff only)."
+    )
+    @app_commands.describe(count="The number to set the count to")
+    async def set_count(self, interaction: discord.Interaction, count: int):
+        if not isinstance(interaction.user, discord.Member) or not any(
+            role.id in COUNTING_MOD_ROLES for role in interaction.user.roles
+        ):
+            await interaction.response.send_message(
+                "❌ You don't have permission to use this command.", ephemeral=True
+            )
+            return
+
+        if interaction.channel_id != COUNTING_CHANNEL_ID:
+            await interaction.response.send_message(
+                f"❌ This command can only be used in <#{COUNTING_CHANNEL_ID}>.",
+                ephemeral=True,
+            )
+            return
+
+        await update_counting_state(count, None)
+        await interaction.response.send_message(
+            f"✅ Count set to **{count}**.", ephemeral=True
+        )
+
+
+async def setup(bot):
+    await bot.add_cog(Counting(bot))
diff --git a/main.py b/main.py
index 5fb17ea..799490c 100644
--- a/main.py
+++ b/main.py
@@ -73,6 +73,9 @@ async def on_ready():
         await bot.load_extension("features.sticky")
         print("✅ Loaded Feature: Sticky Messages")
 
+        await bot.load_extension("features.counting")
+        print("✅ Loaded Feature: Counting")
+
     except Exception as e:
         print(f"❌ Error loading features: {e}")
 

From 815118498b3ece487b74c3a00e23798840914009 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Fri, 12 Jun 2026 12:29:45 -0400
Subject: [PATCH 16/32] 309-Feature add /active-matches command to display all
 active match scores grouped by round

---
 features/tourney/tourney_commands.py | 52 ++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/features/tourney/tourney_commands.py b/features/tourney/tourney_commands.py
index adaad80..69894fb 100644
--- a/features/tourney/tourney_commands.py
+++ b/features/tourney/tourney_commands.py
@@ -2898,6 +2898,57 @@ async def tourney_progress(interaction: discord.Interaction):
         embed.set_footer(text=f"Matcherino ID: {m_id} | Staff: {interaction.user.name}")
         await interaction.followup.send(embed=embed)
 
+    @app_commands.command(
+        name="active-matches",
+        description="Show all currently active match scores grouped by round.",
+    )
+    async def active_matches(interaction: discord.Interaction):
+        if not is_staff(interaction.user):
+            await interaction.response.send_message(
+                "❌ Permission denied.", ephemeral=True
+            )
+            return
+
+        await interaction.response.defer()
+        session = await get_active_tourney_session()
+        if not session or not session.get("matcherino_id"):
+            await interaction.followup.send("❌ No active session found.")
+            return
+
+        m_id = session["matcherino_id"]
+        bracket_url = f"https://matcherino.com/tournaments/{m_id}/bracket"
+
+        from .matcherino import fetch_bracket_progress
+
+        data = fetch_bracket_progress(bracket_url)
+        if data.get("status") != "success":
+            await interaction.followup.send(f"❌ **Error:** {data.get('error')}")
+            return
+
+        matches = data.get("active_matches", [])
+        if not matches:
+            await interaction.followup.send("✅ No active matches right now.")
+            return
+
+        rounds: dict[int, list] = {}
+        for m in matches:
+            rounds.setdefault(m["round"], []).append(m)
+
+        embed = discord.Embed(
+            title="⚔️ Active Matches",
+            description=f"`{len(matches)}` matches currently active",
+            color=discord.Color.blue(),
+        )
+
+        for round_num in sorted(rounds):
+            lines = ""
+            for m in sorted(rounds[round_num], key=lambda x: x["id"]):
+                lines += f"**#{m['id']}** | {m['team_a']} vs {m['team_b']} ({m['score_a']}-{m['score_b']})\n"
+            embed.add_field(name=f"Round {round_num}", value=lines, inline=False)
+
+        embed.set_footer(text=f"Matcherino ID: {m_id} | Staff: {interaction.user.name}")
+        await interaction.followup.send(embed=embed)
+
     # --- Start the Dashboard Task ---
     if bot.get_cog("QueueDashboard") is None:
         asyncio.create_task(bot.add_cog(QueueDashboard(bot)))
@@ -2922,6 +2973,7 @@ async def tourney_progress(interaction: discord.Interaction):
     bot.tree.add_command(match_history)
     bot.tree.add_command(set_ticket_match)
     bot.tree.add_command(tourney_progress)
+    bot.tree.add_command(active_matches)
     bot.tree.add_command(BlacklistGroup(bot))
 
     async def background_stats_update():

From 71c012b41e52b5e8347efa26f656426de0c2c825 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Fri, 12 Jun 2026 13:09:41 -0400
Subject: [PATCH 17/32] 199-Enhancement add translation embed capture to ticket
 transcripts

---
 features/tourney/tourney_utils.py | 40 ++++++++++++++++++++++++++++++-
 1 file changed, 39 insertions(+), 1 deletion(-)

diff --git a/features/tourney/tourney_utils.py b/features/tourney/tourney_utils.py
index c0bb630..6c26f26 100644
--- a/features/tourney/tourney_utils.py
+++ b/features/tourney/tourney_utils.py
@@ -492,6 +492,39 @@ async def close_ticket_via_command(ctx: commands.Context):
     )
 
 
+def _extract_translation_lines(
+    embeds: list[discord.Embed], timestamp: str
+) -> list[str]:
+    result = []
+    for embed in embeds:
+        title = embed.title or ""
+        fields = {f.name: f.value for f in embed.fields}
+        if title.startswith("🌐 Translated from"):
+            lang = title.removeprefix("🌐 Translated from ").strip()
+            original = fields.get("Original Message", "").removeprefix("> ").strip()
+            translation = fields.get("English Translation", "").strip("*").strip()
+            if original and translation:
+                result.append(
+                    f'[{timestamp}] R7 Bot#9997 ({lang} >> English): "{original}" >> "{translation}"'
+                )
+        elif title.startswith("🌐 Translated to"):
+            lang = title.removeprefix("🌐 Translated to ").strip()
+            original = fields.get("Original English", "").removeprefix("> ").strip()
+            translated = next(
+                (
+                    v.strip("*").strip()
+                    for k, v in fields.items()
+                    if k != "Original English"
+                ),
+                None,
+            )
+            if original and translated:
+                result.append(
+                    f'[{timestamp}] R7 Bot#9997 (English >> {lang}): "{original}" >> "{translated}"'
+                )
+    return result
+
+
 async def build_transcript_text(channel: discord.TextChannel) -> str:
     """Collect all messages in the channel into a plain-text transcript,
     with header info from the channel topic.
@@ -529,7 +562,12 @@ async def build_transcript_text(channel: discord.TextChannel) -> str:
             if content:
                 content += " "
             content += f"[Attachments: {attachment_list}]"
-        lines.append(f"[{timestamp}] {author}: {content}")
+
+        translation_lines = _extract_translation_lines(msg.embeds, timestamp)
+
+        if content or not translation_lines:
+            lines.append(f"[{timestamp}] {author}: {content}")
+        lines.extend(translation_lines)
 
     if len(lines) <= 4:  # only header, no messages
         lines.append("No messages in this ticket.")

From 450409ad7b89190b87174ad332e4bdb2f51eb541 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sun, 14 Jun 2026 00:51:25 -0700
Subject: [PATCH 18/32] 201-Feature add transcript generation to redemption
 ticket close flow

---
 features/config.py  |   2 +
 features/economy.py | 115 ++++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 113 insertions(+), 4 deletions(-)

diff --git a/features/config.py b/features/config.py
index f3a9456..06fa98d 100644
--- a/features/config.py
+++ b/features/config.py
@@ -38,6 +38,7 @@
     REDEMPTION_TICKET_CATEGORY_ID = 1481456156080738346
     BOTS_CATEGORY_ID = 767612682357964810
     SUPPORT_TRANSCRIPT_LOG_CHANNEL_ID = 1481117793222004746
+    REDEMPTION_TRANSCRIPT_CHANNEL_ID = 1515605936801316874
     SUPPORT_STAFF_APPS_INFO_CHANNEL_ID = 1261020578790248459
 
     LOG_CHANNEL_ID = 1442374964144640090
@@ -217,6 +218,7 @@
     REDEMPTION_TICKET_CATEGORY_ID = 1481455542236086293
     BOTS_CATEGORY_ID = 1506812222704451677
     SUPPORT_TRANSCRIPT_LOG_CHANNEL_ID = 1480735066924781711
+    REDEMPTION_TRANSCRIPT_CHANNEL_ID = 1515606218654220288
     SUPPORT_STAFF_APPS_INFO_CHANNEL_ID = 1481083131342618754
 
     LOG_CHANNEL_ID = 1442227896302174298
diff --git a/features/economy.py b/features/economy.py
index f468377..9533054 100644
--- a/features/economy.py
+++ b/features/economy.py
@@ -1,3 +1,4 @@
+import io
 import time
 import discord
 from discord import app_commands
@@ -33,6 +34,7 @@
     SHOP_DATA,
     MODERATOR_ROLE_ID,
     REDEMPTION_TICKET_CATEGORY_ID,
+    REDEMPTION_TRANSCRIPT_CHANNEL_ID,
     TRIAL_MODERATOR_ROLE_ID,
     PASSIVE_REWARD_EXCLUDED_CHANNEL_IDS,
 )
@@ -247,6 +249,81 @@ async def handle_redemption_delete_attempt(ctx: commands.Context) -> None:
     )
 
 
+async def _build_redemption_transcript_text(
+    channel: discord.TextChannel,
+    item: str,
+    token_cost: int,
+    balance_before: int,
+    balance_after: int,
+) -> str:
+    opener_raw = _extract_topic_value(channel.topic, "redemption-opener")
+    lines: list[str] = [
+        f"Channel: {channel.name}",
+        f"Opener ID: {opener_raw or 'Unknown'}",
+        f"Item: {item}",
+        f"Token Cost: {token_cost}",
+        f"Balance Before: {balance_before}",
+        f"Balance After: {balance_after}",
+        "",
+    ]
+    async for msg in channel.history(limit=None, oldest_first=True):
+        ts = msg.created_at.strftime("%Y-%m-%d %H:%M")
+        author = f"{msg.author} ({msg.author.id})"
+        content = msg.content or ""
+        if msg.attachments:
+            attachment_list = ", ".join(a.url for a in msg.attachments)
+            if content:
+                content += " "
+            content += f"[Attachments: {attachment_list}]"
+        lines.append(f"[{ts}] {author}: {content}")
+    if len(lines) <= 7:
+        lines.append("No messages in this ticket.")
+    return "\n".join(lines)
+
+
+async def _save_redemption_transcript(
+    channel: discord.TextChannel,
+    actor: discord.Member,
+    item: str,
+    token_cost: int,
+    balance_before: int,
+    balance_after: int,
+    outcome: str,
+) -> None:
+    transcript_text = await _build_redemption_transcript_text(
+        channel, item, token_cost, balance_before, balance_after
+    )
+    transcript_bytes = transcript_text.encode("utf-8")
+    filename = f"{channel.name}_transcript.txt"
+
+    opener_raw = _extract_topic_value(channel.topic, "redemption-opener")
+    opener_display = f"<@{opener_raw}>" if opener_raw else "unknown"
+    item_display = SHOP_DATA.get(item, {}).get("display", item).replace("**", "")
+
+    if outcome == "refunded":
+        balance_original = balance_before + token_cost
+        outcome_line = f"🔄 **Refunded** | **Balance:** {balance_original:,} → {balance_before:,} → {balance_after:,} R7 tokens"
+    else:
+        outcome_line = f"✅ **Fulfilled** | **Balance:** {balance_before:,} → {balance_after:,} R7 tokens"
+
+    log_channel = (
+        channel.guild.get_channel(REDEMPTION_TRANSCRIPT_CHANNEL_ID)
+        if isinstance(REDEMPTION_TRANSCRIPT_CHANNEL_ID, int)
+        else None
+    )
+    if isinstance(log_channel, discord.TextChannel):
+        log_file = discord.File(io.BytesIO(transcript_bytes), filename=filename)
+        await log_channel.send(
+            content=(
+                f"📝 Transcript for redemption ticket **#{channel.name}** "
+                f"deleted by **{actor.name}** (opener: {opener_display}).\n"
+                f"**Item:** {item_display} | **Cost:** {token_cost:,} R7 tokens\n"
+                f"{outcome_line}"
+            ),
+            file=log_file,
+        )
+
+
 class RedemptionClosedOptionsView(discord.ui.View):
     def __init__(self):
         super().__init__(timeout=None)
@@ -314,13 +391,26 @@ async def refund_delete_button(
         opener_raw = _extract_topic_value(
             interaction.channel.topic, "redemption-opener"
         )
-        item = _extract_topic_value(interaction.channel.topic, "item")
+        item = _extract_topic_value(interaction.channel.topic, "item") or ""
+        token_cost = _token_price_for_item(item) if item else 0
+        balance_before = 0
+        balance_after = 0
         if opener_raw and opener_raw.isdigit() and item:
             refund_amount = _token_price_for_item(item)
             if refund_amount > 0:
-                current_balance = await get_user_balance(opener_raw)
-                await update_user_balance(opener_raw, current_balance + refund_amount)
-
+                balance_before = await get_user_balance(opener_raw)
+                balance_after = balance_before + refund_amount
+                await update_user_balance(opener_raw, balance_after)
+
+        await _save_redemption_transcript(
+            interaction.channel,
+            interaction.user,
+            item,
+            token_cost,
+            balance_before,
+            balance_after,
+            outcome="refunded",
+        )
         await interaction.channel.delete(
             reason=f"Redemption ticket refunded and deleted by {interaction.user}"
         )
@@ -365,6 +455,23 @@ async def budget_delete_button(
         except ValueError:
             cost = _budget_cost_for_item(item)
 
+        opener_raw = _extract_topic_value(
+            interaction.channel.topic, "redemption-opener"
+        )
+        token_cost = _token_price_for_item(item) if item else 0
+        current_balance = 0
+        if opener_raw and opener_raw.isdigit():
+            current_balance = await get_user_balance(opener_raw)
+
+        await _save_redemption_transcript(
+            interaction.channel,
+            interaction.user,
+            item,
+            token_cost,
+            current_balance + token_cost,
+            current_balance,
+            outcome="fulfilled",
+        )
         await add_budget_spent(cost)
         await interaction.channel.delete(
             reason=f"Redemption fulfilled and deleted by {interaction.user}"

From 943ca0135610418b17b4ecba1fe891bdd82fd8b7 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sun, 14 Jun 2026 10:22:39 -0700
Subject: [PATCH 19/32] 202-Bug fix bracket progress showing wrong round
 numbers

---
 features/tourney/matcherino.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/features/tourney/matcherino.py b/features/tourney/matcherino.py
index 9538119..5222d15 100644
--- a/features/tourney/matcherino.py
+++ b/features/tourney/matcherino.py
@@ -555,6 +555,16 @@ def fetch_bracket_progress(url: str) -> dict:
         m["resolved_round"] = m.get("round") or m.get("roundNum") or 1
         real_matches.append(m)
 
+    # Normalize round numbers so the first real round is always Round 1.
+    # When participant count is <= half the bracket size, Matcherino gives every
+    # team a first-round BYE. After filtering those out, resolved_round starts
+    # at 2+, shifting every displayed round label up by one.
+    if real_matches:
+        min_round = min(m["resolved_round"] for m in real_matches)
+        if min_round > 1:
+            for m in real_matches:
+                m["resolved_round"] -= min_round - 1
+
     # Build visual numbering map (the numbers staff see on the bracket UI).
     # We keep this consistent with fetch_ticket_context: sort visible matches by API matchNum
     # and assign sequential visual numbers.

From e1eddbe7662252fd02da0d632b43fa4448ccce96 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sun, 14 Jun 2026 14:12:23 -0700
Subject: [PATCH 20/32] 198-Bug improve match history to show pending matchups
 instead of hiding TBD slots

---
 features/tourney/matcherino.py | 96 ++++++++++++++++++++++++++++++++--
 1 file changed, 92 insertions(+), 4 deletions(-)

diff --git a/features/tourney/matcherino.py b/features/tourney/matcherino.py
index 5222d15..b3bc7f5 100644
--- a/features/tourney/matcherino.py
+++ b/features/tourney/matcherino.py
@@ -291,6 +291,50 @@ def get_team_info(entrant_dict):
             m["visualNum"] = i
             visual_match_map[i] = m
 
+        raw_to_visual = {
+            m.get("matchNum"): v_num for v_num, m in visual_match_map.items()
+        }
+
+        def resolve_name(entrant_dict, source_entry, depth=0):
+            name = get_team_info(entrant_dict)["name"]
+            if name not in ("TBD", "BYE"):
+                return name
+            if not source_entry or depth > 1:
+                return "TBD"
+            raw_src = source_entry.get("matchNum")
+            v_src = raw_to_visual.get(raw_src, raw_src)
+            src = visual_match_map.get(v_src)
+            if not src:
+                return f"Waiting on Match #{v_src}"
+            srcs = src.get("entrantSources") or []
+            a = resolve_name(src.get("entrantA"), srcs[0] if srcs else None, depth + 1)
+            b = resolve_name(
+                src.get("entrantB"), srcs[1] if len(srcs) > 1 else None, depth + 1
+            )
+            return f"Waiting on Match #{v_src} ({a} vs {b})"
+
+        def build_tbd_chain(source_entry):
+            if not source_entry:
+                return ["→ No source match information available"]
+            raw_src = source_entry.get("matchNum")
+            v_src = raw_to_visual.get(raw_src, raw_src)
+            src_match = visual_match_map.get(v_src)
+            if not src_match:
+                return [f"→ Waiting on Match #{v_src}"]
+            srcs = src_match.get("entrantSources") or []
+            a_name = resolve_name(
+                src_match.get("entrantA"), srcs[0] if srcs else None, depth=1
+            )
+            b_name = resolve_name(
+                src_match.get("entrantB"), srcs[1] if len(srcs) > 1 else None, depth=1
+            )
+            if "Waiting on" not in a_name and "Waiting on" not in b_name:
+                return [f"→ Match #{v_src}: {a_name} vs {b_name}"]
+            return [
+                f"→ Match #{v_src} [A]: {a_name}",
+                f"→ Match #{v_src} [B]: {b_name}",
+            ]
+
         current_match = visual_match_map.get(int(target_match_number))
 
         if not current_match:
@@ -301,6 +345,22 @@ def get_team_info(entrant_dict):
         team_a = get_team_info(current_match.get("entrantA"))
         team_b = get_team_info(current_match.get("entrantB"))
 
+        sources = current_match.get("entrantSources") or []
+        team_a_is_tbd = team_a["name"] in ("TBD", "BYE")
+        team_b_is_tbd = team_b["name"] in ("TBD", "BYE")
+
+        if team_a_is_tbd:
+            src_a = sources[0] if sources else None
+            if src_a:
+                raw = src_a.get("matchNum")
+                team_a["name"] = f"Waiting on Match #{raw_to_visual.get(raw, raw)}"
+
+        if team_b_is_tbd:
+            src_b = sources[1] if len(sources) > 1 else None
+            if src_b:
+                raw = src_b.get("matchNum")
+                team_b["name"] = f"Waiting on Match #{raw_to_visual.get(raw, raw)}"
+
         match_status = current_match.get("status", "unknown")
 
         # --- IMPROVED TIMING LOGIC ---
@@ -335,8 +395,14 @@ def get_team_info(entrant_dict):
             except Exception:
                 pass
 
-        team_a_history = []
-        team_b_history = []
+        team_a_history = (
+            build_tbd_chain(sources[0] if sources else None) if team_a_is_tbd else []
+        )
+        team_b_history = (
+            build_tbd_chain(sources[1] if len(sources) > 1 else None)
+            if team_b_is_tbd
+            else []
+        )
 
         for v_num, match in visual_match_map.items():
             if str(v_num) == str(target_match_number):
@@ -353,7 +419,18 @@ def get_team_info(entrant_dict):
                 is_pos_a = t_a_past["name"] == team_a["name"]
                 opp_name = t_b_past["name"] if is_pos_a else t_a_past["name"]
 
-                if opp_name.upper() not in ["BYE", "TBD"]:
+                if opp_name.upper() == "TBD":
+                    h_srcs = match.get("entrantSources") or []
+                    opp_idx = 1 if is_pos_a else 0
+                    opp_src = h_srcs[opp_idx] if len(h_srcs) > opp_idx else None
+                    opp_dict = (
+                        match.get("entrantB") if is_pos_a else match.get("entrantA")
+                    )
+                    opp_label = resolve_name(opp_dict, opp_src)
+                    team_a_history.append(
+                        f"Match {v_num}: {team_a['name']} vs {opp_label}"
+                    )
+                elif opp_name.upper() != "BYE":
                     t_score = t_a_past["score"] if is_pos_a else t_b_past["score"]
                     o_score = t_b_past["score"] if is_pos_a else t_a_past["score"]
                     team_a_history.append(
@@ -368,7 +445,18 @@ def get_team_info(entrant_dict):
                 is_pos_a = t_a_past["name"] == team_b["name"]
                 opp_name = t_b_past["name"] if is_pos_a else t_a_past["name"]
 
-                if opp_name.upper() not in ["BYE", "TBD"]:
+                if opp_name.upper() == "TBD":
+                    h_srcs = match.get("entrantSources") or []
+                    opp_idx = 1 if is_pos_a else 0
+                    opp_src = h_srcs[opp_idx] if len(h_srcs) > opp_idx else None
+                    opp_dict = (
+                        match.get("entrantB") if is_pos_a else match.get("entrantA")
+                    )
+                    opp_label = resolve_name(opp_dict, opp_src)
+                    team_b_history.append(
+                        f"Match {v_num}: {team_b['name']} vs {opp_label}"
+                    )
+                elif opp_name.upper() != "BYE":
                     t_score = t_a_past["score"] if is_pos_a else t_b_past["score"]
                     o_score = t_b_past["score"] if is_pos_a else t_a_past["score"]
                     team_b_history.append(

From 962dd5be071299803406a334b8fb349228464043 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sun, 14 Jun 2026 15:05:37 -0700
Subject: [PATCH 21/32] 198-Bug fix entrantSources lookup using entrantId
 matching instead of positional indexing

---
 features/tourney/matcherino.py | 72 ++++++++++++++++++++++++++--------
 1 file changed, 56 insertions(+), 16 deletions(-)

diff --git a/features/tourney/matcherino.py b/features/tourney/matcherino.py
index b3bc7f5..6cf875c 100644
--- a/features/tourney/matcherino.py
+++ b/features/tourney/matcherino.py
@@ -295,6 +295,20 @@ def get_team_info(entrant_dict):
             m.get("matchNum"): v_num for v_num, m in visual_match_map.items()
         }
 
+        def find_src(my_entrant, other_entrant, srcs, fallback_idx=0):
+            """Return the entrantSources entry for my_entrant by matching entrantId."""
+            my_id = (my_entrant or {}).get("entrantId", 0)
+            other_id = (other_entrant or {}).get("entrantId", 0)
+            if my_id != 0:
+                found = next((s for s in srcs if s.get("entrantId") == my_id), None)
+                if found:
+                    return found
+            if other_id != 0:
+                found = next((s for s in srcs if s.get("entrantId") != other_id), None)
+                if found:
+                    return found
+            return srcs[fallback_idx] if len(srcs) > fallback_idx else None
+
         def resolve_name(entrant_dict, source_entry, depth=0):
             name = get_team_info(entrant_dict)["name"]
             if name not in ("TBD", "BYE"):
@@ -307,10 +321,10 @@ def resolve_name(entrant_dict, source_entry, depth=0):
             if not src:
                 return f"Waiting on Match #{v_src}"
             srcs = src.get("entrantSources") or []
-            a = resolve_name(src.get("entrantA"), srcs[0] if srcs else None, depth + 1)
-            b = resolve_name(
-                src.get("entrantB"), srcs[1] if len(srcs) > 1 else None, depth + 1
-            )
+            src_ea = find_src(src.get("entrantA"), src.get("entrantB"), srcs, 0)
+            src_eb = find_src(src.get("entrantB"), src.get("entrantA"), srcs, 1)
+            a = resolve_name(src.get("entrantA"), src_ea, depth + 1)
+            b = resolve_name(src.get("entrantB"), src_eb, depth + 1)
             return f"Waiting on Match #{v_src} ({a} vs {b})"
 
         def build_tbd_chain(source_entry):
@@ -322,12 +336,14 @@ def build_tbd_chain(source_entry):
             if not src_match:
                 return [f"→ Waiting on Match #{v_src}"]
             srcs = src_match.get("entrantSources") or []
-            a_name = resolve_name(
-                src_match.get("entrantA"), srcs[0] if srcs else None, depth=1
+            src_ea = find_src(
+                src_match.get("entrantA"), src_match.get("entrantB"), srcs, 0
             )
-            b_name = resolve_name(
-                src_match.get("entrantB"), srcs[1] if len(srcs) > 1 else None, depth=1
+            src_eb = find_src(
+                src_match.get("entrantB"), src_match.get("entrantA"), srcs, 1
             )
+            a_name = resolve_name(src_match.get("entrantA"), src_ea, depth=1)
+            b_name = resolve_name(src_match.get("entrantB"), src_eb, depth=1)
             if "Waiting on" not in a_name and "Waiting on" not in b_name:
                 return [f"→ Match #{v_src}: {a_name} vs {b_name}"]
             return [
@@ -350,13 +366,17 @@ def build_tbd_chain(source_entry):
         team_b_is_tbd = team_b["name"] in ("TBD", "BYE")
 
         if team_a_is_tbd:
-            src_a = sources[0] if sources else None
+            src_a = find_src(
+                current_match.get("entrantA"), current_match.get("entrantB"), sources, 0
+            )
             if src_a:
                 raw = src_a.get("matchNum")
                 team_a["name"] = f"Waiting on Match #{raw_to_visual.get(raw, raw)}"
 
         if team_b_is_tbd:
-            src_b = sources[1] if len(sources) > 1 else None
+            src_b = find_src(
+                current_match.get("entrantB"), current_match.get("entrantA"), sources, 1
+            )
             if src_b:
                 raw = src_b.get("matchNum")
                 team_b["name"] = f"Waiting on Match #{raw_to_visual.get(raw, raw)}"
@@ -396,10 +416,26 @@ def build_tbd_chain(source_entry):
                 pass
 
         team_a_history = (
-            build_tbd_chain(sources[0] if sources else None) if team_a_is_tbd else []
+            build_tbd_chain(
+                find_src(
+                    current_match.get("entrantA"),
+                    current_match.get("entrantB"),
+                    sources,
+                    0,
+                )
+            )
+            if team_a_is_tbd
+            else []
         )
         team_b_history = (
-            build_tbd_chain(sources[1] if len(sources) > 1 else None)
+            build_tbd_chain(
+                find_src(
+                    current_match.get("entrantB"),
+                    current_match.get("entrantA"),
+                    sources,
+                    1,
+                )
+            )
             if team_b_is_tbd
             else []
         )
@@ -421,11 +457,13 @@ def build_tbd_chain(source_entry):
 
                 if opp_name.upper() == "TBD":
                     h_srcs = match.get("entrantSources") or []
-                    opp_idx = 1 if is_pos_a else 0
-                    opp_src = h_srcs[opp_idx] if len(h_srcs) > opp_idx else None
                     opp_dict = (
                         match.get("entrantB") if is_pos_a else match.get("entrantA")
                     )
+                    my_dict = (
+                        match.get("entrantA") if is_pos_a else match.get("entrantB")
+                    )
+                    opp_src = find_src(opp_dict, my_dict, h_srcs)
                     opp_label = resolve_name(opp_dict, opp_src)
                     team_a_history.append(
                         f"Match {v_num}: {team_a['name']} vs {opp_label}"
@@ -447,11 +485,13 @@ def build_tbd_chain(source_entry):
 
                 if opp_name.upper() == "TBD":
                     h_srcs = match.get("entrantSources") or []
-                    opp_idx = 1 if is_pos_a else 0
-                    opp_src = h_srcs[opp_idx] if len(h_srcs) > opp_idx else None
                     opp_dict = (
                         match.get("entrantB") if is_pos_a else match.get("entrantA")
                     )
+                    my_dict = (
+                        match.get("entrantA") if is_pos_a else match.get("entrantB")
+                    )
+                    opp_src = find_src(opp_dict, my_dict, h_srcs)
                     opp_label = resolve_name(opp_dict, opp_src)
                     team_b_history.append(
                         f"Match {v_num}: {team_b['name']} vs {opp_label}"

From e1aa714be1f4550a11cd0173297ceaf5934edabd Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sun, 14 Jun 2026 15:46:25 -0700
Subject: [PATCH 22/32] 198-Bug update TBD slot display with source match score
 and teams

---
 features/tourney/matcherino.py | 37 ++++++++++++++++++++++++++--------
 1 file changed, 29 insertions(+), 8 deletions(-)

diff --git a/features/tourney/matcherino.py b/features/tourney/matcherino.py
index 6cf875c..cdf6a7f 100644
--- a/features/tourney/matcherino.py
+++ b/features/tourney/matcherino.py
@@ -272,7 +272,7 @@ def get_team_info(entrant_dict):
             if not entrant_dict:
                 return {"name": "TBD", "score": 0, "players": []}
             e_id = entrant_dict.get("entrantId", 0)
-            score = entrant_dict.get("score", 0)
+            score = entrant_dict.get("score") or 0
             info = entrant_map.get(e_id, {"name": "TBD", "players": []})
             return {"name": info["name"], "score": score, "players": info["players"]}
 
@@ -325,6 +325,10 @@ def resolve_name(entrant_dict, source_entry, depth=0):
             src_eb = find_src(src.get("entrantB"), src.get("entrantA"), srcs, 1)
             a = resolve_name(src.get("entrantA"), src_ea, depth + 1)
             b = resolve_name(src.get("entrantB"), src_eb, depth + 1)
+            if "Waiting on" not in a and "Waiting on" not in b:
+                a_score = src.get("entrantA", {}).get("score") or 0
+                b_score = src.get("entrantB", {}).get("score") or 0
+                return f"Waiting on Match #{v_src} ({a} {a_score} - {b_score} {b})"
             return f"Waiting on Match #{v_src} ({a} vs {b})"
 
         def build_tbd_chain(source_entry):
@@ -345,7 +349,9 @@ def build_tbd_chain(source_entry):
             a_name = resolve_name(src_match.get("entrantA"), src_ea, depth=1)
             b_name = resolve_name(src_match.get("entrantB"), src_eb, depth=1)
             if "Waiting on" not in a_name and "Waiting on" not in b_name:
-                return [f"→ Match #{v_src}: {a_name} vs {b_name}"]
+                a_score = src_match.get("entrantA", {}).get("score") or 0
+                b_score = src_match.get("entrantB", {}).get("score") or 0
+                return [f"→ Match #{v_src}: {a_name} {a_score} - {b_score} {b_name}"]
             return [
                 f"→ Match #{v_src} [A]: {a_name}",
                 f"→ Match #{v_src} [B]: {b_name}",
@@ -365,21 +371,36 @@ def build_tbd_chain(source_entry):
         team_a_is_tbd = team_a["name"] in ("TBD", "BYE")
         team_b_is_tbd = team_b["name"] in ("TBD", "BYE")
 
+        def tbd_label(src_entry):
+            if not src_entry:
+                return "TBD"
+            raw = src_entry.get("matchNum")
+            v = raw_to_visual.get(raw, raw)
+            src_m = visual_match_map.get(v)
+            if not src_m:
+                return f"Waiting on Match #{v}"
+            srcs_m = src_m.get("entrantSources") or []
+            src_mea = find_src(src_m.get("entrantA"), src_m.get("entrantB"), srcs_m, 0)
+            src_meb = find_src(src_m.get("entrantB"), src_m.get("entrantA"), srcs_m, 1)
+            a_name = resolve_name(src_m.get("entrantA"), src_mea)
+            b_name = resolve_name(src_m.get("entrantB"), src_meb)
+            a_sc = src_m.get("entrantA", {}).get("score") or 0
+            b_sc = src_m.get("entrantB", {}).get("score") or 0
+            return f"Waiting on Match #{v} [{a_name} {a_sc} - {b_sc} {b_name}]"
+
         if team_a_is_tbd:
             src_a = find_src(
                 current_match.get("entrantA"), current_match.get("entrantB"), sources, 0
             )
-            if src_a:
-                raw = src_a.get("matchNum")
-                team_a["name"] = f"Waiting on Match #{raw_to_visual.get(raw, raw)}"
+            team_a["name"] = tbd_label(src_a)
+            team_a["score"] = None
 
         if team_b_is_tbd:
             src_b = find_src(
                 current_match.get("entrantB"), current_match.get("entrantA"), sources, 1
             )
-            if src_b:
-                raw = src_b.get("matchNum")
-                team_b["name"] = f"Waiting on Match #{raw_to_visual.get(raw, raw)}"
+            team_b["name"] = tbd_label(src_b)
+            team_b["score"] = None
 
         match_status = current_match.get("status", "unknown")
 

From 5cc6ced855c68e1241a7e3fcbf030cb5cbb81658 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sat, 20 Jun 2026 13:51:30 -0700
Subject: [PATCH 23/32] 312-Feature add monthly tournament reports, auto-detect
 Matcherino ID on start, and archive reports to dedicated channel

---
 features/config.py                   |   4 +
 features/tourney/tourney_commands.py | 149 +++++++++++++---
 features/tourney/tourney_reports.py  | 256 +++++++++++++++++++++++++++
 main.py                              |   3 +
 4 files changed, 390 insertions(+), 22 deletions(-)
 create mode 100644 features/tourney/tourney_reports.py

diff --git a/features/config.py b/features/config.py
index 06fa98d..c87ca29 100644
--- a/features/config.py
+++ b/features/config.py
@@ -20,6 +20,8 @@
     TOURNEY_SUPPORT_CHANNEL_ID = 1442037795987259464
     PRE_TOURNEY_SUPPORT_CHANNEL_ID = 1448917516071207133
     TOURNEY_ADMIN_CHANNEL_ID = 724835692395626516
+    TOURNEY_REPORT_CHANNEL_ID = 1516162989374570689
+    TOURNEY_SCHEDULE_CHANNEL_ID = 754927753643688046
     SPANISH_CHANNEL_ID = 1052348820513636463
 
     TOURNEY_ADMIN_ROLE_ID = 1160989152381251756
@@ -200,6 +202,8 @@
     TOURNEY_SUPPORT_CHANNEL_ID = 1448916985713791000
     PRE_TOURNEY_SUPPORT_CHANNEL_ID = 1448917121743716485
     TOURNEY_ADMIN_CHANNEL_ID = 1452338842798526514
+    TOURNEY_REPORT_CHANNEL_ID = 1516169206553509919
+    TOURNEY_SCHEDULE_CHANNEL_ID = 1516186562478735400
     SPANISH_CHANNEL_ID = 1477148473710084127
 
     TOURNEY_ADMIN_ROLE_ID = 1442028161889079469
diff --git a/features/tourney/tourney_commands.py b/features/tourney/tourney_commands.py
index 69894fb..1a4e77b 100644
--- a/features/tourney/tourney_commands.py
+++ b/features/tourney/tourney_commands.py
@@ -60,6 +60,8 @@
     HALL_OF_FAME_CHANNEL_ID,
     BOT_VERSION,
     TOURNEY_ADMIN_ROLE_ID,
+    TOURNEY_REPORT_CHANNEL_ID,
+    TOURNEY_SCHEDULE_CHANNEL_ID,
 )
 from .tourney_utils import (
     close_ticket_via_command,
@@ -1340,6 +1342,61 @@ async def start_tourney_command(ctx: commands.Context, region: str = None):
         else:
             await reset_tourney_session_start_time(existing_session["_id"])
 
+        # Auto-detect Matcherino ID from #tourney-schedule (±1 day of today)
+        auto_matcherino_id = None
+        auto_detect_error = None
+        schedule_channel = ctx.bot.get_channel(TOURNEY_SCHEDULE_CHANNEL_ID)
+        if not schedule_channel:
+            auto_detect_error = "⚠️ Auto-detect: `TOURNEY_SCHEDULE_CHANNEL_ID` not found — check `config.py`."
+        else:
+            today = datetime.datetime.now(datetime.timezone.utc).date()
+            msgs_checked = 0
+            closest_date_seen = None
+            try:
+                async for msg in schedule_channel.history(limit=100):
+                    content = msg.content or ""
+                    date_match = re.search(
+                        r"•\s*\**\s*Date:\**\s*(.+)", content, re.IGNORECASE
+                    )
+                    if not date_match:
+                        continue
+                    msgs_checked += 1
+                    date_str = date_match.group(1).strip()
+                    try:
+                        parsed_date = datetime.datetime.strptime(
+                            date_str, "%B %d, %Y"
+                        ).date()
+                    except ValueError:
+                        auto_detect_error = f"⚠️ Auto-detect: Found a date but couldn't parse it: `{date_str}` — expected format `June 19, 2026`."
+                        continue
+                    closest_date_seen = parsed_date
+                    if abs((parsed_date - today).days) <= 1:
+                        url_match = re.search(
+                            r"matcherino\.com/supercell/tournaments/(\d+)", content
+                        )
+                        if url_match:
+                            auto_matcherino_id = url_match.group(1)
+                            break
+                        else:
+                            auto_detect_error = f"⚠️ Auto-detect: Found the schedule post for `{date_str}` but no Matcherino URL in the message."
+                            break
+
+                if not auto_matcherino_id and not auto_detect_error:
+                    if msgs_checked == 0:
+                        auto_detect_error = f"⚠️ Auto-detect: No messages with a `• Date:` field found in <#{TOURNEY_SCHEDULE_CHANNEL_ID}>."
+                    else:
+                        auto_detect_error = (
+                            f"⚠️ Auto-detect: No schedule post within ±1 day of today ({today.strftime('%B %d, %Y')}). "
+                            f"Closest date found: `{closest_date_seen.strftime('%B %d, %Y') if closest_date_seen else 'none'}`."
+                        )
+            except Exception as e:
+                auto_detect_error = f"⚠️ Auto-detect error: `{e}`"
+
+        if auto_matcherino_id:
+            active_session = await get_active_tourney_session()
+            if active_session:
+                await update_matcherino_id(active_session["_id"], auto_matcherino_id)
+
         await lock_command(ctx)
 
         # --- SA REGION LOGIC ---
@@ -1479,8 +1536,16 @@ async def start_tourney_command(ctx: commands.Context, region: str = None):
                         except Exception as e:
                             print(f"Failed to delete pre-tourney ticket {ch.name}: {e}")
 
+        if auto_matcherino_id:
+            matcherino_notice = f"🔗 Matcherino ID auto-set to `{auto_matcherino_id}` from the schedule. If wrong, use `/set-matcherino` to fix it."
+        else:
+            matcherino_notice = (
+                auto_detect_error
+                or "⚠️ Could not auto-detect Matcherino ID. Set it manually with `/set-matcherino`."
+            )
+
         await ctx.send(
-            f"✅ Tourney Started! Channels updated and {deleted_count} pre-tourney tickets deleted.\n⚠️ Don't forget to set the new Matcherino ID with `/set-matcherino` and enable ML data collection if needed."
+            f"✅ Tourney Started! Channels updated and {deleted_count} pre-tourney tickets deleted.\n{matcherino_notice}"
         )
 
         # Grant Tourney Admin the Timeout Members permission for the duration of the tourney.
@@ -1529,8 +1594,6 @@ async def _rename_admin_role():
                     "hype_message_id": None,
                 },
             }
-            await dashboard_cog.start_dashboard()
-
         # Apply 60s slow mode to general channel during tourney.
         general_channel = guild.get_channel(GENERAL_CHANNEL_ID)
         if isinstance(general_channel, discord.TextChannel):
@@ -1542,6 +1605,11 @@ async def _rename_admin_role():
             except Exception as e:
                 print(f"Failed to set slow mode on general channel: {e}")
 
+        # Start dashboard last so it's the final message in #tourney-admin,
+        # preventing an immediate delete+repost flash on the first 5-minute tick.
+        if dashboard_cog:
+            await dashboard_cog.start_dashboard()
+
     @bot.command(name="endtourney")
     async def end_tourney_command(ctx: commands.Context):
         """
@@ -1588,13 +1656,6 @@ async def end_tourney_command(ctx: commands.Context):
             except Exception as e:
                 print(f"!endtourney announcement sync error: {e}")
 
-        # Do a final progress dashboard refresh before stopping so it shows Tournament Over.
-        if dashboard_cog:
-            try:
-                await dashboard_cog.update_progress_dashboard()
-            except Exception as e:
-                print(f"!endtourney final progress update error: {e}")
-
         winner_was_posted = (
             dashboard_cog is not None
             and dashboard_cog._winner_announcement_state.get("winner") is not None
@@ -1684,16 +1745,55 @@ async def _retry_winner_post():
                     icon = f"**{i + 1}.**"  # e.g. "4.", "5.", "6."
 
                 staff_msg += (
-                    f"{icon} **{s['username']}**: {s['tickets_closed']} tickets\n"
+                    f"{icon} <@{s['user_id']}>: {s['tickets_closed']} tickets\n"
                 )
 
             if not staff_msg:
                 staff_msg = "No tickets closed."
 
-            # 3. Send Embed
-            stat_embed = discord.Embed(
-                title="📊 Tournament Report", color=discord.Color.gold()
-            )
+            # 3. Look up tournament name (Matcherino API) and canonical date (#tourney-schedule)
+            tourney_date_str = None
+            tourney_name = None
+            matcherino_id = session.get("matcherino_id")
+            if matcherino_id:
+                try:
+                    payout_data = fetch_payout_report(str(matcherino_id))
+                    if "error" not in payout_data:
+                        tourney_name = payout_data.get("tourney_name")
+                except Exception as e:
+                    print(f"⚠️ Could not fetch tourney name from Matcherino: {e}")
+
+                ann_channel = ctx.bot.get_channel(TOURNEY_SCHEDULE_CHANNEL_ID)
+                if ann_channel:
+                    try:
+                        async for msg in ann_channel.history(limit=500):
+                            if str(matcherino_id) in (msg.content or ""):
+                                m = re.search(
+                                    r"•\s*\**\s*Date:\**\s*(.+)",
+                                    msg.content,
+                                    re.IGNORECASE,
+                                )
+                                if m:
+                                    tourney_date_str = m.group(1).strip()
+                                break
+                    except Exception as e:
+                        print(f"⚠️ Could not look up tourney date from schedule: {e}")
+
+            # 4. Build Embed
+            if tourney_name and matcherino_id:
+                matcherino_url = (
+                    f"https://matcherino.com/supercell/tournaments/{matcherino_id}"
+                )
+                stat_embed = discord.Embed(
+                    title=f"📊 Tournament Report ({tourney_name})",
+                    url=matcherino_url,
+                    color=discord.Color.gold(),
+                )
+            else:
+                stat_embed = discord.Embed(
+                    title="📊 Tournament Report",
+                    color=discord.Color.gold(),
+                )
             stat_embed.add_field(
                 name="⏱️ Duration", value=f"`{hours}h {minutes}m`", inline=True
             )
@@ -1715,15 +1815,20 @@ async def _retry_winner_post():
             stat_embed.add_field(
                 name="🏆 Top Tourney Admins", value=staff_msg, inline=False
             )
+            if tourney_date_str:
+                stat_embed.add_field(
+                    name="📅 Tournament Date", value=tourney_date_str, inline=False
+                )
+            if matcherino_id:
+                stat_embed.set_footer(text=f"Matcherino ID: {matcherino_id}")
 
-            report_msg = await ctx.send(embed=stat_embed)
-
-            try:
-                await report_msg.pin()
-            except Exception as e:
-                print(f"⚠️ Could not pin report: {e}")
+            # 5. Send to command channel (no pin) and archive to #tourney-reports
+            await ctx.send(embed=stat_embed)
+            report_channel = ctx.bot.get_channel(TOURNEY_REPORT_CHANNEL_ID)
+            if report_channel:
+                await report_channel.send(embed=stat_embed)
 
-            # 4. Close Session in DB
+            # 6. Close Session in DB
             await end_tourney_session(session["_id"])
             await set_tourney_collect_data(session["_id"], False)
             clear_bracket_teams_cache()
diff --git a/features/tourney/tourney_reports.py b/features/tourney/tourney_reports.py
new file mode 100644
index 0000000..b574707
--- /dev/null
+++ b/features/tourney/tourney_reports.py
@@ -0,0 +1,256 @@
+import datetime
+import re
+import zoneinfo
+
+import discord
+from discord import app_commands
+from discord.ext import commands, tasks
+
+from features.config import (
+    ALLOWED_STAFF_ROLES,
+    TOURNEY_REPORT_CHANNEL_ID,
+)
+
+
+def is_staff(member: discord.Member) -> bool:
+    return any(role.id in ALLOWED_STAFF_ROLES for role in member.roles)
+
+
+def _prev_month(year: int, month: int) -> tuple[int, int]:
+    if month == 1:
+        return year - 1, 12
+    return year, month - 1
+
+
+def _month_range(year: int, month: int) -> tuple[datetime.datetime, datetime.datetime]:
+    start = datetime.datetime(year, month, 1, tzinfo=datetime.timezone.utc)
+    ny, nm = (year, month + 1) if month < 12 else (year + 1, 1)
+    end = datetime.datetime(ny, nm, 1, tzinfo=datetime.timezone.utc)
+    return start, end
+
+
+def _parse_tourney_date(date_str: str) -> datetime.datetime | None:
+    for fmt in (
+        "%B %d, %Y",
+        "%B %dst, %Y",
+        "%B %dnd, %Y",
+        "%B %drd, %Y",
+        "%B %dth, %Y",
+    ):
+        try:
+            return datetime.datetime.strptime(date_str.strip(), fmt).replace(
+                tzinfo=datetime.timezone.utc
+            )
+        except ValueError:
+            continue
+    return None
+
+
+async def _run_monthly_report(
+    bot: commands.Bot,
+    year: int,
+    month: int,
+    *,
+    status_cb=None,
+) -> str:
+    """
+    Core logic for generating a monthly tournament report.
+
+    Reads #tourney-reports for per-tourney embeds whose Tournament Date falls
+    in the given month/year. Aggregates and posts a combined embed to the same
+    channel.
+
+    status_cb: optional async callable(str) for streaming progress to a slash command.
+    Returns a summary string on success, or raises ValueError with an error message.
+    """
+
+    async def status(msg: str):
+        print(msg)
+        if status_cb:
+            await status_cb(msg)
+
+    month_label = datetime.datetime(year, month, 1).strftime("%B %Y")
+    start_dt, end_dt = _month_range(year, month)
+
+    report_channel = bot.get_channel(TOURNEY_REPORT_CHANNEL_ID)
+    if not report_channel:
+        raise ValueError(
+            "⚠️ `TOURNEY_REPORT_CHANNEL_ID` not found — update it in `config.py`."
+        )
+
+    await status(f"🔍 Scanning {report_channel.mention} for **{month_label}**...")
+
+    total_tickets = 0
+    total_messages = 0
+    peak_queues: list[int] = []
+    staff_totals: dict[str, int] = {}
+    tourney_count = 0
+    parse_warnings: list[str] = []
+
+    async for msg in report_channel.history(limit=1000):
+        if msg.author.id != bot.user.id:
+            continue
+        for embed in msg.embeds:
+            # Skip monthly rollup embeds to avoid double-counting
+            if embed.title and "Monthly Tournament Report" in embed.title:
+                continue
+
+            date_field = next(
+                (f for f in embed.fields if "Tournament Date" in f.name), None
+            )
+            if not date_field:
+                continue
+
+            parsed = _parse_tourney_date(date_field.value)
+            if not parsed:
+                parse_warnings.append(
+                    f"⚠️ Could not parse date `{date_field.value}` "
+                    f"from embed posted {msg.created_at.strftime('%Y-%m-%d')} — skipped."
+                )
+                continue
+
+            if not (start_dt <= parsed < end_dt):
+                continue
+
+            tourney_count += 1
+
+            for field in embed.fields:
+                name = field.name
+                val = field.value
+                if "Total Tickets" in name:
+                    m = re.search(r"\d+", val)
+                    if m:
+                        total_tickets += int(m.group())
+                elif "Total Messages" in name:
+                    m = re.search(r"\d+", val)
+                    if m:
+                        total_messages += int(m.group())
+                elif "Peak Queue" in name:
+                    m = re.search(r"\d+", val)
+                    if m:
+                        peak_queues.append(int(m.group()))
+                elif "Top Tourney Admins" in name:
+                    for user_id, count in re.findall(r"<@(\d+)>: (\d+) tickets", val):
+                        staff_totals[user_id] = staff_totals.get(user_id, 0) + int(
+                            count
+                        )
+
+    for warning in parse_warnings:
+        await status(warning)
+
+    if tourney_count == 0:
+        return (
+            f"📊 No tournaments found in **{month_label}**. "
+            f"If reports exist for this month, ensure they include a **📅 Tournament Date** field."
+        )
+
+    avg_peak = round(sum(peak_queues) / len(peak_queues), 1) if peak_queues else 0
+
+    sorted_staff = sorted(staff_totals.items(), key=lambda x: x[1], reverse=True)
+    medals = ["🥇", "🥈", "🥉"]
+    staff_lines = []
+    for i, (user_id, count) in enumerate(sorted_staff[:12]):
+        icon = medals[i] if i < 3 else f"**{i + 1}.**"
+        staff_lines.append(f"{icon} <@{user_id}>: {count} tickets")
+    staff_msg = "\n".join(staff_lines) if staff_lines else "No tickets closed."
+
+    embed = discord.Embed(
+        title=f"📅 Monthly Tournament Report — {month_label}",
+        color=discord.Color.purple(),
+    )
+    embed.add_field(name="🏆 Tournaments", value=f"`{tourney_count}`", inline=True)
+    embed.add_field(name="📩 Total Tickets", value=f"`{total_tickets}`", inline=True)
+    embed.add_field(name="💬 Total Messages", value=f"`{total_messages}`", inline=True)
+    embed.add_field(
+        name="📈 Avg Peak Queue", value=f"`{avg_peak}` tickets", inline=True
+    )
+    embed.add_field(name="🏆 Top Tourney Admins", value=staff_msg, inline=False)
+
+    await report_channel.send(embed=embed)
+    return (
+        f"✅ Monthly report for **{month_label}** posted — "
+        f"{tourney_count} tournament(s), {total_tickets} total tickets."
+    )
+
+
+class TourneyReports(commands.Cog):
+    def __init__(self, bot: commands.Bot):
+        self.bot = bot
+        self.monthly_report_task.start()
+
+    def cog_unload(self):
+        self.monthly_report_task.cancel()
+
+    # ⚠️ FOR TESTING: Change to @tasks.loop(seconds=30) and comment out the day != 1 guard
+    @tasks.loop(time=datetime.time(hour=6, minute=0, tzinfo=zoneinfo.ZoneInfo("UTC")))
+    async def monthly_report_task(self):
+        if not self.bot.is_ready():
+            return
+        now = datetime.datetime.now(datetime.timezone.utc)
+        if now.day != 1:
+            return
+
+        py, pm = _prev_month(now.year, now.month)
+        try:
+            result = await _run_monthly_report(self.bot, py, pm)
+            print(f"✅ Auto monthly report: {result}")
+        except ValueError as e:
+            print(f"❌ Auto monthly report failed: {e}")
+        except Exception as e:
+            print(f"❌ Auto monthly report unexpected error: {e}")
+
+    @app_commands.command(
+        name="monthly-report",
+        description="STAFF ONLY: Generate (or re-generate) a monthly tournament report.",
+    )
+    @app_commands.describe(
+        month="Month number (1–12). Defaults to last month.",
+        year="4-digit year. Defaults to the year of last month.",
+    )
+    async def monthly_report_cmd(
+        self,
+        interaction: discord.Interaction,
+        month: int | None = None,
+        year: int | None = None,
+    ):
+        if not is_staff(interaction.user):
+            await interaction.response.send_message(
+                "❌ You don't have permission to use this command.", ephemeral=True
+            )
+            return
+
+        if month is not None and not (1 <= month <= 12):
+            await interaction.response.send_message(
+                "❌ Month must be between 1 and 12.", ephemeral=True
+            )
+            return
+
+        now = datetime.datetime.now(datetime.timezone.utc)
+        if month is None or year is None:
+            py, pm = _prev_month(now.year, now.month)
+            month = month if month is not None else pm
+            year = year if year is not None else py
+
+        await interaction.response.defer(ephemeral=True)
+
+        messages: list[str] = []
+
+        async def status_cb(msg: str):
+            messages.append(msg)
+            await interaction.edit_original_response(content="\n".join(messages))
+
+        try:
+            result = await _run_monthly_report(
+                self.bot, year, month, status_cb=status_cb
+            )
+            messages.append(result)
+        except ValueError as e:
+            messages.append(str(e))
+        except Exception as e:
+            messages.append(f"❌ Unexpected error: {e}")
+
+        await interaction.edit_original_response(content="\n".join(messages))
+
+
+async def setup(bot: commands.Bot):
+    await bot.add_cog(TourneyReports(bot))
diff --git a/main.py b/main.py
index 799490c..fe889b4 100644
--- a/main.py
+++ b/main.py
@@ -76,6 +76,9 @@ async def on_ready():
         await bot.load_extension("features.counting")
         print("✅ Loaded Feature: Counting")
 
+        await bot.load_extension("features.tourney.tourney_reports")
+        print("✅ Loaded Feature: Tourney Reports")
+
     except Exception as e:
         print(f"❌ Error loading features: {e}")
 

From d47690c66a5f3b9501729274b51faa00ced24e3a Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sat, 20 Jun 2026 14:06:14 -0700
Subject: [PATCH 24/32] 312-Feature add tests for tourney reports pure
 functions and schedule parsing regex

---
 tests/test_tourney_reports.py | 274 ++++++++++++++++++++++++++++++++++
 1 file changed, 274 insertions(+)
 create mode 100644 tests/test_tourney_reports.py

diff --git a/tests/test_tourney_reports.py b/tests/test_tourney_reports.py
new file mode 100644
index 0000000..54a521d
--- /dev/null
+++ b/tests/test_tourney_reports.py
@@ -0,0 +1,274 @@
+"""Tests for pure functions in features/tourney/tourney_reports.py and
+the date/URL regex patterns introduced on branch 312-Feature."""
+
+import datetime
+import re
+
+
+from features.tourney.tourney_reports import (
+    _month_range,
+    _parse_tourney_date,
+    _prev_month,
+)
+
+# Regex patterns copied from tourney_commands.py (starttourney auto-detect)
+DATE_REGEX = re.compile(r"•\s*\**\s*Date:\**\s*(.+)", re.IGNORECASE)
+MATCHERINO_URL_REGEX = re.compile(r"matcherino\.com/supercell/tournaments/(\d+)")
+
+# Regex pattern from _run_monthly_report staff parsing
+STAFF_LINE_REGEX = re.compile(r"<@(\d+)>: (\d+) tickets")
+
+
+# ---------------------------------------------------------------------------
+# _prev_month
+# ---------------------------------------------------------------------------
+
+
+def test_prev_month_normal():
+    assert _prev_month(2026, 6) == (2026, 5)
+
+
+def test_prev_month_january_rolls_back_to_december():
+    assert _prev_month(2026, 1) == (2025, 12)
+
+
+def test_prev_month_december():
+    assert _prev_month(2026, 12) == (2026, 11)
+
+
+def test_prev_month_february():
+    assert _prev_month(2026, 2) == (2026, 1)
+
+
+# ---------------------------------------------------------------------------
+# _month_range
+# ---------------------------------------------------------------------------
+
+
+def test_month_range_normal():
+    start, end = _month_range(2026, 6)
+    assert start == datetime.datetime(2026, 6, 1, tzinfo=datetime.timezone.utc)
+    assert end == datetime.datetime(2026, 7, 1, tzinfo=datetime.timezone.utc)
+
+
+def test_month_range_december_rolls_to_next_year():
+    start, end = _month_range(2026, 12)
+    assert start == datetime.datetime(2026, 12, 1, tzinfo=datetime.timezone.utc)
+    assert end == datetime.datetime(2027, 1, 1, tzinfo=datetime.timezone.utc)
+
+
+def test_month_range_january():
+    start, end = _month_range(2026, 1)
+    assert start == datetime.datetime(2026, 1, 1, tzinfo=datetime.timezone.utc)
+    assert end == datetime.datetime(2026, 2, 1, tzinfo=datetime.timezone.utc)
+
+
+def test_month_range_start_is_utc_aware():
+    start, end = _month_range(2026, 3)
+    assert start.tzinfo == datetime.timezone.utc
+    assert end.tzinfo == datetime.timezone.utc
+
+
+def test_month_range_date_falls_inside():
+    start, end = _month_range(2026, 6)
+    test_date = datetime.datetime(2026, 6, 19, tzinfo=datetime.timezone.utc)
+    assert start <= test_date < end
+
+
+def test_month_range_date_falls_outside():
+    start, end = _month_range(2026, 6)
+    test_date = datetime.datetime(2026, 7, 1, tzinfo=datetime.timezone.utc)
+    assert not (start <= test_date < end)
+
+
+# ---------------------------------------------------------------------------
+# _parse_tourney_date
+# ---------------------------------------------------------------------------
+
+
+def test_parse_standard_format():
+    result = _parse_tourney_date("June 19, 2026")
+    assert result is not None
+    assert result.month == 6
+    assert result.day == 19
+    assert result.year == 2026
+
+
+def test_parse_with_ordinal_st():
+    result = _parse_tourney_date("June 1st, 2026")
+    assert result is not None
+    assert result.day == 1
+
+
+def test_parse_with_ordinal_nd():
+    result = _parse_tourney_date("June 2nd, 2026")
+    assert result is not None
+    assert result.day == 2
+
+
+def test_parse_with_ordinal_rd():
+    result = _parse_tourney_date("June 3rd, 2026")
+    assert result is not None
+    assert result.day == 3
+
+
+def test_parse_with_ordinal_th():
+    result = _parse_tourney_date("June 4th, 2026")
+    assert result is not None
+    assert result.day == 4
+
+
+def test_parse_returns_none_for_invalid():
+    assert _parse_tourney_date("not a date") is None
+
+
+def test_parse_returns_none_for_empty():
+    assert _parse_tourney_date("") is None
+
+
+def test_parse_returns_none_for_wrong_format():
+    assert _parse_tourney_date("19/06/2026") is None
+
+
+def test_parse_result_is_utc_aware():
+    result = _parse_tourney_date("June 19, 2026")
+    assert result.tzinfo == datetime.timezone.utc
+
+
+def test_parse_strips_leading_whitespace():
+    result = _parse_tourney_date("  June 19, 2026")
+    assert result is not None
+    assert result.day == 19
+
+
+# ---------------------------------------------------------------------------
+# Date regex (schedule announcement parsing)
+# ---------------------------------------------------------------------------
+
+
+def test_date_regex_plain_format():
+    content = "• Date: June 19, 2026"
+    m = DATE_REGEX.search(content)
+    assert m is not None
+    assert m.group(1).strip() == "June 19, 2026"
+
+
+def test_date_regex_bold_format():
+    content = "• **Date:** June 20, 2026"
+    m = DATE_REGEX.search(content)
+    assert m is not None
+    assert m.group(1).strip() == "June 20, 2026"
+
+
+def test_date_regex_with_emoji_prefix():
+    # Real announcement format: 🗓️ • **Date:** June 20, 2026
+    content = "🗓️ • **Date:** June 20, 2026"
+    m = DATE_REGEX.search(content)
+    assert m is not None
+    assert m.group(1).strip() == "June 20, 2026"
+
+
+def test_date_regex_case_insensitive():
+    content = "• date: June 19, 2026"
+    m = DATE_REGEX.search(content)
+    assert m is not None
+
+
+def test_date_regex_no_match_without_bullet():
+    content = "Date: June 19, 2026"
+    m = DATE_REGEX.search(content)
+    assert m is None
+
+
+def test_date_regex_multiline_finds_correct_line():
+    content = (
+        "Remaining 7 NA Tourney\n"
+        "🗓️ • **Date:** June 20, 2026\n"
+        "🪜 • **Bracket Size:** 256 Teams\n"
+        "✔️ **Register:** https://matcherino.com/supercell/tournaments/208611"
+    )
+    m = DATE_REGEX.search(content)
+    assert m is not None
+    assert m.group(1).strip() == "June 20, 2026"
+
+
+# ---------------------------------------------------------------------------
+# Matcherino URL regex (schedule announcement parsing)
+# ---------------------------------------------------------------------------
+
+
+def test_matcherino_url_extracts_id():
+    content = "✔️ **Register:** https://matcherino.com/supercell/tournaments/208611"
+    m = MATCHERINO_URL_REGEX.search(content)
+    assert m is not None
+    assert m.group(1) == "208611"
+
+
+def test_matcherino_url_in_full_announcement():
+    content = (
+        "Remaining 7 NA Tourney\n"
+        "🗓️ • **Date:** June 20, 2026\n"
+        "✔️ **Register:** https://matcherino.com/supercell/tournaments/208611\n"
+    )
+    m = MATCHERINO_URL_REGEX.search(content)
+    assert m is not None
+    assert m.group(1) == "208611"
+
+
+def test_matcherino_url_no_match_for_wrong_domain():
+    content = "https://otherdomain.com/supercell/tournaments/12345"
+    m = MATCHERINO_URL_REGEX.search(content)
+    assert m is None
+
+
+def test_matcherino_url_no_match_when_absent():
+    content = "No URL in this message"
+    m = MATCHERINO_URL_REGEX.search(content)
+    assert m is None
+
+
+# ---------------------------------------------------------------------------
+# Staff line regex (_run_monthly_report embed parsing)
+# ---------------------------------------------------------------------------
+
+
+def test_staff_line_parses_gold_medal():
+    line = "🥇 <@408419700729708545>: 54 tickets"
+    matches = STAFF_LINE_REGEX.findall(line)
+    assert len(matches) == 1
+    assert matches[0] == ("408419700729708545", "54")
+
+
+def test_staff_line_parses_numbered_entry():
+    # Numbered entries like **4.** <@id>: N tickets
+    line = "**4.** <@824311612227715083>: 12 tickets"
+    matches = STAFF_LINE_REGEX.findall(line)
+    assert len(matches) == 1
+    assert matches[0] == ("824311612227715083", "12")
+
+
+def test_staff_line_parses_multiple_lines():
+    block = (
+        "🥇 <@111>: 54 tickets\n"
+        "🥈 <@222>: 23 tickets\n"
+        "🥉 <@333>: 10 tickets\n"
+        "**4.** <@444>: 5 tickets\n"
+    )
+    matches = STAFF_LINE_REGEX.findall(block)
+    assert len(matches) == 4
+    assert matches[0] == ("111", "54")
+    assert matches[3] == ("444", "5")
+
+
+def test_staff_line_aggregation_across_embeds():
+    # Simulate combining two embed staff fields
+    embed1 = "🥇 <@111>: 30 tickets\n🥈 <@222>: 20 tickets"
+    embed2 = "🥇 <@222>: 15 tickets\n🥈 <@111>: 10 tickets"
+
+    totals: dict[str, int] = {}
+    for block in [embed1, embed2]:
+        for uid, count in STAFF_LINE_REGEX.findall(block):
+            totals[uid] = totals.get(uid, 0) + int(count)
+
+    assert totals["111"] == 40
+    assert totals["222"] == 35

From 7797c14deb9d15e531b426f2f92d35704af9f680 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sat, 20 Jun 2026 15:06:40 -0700
Subject: [PATCH 25/32] 316-Enhancement remove 5-match bottleneck cap

---
 features/tourney/tourney_commands.py | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/features/tourney/tourney_commands.py b/features/tourney/tourney_commands.py
index 1a4e77b..73f2662 100644
--- a/features/tourney/tourney_commands.py
+++ b/features/tourney/tourney_commands.py
@@ -594,8 +594,16 @@ async def update_progress_dashboard(self):
 
             if data["bottlenecks"]:
                 bn_text = ""
-                for bn in data["bottlenecks"][:5]:
-                    bn_text += f"**#{bn['id']}** (Round {bn['round']}) | {bn['team_a']} vs {bn['team_b']} ({bn['score_a']}-{bn['score_b']})\n"
+                shown = 0
+                total_bn = len(data["bottlenecks"])
+                for bn in data["bottlenecks"]:
+                    line = f"**#{bn['id']}** (Round {bn['round']}) | {bn['team_a']} vs {bn['team_b']} ({bn['score_a']}-{bn['score_b']})\n"
+                    if len(bn_text) + len(line) > 1000:
+                        break
+                    bn_text += line
+                    shown += 1
+                if shown < total_bn:
+                    bn_text += f"*+{total_bn - shown} more...*"
                 embed.add_field(
                     name="⚠️ Bottleneck Matches", value=bn_text, inline=False
                 )
@@ -2990,8 +2998,16 @@ async def tourney_progress(interaction: discord.Interaction):
         # Bottlenecks (Laggards behind dominant round)
         if data["bottlenecks"]:
             bn_text = ""
-            for bn in data["bottlenecks"][:5]:
-                bn_text += f"**#{bn['id']}** (Round {bn['round']}) | {bn['team_a']} vs {bn['team_b']} ({bn['score_a']}-{bn['score_b']})\n"
+            shown = 0
+            total_bn = len(data["bottlenecks"])
+            for bn in data["bottlenecks"]:
+                line = f"**#{bn['id']}** (Round {bn['round']}) | {bn['team_a']} vs {bn['team_b']} ({bn['score_a']}-{bn['score_b']})\n"
+                if len(bn_text) + len(line) > 1000:
+                    break
+                bn_text += line
+                shown += 1
+            if shown < total_bn:
+                bn_text += f"*+{total_bn - shown} more...*"
             embed.add_field(name="⚠️ Bottleneck Matches", value=bn_text, inline=False)
         else:
             embed.add_field(

From 4974f32f88800f6ea422433fe2a6da15d0a1cf9a Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sat, 20 Jun 2026 15:23:05 -0700
Subject: [PATCH 26/32] 318-Enhancement replace previous cleanup warning
 instead of stacking a new one

---
 features/event.py | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/features/event.py b/features/event.py
index dd7f881..93751a2 100644
--- a/features/event.py
+++ b/features/event.py
@@ -296,6 +296,7 @@ async def cancel(self, interaction: discord.Interaction, button: discord.ui.Butt
 class Events(commands.Cog):
     def __init__(self, bot):
         self.bot = bot
+        self._warning_msg_ids: dict[int, int] = {}  # channel_id → warning message_id
         self.cleanup_check_task.start()
 
     def cog_unload(self):
@@ -415,8 +416,17 @@ async def cleanup_check_task(self):
                             inline=False,
                         )
 
+                        old_msg_id = self._warning_msg_ids.get(channel_id)
+                        if old_msg_id:
+                            try:
+                                old_msg = await staff_channel.fetch_message(old_msg_id)
+                                await old_msg.delete()
+                            except (discord.NotFound, discord.HTTPException):
+                                pass
+
                         view = ClearChannelView(channel_id)
-                        await staff_channel.send(embed=embed, view=view)
+                        new_msg = await staff_channel.send(embed=embed, view=view)
+                        self._warning_msg_ids[channel_id] = new_msg.id
                         print(f"⚠️ Sent cleanup alert for #{name}-event")
 
                     break

From 2786a3a108915652e4848ca7f4c10e4427299f3c Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sat, 20 Jun 2026 15:39:46 -0700
Subject: [PATCH 27/32] 317-Enhancement add slow mode auto-disable after 1 hour
 with general channel notifications

---
 features/tourney/tourney_commands.py | 37 ++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/features/tourney/tourney_commands.py b/features/tourney/tourney_commands.py
index 73f2662..b0f1d1b 100644
--- a/features/tourney/tourney_commands.py
+++ b/features/tourney/tourney_commands.py
@@ -1172,6 +1172,9 @@ async def blacklist_list(self, interaction: discord.Interaction):
 def setup_tourney_commands(bot: commands.Bot):
     sticky_redirect_state = {"enabled": False, "region": None}
     admin_role_original_name: list[str | None] = [None]  # mutable container for closure
+    slowmode_auto_disable_task: list[asyncio.Task | None] = [
+        None
+    ]  # mutable container for closure
 
     @bot.command(name="close", aliases=["c"])
     async def close_command(ctx: commands.Context):
@@ -1610,9 +1613,35 @@ async def _rename_admin_role():
                 await ctx.send(
                     f"🐢 Slow mode (60s) has been enabled in {general_channel.mention}."
                 )
+                await general_channel.send(
+                    "🐢 Slow mode has been enabled for the duration of the tournament. It will be automatically removed after 1 hour."
+                )
             except Exception as e:
                 print(f"Failed to set slow mode on general channel: {e}")
 
+        # Cancel any existing auto-disable timer before starting a new one.
+        if slowmode_auto_disable_task[0] and not slowmode_auto_disable_task[0].done():
+            slowmode_auto_disable_task[0].cancel()
+
+        async def auto_disable_slowmode():
+            try:
+                await asyncio.sleep(3600)  # 1 hour
+            except asyncio.CancelledError:
+                return  # Cancelled by !endtourney or a subsequent !starttourney
+
+            channel = bot.get_channel(GENERAL_CHANNEL_ID)
+            if isinstance(channel, discord.TextChannel):
+                try:
+                    await channel.edit(slowmode_delay=0)
+                    await channel.send(
+                        "🐇 Slow mode has been automatically removed. You can now chat freely!"
+                    )
+                    print(f"✅ Slow mode auto-disabled on #{channel.name}")
+                except Exception as e:
+                    print(f"Failed to auto-disable slow mode: {e}")
+
+        slowmode_auto_disable_task[0] = asyncio.create_task(auto_disable_slowmode())
+
         # Start dashboard last so it's the final message in #tourney-admin,
         # preventing an immediate delete+repost flash on the first 5-minute tick.
         if dashboard_cog:
@@ -1856,6 +1885,11 @@ async def _retry_winner_post():
             except Exception as e:
                 print(f"Failed to restore Admin role name: {e}")
 
+        # Cancel the auto-disable timer since we're removing slow mode now.
+        if slowmode_auto_disable_task[0] and not slowmode_auto_disable_task[0].done():
+            slowmode_auto_disable_task[0].cancel()
+        slowmode_auto_disable_task[0] = None
+
         # Remove slow mode from general channel now that tourney is over.
         general_channel = guild.get_channel(GENERAL_CHANNEL_ID)
         if isinstance(general_channel, discord.TextChannel):
@@ -1864,6 +1898,9 @@ async def _retry_winner_post():
                 await ctx.send(
                     f"🐇 Slow mode has been removed from {general_channel.mention}."
                 )
+                await general_channel.send(
+                    "🐇 The tournament has ended — slow mode has been removed. Chat freely!"
+                )
             except Exception as e:
                 print(f"Failed to remove slow mode on general channel: {e}")
 

From 78da21bd86a3e5820152c80d677c8f4044b774aa Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sat, 20 Jun 2026 16:07:24 -0700
Subject: [PATCH 28/32] 184-Bug fix quest rewards to better incentivize harder
 quests

---
 database/mongo.py  | 24 ++++++++++++------------
 features/quests.py | 12 ++++++------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/database/mongo.py b/database/mongo.py
index 574e568..a0ef41d 100644
--- a/database/mongo.py
+++ b/database/mongo.py
@@ -675,25 +675,25 @@ async def add_hypercharge_to_user(user_id: str, brawler_id: str, hc_name: str):
 
 
 async def init_default_quests(default_quests_list):
-    """Ensures default quests exist in the DB (Run once)."""
+    """Upserts default quests into the DB, syncing rewards to code on every startup."""
     if db is None:
         return
-    # Check if quests already exist to avoid duplicates
-    if await db.quests.count_documents({}) == 0:
-        for q in default_quests_list:
-            # Matches your screenshot structure
-            await db.quests.insert_one(
-                {
-                    "name": q[0],
+    for q in default_quests_list:
+        await db.quests.update_one(
+            {"name": q[0]},
+            {
+                "$set": {
                     "description": q[1],
                     "reward_tokens": q[2],
                     "reward_exp": q[3],
-                    "target_count": q[4],  # Matches screenshot
-                    "quest_type": q[5],  # Matches screenshot
+                    "target_count": q[4],
+                    "quest_type": q[5],
                     "is_active": True,
                 }
-            )
-        print("✅ Default Quests Initialized in MongoDB")
+            },
+            upsert=True,
+        )
+    print("✅ Default Quests synced to MongoDB")
 
 
 async def get_active_quest(user_id: str, q_type: str):
diff --git a/features/quests.py b/features/quests.py
index 7a8405e..31ba174 100644
--- a/features/quests.py
+++ b/features/quests.py
@@ -25,20 +25,20 @@
 DEFAULT_QUESTS = [
     # Daily Quests
     # Name | Desc | Tokens | XP | Target | Type
-    ("Daily Chatter", "Send 80 messages today.", 50, 200, 80, "daily"),
-    ("Quick Convo", "Send 160 messages today.", 75, 250, 160, "daily"),
-    ("Engaged Today", "Send 240 messages today.", 100, 300, 240, "daily"),
+    ("Daily Chatter", "Send 80 messages today.", 50, 100, 80, "daily"),
+    ("Quick Convo", "Send 160 messages today.", 115, 200, 160, "daily"),
+    ("Engaged Today", "Send 240 messages today.", 250, 300, 240, "daily"),
     # Weekly Quests
-    ("Weekly Regular", "Send 500 messages this week.", 250, 1000, 500, "weekly"),
+    ("Weekly Regular", "Send 500 messages this week.", 225, 1000, 500, "weekly"),
     (
         "Consistent Contributor",
         "Send 750 messages this week.",
         400,
-        2500,
+        2000,
         750,
         "weekly",
     ),
-    ("Server Pillar", "Send 1000 messages this week.", 600, 3000, 1000, "weekly"),
+    ("Server Pillar", "Send 1000 messages this week.", 640, 3000, 1000, "weekly"),
 ]
 
 

From 41af5c385f9dd51f31a1cca68ee71562ee29bdf4 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sat, 20 Jun 2026 17:09:40 -0700
Subject: [PATCH 29/32] 200-Feature add megabox quest type with dedicated daily
 and weekly quest slots

---
 database/mongo.py          |  86 +++++++++++++++---------------
 features/brawl/commands.py |  12 +++++
 features/quests.py         | 106 ++++++++++++++++++++++++++++---------
 3 files changed, 134 insertions(+), 70 deletions(-)

diff --git a/database/mongo.py b/database/mongo.py
index a0ef41d..4784374 100644
--- a/database/mongo.py
+++ b/database/mongo.py
@@ -688,6 +688,7 @@ async def init_default_quests(default_quests_list):
                     "reward_exp": q[3],
                     "target_count": q[4],
                     "quest_type": q[5],
+                    "quest_category": q[6],
                     "is_active": True,
                 }
             },
@@ -696,8 +697,11 @@ async def init_default_quests(default_quests_list):
     print("✅ Default Quests synced to MongoDB")
 
 
-async def get_active_quest(user_id: str, q_type: str):
-    """Retrieves the user's current active quest status."""
+async def get_active_quest(user_id: str, q_key: str):
+    """Retrieves the user's current active quest status.
+
+    q_key is one of: daily_message, weekly_message, daily_megabox, weekly_megabox
+    """
     if db is None:
         return None
 
@@ -705,76 +709,63 @@ async def get_active_quest(user_id: str, q_type: str):
     if not user_q:
         return None
 
-    quest_entry = user_q.get(q_type)
+    quest_entry = user_q.get(q_key)
     if not quest_entry:
         return None
 
-    # Check expiration (Daily vs Weekly)
+    period = q_key.split("_")[0]  # "daily" or "weekly"
     now = datetime.utcnow()
     stored_date = quest_entry.get("date_assigned")
 
-    # Safety check if date is missing
     if not stored_date:
         return None
 
     is_expired = False
-    if q_type == "daily":
-        # Expired if the stored date is NOT today
+    if period == "daily":
         if stored_date.date() != now.date():
             is_expired = True
-    elif q_type == "weekly":
-        # Expired if the stored week number is NOT this week
+    elif period == "weekly":
         if stored_date.isocalendar()[1] != now.isocalendar()[1]:
             is_expired = True
 
     if is_expired:
-        return None  # Time for a new one!
+        return None
 
-    # FIX: Return the quest even if it's completed, so we don't assign a new one today.
     return quest_entry
 
 
-async def assign_random_quest(user_id: str, q_type: str):
-    """Picks a random active quest from the DB and assigns it to the user."""
+async def assign_random_quest(user_id: str, q_key: str):
+    """Picks a random active quest from the DB and assigns it to the user.
+
+    q_key is one of: daily_message, weekly_message, daily_megabox, weekly_megabox
+    """
     if db is None:
         return None
 
-    # 1. Simplified Query: Just look for the type (ignores is_active type mismatch)
-    # We also fetch EVERYTHING to see what's actually in there.
+    period, category = q_key.split("_", 1)  # e.g. "daily", "message"
+
     cursor = db.quests.find({})
     all_quests = await cursor.to_list(length=None)
 
-    # Filter in Python to be safe (handles "daily" vs "Daily" and 1 vs True)
-    matching_quests = []
-    for q in all_quests:
-        # Check 'quest_type' (or 'type' if legacy)
-        db_type = q.get("quest_type", q.get("type", "unknown"))
-
-        if str(db_type).lower() == q_type.lower():
-            matching_quests.append(q)
+    matching_quests = [
+        q
+        for q in all_quests
+        if str(q.get("quest_type", "")).lower() == period
+        and str(q.get("quest_category", "")).lower() == category
+    ]
 
-    # 2. Debugging Output if empty
     if not matching_quests:
-        print(f"⚠️ No matching '{q_type}' quests found!")
-        print(f"   └─ Total Quests in DB: {len(all_quests)}")
-        if all_quests:
-            print(f"   └─ Example Quest Keys: {list(all_quests[0].keys())}")
-            print(
-                f"   └─ Example Quest Type: {all_quests[0].get('quest_type', 'MISSING')}"
-            )
+        print(f"⚠️ No matching quests found for key '{q_key}'")
         return None
 
-    # 3. Pick one randomly
     import random
 
     quest = random.choice(matching_quests)
 
-    # 4. Create the new user entry
     new_entry = {
         "quest_id": quest["_id"],
         "name": quest["name"],
         "description": quest["description"],
-        # Handle 'target' vs 'target_count' mismatch safely
         "target_count": quest.get("target_count", quest.get("target", 100)),
         "reward_tokens": quest.get("reward_tokens", 0),
         "reward_exp": quest.get("reward_exp", 0),
@@ -783,24 +774,33 @@ async def assign_random_quest(user_id: str, q_type: str):
         "date_assigned": datetime.utcnow(),
     }
 
-    # 5. Save to user_quests
     await db.user_quests.update_one(
-        {"_id": user_id}, {"$set": {q_type: new_entry}}, upsert=True
+        {"_id": user_id}, {"$set": {q_key: new_entry}}, upsert=True
     )
 
     return new_entry
 
 
-async def update_quest_progress(user_id: str, q_type: str, amount: int = 1):
-    """Increments progress and checks for completion."""
+async def reset_user_quests(user_id: str):
+    """Deletes a user's quest assignments so they get freshly assigned on next /quests."""
+    if db is None:
+        return
+    await db.user_quests.delete_one({"_id": user_id})
+
+
+async def update_quest_progress(user_id: str, q_key: str, amount: int = 1):
+    """Increments progress and checks for completion.
+
+    q_key is one of: daily_message, weekly_message, daily_megabox, weekly_megabox
+    """
     if db is None:
         return False, None
 
     user_q = await db.user_quests.find_one({"_id": user_id})
-    if not user_q or q_type not in user_q:
+    if not user_q or q_key not in user_q:
         return False, None
 
-    quest = user_q[q_type]
+    quest = user_q[q_key]
     if quest["completed"]:
         return False, None
 
@@ -808,16 +808,14 @@ async def update_quest_progress(user_id: str, q_type: str, amount: int = 1):
     target = quest["target_count"]
 
     if new_progress >= target:
-        # Complete!
         await db.user_quests.update_one(
             {"_id": user_id},
-            {"$set": {f"{q_type}.progress": target, f"{q_type}.completed": True}},
+            {"$set": {f"{q_key}.progress": target, f"{q_key}.completed": True}},
         )
         return True, quest
     else:
-        # Update
         await db.user_quests.update_one(
-            {"_id": user_id}, {"$inc": {f"{q_type}.progress": amount}}
+            {"_id": user_id}, {"$inc": {f"{q_key}.progress": amount}}
         )
         return False, None
 
diff --git a/features/brawl/commands.py b/features/brawl/commands.py
index d9b204d..16363d4 100644
--- a/features/brawl/commands.py
+++ b/features/brawl/commands.py
@@ -701,6 +701,12 @@ async def megabox(self, interaction: discord.Interaction):
         embed.set_footer(text=SUPERCELL_DISCLAIMER)
         await interaction.followup.send(embed=embed)
 
+        quests_cog = self.bot.get_cog("Quests")
+        if quests_cog:
+            await quests_cog.process_quest_update(
+                user_id, interaction.channel, "megabox"
+            )
+
     @app_commands.command(name="starrdrop", description="Open a random Starr Drop!")
     async def starrdrop(self, interaction: discord.Interaction):
         await interaction.response.defer()
@@ -729,6 +735,12 @@ async def starrdrop(self, interaction: discord.Interaction):
         embed.set_footer(text=SUPERCELL_DISCLAIMER)
         await interaction.followup.send(embed=embed)
 
+        quests_cog = self.bot.get_cog("Quests")
+        if quests_cog:
+            await quests_cog.process_quest_update(
+                user_id, interaction.channel, "megabox"
+            )
+
     @app_commands.command(
         name="brawlers", description="View your collection with levels"
     )
diff --git a/features/quests.py b/features/quests.py
index 31ba174..b3a901f 100644
--- a/features/quests.py
+++ b/features/quests.py
@@ -15,6 +15,7 @@
     get_active_quest,
     assign_random_quest,
     update_quest_progress,
+    reset_user_quests,
     get_user_balance,
     update_user_balance,
     get_leveling_data,
@@ -23,13 +24,31 @@
 
 # --- DEFAULT QUESTS CONFIGURATION ---
 DEFAULT_QUESTS = [
-    # Daily Quests
-    # Name | Desc | Tokens | XP | Target | Type
-    ("Daily Chatter", "Send 80 messages today.", 50, 100, 80, "daily"),
-    ("Quick Convo", "Send 160 messages today.", 115, 200, 160, "daily"),
-    ("Engaged Today", "Send 240 messages today.", 250, 300, 240, "daily"),
-    # Weekly Quests
-    ("Weekly Regular", "Send 500 messages this week.", 225, 1000, 500, "weekly"),
+    # Name | Desc | Tokens | XP | Target | Type | Category
+    # Daily Message Quests
+    ("Daily Chatter", "Send 80 messages today.", 50, 100, 80, "daily", "message"),
+    ("Quick Convo", "Send 160 messages today.", 115, 200, 160, "daily", "message"),
+    ("Engaged Today", "Send 240 messages today.", 250, 300, 240, "daily", "message"),
+    # Daily Megabox Quests
+    (
+        "Mega Box Maniac",
+        "Open 100 Mega Boxes or Starr Drops today.",
+        50,
+        100,
+        100,
+        "daily",
+        "megabox",
+    ),
+    # Weekly Message Quests
+    (
+        "Weekly Regular",
+        "Send 500 messages this week.",
+        225,
+        1000,
+        500,
+        "weekly",
+        "message",
+    ),
     (
         "Consistent Contributor",
         "Send 750 messages this week.",
@@ -37,8 +56,27 @@
         2000,
         750,
         "weekly",
+        "message",
+    ),
+    (
+        "Server Pillar",
+        "Send 1000 messages this week.",
+        640,
+        3000,
+        1000,
+        "weekly",
+        "message",
+    ),
+    # Weekly Megabox Quests
+    (
+        "Mega Box Grinder",
+        "Open 500 Mega Boxes or Starr Drops this week.",
+        250,
+        500,
+        500,
+        "weekly",
+        "megabox",
     ),
-    ("Server Pillar", "Send 1000 messages this week.", 640, 3000, 1000, "weekly"),
 ]
 
 
@@ -67,26 +105,24 @@ async def cog_load(self):
 
     async def process_quest_update(self, user_id, channel, action_type="message"):
         """Checks daily/weekly quests for progress."""
-        for q_type in ["daily", "weekly"]:
+        if action_type == "message":
+            q_keys = ["daily_message", "weekly_message"]
+        elif action_type == "megabox":
+            q_keys = ["daily_megabox", "weekly_megabox"]
+        else:
+            return
+
+        for q_key in q_keys:
             # 1. Get or Assign Quest
-            quest = await get_active_quest(user_id, q_type)
+            quest = await get_active_quest(user_id, q_key)
             if not quest:
-                quest = await assign_random_quest(user_id, q_type)
+                quest = await assign_random_quest(user_id, q_key)
 
             if not quest:
                 continue
 
-            # 2. Filter: Only process message updates since invite quests are gone
-            if (
-                action_type == "message"
-                and "message" not in quest["description"].lower()
-            ):
-                continue
-            if action_type == "invite":
-                continue  # Explicitly ignore invites
-
-            # 3. Update Progress
-            completed, q_data = await update_quest_progress(user_id, q_type)
+            # 2. Update Progress
+            completed, q_data = await update_quest_progress(user_id, q_key)
 
             # 4. Handle Completion
             if completed and q_data:
@@ -172,12 +208,18 @@ async def quests(self, interaction: discord.Interaction):
             color=discord.Color.blue(),
         )
 
-        for q_type in ["daily", "weekly"]:
-            quest = await get_active_quest(user_id, q_type)
+        quest_slots = [
+            ("daily_message", "Daily Message Quest"),
+            ("weekly_message", "Weekly Message Quest"),
+            ("daily_megabox", "Daily Megabox Quest"),
+            ("weekly_megabox", "Weekly Megabox Quest"),
+        ]
+
+        for q_key, title in quest_slots:
+            quest = await get_active_quest(user_id, q_key)
             if not quest:
-                quest = await assign_random_quest(user_id, q_type)
+                quest = await assign_random_quest(user_id, q_key)
 
-            title = f"{q_type.capitalize()} Quest"
             if quest:
                 # Progress Bar Logic
                 prog = quest.get("progress", 0)
@@ -206,6 +248,18 @@ async def quests(self, interaction: discord.Interaction):
 
         await interaction.response.send_message(embed=embed)
 
+    @app_commands.command(
+        name="reset-quests", description="[STAFF] Reset a user's quest assignments."
+    )
+    @app_commands.default_permissions(administrator=True)
+    @app_commands.describe(user="The user whose quests to reset.")
+    async def resetquests(self, interaction: discord.Interaction, user: discord.Member):
+        await reset_user_quests(str(user.id))
+        await interaction.response.send_message(
+            f"✅ Quest assignments reset for {user.mention}. They'll get new quests on next `/quests`.",
+            ephemeral=True,
+        )
+
 
 async def setup(bot):
     await bot.add_cog(Quests(bot))

From db46b21f4c4a88cf9b56fd9a29aca15dc7010633 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sat, 20 Jun 2026 18:48:45 -0700
Subject: [PATCH 30/32] 325-Enhancement update README and help commands for
 v1.10.0

---
 README.md                            | 32 ++++++++++++++++++++++------
 features/general.py                  | 21 +++++++++++++++++-
 features/tourney/tourney_commands.py |  1 +
 3 files changed, 46 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 68664f2..132a5df 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 ## Overview
 **Name:** Remaining7 Discord Bot
-**Version:** v1.9.2
+**Version:** v1.10.0
 **Contributors:** remainingdelta, nightwarrior5
 **Objective:** A feature-rich Discord bot for the Remaining7 community server (16k+ members). Handles an R7 Token economy, leveling, quests, a Brawl Stars collection minigame, tournament management with Matcherino integration, support tickets, event operations, a security protocol, and multi-language translation.
 **Server Link:** https://discord.gg/6MzrjS2X8k
@@ -42,6 +42,8 @@ Remaining7-Discord-Bot/
 │   ├── event.py                     # Event channel cleanup & reward payouts
 │   ├── general.py                   # /help, /mod-help, /admin-help, /version, /convert-time
 │   ├── translation.py               # !t prefix & /translate slash command (55 languages)
+│   ├── counting.py                  # Sequential counting game with /set-count
+│   ├── sticky.py                    # !sticky / !unsticky persistent channel messages
 │   ├── support_tickets.py           # General support tickets (issues, support, apps, partnership)
 │   ├── github_tickets.py           # AI-powered GitHub issue creation from tickets (Gemini)
 │   ├── ticket_command_router.py     # Shared routing for tourney & support ticket commands
@@ -91,10 +93,14 @@ Remaining7-Discord-Bot/
 - `/levels-leaderboard [page]` — server-wide level rankings (paginated).
 
 ### Quest System
-- **Daily Quests:** 80 / 160 / 240 messages → 50–100 tokens + 200–300 XP.
-- **Weekly Quests:** 500 / 750 / 1000 messages → 250–600 tokens + 1000–3000 XP.
-- `/quests` — interactive progress bars for active quests.
-- Quests auto-assign randomly; completion rewards are granted instantly.
+Every user always has **4 active quests** — one daily and one weekly per category:
+- **Daily Message Quests:** 80 / 160 / 240 messages → 50 / 115 / 250 tokens + 100 / 200 / 300 XP.
+- **Weekly Message Quests:** 500 / 750 / 1000 messages → 225 / 400 / 640 tokens + 1000 / 2000 / 3000 XP.
+- **Daily Megabox Quest:** Open 100 Mega Boxes or Starr Drops → 50 tokens + 100 XP.
+- **Weekly Megabox Quest:** Open 500 Mega Boxes or Starr Drops → 250 tokens + 500 XP.
+- `/quests` — interactive progress bars for all 4 active quests.
+- `/reset-quests <user>` (Admin) — force-reset a user's quest assignments.
+- Quests auto-assign randomly per slot; completion rewards are granted instantly.
 
 ### Brawl Stars Collection Minigame
 - **Gacha Drops:**
@@ -135,6 +141,9 @@ Remaining7-Discord-Bot/
 - **Rate Limits:** Max 3 open tickets per user, 180s cooldown. Auto-reopen after 6-hour lock.
 - **Auto-translation:** Ticket messages auto-translated via `deep-translator` + `langdetect`.
 - **Test Mode:** `/tourney-test-mode` — toggle 100-ticket limit and 0.1s cooldown for testing.
+- **Active Matches:** `/active-matches` — display all active match scores grouped by round.
+- **Monthly Reports:** Auto-generated monthly tournament reports posted to a dedicated archive channel. Matcherino ID is auto-detected on `!starttourney`.
+- **Slow Mode:** `!starttourney` enables 60s slow mode in general chat with a public notice; auto-removed after 1 hour (or immediately on `!endtourney`).
 - **Staff Guide:** `/tourney-admin-help`.
 - **SA Mode:** South America region variant with separate ticket categories and region-specific workflow.
 
@@ -162,9 +171,10 @@ Remaining7-Discord-Bot/
 
 ### Event Management
 - **Automated Monitoring:** Daily background task at 12:00 AM ET scans event channels.
-- **Smart Alerts:** Alert sent when messages are 7+ days old (prevents exceeding Discord's 14-day bulk-delete limit).
+- **Smart Alerts:** Alert sent when messages are 7+ days old (prevents exceeding Discord's 14-day bulk-delete limit). Previous day's alert is replaced instead of stacking.
 - **Manual Cleanup:** `/clear-red`, `/clear-blue`, `/clear-green` for instant channel wipes.
 - **Reward Payouts:** `/event-rewards <message_id>` parses `@User 500` format to batch-distribute tokens with confirmation.
+- **Poll Rewards:** `/poll-rewards <message_id>` distributes tokens to all users who voted on a poll.
 - **Staff Guide:** `/event-staff-help`.
 
 ### Security Protocol
@@ -178,6 +188,14 @@ Remaining7-Discord-Bot/
 - `/translate <language> <phrase>` — translate English text into any of 55 supported languages.
 - Auto-detects source language. Google Translate backend.
 
+### Counting Game
+- Sequential counting game in a designated channel — users must send the next number in sequence.
+- `/set-count <number>` (Staff) — manually set the current count.
+
+### Sticky Messages
+- `!sticky <message>` — pin a message that reposts automatically when other messages are sent.
+- `!unsticky` — remove the active sticky message from a channel.
+
 ### Utility
 - `/convert-time <date> <time> <timezone>` — convert a date and time to all Discord timestamp formats. Supports 20+ timezone aliases (EST, PT, GMT, etc.) and IANA names.
 - `/version` — view the bot's current version.
@@ -258,7 +276,7 @@ Uses MongoDB database `r7_bot_db` with the following collections:
 | Task | Schedule | Description |
 |---|---|---|
 | Message listener | On every message | XP generation; passive token earning restricted to general chat (20s cooldown) |
-| Quest tracker | On every message in general chat | Track quest progress, auto-complete and reward |
+| Quest tracker | On every message / megabox open | Track message & megabox quest progress, auto-complete and reward |
 | Event cleanup | Daily at 12:00 AM ET | Scan event channels for stale messages |
 | Queue dashboard | Every 15 seconds | Update tourney queue embed during live tournaments |
 | Supply drop | Every 6 hours | Random token drop in general chat |
diff --git a/features/general.py b/features/general.py
index 6a434ac..8b2adfc 100644
--- a/features/general.py
+++ b/features/general.py
@@ -62,6 +62,12 @@ async def help_command(self, interaction: discord.Interaction):
         )
         embed.add_field(name="🌐 Translation", value=translation_text, inline=False)
 
+        counting_text = (
+            "Type the next number in sequence in the counting channel!\n"
+            "*(Stay on track — any wrong number resets the count)*"
+        )
+        embed.add_field(name="🔢 Counting Game", value=counting_text, inline=False)
+
         utility_text = (
             "`/convert-time` - Convert a date and time to Discord timestamp formats\n"
             "`/version` - View the bot's current version"
@@ -108,6 +114,14 @@ async def mod_help(self, interaction: discord.Interaction):
         )
         embed.add_field(name="🚨 Security Protocol", value=security_text, inline=False)
 
+        # Server Tools
+        tools_text = (
+            "`/set-count <number>` - Manually set the current count in the counting channel.\n"
+            "`!sticky <message>` - Pin a message that reposts whenever others send in that channel.\n"
+            "`!unsticky` - Remove the active sticky message from a channel."
+        )
+        embed.add_field(name="🔧 Server Tools", value=tools_text, inline=False)
+
         await interaction.response.send_message(embed=embed, ephemeral=True)
 
     @app_commands.command(
@@ -141,7 +155,8 @@ async def admin_help(self, interaction: discord.Interaction):
         # --- Event Operations ---
         event_text = (
             "`/event-rewards <msg_id>` - Process token distribution from an announcement message.\n"
-            "*(Requires formatting: @User 500)*"
+            "`/poll-rewards <msg_id>` - Distribute tokens to all users who voted on a poll.\n"
+            "*(Requires formatting: @User 500 for event-rewards)*"
         )
         embed.add_field(name="🏆 Event Operations", value=event_text, inline=False)
 
@@ -167,6 +182,10 @@ async def admin_help(self, interaction: discord.Interaction):
             name="⚔️ Tournament & Financials", value=tourney_text, inline=False
         )
 
+        # --- Quest Management ---
+        quest_text = "`/reset-quests <user>` - Force-reset a user's quest assignments."
+        embed.add_field(name="📜 Quest Management", value=quest_text, inline=False)
+
         # Ephemeral = True ensures only the Admin sees this menu
         await interaction.response.send_message(embed=embed, ephemeral=True)
 
diff --git a/features/tourney/tourney_commands.py b/features/tourney/tourney_commands.py
index b0f1d1b..08eca75 100644
--- a/features/tourney/tourney_commands.py
+++ b/features/tourney/tourney_commands.py
@@ -2585,6 +2585,7 @@ async def tourney_admin_help(interaction: discord.Interaction):
             "`/set-matcherino` - Set the active Matcherino bracket ID for the session.\n"
             "`/match-info` - Show live rosters, scores, and match status for a match number.\n"
             "`/match-history` - Show a team's previous rounds for a given match.\n"
+            "`/active-matches` - Display all active match scores grouped by round.\n"
             "`/set-ticket-match` - Correct this ticket's match number or team name.\n"
             "`/tourney-progress` - Real-time bracket health check with stage announcements."
         )

From 245354abf7d86423f7eda95ec7250f134d348600 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sat, 20 Jun 2026 18:55:31 -0700
Subject: [PATCH 31/32] 327-Enhancement bump version to v1.10.0

---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index 922d7d1..87599a8 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "remaining7-discord-bot"
-version = "1.9.2"
+version = "1.10.0"
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"

From c201cfe0a7247a82f4c49706111203a999626338 Mon Sep 17 00:00:00 2001
From: Shiven Ajwaliya <shiven.ajwaliya@yahoo.com>
Date: Sat, 20 Jun 2026 19:01:33 -0700
Subject: [PATCH 32/32] 326-Enhancement add unit tests for TIMEZONE_ALIASES and
 convert_time command

---
 tests/test_convert_time.py | 130 +++++++++++++++++++++++++++++++++++++
 1 file changed, 130 insertions(+)
 create mode 100644 tests/test_convert_time.py

diff --git a/tests/test_convert_time.py b/tests/test_convert_time.py
new file mode 100644
index 0000000..84e7c77
--- /dev/null
+++ b/tests/test_convert_time.py
@@ -0,0 +1,130 @@
+"""Tests for TIMEZONE_ALIASES and convert_time command in features/general.py."""
+
+from features.general import General
+
+
+# --- TIMEZONE_ALIASES ---
+
+
+def test_alias_est_resolves_to_new_york():
+    assert General.TIMEZONE_ALIASES["EST"] == "America/New_York"
+
+
+def test_alias_pt_resolves_to_los_angeles():
+    assert General.TIMEZONE_ALIASES["PT"] == "America/Los_Angeles"
+
+
+def test_alias_utc_resolves_to_utc():
+    assert General.TIMEZONE_ALIASES["UTC"] == "UTC"
+
+
+def test_alias_ist_resolves_to_kolkata():
+    assert General.TIMEZONE_ALIASES["IST"] == "Asia/Kolkata"
+
+
+def test_alias_jst_resolves_to_tokyo():
+    assert General.TIMEZONE_ALIASES["JST"] == "Asia/Tokyo"
+
+
+def test_alias_gmt_resolves_to_london():
+    assert General.TIMEZONE_ALIASES["GMT"] == "Europe/London"
+
+
+def test_alias_cet_resolves_to_berlin():
+    assert General.TIMEZONE_ALIASES["CET"] == "Europe/Berlin"
+
+
+# --- convert_time command ---
+
+
+async def test_convert_time_valid_input_sends_embed(mock_bot, mock_interaction):
+    cog = General(mock_bot)
+    await cog.convert_time.callback(
+        cog, mock_interaction, "2025-01-01", "12:00 PM", "UTC"
+    )
+
+    mock_interaction.response.send_message.assert_called_once()
+    kwargs = mock_interaction.response.send_message.call_args.kwargs
+    assert "embed" in kwargs
+
+
+async def test_convert_time_embed_contains_discord_timestamp(
+    mock_bot, mock_interaction
+):
+    cog = General(mock_bot)
+    await cog.convert_time.callback(
+        cog, mock_interaction, "2025-01-01", "12:00 PM", "UTC"
+    )
+
+    embed = mock_interaction.response.send_message.call_args.kwargs["embed"]
+    assert "<t:" in embed.description
+
+
+async def test_convert_time_alias_works(mock_bot, mock_interaction):
+    """EST alias should resolve and return an embed, not an error."""
+    cog = General(mock_bot)
+    await cog.convert_time.callback(
+        cog, mock_interaction, "2025-06-15", "3:00 PM", "EST"
+    )
+
+    kwargs = mock_interaction.response.send_message.call_args.kwargs
+    assert "embed" in kwargs
+
+
+async def test_convert_time_iana_timezone_works(mock_bot, mock_interaction):
+    """Direct IANA timezone name should be accepted."""
+    cog = General(mock_bot)
+    await cog.convert_time.callback(
+        cog, mock_interaction, "2025-06-15", "3:00 PM", "America/New_York"
+    )
+
+    kwargs = mock_interaction.response.send_message.call_args.kwargs
+    assert "embed" in kwargs
+
+
+async def test_convert_time_invalid_timezone_sends_ephemeral_error(
+    mock_bot, mock_interaction
+):
+    cog = General(mock_bot)
+    await cog.convert_time.callback(
+        cog, mock_interaction, "2025-01-01", "12:00 PM", "FAKETZ"
+    )
+
+    mock_interaction.response.send_message.assert_called_once()
+    kwargs = mock_interaction.response.send_message.call_args.kwargs
+    assert kwargs.get("ephemeral") is True
+
+
+async def test_convert_time_invalid_date_sends_ephemeral_error(
+    mock_bot, mock_interaction
+):
+    cog = General(mock_bot)
+    await cog.convert_time.callback(
+        cog, mock_interaction, "not-a-date", "12:00 PM", "UTC"
+    )
+
+    mock_interaction.response.send_message.assert_called_once()
+    kwargs = mock_interaction.response.send_message.call_args.kwargs
+    assert kwargs.get("ephemeral") is True
+
+
+async def test_convert_time_invalid_time_format_sends_ephemeral_error(
+    mock_bot, mock_interaction
+):
+    cog = General(mock_bot)
+    await cog.convert_time.callback(cog, mock_interaction, "2025-01-01", "25:99", "UTC")
+
+    mock_interaction.response.send_message.assert_called_once()
+    kwargs = mock_interaction.response.send_message.call_args.kwargs
+    assert kwargs.get("ephemeral") is True
+
+
+async def test_convert_time_footer_shows_alias_expansion(mock_bot, mock_interaction):
+    """Footer should note the alias expansion when an abbreviation is used."""
+    cog = General(mock_bot)
+    await cog.convert_time.callback(
+        cog, mock_interaction, "2025-01-01", "12:00 PM", "EST"
+    )
+
+    embed = mock_interaction.response.send_message.call_args.kwargs["embed"]
+    assert "from EST" in embed.footer.text