diff --git a/CHANGELOG.md b/CHANGELOG.md
index 83c4f1bdd4..f2c31e9487 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,7 +9,7 @@ however, insignificant breaking changes do not guarantee a major version bump, s
 # v4.2.0
 
 Upgraded discord.py to version 2.6.3, added support for CV2.
-Forwarded messages now properly show in threads, rather than showing as an empty embed.
+Forwarded messages now properly show in threads, rather then showing as an empty embed.
 
 ### Fixed
 - Make Modmail keep working when typing is disabled due to an outage caused by Discord.
@@ -18,7 +18,7 @@ Forwarded messages now properly show in threads, rather than showing as an empty
 - Eliminated duplicate logs and notes.
 - Addressed inconsistent use of `logkey` after ticket restoration.
 - Fixed issues with identifying the user who sent internal messages.
-- Solved an ancient bug where closing with words like `evening` wouldn't work.
+- Solved an ancient bug where closing with words like `evening` wouldnt work.
 - Fixed the command from being included in the reply  in rare conditions.
 
 ### Added
@@ -29,16 +29,39 @@ Commands:
 * `clearsnoozed`: Clears all snoozed items.
 
 Configuration Options:
-* `max_snooze_time`: Sets the maximum duration for snooze.
+* `snooze_default_duration`: Sets the maximum duration for snooze.
 * `snooze_title`: Customizes the title for snooze notifications.
 * `snooze_text`: Customizes the text for snooze notifications.
 * `unsnooze_text`: Customizes the text for unsnooze notifications.
 * `unsnooze_notify_channel`: Specifies the channel for unsnooze notifications.
+* `unsnooze_history_limit`: Limits the number of messages replayed when unsnoozing (genesis message and notes are always shown).
+* `snooze_behavior`: Choose between `delete` (legacy) or `move` behavior for snoozing.
+* `snoozed_category_id`: Target category for `move` snoozing; required when `snooze_behavior` is `move`.
 * `thread_min_characters`: Minimum number of characters required.
 * `thread_min_characters_title`: Title shown when the message is too short.
 * `thread_min_characters_response`: Response shown to the user if their message is too short.
 * `thread_min_characters_footer`: Footer displaying the minimum required characters.
 
+Features:
+* Thread-creation menu: Adds an interactive select step before a thread channel is created.
+  * Commands:
+    * `threadmenu toggle`: Enable/disable the menu.
+    * `threadmenu show`: List current top-level options.
+    * `threadmenu option add`: Interactive wizard to create an option.
+    * `threadmenu option edit/remove/show`: Manage or inspect an existing option.
+    * `threadmenu submenu create/delete/list/show`: Manage submenus.
+    * `threadmenu submenu option add/edit/remove`: Manage options inside a submenu.
+  * Configuration / Behavior:
+    * Per-option `category` targeting when creating a thread; falls back to `main_category_id` if invalid/missing.
+    * Optional selection logging (`thread_creation_menu_selection_log`) posts the chosen option in the new thread.
+    * Anonymous prompt support (`thread_creation_menu_anonymous_menu`).
+
+
+Behavioral changes:
+- When `snooze_behavior` is set to `move`, the snoozed category now has a hard limit of 49 channels. New snoozes are blocked once it’s full until space is freed.
+- When switching `snooze_behavior` to `move` via `?config set`, the bot reminds admins to set `snoozed_category_id` if it’s missing.
+- Thread-creation menu options & submenu options now support an optional per-option `category` target. The interactive wizards (`threadmenu option add` / `threadmenu submenu option add`) and edit commands allow specifying or updating a category. If the stored category is missing or invalid at selection time, channel creation automatically falls back to `main_category_id`.
+
 # v4.1.2
 
 ### Fixed
diff --git a/bot.py b/bot.py
index 671d9ab9c4..0435cedc3d 100644
--- a/bot.py
+++ b/bot.py
@@ -4,7 +4,6 @@
 import asyncio
 import copy
 import hashlib
-import logging
 import os
 import re
 import string
@@ -12,7 +11,7 @@
 import sys
 import platform
 import typing
-from datetime import datetime, timezone, timedelta
+from datetime import datetime, timezone
 from subprocess import PIPE
 from types import SimpleNamespace
 
@@ -80,16 +79,24 @@ def __init__(self):
         if not self.config["enable_presence_intent"]:
             intents.presences = False
 
-        super().__init__(command_prefix=None, intents=intents)  # implemented in `get_prefix`
+        super().__init__(
+            command_prefix=None, intents=intents
+        )  # implemented in `get_prefix`
         self.session = None
         self._api = None
         self.formatter = SafeFormatter()
-        self.loaded_cogs = ["cogs.modmail", "cogs.plugins", "cogs.utility"]
+        self.loaded_cogs = [
+            "cogs.modmail",
+            "cogs.plugins",
+            "cogs.utility",
+            "cogs.threadmenu",
+        ]
         self._connected = None
         self.start_time = discord.utils.utcnow()
         self._started = False
 
         self.threads = ThreadManager(self)
+        self._message_queues = {}  # User ID -> asyncio.Queue for message ordering
 
         log_dir = os.path.join(temp_dir, "logs")
         if not os.path.exists(log_dir):
@@ -101,7 +108,10 @@ def __init__(self):
         self.startup()
 
     def get_guild_icon(
-        self, guild: typing.Optional[discord.Guild], *, size: typing.Optional[int] = None
+        self,
+        guild: typing.Optional[discord.Guild],
+        *,
+        size: typing.Optional[int] = None,
     ) -> str:
         if guild is None:
             guild = self.guild
@@ -245,7 +255,11 @@ async def _cancel_tasks():
             async with self:
                 task_retriever = asyncio.all_tasks
                 loop = self.loop
-                tasks = {t for t in task_retriever() if not t.done() and t.get_coro() != cancel_tasks_coro}
+                tasks = {
+                    t
+                    for t in task_retriever()
+                    if not t.done() and t.get_coro() != cancel_tasks_coro
+                }
 
                 if not tasks:
                     return
@@ -290,7 +304,9 @@ def bot_owner_ids(self):
             owner_ids = set(map(int, str(owner_ids).split(",")))
         if self.owner_id is not None:
             owner_ids.add(self.owner_id)
-        permissions = self.config["level_permissions"].get(PermissionLevel.OWNER.name, [])
+        permissions = self.config["level_permissions"].get(
+            PermissionLevel.OWNER.name, []
+        )
         for perm in permissions:
             owner_ids.add(int(perm))
         return owner_ids
@@ -316,7 +332,10 @@ def log_channel(self) -> typing.Optional[discord.TextChannel]:
             try:
                 channel = self.main_category.channels[0]
                 self.config["log_channel_id"] = channel.id
-                logger.warning("No log channel set, setting #%s to be the log channel.", channel.name)
+                logger.warning(
+                    "No log channel set, setting #%s to be the log channel.",
+                    channel.name,
+                )
                 return channel
             except IndexError:
                 pass
@@ -378,7 +397,9 @@ def auto_triggers(self) -> typing.Dict[str, str]:
     def token(self) -> str:
         token = self.config["token"]
         if token is None:
-            logger.critical("TOKEN must be set, set this as bot token found on the Discord Developer Portal.")
+            logger.critical(
+                "TOKEN must be set, set this as bot token found on the Discord Developer Portal."
+            )
             sys.exit(0)
         return token
 
@@ -432,7 +453,9 @@ def main_category(self) -> typing.Optional[discord.CategoryChannel]:
             category_id = self.config["main_category_id"]
             if category_id is not None:
                 try:
-                    cat = discord.utils.get(self.modmail_guild.categories, id=int(category_id))
+                    cat = discord.utils.get(
+                        self.modmail_guild.categories, id=int(category_id)
+                    )
                     if cat is not None:
                         return cat
                 except ValueError:
@@ -486,7 +509,9 @@ def command_perm(self, command_name: str) -> PermissionLevel:
             try:
                 return PermissionLevel[level.upper()]
             except KeyError:
-                logger.warning("Invalid override_command_level for command %s.", command_name)
+                logger.warning(
+                    "Invalid override_command_level for command %s.", command_name
+                )
                 self.config["override_command_level"].pop(command_name)
 
         command = self.get_command(command_name)
@@ -494,7 +519,11 @@ def command_perm(self, command_name: str) -> PermissionLevel:
             logger.debug("Command %s not found.", command_name)
             return PermissionLevel.INVALID
         level = next(
-            (check.permission_level for check in command.checks if hasattr(check, "permission_level")),
+            (
+                check.permission_level
+                for check in command.checks
+                if hasattr(check, "permission_level")
+            ),
             None,
         )
         if level is None:
@@ -537,7 +566,8 @@ async def on_ready(self):
         logger.info("Logged in as: %s", self.user)
         logger.info("Bot ID: %s", self.user.id)
         owners = ", ".join(
-            getattr(self.get_user(owner_id), "name", str(owner_id)) for owner_id in self.bot_owner_ids
+            getattr(self.get_user(owner_id), "name", str(owner_id))
+            for owner_id in self.bot_owner_ids
         )
         logger.info("Owners: %s", owners)
         logger.info("Prefix: %s", self.prefix)
@@ -563,13 +593,18 @@ async def on_ready(self):
 
         for recipient_id, items in tuple(closures.items()):
             after = (
-                datetime.fromisoformat(items["time"]).astimezone(timezone.utc) - discord.utils.utcnow()
+                datetime.fromisoformat(items["time"]).astimezone(timezone.utc)
+                - discord.utils.utcnow()
             ).total_seconds()
             if after <= 0:
                 logger.debug("Closing thread for recipient %s.", recipient_id)
                 after = 0
             else:
-                logger.debug("Thread for recipient %s will be closed after %s seconds.", recipient_id, after)
+                logger.debug(
+                    "Thread for recipient %s will be closed after %s seconds.",
+                    recipient_id,
+                    after,
+                )
 
             thread = await self.threads.find(recipient_id=int(recipient_id))
 
@@ -590,8 +625,13 @@ async def on_ready(self):
             )
 
         for log in await self.api.get_open_logs():
-            if self.get_channel(int(log["channel_id"])) is None:
-                logger.debug("Unable to resolve thread with channel %s.", log["channel_id"])
+            if (
+                log.get("channel_id") is None
+                or self.get_channel(int(log["channel_id"])) is None
+            ):
+                logger.debug(
+                    "Unable to resolve thread with channel %s.", log["channel_id"]
+                )
                 log_data = await self.api.post_log(
                     log["channel_id"],
                     {
@@ -609,18 +649,29 @@ async def on_ready(self):
                     },
                 )
                 if log_data:
-                    logger.debug("Successfully closed thread with channel %s.", log["channel_id"])
+                    logger.debug(
+                        "Successfully closed thread with channel %s.", log["channel_id"]
+                    )
                 else:
-                    logger.debug("Failed to close thread with channel %s, skipping.", log["channel_id"])
+                    logger.debug(
+                        "Failed to close thread with channel %s, skipping.",
+                        log["channel_id"],
+                    )
 
-        other_guilds = [guild for guild in self.guilds if guild not in {self.guild, self.modmail_guild}]
+        other_guilds = [
+            guild
+            for guild in self.guilds
+            if guild not in {self.guild, self.modmail_guild}
+        ]
         if any(other_guilds):
             logger.warning(
                 "The bot is in more servers other than the main and staff server. "
                 "This may cause data compromise (%s).",
                 ", ".join(str(guild.name) for guild in other_guilds),
             )
-            logger.warning("If the external servers are valid, you may ignore this message.")
+            logger.warning(
+                "If the external servers are valid, you may ignore this message."
+            )
 
         self.post_metadata.start()
         self.autoupdate.start()
@@ -649,7 +700,9 @@ async def get_or_fetch_user(self, id: int) -> discord.User:
         return self.get_user(id) or await self.fetch_user(id)
 
     @staticmethod
-    async def get_or_fetch_member(guild: discord.Guild, member_id: int) -> typing.Optional[discord.Member]:
+    async def get_or_fetch_member(
+        guild: discord.Guild, member_id: int
+    ) -> typing.Optional[discord.Member]:
         """
         Attempt to get a member from cache; on failure fetch from the API.
 
@@ -722,7 +775,9 @@ def check_guild_age(self, author: discord.Member) -> bool:
             logger.debug("Blocked due to guild age, user %s.", author.name)
 
             if str(author.id) not in self.blocked_users:
-                new_reason = f"System Message: Recently Joined. User can try again {delta}."
+                new_reason = (
+                    f"System Message: Recently Joined. User can try again {delta}."
+                )
                 self.blocked_users[str(author.id)] = new_reason
 
             return False
@@ -735,7 +790,9 @@ def check_manual_blocked_roles(self, author: discord.Member) -> bool:
                     blocked_reason = self.blocked_roles.get(str(r.id)) or ""
 
                     try:
-                        end_time, after = extract_block_timestamp(blocked_reason, author.id)
+                        end_time, after = extract_block_timestamp(
+                            blocked_reason, author.id
+                        )
                     except ValueError:
                         return False
 
@@ -778,7 +835,9 @@ def check_manual_blocked(self, author: discord.Member) -> bool:
 
     async def _process_blocked(self, message):
         _, blocked_emoji = await self.retrieve_emoji()
-        if await self.is_blocked(message.author, channel=message.channel, send_message=True):
+        if await self.is_blocked(
+            message.author, channel=message.channel, send_message=True
+        ):
             await self.add_reaction(message, blocked_emoji)
             return True
         return False
@@ -854,7 +913,10 @@ async def get_thread_cooldown(self, author: discord.Member):
             return
 
         try:
-            cooldown = datetime.fromisoformat(last_log_closed_at).astimezone(timezone.utc) + thread_cooldown
+            cooldown = (
+                datetime.fromisoformat(last_log_closed_at).astimezone(timezone.utc)
+                + thread_cooldown
+            )
         except ValueError:
             logger.warning("Error with 'thread_cooldown'.", exc_info=True)
             cooldown = datetime.fromisoformat(last_log_closed_at).astimezone(
@@ -870,7 +932,10 @@ async def get_thread_cooldown(self, author: discord.Member):
 
     @staticmethod
     async def add_reaction(
-        msg, reaction: typing.Union[discord.Emoji, discord.Reaction, discord.PartialEmoji, str]
+        msg,
+        reaction: typing.Union[
+            discord.Emoji, discord.Reaction, discord.PartialEmoji, str
+        ],
     ) -> bool:
         if reaction != "disable":
             try:
@@ -880,6 +945,38 @@ async def add_reaction(
                 return False
         return True
 
+    async def _queue_dm_message(self, message: discord.Message) -> None:
+        """Queue DM messages to ensure they're processed in order per user."""
+        user_id = message.author.id
+
+        if user_id not in self._message_queues:
+            self._message_queues[user_id] = asyncio.Queue()
+            # Start processing task for this user
+            self.loop.create_task(self._process_user_messages(user_id))
+
+        await self._message_queues[user_id].put(message)
+
+    async def _process_user_messages(self, user_id: int) -> None:
+        """Process messages for a specific user in order."""
+        queue = self._message_queues[user_id]
+
+        while True:
+            try:
+                # Wait for a message with timeout to clean up inactive queues
+                message = await asyncio.wait_for(queue.get(), timeout=300)  # 5 minutes
+                await self.process_dm_modmail(message)
+                queue.task_done()
+            except asyncio.TimeoutError:
+                # Clean up inactive queue
+                if queue.empty():
+                    self._message_queues.pop(user_id, None)
+                    break
+            except Exception as e:
+                logger.error(
+                    f"Error processing message for user {user_id}: {e}", exc_info=True
+                )
+                queue.task_done()
+
     async def process_dm_modmail(self, message: discord.Message) -> None:
         """Processes messages sent to the bot."""
         blocked = await self._process_blocked(message)
@@ -899,12 +996,17 @@ async def process_dm_modmail(self, message: discord.Message) -> None:
                         await message.channel.send(
                             embed=discord.Embed(
                                 title=self.config["cooldown_thread_title"],
-                                description=self.config["cooldown_thread_response"].format(delta=delta),
+                                description=self.config[
+                                    "cooldown_thread_response"
+                                ].format(delta=delta),
                                 color=self.error_color,
                             )
                         )
                         return
-                    if self.config["dm_disabled"] in (DMDisabled.NEW_THREADS, DMDisabled.ALL_THREADS):
+                    if self.config["dm_disabled"] in (
+                        DMDisabled.NEW_THREADS,
+                        DMDisabled.ALL_THREADS,
+                    ):
                         embed = discord.Embed(
                             title=self.config["disabled_new_thread_title"],
                             color=self.error_color,
@@ -915,7 +1017,8 @@ async def process_dm_modmail(self, message: discord.Message) -> None:
                             icon_url=self.get_guild_icon(guild=message.guild, size=128),
                         )
                         logger.info(
-                            "A new thread was blocked from %s due to disabled Modmail.", message.author
+                            "A new thread was blocked from %s due to disabled Modmail.",
+                            message.author,
                         )
                         await self.add_reaction(message, blocked_emoji)
                         return await message.channel.send(embed=embed)
@@ -931,11 +1034,17 @@ async def process_dm_modmail(self, message: discord.Message) -> None:
                             text=self.config["disabled_current_thread_footer"],
                             icon_url=self.get_guild_icon(guild=message.guild, size=128),
                         )
-                        logger.info("A message was blocked from %s due to disabled Modmail.", message.author)
+                        logger.info(
+                            "A message was blocked from %s due to disabled Modmail.",
+                            message.author,
+                        )
                         await self.add_reaction(message, blocked_emoji)
                         return await message.channel.send(embed=embed)
                 # Extract forwarded content using utility function
-                combined_content = extract_forwarded_content(message) or "[Forwarded message with no content]"
+                combined_content = (
+                    extract_forwarded_content(message)
+                    or "[Forwarded message with no content]"
+                )
 
                 class ForwardedMessage:
                     def __init__(self, original_message, forwarded_content):
@@ -958,10 +1067,16 @@ def __init__(self, original_message, forwarded_content):
             else:
                 message.content = "[Forwarded message with no content]"
         # 2. Single-message forward (MessageType.forward)
-        elif getattr(message, "type", None) == getattr(discord.MessageType, "forward", None):
+        elif getattr(message, "type", None) == getattr(
+            discord.MessageType, "forward", None
+        ):
             # Check for message.reference and its type
             ref = getattr(message, "reference", None)
-            if ref and getattr(ref, "type", None) == getattr(discord, "MessageReferenceType", None).forward:
+            if (
+                ref
+                and getattr(ref, "type", None)
+                == getattr(discord, "MessageReferenceType", None).forward
+            ):
                 # Try to fetch the referenced message
                 ref_msg = None
                 try:
@@ -983,12 +1098,17 @@ def __init__(self, original_message, forwarded_content):
                             await message.channel.send(
                                 embed=discord.Embed(
                                     title=self.config["cooldown_thread_title"],
-                                    description=self.config["cooldown_thread_response"].format(delta=delta),
+                                    description=self.config[
+                                        "cooldown_thread_response"
+                                    ].format(delta=delta),
                                     color=self.error_color,
                                 )
                             )
                             return
-                        if self.config["dm_disabled"] in (DMDisabled.NEW_THREADS, DMDisabled.ALL_THREADS):
+                        if self.config["dm_disabled"] in (
+                            DMDisabled.NEW_THREADS,
+                            DMDisabled.ALL_THREADS,
+                        ):
                             embed = discord.Embed(
                                 title=self.config["disabled_new_thread_title"],
                                 color=self.error_color,
@@ -996,27 +1116,37 @@ def __init__(self, original_message, forwarded_content):
                             )
                             embed.set_footer(
                                 text=self.config["disabled_new_thread_footer"],
-                                icon_url=self.get_guild_icon(guild=message.guild, size=128),
+                                icon_url=self.get_guild_icon(
+                                    guild=message.guild, size=128
+                                ),
                             )
                             logger.info(
-                                "A new thread was blocked from %s due to disabled Modmail.", message.author
+                                "A new thread was blocked from %s due to disabled Modmail.",
+                                message.author,
                             )
                             await self.add_reaction(message, blocked_emoji)
                             return await message.channel.send(embed=embed)
-                        thread = await self.threads.create(message.author, message=message)
+                        thread = await self.threads.create(
+                            message.author, message=message
+                        )
                     else:
                         if self.config["dm_disabled"] == DMDisabled.ALL_THREADS:
                             embed = discord.Embed(
                                 title=self.config["disabled_current_thread_title"],
                                 color=self.error_color,
-                                description=self.config["disabled_current_thread_response"],
+                                description=self.config[
+                                    "disabled_current_thread_response"
+                                ],
                             )
                             embed.set_footer(
                                 text=self.config["disabled_current_thread_footer"],
-                                icon_url=self.get_guild_icon(guild=message.guild, size=128),
+                                icon_url=self.get_guild_icon(
+                                    guild=message.guild, size=128
+                                ),
                             )
                             logger.info(
-                                "A message was blocked from %s due to disabled Modmail.", message.author
+                                "A message was blocked from %s due to disabled Modmail.",
+                                message.author,
                             )
                             await self.add_reaction(message, blocked_emoji)
                             return await message.channel.send(embed=embed)
@@ -1026,7 +1156,9 @@ class ForwardedMessage:
                         def __init__(self, original_message, ref_message):
                             self.author = original_message.author
                             # Use the utility function to extract content or fallback to ref message content
-                            extracted_content = extract_forwarded_content(original_message)
+                            extracted_content = extract_forwarded_content(
+                                original_message
+                            )
                             self.content = (
                                 extracted_content
                                 or ref_message.content
@@ -1055,13 +1187,33 @@ def __init__(self, original_message, ref_message):
         if thread and thread.snoozed:
             await thread.restore_from_snooze()
             self.threads.cache[thread.id] = thread
-            # Update the DB with the new channel_id after restoration
-            if thread.channel:
-                await self.api.logs.update_one(
-                    {"recipient.id": str(thread.id)}, {"$set": {"channel_id": str(thread.channel.id)}}
+            # No need to re-fetch the thread - it's already restored and cached properly
+
+        # If the previous thread was closed with delete_channel=True the channel object
+        # stored on the thread will now be invalid (deleted). In some rare race cases
+        # the thread can still be returned from the cache (or reconstructed) while the
+        # channel lookup returns None, causing downstream relay attempts to raise
+        # discord.NotFound ("Channel not found when trying to send message."). Treat
+        # this situation as "no active thread" so the user's new DM starts a fresh
+        # thread instead of silently failing.
+        try:
+            if (
+                thread
+                and thread.channel
+                and isinstance(thread.channel, discord.TextChannel)
+                and self.get_channel(getattr(thread.channel, "id", None)) is None
+            ):
+                logger.info(
+                    "Stale thread detected for %s (channel deleted). Purging cache entry and creating new thread.",
+                    message.author,
                 )
-        # Re-fetch the thread object to ensure channel is valid
-        thread = await self.threads.find(recipient=message.author)
+                # Best-effort removal; ignore if already gone.
+                self.threads.cache.pop(thread.id, None)
+                thread = None
+        except Exception:
+            # If any attribute access fails, fall back to treating it as closed.
+            self.threads.cache.pop(getattr(thread, "id", None), None)
+            thread = None
 
         if thread is None:
             delta = await self.get_thread_cooldown(message.author)
@@ -1069,13 +1221,18 @@ def __init__(self, original_message, ref_message):
                 await message.channel.send(
                     embed=discord.Embed(
                         title=self.config["cooldown_thread_title"],
-                        description=self.config["cooldown_thread_response"].format(delta=delta),
+                        description=self.config["cooldown_thread_response"].format(
+                            delta=delta
+                        ),
                         color=self.error_color,
                     )
                 )
                 return
 
-            if self.config["dm_disabled"] in (DMDisabled.NEW_THREADS, DMDisabled.ALL_THREADS):
+            if self.config["dm_disabled"] in (
+                DMDisabled.NEW_THREADS,
+                DMDisabled.ALL_THREADS,
+            ):
                 embed = discord.Embed(
                     title=self.config["disabled_new_thread_title"],
                     color=self.error_color,
@@ -1085,11 +1242,17 @@ def __init__(self, original_message, ref_message):
                     text=self.config["disabled_new_thread_footer"],
                     icon_url=self.get_guild_icon(guild=message.guild, size=128),
                 )
-                logger.info("A new thread was blocked from %s due to disabled Modmail.", message.author)
+                logger.info(
+                    "A new thread was blocked from %s due to disabled Modmail.",
+                    message.author,
+                )
                 await self.add_reaction(message, blocked_emoji)
                 return await message.channel.send(embed=embed)
 
             thread = await self.threads.create(message.author, message=message)
+            # If thread menu is enabled, thread creation is deferred until user selects an option.
+            if getattr(thread, "_pending_menu", False):
+                return
         else:
             if self.config["dm_disabled"] == DMDisabled.ALL_THREADS:
                 embed = discord.Embed(
@@ -1101,7 +1264,10 @@ def __init__(self, original_message, ref_message):
                     text=self.config["disabled_current_thread_footer"],
                     icon_url=self.get_guild_icon(guild=message.guild, size=128),
                 )
-                logger.info("A message was blocked from %s due to disabled Modmail.", message.author)
+                logger.info(
+                    "A message was blocked from %s due to disabled Modmail.",
+                    message.author,
+                )
                 await self.add_reaction(message, blocked_emoji)
                 return await message.channel.send(embed=embed)
 
@@ -1111,6 +1277,58 @@ def __init__(self, original_message, ref_message):
             except Exception:
                 logger.error("Failed to send message:", exc_info=True)
                 await self.add_reaction(message, blocked_emoji)
+
+                try:
+                    # Re-check channel existence
+                    if (
+                        thread
+                        and thread.channel
+                        and isinstance(thread.channel, discord.TextChannel)
+                    ):
+                        if self.get_channel(thread.channel.id) is None:
+                            logger.info(
+                                "Relay failed due to deleted channel for %s; creating new thread.",
+                                message.author,
+                            )
+                            self.threads.cache.pop(thread.id, None)
+                            new_thread = await self.threads.create(
+                                message.author, message=message
+                            )
+                            if (
+                                not getattr(new_thread, "_pending_menu", False)
+                                and not new_thread.cancelled
+                            ):
+                                try:
+                                    await new_thread.send(message)
+                                except Exception:
+                                    logger.error(
+                                        "Failed to relay message after creating new thread:",
+                                        exc_info=True,
+                                    )
+                                else:
+                                    for user in new_thread.recipients:
+                                        if user != message.author:
+                                            try:
+                                                await new_thread.send(message, user)
+                                            except Exception:
+                                                logger.error(
+                                                    "Failed to send message to additional recipient:",
+                                                    exc_info=True,
+                                                )
+                                    await self.add_reaction(message, sent_emoji)
+                                    self.dispatch(
+                                        "thread_reply",
+                                        new_thread,
+                                        False,
+                                        message,
+                                        False,
+                                        False,
+                                    )
+                except Exception:
+                    logger.warning(
+                        "Unexpected failure in DM relay/new-thread follow-up block.",
+                        exc_info=True,
+                    )
             else:
                 for user in thread.recipients:
                     # send to all other recipients
@@ -1168,7 +1386,9 @@ async def get_contexts(self, message, *, cls=commands.Context):
         alias = self.aliases.get(invoker)
         if alias is not None and snippet_text is None:
             ctxs = []
-            aliases = normalize_alias(alias, message.content[len(f"{invoked_prefix}{invoker}") :])
+            aliases = normalize_alias(
+                alias, message.content[len(f"{invoked_prefix}{invoker}") :]
+            )
             if not aliases:
                 logger.warning("Alias %s is invalid, removing.", invoker)
                 self.aliases.pop(invoker)
@@ -1181,7 +1401,9 @@ async def get_contexts(self, message, *, cls=commands.Context):
                     command_invocation_text = alias
                 else:
                     command = self._get_snippet_command()
-                    command_invocation_text = f"{invoked_prefix}{command} {snippet_text}"
+                    command_invocation_text = (
+                        f"{invoked_prefix}{command} {snippet_text}"
+                    )
                 view = StringView(invoked_prefix + command_invocation_text)
                 ctx_ = cls(prefix=self.prefix, view=view, bot=self, message=message)
                 ctx_.thread = thread
@@ -1219,11 +1441,20 @@ async def trigger_auto_triggers(self, message, channel, *, cls=commands.Context)
         invoker = None
 
         if self.config.get("use_regex_autotrigger"):
-            trigger = next(filter(lambda x: re.search(x, message.content), self.auto_triggers.keys()))
+            trigger = next(
+                filter(
+                    lambda x: re.search(x, message.content), self.auto_triggers.keys()
+                )
+            )
             if trigger:
                 invoker = re.search(trigger, message.content).group(0)
         else:
-            trigger = next(filter(lambda x: x.lower() in message.content.lower(), self.auto_triggers.keys()))
+            trigger = next(
+                filter(
+                    lambda x: x.lower() in message.content.lower(),
+                    self.auto_triggers.keys(),
+                )
+            )
             if trigger:
                 invoker = trigger.lower()
 
@@ -1243,7 +1474,9 @@ async def trigger_auto_triggers(self, message, channel, *, cls=commands.Context)
             message.content = invoked_prefix + alias
             ctxs += await self.get_contexts(message)
 
-        message.author = self.modmail_guild.me  # Fix message so commands execute properly
+        message.author = (
+            self.modmail_guild.me
+        )  # Fix message so commands execute properly
 
         for ctx in ctxs:
             if ctx.command:
@@ -1318,7 +1551,10 @@ async def on_message(self, message):
             await message.delete()
 
         if (
-            (f"<@{self.user.id}" in message.content or f"<@!{self.user.id}" in message.content)
+            (
+                f"<@{self.user.id}" in message.content
+                or f"<@!{self.user.id}" in message.content
+            )
             and self.config["alert_on_mention"]
             and not message.author.bot
         ):
@@ -1338,7 +1574,9 @@ async def on_message(self, message):
 
         # --- MODERATOR-ONLY MESSAGE LOGGING ---
         # If a moderator sends a message directly in a thread channel (not via modmail command), log it
-        if not message.author.bot and not isinstance(message.channel, discord.DMChannel):
+        if not message.author.bot and not isinstance(
+            message.channel, discord.DMChannel
+        ):
             thread = await self.threads.find(channel=message.channel)
             if thread is not None:
                 ctxs = await self.get_contexts(message)
@@ -1356,23 +1594,60 @@ async def process_commands(self, message):
             return
 
         if isinstance(message.channel, discord.DMChannel):
-            return await self.process_dm_modmail(message)
+            return await self._queue_dm_message(message)
 
         ctxs = await self.get_contexts(message)
         for ctx in ctxs:
             if ctx.command:
-                if not any(1 for check in ctx.command.checks if hasattr(check, "permission_level")):
+                if not any(
+                    1
+                    for check in ctx.command.checks
+                    if hasattr(check, "permission_level")
+                ):
                     logger.debug(
                         "Command %s has no permissions check, adding invalid level.",
                         ctx.command.qualified_name,
                     )
                     checks.has_permissions(PermissionLevel.INVALID)(ctx.command)
 
+                # Check if thread is unsnoozing and queue command if so
+                thread = await self.threads.find(channel=ctx.channel)
+                if thread and thread._unsnoozing:
+                    queued = await thread.queue_command(ctx, ctx.command)
+                    if queued:
+                        # Send a brief acknowledgment that command is queued
+                        try:
+                            await ctx.message.add_reaction("⏳")
+                        except Exception as e:
+                            logger.warning("Failed to add queued-reaction: %s", e)
+                        continue
+
                 await self.invoke(ctx)
                 continue
 
             thread = await self.threads.find(channel=ctx.channel)
             if thread is not None:
+                # If thread is snoozed (moved), auto-unsnooze when a mod sends a message directly in channel
+                behavior = self.config.get("snooze_behavior", "delete").lower()
+                if thread.snoozed and behavior == "move":
+                    if not thread.snooze_data:
+                        try:
+                            log_entry = await self.api.logs.find_one(
+                                {"recipient.id": str(thread.id), "snoozed": True}
+                            )
+                            if log_entry:
+                                thread.snooze_data = log_entry.get("snooze_data")
+                        except Exception:
+                            logger.debug(
+                                "Failed to add queued command reaction (⏳).",
+                                exc_info=True,
+                            )
+                    try:
+                        await thread.restore_from_snooze()
+                        # refresh local cache
+                        self.threads.cache[thread.id] = thread
+                    except Exception as e:
+                        logger.warning("Auto-unsnooze on direct message failed: %s", e)
                 anonymous = False
                 plain = False
                 if self.config.get("anon_reply_without_command"):
@@ -1387,7 +1662,9 @@ async def process_commands(self, message):
                 ):
                     await thread.reply(message, anonymous=anonymous, plain=plain)
             elif ctx.invoked_with:
-                exc = commands.CommandNotFound('Command "{}" is not found'.format(ctx.invoked_with))
+                exc = commands.CommandNotFound(
+                    'Command "{}" is not found'.format(ctx.invoked_with)
+                )
                 self.dispatch("command_error", ctx, exc)
 
     async def on_typing(self, channel, user, _):
@@ -1406,7 +1683,10 @@ async def on_typing(self, channel, user, _):
                 try:
                     await thread.channel.typing()
                 except Exception:
-                    pass
+                    logger.debug(
+                        "Failed to trigger typing indicator in recipient DM.",
+                        exc_info=True,
+                    )
         else:
             if not self.config.get("mod_typing"):
                 return
@@ -1419,7 +1699,11 @@ async def on_typing(self, channel, user, _):
                     try:
                         await user.typing()
                     except Exception:
-                        pass
+                        logger.debug(
+                            "Failed to trigger typing for recipient %s.",
+                            getattr(user, "id", "?"),
+                            exc_info=True,
+                        )
 
     async def handle_reaction_events(self, payload):
         user = self.get_user(payload.user_id)
@@ -1472,14 +1756,18 @@ async def handle_reaction_events(self, payload):
                 message.author == self.user
                 and message.embeds
                 and self.config.get("confirm_thread_creation")
-                and message.embeds[0].title == self.config["confirm_thread_creation_title"]
-                and message.embeds[0].description == self.config["confirm_thread_response"]
+                and message.embeds[0].title
+                == self.config["confirm_thread_creation_title"]
+                and message.embeds[0].description
+                == self.config["confirm_thread_response"]
             ):
                 return
             if not thread.recipient.dm_channel:
                 await thread.recipient.create_dm()
             try:
-                linked_messages = await thread.find_linked_message_from_dm(message, either_direction=True)
+                linked_messages = await thread.find_linked_message_from_dm(
+                    message, either_direction=True
+                )
             except ValueError as e:
                 logger.warning("Failed to find linked message for reactions: %s", e)
                 return
@@ -1492,7 +1780,7 @@ async def handle_reaction_events(self, payload):
                 logger.warning("Failed to find linked message for reactions: %s", e)
                 return
 
-        if self.config["transfer_reactions"] and linked_messages is not [None]:
+        if self.config["transfer_reactions"] and linked_messages != [None]:
             if payload.event_type == "REACTION_ADD":
                 for msg in linked_messages:
                     await self.add_reaction(msg, reaction)
@@ -1508,7 +1796,10 @@ async def handle_reaction_events(self, payload):
     async def handle_react_to_contact(self, payload):
         react_message_id = tryint(self.config.get("react_to_contact_message"))
         react_message_emoji = self.config.get("react_to_contact_emoji")
-        if not all((react_message_id, react_message_emoji)) or payload.message_id != react_message_id:
+        if (
+            not all((react_message_id, react_message_emoji))
+            or payload.message_id != react_message_id
+        ):
             return
         if payload.emoji.is_unicode_emoji():
             emoji_fmt = payload.emoji.name
@@ -1525,7 +1816,10 @@ async def handle_react_to_contact(self, payload):
         await message.remove_reaction(payload.emoji, member)
         await message.add_reaction(emoji_fmt)  # bot adds as well
 
-        if self.config["dm_disabled"] in (DMDisabled.NEW_THREADS, DMDisabled.ALL_THREADS):
+        if self.config["dm_disabled"] in (
+            DMDisabled.NEW_THREADS,
+            DMDisabled.ALL_THREADS,
+        ):
             embed = discord.Embed(
                 title=self.config["disabled_new_thread_title"],
                 color=self.error_color,
@@ -1541,8 +1835,23 @@ async def handle_react_to_contact(self, payload):
             )
             return await member.send(embed=embed)
 
+        # Check if user has a snoozed thread
+        existing_thread = await self.threads.find(recipient=member)
+        if existing_thread and existing_thread.snoozed:
+            # Unsnooze the thread
+            await existing_thread.restore_from_snooze()
+            self.threads.cache[existing_thread.id] = existing_thread
+            # Send notification to the thread channel
+            if existing_thread.channel:
+                await existing_thread.channel.send(
+                    f"ℹ️ {member.mention} reacted to contact and their snoozed thread has been unsnoozed."
+                )
+            return
+
         ctx = await self.get_context(message)
-        await ctx.invoke(self.get_command("contact"), users=[member], manual_trigger=False)
+        await ctx.invoke(
+            self.get_command("contact"), users=[member], manual_trigger=False
+        )
 
     async def on_raw_reaction_add(self, payload):
         await asyncio.gather(
@@ -1574,7 +1883,9 @@ async def on_guild_channel_delete(self, channel):
             await self.config.update()
             return
 
-        audit_logs = self.modmail_guild.audit_logs(limit=10, action=discord.AuditLogAction.channel_delete)
+        audit_logs = self.modmail_guild.audit_logs(
+            limit=10, action=discord.AuditLogAction.channel_delete
+        )
         found_entry = False
         async for entry in audit_logs:
             if int(entry.target.id) == channel.id:
@@ -1582,7 +1893,9 @@ async def on_guild_channel_delete(self, channel):
                 break
 
         if not found_entry:
-            logger.debug("Cannot find the audit log entry for channel delete of %d.", channel.id)
+            logger.debug(
+                "Cannot find the audit log entry for channel delete of %d.", channel.id
+            )
             return
 
         mod = entry.user
@@ -1609,15 +1922,15 @@ async def on_member_remove(self, member):
                     remaining_guilds = member.mutual_guilds
 
                     if remaining_guilds:
-                        remaining_guild_names = [guild.name for guild in remaining_guilds]
+                        remaining_guild_names = [
+                            guild.name for guild in remaining_guilds
+                        ]
                         leave_message = (
                             f"The recipient has left {guild_left}. "
                             f"They are still in {human_join(remaining_guild_names, final='and')}."
                         )
                     else:
-                        leave_message = (
-                            f"The recipient has left {guild_left}. We no longer share any mutual servers."
-                        )
+                        leave_message = f"The recipient has left {guild_left}. We no longer share any mutual servers."
                 else:
                     leave_message = "The recipient has left the server."
 
@@ -1648,7 +1961,9 @@ async def on_message_delete(self, message):
             if not thread:
                 return
             try:
-                message = await thread.find_linked_message_from_dm(message, get_thread_channel=True)
+                message = await thread.find_linked_message_from_dm(
+                    message, get_thread_channel=True
+                )
             except ValueError as e:
                 if str(e) != "Thread channel message not found.":
                     logger.debug("Failed to find linked message to delete: %s", e)
@@ -1674,11 +1989,20 @@ async def on_message_delete(self, message):
 
         try:
             await thread.delete_message(message, note=False)
-            embed = discord.Embed(description="Successfully deleted message.", color=self.main_color)
+            embed = discord.Embed(
+                description="Successfully deleted message.", color=self.main_color
+            )
         except ValueError as e:
-            if str(e) not in {"DM message not found.", "Malformed thread message."}:
+            # Treat common non-fatal cases as benign: relay counterpart not present, note embeds, etc.
+            if str(e) not in {
+                "DM message not found.",
+                "Malformed thread message.",
+                "Thread message not found.",
+            }:
                 logger.debug("Failed to find linked message to delete: %s", e)
-                embed = discord.Embed(description="Failed to delete message.", color=self.error_color)
+                embed = discord.Embed(
+                    description="Failed to delete message.", color=self.error_color
+                )
             else:
                 return
         except discord.NotFound:
@@ -1706,7 +2030,9 @@ async def on_message_edit(self, before, after):
                 _, blocked_emoji = await self.retrieve_emoji()
                 await self.add_reaction(after, blocked_emoji)
             else:
-                embed = discord.Embed(description="Successfully Edited Message", color=self.main_color)
+                embed = discord.Embed(
+                    description="Successfully Edited Message", color=self.main_color
+                )
                 embed.set_footer(text=f"Message ID: {after.id}")
                 await after.channel.send(embed=embed)
 
@@ -1715,7 +2041,11 @@ async def on_error(self, event_method, *args, **kwargs):
         logger.error("Unexpected exception:", exc_info=sys.exc_info())
 
     async def on_command_error(
-        self, context: commands.Context, exception: Exception, *, unhandled_by_cog: bool = False
+        self,
+        context: commands.Context,
+        exception: Exception,
+        *,
+        unhandled_by_cog: bool = False,
     ) -> None:
         if not unhandled_by_cog:
             command = context.command
@@ -1729,8 +2059,13 @@ async def on_command_error(
             try:
                 await context.typing()
             except Exception:
-                pass
-            await context.send(embed=discord.Embed(color=self.error_color, description=str(exception)))
+                logger.debug(
+                    "Failed to start typing context for command error feedback.",
+                    exc_info=True,
+                )
+            await context.send(
+                embed=discord.Embed(color=self.error_color, description=str(exception))
+            )
         elif isinstance(exception, commands.CommandNotFound):
             logger.warning("CommandNotFound: %s", exception)
         elif isinstance(exception, commands.MissingRequiredArgument):
@@ -1748,10 +2083,14 @@ async def on_command_error(
                 if not await check(context):
                     if hasattr(check, "fail_msg"):
                         await context.send(
-                            embed=discord.Embed(color=self.error_color, description=check.fail_msg)
+                            embed=discord.Embed(
+                                color=self.error_color, description=check.fail_msg
+                            )
                         )
                     if hasattr(check, "permission_level"):
-                        corrected_permission_level = self.command_perm(context.command.qualified_name)
+                        corrected_permission_level = self.command_perm(
+                            context.command.qualified_name
+                        )
                         logger.warning(
                             "User %s does not have permission to use this command: `%s` (%s).",
                             context.author.name,
@@ -1760,7 +2099,10 @@ async def on_command_error(
                         )
             logger.warning("CheckFailure: %s", exception)
         elif isinstance(exception, commands.DisabledCommand):
-            logger.info("DisabledCommand: %s is trying to run eval but it's disabled", context.author.name)
+            logger.info(
+                "DisabledCommand: %s is trying to run eval but it's disabled",
+                context.author.name,
+            )
         else:
             logger.error("Unexpected exception:", exc_info=exception)
 
@@ -1786,13 +2128,21 @@ async def post_metadata(self):
         if info.team is not None:
             data.update(
                 {
-                    "owner_name": info.team.owner.name if info.team.owner is not None else "No Owner",
+                    "owner_name": info.team.owner.name
+                    if info.team.owner is not None
+                    else "No Owner",
                     "owner_id": info.team.owner_id,
                     "team": True,
                 }
             )
         else:
-            data.update({"owner_name": info.owner.name, "owner_id": info.owner.id, "team": False})
+            data.update(
+                {
+                    "owner_name": info.owner.name,
+                    "owner_id": info.owner.id,
+                    "team": False,
+                }
+            )
 
         async with self.session.post("https://api.modmail.dev/metadata", json=data):
             logger.debug("Uploading metadata to Modmail server.")
@@ -1845,7 +2195,7 @@ async def autoupdate(self):
                 user = data["user"]
                 embed.add_field(
                     name="Merge Commit",
-                    value=f"[`{short_sha}`]({html_url}) " f"{message} - {user['username']}",
+                    value=f"[`{short_sha}`]({html_url}) {message} - {user['username']}",
                 )
                 embed.set_author(
                     name=user["username"] + " - Updating Bot",
@@ -1853,7 +2203,9 @@ async def autoupdate(self):
                     url=user["url"],
                 )
 
-                embed.set_footer(text=f"Updating Modmail v{self.version} -> v{latest.version}")
+                embed.set_footer(
+                    text=f"Updating Modmail v{self.version} -> v{latest.version}"
+                )
 
                 embed.description = latest.description
                 for name, value in latest.fields.items():
@@ -1892,10 +2244,16 @@ async def autoupdate(self):
 
                     logger.info("Bot has been updated.")
                     channel = self.update_channel
-                    if self.hosting_method in (HostingMethod.PM2, HostingMethod.SYSTEMD):
-                        embed = discord.Embed(title="Bot has been updated", color=self.main_color)
+                    if self.hosting_method in (
+                        HostingMethod.PM2,
+                        HostingMethod.SYSTEMD,
+                    ):
+                        embed = discord.Embed(
+                            title="Bot has been updated", color=self.main_color
+                        )
                         embed.set_footer(
-                            text=f"Updating Modmail v{self.version} " f"-> v{latest.version} {message}"
+                            text=f"Updating Modmail v{self.version} "
+                            f"-> v{latest.version} {message}"
                         )
                         if self.config["update_notifications"]:
                             await channel.send(embed=embed)
@@ -1905,7 +2263,9 @@ async def autoupdate(self):
                             description=f"If you do not have an auto-restart setup, please manually start the bot. {message}",
                             color=self.main_color,
                         )
-                        embed.set_footer(text=f"Updating Modmail v{self.version} -> v{latest.version}")
+                        embed.set_footer(
+                            text=f"Updating Modmail v{self.version} -> v{latest.version}"
+                        )
                         if self.config["update_notifications"]:
                             await channel.send(embed=embed)
                     return await self.close()
@@ -1925,7 +2285,10 @@ async def before_autoupdate(self):
             self.autoupdate.cancel()
             return
 
-        if not self.config.get("github_token") and self.hosting_method == HostingMethod.HEROKU:
+        if (
+            not self.config.get("github_token")
+            and self.hosting_method == HostingMethod.HEROKU
+        ):
             logger.warning("GitHub access token not found.")
             logger.warning("Autoupdates disabled.")
             self.autoupdate.cancel()
@@ -1941,7 +2304,9 @@ async def log_expiry(self):
         expiration_datetime = now - log_expire_after
         # WARNING: comparison is done lexicographically, not by date.
         # This is fine as long as the date is in zero-padded ISO format, which it should be.
-        expired_logs = await self.db.logs.delete_many({"closed_at": {"$lte": str(expiration_datetime)}})
+        expired_logs = await self.db.logs.delete_many(
+            {"closed_at": {"$lte": str(expiration_datetime)}}
+        )
 
         logger.info(f"Deleted {expired_logs.deleted_count} expired logs.")
 
@@ -1961,7 +2326,9 @@ def format_channel_name(self, author, exclude_channel=None, force_null=False):
             elif self.config["use_user_id_channel_name"]:
                 name = new_name = str(author.id)
             elif self.config["use_timestamp_channel_name"]:
-                name = new_name = author.created_at.isoformat(sep="-", timespec="minutes")
+                name = new_name = author.created_at.isoformat(
+                    sep="-", timespec="minutes"
+                )
             else:
                 if self.config["use_nickname_channel_name"]:
                     author_member = self.guild.get_member(author.id)
@@ -1972,7 +2339,14 @@ def format_channel_name(self, author, exclude_channel=None, force_null=False):
                 if force_null:
                     name = "null"
 
-                name = "".join(l for l in name if l not in string.punctuation and l.isprintable()) or "null"
+                name = (
+                    "".join(
+                        l
+                        for l in name
+                        if l not in string.punctuation and l.isprintable()
+                    )
+                    or "null"
+                )
                 if author.discriminator != "0":
                     name += f"-{author.discriminator}"
                 new_name = name
@@ -2009,7 +2383,10 @@ def main():
                     "Unable to import cairosvg, install GTK Installer for Windows and restart your system (https://github.com/tschoonj/GTK-for-Windows-Runtime-Environment-Installer/releases/latest)"
                 )
         else:
-            if "ubuntu" in platform.version().lower() or "debian" in platform.version().lower():
+            if (
+                "ubuntu" in platform.version().lower()
+                or "debian" in platform.version().lower()
+            ):
                 logger.error(
                     "Unable to import cairosvg, try running `sudo apt-get install libpangocairo-1.0-0` or report on our support server with your OS details: https://discord.gg/etJNHCQ"
                 )
diff --git a/cogs/modmail.py b/cogs/modmail.py
index a63eea9103..0b53b2937a 100644
--- a/cogs/modmail.py
+++ b/cogs/modmail.py
@@ -7,6 +7,7 @@
 
 import discord
 from discord.ext import commands
+from discord.ext import tasks
 from discord.ext.commands.view import StringView
 from discord.ext.commands.cooldowns import BucketType
 from discord.role import Role
@@ -29,6 +30,65 @@ class Modmail(commands.Cog):
 
     def __init__(self, bot):
         self.bot = bot
+        self._snoozed_cache = []
+        self._auto_unsnooze_task = self.bot.loop.create_task(self.auto_unsnooze_task())
+
+    async def auto_unsnooze_task(self):
+        await self.bot.wait_until_ready()
+        last_db_query = 0
+        while not self.bot.is_closed():
+            now = datetime.now(timezone.utc)
+            try:
+                # Query DB every 2 minutes
+                if (now.timestamp() - last_db_query) > 120:
+                    snoozed_threads = await self.bot.api.logs.find(
+                        {"snooze_until": {"$gte": now.isoformat()}}
+                    ).to_list(None)
+                    self._snoozed_cache = snoozed_threads or []
+                    last_db_query = now.timestamp()
+                # Check cache every 10 seconds
+                to_unsnooze = []
+                for thread_data in list(self._snoozed_cache):
+                    snooze_until = thread_data.get("snooze_until")
+                    recipient = thread_data.get("recipient")
+                    if not recipient or not recipient.get("id"):
+                        continue
+                    thread_id = int(recipient.get("id"))
+                    if snooze_until:
+                        try:
+                            dt = parser.isoparse(snooze_until)
+                        except Exception:
+                            continue
+                        if now >= dt:
+                            to_unsnooze.append(thread_data)
+                for thread_data in to_unsnooze:
+                    recipient = thread_data.get("recipient")
+                    if not recipient or not recipient.get("id"):
+                        continue
+                    thread_id = int(recipient.get("id"))
+                    thread = self.bot.threads.cache.get(
+                        thread_id
+                    ) or await self.bot.threads.find(id=thread_id)
+                    if thread and thread.snoozed:
+                        await thread.restore_from_snooze()
+                        logging.info(
+                            f"[AUTO-UNSNOOZE] Thread {thread_id} auto-unsnoozed."
+                        )
+                        try:
+                            channel = thread.channel
+                            if channel:
+                                await channel.send(
+                                    "⏰ This thread has been automatically unsnoozed."
+                                )
+                        except Exception as e:
+                            logger.info(
+                                "Failed to notify channel after auto-unsnooze: %s",
+                                e,
+                            )
+                        self._snoozed_cache.remove(thread_data)
+            except Exception as e:
+                logging.error(f"Error in auto_unsnooze_task: {e}")
+            await asyncio.sleep(10)
 
     def _resolve_user(self, user_str):
         """Helper to resolve a user from mention, ID, or username."""
@@ -55,7 +115,9 @@ async def setup(self, ctx):
         """
 
         if ctx.guild != self.bot.modmail_guild:
-            return await ctx.send(f"You can only setup in the Modmail guild: {self.bot.modmail_guild}.")
+            return await ctx.send(
+                f"You can only setup in the Modmail guild: {self.bot.modmail_guild}."
+            )
 
         if self.bot.main_category is not None:
             logger.debug("Can't re-setup server, main_category is found.")
@@ -70,7 +132,9 @@ async def setup(self, ctx):
             return await ctx.send(embed=embed)
 
         overwrites = {
-            self.bot.modmail_guild.default_role: discord.PermissionOverwrite(read_messages=False),
+            self.bot.modmail_guild.default_role: discord.PermissionOverwrite(
+                read_messages=False
+            ),
             self.bot.modmail_guild.me: discord.PermissionOverwrite(read_messages=True),
         }
 
@@ -90,11 +154,15 @@ async def setup(self, ctx):
                     logger.info("Granting %s access to Modmail category.", key.name)
                     overwrites[key] = discord.PermissionOverwrite(read_messages=True)
 
-        category = await self.bot.modmail_guild.create_category(name="Modmail", overwrites=overwrites)
+        category = await self.bot.modmail_guild.create_category(
+            name="Modmail", overwrites=overwrites
+        )
 
         await category.edit(position=0)
 
-        log_channel = await self.bot.modmail_guild.create_text_channel(name="bot-logs", category=category)
+        log_channel = await self.bot.modmail_guild.create_text_channel(
+            name="bot-logs", category=category
+        )
 
         embed = discord.Embed(
             title="Friendly Reminder",
@@ -111,7 +179,9 @@ async def setup(self, ctx):
             "feeling extra generous, buy us coffee on [Patreon](https://patreon.com/kyber) :heart:!",
         )
 
-        embed.set_footer(text=f'Type "{self.bot.prefix}help" for a complete list of commands.')
+        embed.set_footer(
+            text=f'Type "{self.bot.prefix}help" for a complete list of commands.'
+        )
         await log_channel.send(embed=embed)
 
         self.bot.config["main_category_id"] = category.id
@@ -127,7 +197,10 @@ async def setup(self, ctx):
             f"- `{self.bot.prefix}config help` for a list of available customizations."
         )
 
-        if not self.bot.config["command_permissions"] and not self.bot.config["level_permissions"]:
+        if (
+            not self.bot.config["command_permissions"]
+            and not self.bot.config["level_permissions"]
+        ):
             await self.bot.update_perms(PermissionLevel.REGULAR, -1)
             for owner_id in self.bot.bot_owner_ids:
                 await self.bot.update_perms(PermissionLevel.OWNER, owner_id)
@@ -160,11 +233,16 @@ async def snippet(self, ctx, *, name: str.lower = None):
             if name == "compact":
                 embeds = []
 
-                for i, names in enumerate(zip_longest(*(iter(sorted(self.bot.snippets)),) * 15)):
+                for i, names in enumerate(
+                    zip_longest(*(iter(sorted(self.bot.snippets)),) * 15)
+                ):
                     description = format_description(i, names)
-                    embed = discord.Embed(color=self.bot.main_color, description=description)
+                    embed = discord.Embed(
+                        color=self.bot.main_color, description=description
+                    )
                     embed.set_author(
-                        name="Snippets", icon_url=self.bot.get_guild_icon(guild=ctx.guild, size=128)
+                        name="Snippets",
+                        icon_url=self.bot.get_guild_icon(guild=ctx.guild, size=128),
                     )
                     embeds.append(embed)
 
@@ -175,25 +253,41 @@ async def snippet(self, ctx, *, name: str.lower = None):
             snippet_name = self.bot._resolve_snippet(name)
 
             if snippet_name is None:
-                embed = create_not_found_embed(name, self.bot.snippets.keys(), "Snippet")
+                embed = create_not_found_embed(
+                    name, self.bot.snippets.keys(), "Snippet"
+                )
             else:
                 val = self.bot.snippets[snippet_name]
                 embed = discord.Embed(
-                    title=f'Snippet - "{snippet_name}":', description=val, color=self.bot.main_color
+                    title=f'Snippet - "{snippet_name}":',
+                    description=val,
+                    color=self.bot.main_color,
                 )
             return await ctx.send(embed=embed)
 
         if not self.bot.snippets:
             embed = discord.Embed(
-                color=self.bot.error_color, description="You dont have any snippets at the moment."
+                color=self.bot.error_color,
+                description="You dont have any snippets at the moment.",
+            )
+            embed.set_footer(
+                text=f'Check "{self.bot.prefix}help snippet add" to add a snippet.'
+            )
+            embed.set_author(
+                name="Snippets",
+                icon_url=self.bot.get_guild_icon(guild=ctx.guild, size=128),
             )
-            embed.set_footer(text=f'Check "{self.bot.prefix}help snippet add" to add a snippet.')
-            embed.set_author(name="Snippets", icon_url=self.bot.get_guild_icon(guild=ctx.guild, size=128))
             return await ctx.send(embed=embed)
 
-        embeds = [discord.Embed(color=self.bot.main_color) for _ in range((len(self.bot.snippets) // 10) + 1)]
+        embeds = [
+            discord.Embed(color=self.bot.main_color)
+            for _ in range((len(self.bot.snippets) // 10) + 1)
+        ]
         for embed in embeds:
-            embed.set_author(name="Snippets", icon_url=self.bot.get_guild_icon(guild=ctx.guild, size=128))
+            embed.set_author(
+                name="Snippets",
+                icon_url=self.bot.get_guild_icon(guild=ctx.guild, size=128),
+            )
 
         for i, snippet in enumerate(sorted(self.bot.snippets.items())):
             embeds[i // 10].add_field(
@@ -337,11 +431,11 @@ async def snippet_remove(self, ctx, *, name: str.lower):
 
             deleted_aliases_string = ",".join(f"`{alias}`" for alias in deleted_aliases)
             if len(deleted_aliases) == 1:
-                deleted_aliases_output = f"The `{deleted_aliases_string}` direct alias has been removed."
-            elif deleted_aliases:
                 deleted_aliases_output = (
-                    f"The following direct aliases have been removed: {deleted_aliases_string}."
+                    f"The `{deleted_aliases_string}` direct alias has been removed."
                 )
+            elif deleted_aliases:
+                deleted_aliases_output = f"The following direct aliases have been removed: {deleted_aliases_string}."
             else:
                 deleted_aliases_output = None
 
@@ -448,7 +542,10 @@ async def move(self, ctx, *, arguments):
             silent = any(word in silent_words for word in options.split())
 
         await thread.channel.move(
-            category=category, end=True, sync_permissions=True, reason=f"{ctx.author} moved this thread."
+            category=category,
+            end=True,
+            sync_permissions=True,
+            reason=f"{ctx.author} moved this thread.",
         )
 
         if self.bot.config["thread_move_notify"] and not silent:
@@ -471,21 +568,28 @@ async def move(self, ctx, *, arguments):
         await self.bot.add_reaction(ctx.message, sent_emoji)
 
     async def send_scheduled_close_message(self, ctx, after, silent=False):
-        human_delta = human_timedelta(after.dt)
+        """Send a scheduled close notice only to the staff thread channel.
 
+        Uses Discord relative timestamp formatting for better UX.
+        """
+        ts = int(
+            (
+                after.dt if after.dt.tzinfo else after.dt.replace(tzinfo=timezone.utc)
+            ).timestamp()
+        )
         embed = discord.Embed(
             title="Scheduled close",
-            description=f"This thread will{' silently' if silent else ''} close in {human_delta}.",
+            description=f"This thread will{' silently' if silent else ''} close <t:{ts}:R>.",
             color=self.bot.error_color,
         )
-
         if after.arg and not silent:
             embed.add_field(name="Message", value=after.arg)
-
         embed.set_footer(text="Closing will be cancelled if a thread message is sent.")
         embed.timestamp = after.dt
 
-        await ctx.send(embed=embed)
+        thread = getattr(ctx, "thread", None)
+        if thread and ctx.channel == thread.channel:
+            await thread.channel.send(embed=embed)
 
     @commands.command(usage="[after] [close message]")
     @checks.has_permissions(PermissionLevel.SUPPORTER)
@@ -526,7 +630,8 @@ async def close(
             if thread.close_task is not None or thread.auto_close_task is not None:
                 await thread.cancel_closure(all=True)
                 embed = discord.Embed(
-                    color=self.bot.error_color, description="Scheduled close has been cancelled."
+                    color=self.bot.error_color,
+                    description="Scheduled close has been cancelled.",
                 )
             else:
                 embed = discord.Embed(
@@ -543,7 +648,9 @@ async def close(
         if after and after.dt > after.now:
             await self.send_scheduled_close_message(ctx, after, silent)
 
-        await thread.close(closer=ctx.author, after=close_after, message=message, silent=silent)
+        await thread.close(
+            closer=ctx.author, after=close_after, message=message, silent=silent
+        )
 
     @staticmethod
     def parse_user_or_role(ctx, user_or_role):
@@ -559,7 +666,9 @@ def parse_user_or_role(ctx, user_or_role):
     @commands.command(aliases=["alert"])
     @checks.has_permissions(PermissionLevel.SUPPORTER)
     @checks.thread_only()
-    async def notify(self, ctx, *, user_or_role: Union[discord.Role, User, str.lower, None] = None):
+    async def notify(
+        self, ctx, *, user_or_role: Union[discord.Role, User, str.lower, None] = None
+    ):
         """
         Notify a user or role when the next thread message received.
 
@@ -597,7 +706,9 @@ async def notify(self, ctx, *, user_or_role: Union[discord.Role, User, str.lower
     @commands.command(aliases=["unalert"])
     @checks.has_permissions(PermissionLevel.SUPPORTER)
     @checks.thread_only()
-    async def unnotify(self, ctx, *, user_or_role: Union[discord.Role, User, str.lower, None] = None):
+    async def unnotify(
+        self, ctx, *, user_or_role: Union[discord.Role, User, str.lower, None] = None
+    ):
         """
         Un-notify a user, role, or yourself from a thread.
 
@@ -625,14 +736,17 @@ async def unnotify(self, ctx, *, user_or_role: Union[discord.Role, User, str.low
             mentions.remove(mention)
             await self.bot.config.update()
             embed = discord.Embed(
-                color=self.bot.main_color, description=f"{mention} will no longer be notified."
+                color=self.bot.main_color,
+                description=f"{mention} will no longer be notified.",
             )
         return await ctx.send(embed=embed)
 
     @commands.command(aliases=["sub"])
     @checks.has_permissions(PermissionLevel.SUPPORTER)
     @checks.thread_only()
-    async def subscribe(self, ctx, *, user_or_role: Union[discord.Role, User, str.lower, None] = None):
+    async def subscribe(
+        self, ctx, *, user_or_role: Union[discord.Role, User, str.lower, None] = None
+    ):
         """
         Notify a user, role, or yourself for every thread message received.
 
@@ -670,7 +784,9 @@ async def subscribe(self, ctx, *, user_or_role: Union[discord.Role, User, str.lo
     @commands.command(aliases=["unsub"])
     @checks.has_permissions(PermissionLevel.SUPPORTER)
     @checks.thread_only()
-    async def unsubscribe(self, ctx, *, user_or_role: Union[discord.Role, User, str.lower, None] = None):
+    async def unsubscribe(
+        self, ctx, *, user_or_role: Union[discord.Role, User, str.lower, None] = None
+    ):
         """
         Unsubscribe a user, role, or yourself from a thread.
 
@@ -736,10 +852,13 @@ async def msglink(self, ctx, message_id: int):
                 continue
         if not found:
             embed = discord.Embed(
-                color=self.bot.error_color, description="Message not found or no longer exists."
+                color=self.bot.error_color,
+                description="Message not found or no longer exists.",
             )
         else:
-            embed = discord.Embed(color=self.bot.main_color, description=message.jump_url)
+            embed = discord.Embed(
+                color=self.bot.main_color, description=message.jump_url
+            )
         await ctx.send(embed=embed)
 
     @commands.command()
@@ -748,7 +867,9 @@ async def msglink(self, ctx, message_id: int):
     async def loglink(self, ctx):
         """Retrieves the link to the current thread's logs."""
         log_link = await self.bot.api.get_log_link(ctx.channel.id)
-        await ctx.send(embed=discord.Embed(color=self.bot.main_color, description=log_link))
+        await ctx.send(
+            embed=discord.Embed(color=self.bot.main_color, description=log_link)
+        )
 
     def format_log_embeds(self, logs, avatar_url):
         embeds = []
@@ -761,16 +882,16 @@ def format_log_embeds(self, logs, avatar_url):
             prefix = self.bot.config["log_url_prefix"].strip("/")
             if prefix == "NONE":
                 prefix = ""
-            log_url = (
-                f"{self.bot.config['log_url'].strip('/')}{'/' + prefix if prefix else ''}/{entry['key']}"
-            )
+            log_url = f"{self.bot.config['log_url'].strip('/')}{'/' + prefix if prefix else ''}/{entry['key']}"
 
             username = entry["recipient"]["name"]
             if entry["recipient"]["discriminator"] != "0":
                 username += "#" + entry["recipient"]["discriminator"]
 
             embed = discord.Embed(color=self.bot.main_color, timestamp=created_at)
-            embed.set_author(name=f"{title} - {username}", icon_url=avatar_url, url=log_url)
+            embed.set_author(
+                name=f"{title} - {username}", icon_url=avatar_url, url=log_url
+            )
             embed.url = log_url
             embed.add_field(name="Created", value=human_timedelta(created_at))
             closer = entry.get("closer")
@@ -786,7 +907,9 @@ def format_log_embeds(self, logs, avatar_url):
             if entry.get("title"):
                 embed.add_field(name="Title", value=entry["title"], inline=False)
 
-            embed.add_field(name="Preview", value=format_preview(entry["messages"]), inline=False)
+            embed.add_field(
+                name="Preview", value=format_preview(entry["messages"]), inline=False
+            )
 
             if closer is not None:
                 # BUG: Currently, logviewer can't display logs without a closer.
@@ -810,7 +933,9 @@ async def title(self, ctx, *, name: str):
         await ctx.message.pin()
         await self.bot.add_reaction(ctx.message, sent_emoji)
 
-    @commands.command(usage="<users_or_roles...> [options]", cooldown_after_parsing=True)
+    @commands.command(
+        usage="<users_or_roles...> [options]", cooldown_after_parsing=True
+    )
     @checks.has_permissions(PermissionLevel.SUPPORTER)
     @checks.thread_only()
     @commands.cooldown(1, 600, BucketType.channel)
@@ -881,7 +1006,9 @@ async def adduser(self, ctx, *users_arg: Union[discord.Member, discord.Role, str
                 em.timestamp = discord.utils.utcnow()
             em.set_footer(
                 text=str(ctx.author),
-                icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else None,
+                icon_url=ctx.author.display_avatar.url
+                if ctx.author.display_avatar
+                else None,
             )
             for u in users:
                 to_exec.append(u.send(embed=em))
@@ -899,7 +1026,10 @@ async def adduser(self, ctx, *users_arg: Union[discord.Member, discord.Role, str
             if self.bot.config["show_timestamp"]:
                 em.timestamp = discord.utils.utcnow()
             em.set_footer(
-                text=f"{users[0]}", icon_url=users[0].display_avatar.url if users[0].display_avatar else None
+                text=f"{users[0]}",
+                icon_url=users[0].display_avatar.url
+                if users[0].display_avatar
+                else None,
             )
 
             for i in ctx.thread.recipients:
@@ -913,11 +1043,15 @@ async def adduser(self, ctx, *users_arg: Union[discord.Member, discord.Role, str
         sent_emoji, _ = await self.bot.retrieve_emoji()
         await self.bot.add_reaction(ctx.message, sent_emoji)
 
-    @commands.command(usage="<users_or_roles...> [options]", cooldown_after_parsing=True)
+    @commands.command(
+        usage="<users_or_roles...> [options]", cooldown_after_parsing=True
+    )
     @checks.has_permissions(PermissionLevel.SUPPORTER)
     @checks.thread_only()
     @commands.cooldown(1, 600, BucketType.channel)
-    async def removeuser(self, ctx, *users_arg: Union[discord.Member, discord.Role, str]):
+    async def removeuser(
+        self, ctx, *users_arg: Union[discord.Member, discord.Role, str]
+    ):
         """Removes a user from a modmail thread
 
         `options` can be `silent` or `silently`.
@@ -968,7 +1102,8 @@ async def removeuser(self, ctx, *users_arg: Union[discord.Member, discord.Role,
         to_exec = []
         if not silent:
             description = self.bot.formatter.format(
-                self.bot.config["private_removed_from_group_response"], moderator=ctx.author
+                self.bot.config["private_removed_from_group_response"],
+                moderator=ctx.author,
             )
             em = discord.Embed(
                 title=self.bot.config["private_removed_from_group_title"],
@@ -979,7 +1114,9 @@ async def removeuser(self, ctx, *users_arg: Union[discord.Member, discord.Role,
                 em.timestamp = discord.utils.utcnow()
             em.set_footer(
                 text=str(ctx.author),
-                icon_url=ctx.author.display_avatar.url if ctx.author.display_avatar else None,
+                icon_url=ctx.author.display_avatar.url
+                if ctx.author.display_avatar
+                else None,
             )
             for u in users:
                 to_exec.append(u.send(embed=em))
@@ -997,7 +1134,10 @@ async def removeuser(self, ctx, *users_arg: Union[discord.Member, discord.Role,
             if self.bot.config["show_timestamp"]:
                 em.timestamp = discord.utils.utcnow()
             em.set_footer(
-                text=f"{users[0]}", icon_url=users[0].display_avatar.url if users[0].display_avatar else None
+                text=f"{users[0]}",
+                icon_url=users[0].display_avatar.url
+                if users[0].display_avatar
+                else None,
             )
 
             for i in ctx.thread.recipients:
@@ -1011,11 +1151,15 @@ async def removeuser(self, ctx, *users_arg: Union[discord.Member, discord.Role,
         sent_emoji, _ = await self.bot.retrieve_emoji()
         await self.bot.add_reaction(ctx.message, sent_emoji)
 
-    @commands.command(usage="<users_or_roles...> [options]", cooldown_after_parsing=True)
+    @commands.command(
+        usage="<users_or_roles...> [options]", cooldown_after_parsing=True
+    )
     @checks.has_permissions(PermissionLevel.SUPPORTER)
     @checks.thread_only()
     @commands.cooldown(1, 600, BucketType.channel)
-    async def anonadduser(self, ctx, *users_arg: Union[discord.Member, discord.Role, str]):
+    async def anonadduser(
+        self, ctx, *users_arg: Union[discord.Member, discord.Role, str]
+    ):
         """Adds a user to a modmail thread anonymously
 
         `options` can be `silent` or `silently`.
@@ -1069,10 +1213,12 @@ async def anonadduser(self, ctx, *users_arg: Union[discord.Member, discord.Role,
 
             tag = self.bot.config["mod_tag"]
             if tag is None:
-                tag = str(get_top_role(ctx.author, self.bot.config["use_hoisted_top_role"]))
+                tag = str(
+                    get_top_role(ctx.author, self.bot.config["use_hoisted_top_role"])
+                )
             name = self.bot.config["anon_username"]
             if name is None:
-                name = tag
+                name = "Anonymous"
             avatar_url = self.bot.config["anon_avatar_url"]
             if avatar_url is None:
                 avatar_url = self.bot.get_guild_icon(guild=ctx.guild, size=128)
@@ -1093,7 +1239,10 @@ async def anonadduser(self, ctx, *users_arg: Union[discord.Member, discord.Role,
             if self.bot.config["show_timestamp"]:
                 em.timestamp = discord.utils.utcnow()
             em.set_footer(
-                text=f"{users[0]}", icon_url=users[0].display_avatar.url if users[0].display_avatar else None
+                text=f"{users[0]}",
+                icon_url=users[0].display_avatar.url
+                if users[0].display_avatar
+                else None,
             )
 
             for i in ctx.thread.recipients:
@@ -1107,11 +1256,15 @@ async def anonadduser(self, ctx, *users_arg: Union[discord.Member, discord.Role,
         sent_emoji, _ = await self.bot.retrieve_emoji()
         await self.bot.add_reaction(ctx.message, sent_emoji)
 
-    @commands.command(usage="<users_or_roles...> [options]", cooldown_after_parsing=True)
+    @commands.command(
+        usage="<users_or_roles...> [options]", cooldown_after_parsing=True
+    )
     @checks.has_permissions(PermissionLevel.SUPPORTER)
     @checks.thread_only()
     @commands.cooldown(1, 600, BucketType.channel)
-    async def anonremoveuser(self, ctx, *users_arg: Union[discord.Member, discord.Role, str]):
+    async def anonremoveuser(
+        self, ctx, *users_arg: Union[discord.Member, discord.Role, str]
+    ):
         """Removes a user from a modmail thread anonymously
 
         `options` can be `silent` or `silently`.
@@ -1152,7 +1305,9 @@ async def anonremoveuser(self, ctx, *users_arg: Union[discord.Member, discord.Ro
         if not silent:
             em = discord.Embed(
                 title=self.bot.config["private_removed_from_group_title"],
-                description=self.bot.config["private_removed_from_group_description_anon"],
+                description=self.bot.config[
+                    "private_removed_from_group_description_anon"
+                ],
                 color=self.bot.main_color,
             )
             if self.bot.config["show_timestamp"]:
@@ -1160,10 +1315,12 @@ async def anonremoveuser(self, ctx, *users_arg: Union[discord.Member, discord.Ro
 
             tag = self.bot.config["mod_tag"]
             if tag is None:
-                tag = str(get_top_role(ctx.author, self.bot.config["use_hoisted_top_role"]))
+                tag = str(
+                    get_top_role(ctx.author, self.bot.config["use_hoisted_top_role"])
+                )
             name = self.bot.config["anon_username"]
             if name is None:
-                name = tag
+                name = "Anonymous"
             avatar_url = self.bot.config["anon_avatar_url"]
             if avatar_url is None:
                 avatar_url = self.bot.get_guild_icon(guild=ctx.guild, size=128)
@@ -1184,7 +1341,10 @@ async def anonremoveuser(self, ctx, *users_arg: Union[discord.Member, discord.Ro
             if self.bot.config["show_timestamp"]:
                 em.timestamp = discord.utils.utcnow()
             em.set_footer(
-                text=f"{users[0]}", icon_url=users[0].display_avatar.url if users[0].display_avatar else None
+                text=f"{users[0]}",
+                icon_url=users[0].display_avatar.url
+                if users[0].display_avatar
+                else None,
             )
 
             for i in ctx.thread.recipients:
@@ -1250,7 +1410,9 @@ async def logs_closed_by(self, ctx, *, user: User = None):
         user = user if user is not None else ctx.author
 
         entries = await self.bot.api.search_closed_by(user.id)
-        embeds = self.format_log_embeds(entries, avatar_url=self.bot.get_guild_icon(guild=ctx.guild))
+        embeds = self.format_log_embeds(
+            entries, avatar_url=self.bot.get_guild_icon(guild=ctx.guild)
+        )
 
         if not embeds:
             embed = discord.Embed(
@@ -1322,7 +1484,9 @@ async def logs_responded(self, ctx, *, user: User = None):
 
         entries = await self.bot.api.get_responded_logs(user.id)
 
-        embeds = self.format_log_embeds(entries, avatar_url=self.bot.get_guild_icon(guild=ctx.guild))
+        embeds = self.format_log_embeds(
+            entries, avatar_url=self.bot.get_guild_icon(guild=ctx.guild)
+        )
 
         if not embeds:
             embed = discord.Embed(
@@ -1348,7 +1512,9 @@ async def logs_search(self, ctx, limit: Optional[int] = None, *, query):
 
         entries = await self.bot.api.search_by_text(query, limit)
 
-        embeds = self.format_log_embeds(entries, avatar_url=self.bot.get_guild_icon(guild=ctx.guild))
+        embeds = self.format_log_embeds(
+            entries, avatar_url=self.bot.get_guild_icon(guild=ctx.guild)
+        )
 
         if not embeds:
             embed = discord.Embed(
@@ -1392,7 +1558,10 @@ async def freply(self, ctx, *, msg: str = ""):
         automatically embedding image URLs.
         """
         msg = self.bot.formatter.format(
-            msg, channel=ctx.channel, recipient=ctx.thread.recipient, author=ctx.message.author
+            msg,
+            channel=ctx.channel,
+            recipient=ctx.thread.recipient,
+            author=ctx.message.author,
         )
         ctx.message.content = msg
         async with safe_typing(ctx):
@@ -1414,7 +1583,10 @@ async def fareply(self, ctx, *, msg: str = ""):
         automatically embedding image URLs.
         """
         msg = self.bot.formatter.format(
-            msg, channel=ctx.channel, recipient=ctx.thread.recipient, author=ctx.message.author
+            msg,
+            channel=ctx.channel,
+            recipient=ctx.thread.recipient,
+            author=ctx.message.author,
         )
         ctx.message.content = msg
         async with safe_typing(ctx):
@@ -1436,7 +1608,10 @@ async def fpreply(self, ctx, *, msg: str = ""):
         automatically embedding image URLs.
         """
         msg = self.bot.formatter.format(
-            msg, channel=ctx.channel, recipient=ctx.thread.recipient, author=ctx.message.author
+            msg,
+            channel=ctx.channel,
+            recipient=ctx.thread.recipient,
+            author=ctx.message.author,
         )
         ctx.message.content = msg
         async with safe_typing(ctx):
@@ -1458,7 +1633,10 @@ async def fpareply(self, ctx, *, msg: str = ""):
         automatically embedding image URLs.
         """
         msg = self.bot.formatter.format(
-            msg, channel=ctx.channel, recipient=ctx.thread.recipient, author=ctx.message.author
+            msg,
+            channel=ctx.channel,
+            recipient=ctx.thread.recipient,
+            author=ctx.message.author,
         )
         ctx.message.content = msg
         async with safe_typing(ctx):
@@ -1522,6 +1700,13 @@ async def note(self, ctx, *, msg: str = ""):
         async with safe_typing(ctx):
             msg = await ctx.thread.note(ctx.message)
             await msg.pin()
+        # Acknowledge and clean up the invoking command message
+        sent_emoji, _ = await self.bot.retrieve_emoji()
+        await self.bot.add_reaction(ctx.message, sent_emoji)
+        try:
+            await ctx.message.delete(delay=3)
+        except (discord.Forbidden, discord.NotFound):
+            pass
 
     @note.command(name="persistent", aliases=["persist"])
     @checks.has_permissions(PermissionLevel.SUPPORTER)
@@ -1534,7 +1719,16 @@ async def note_persistent(self, ctx, *, msg: str = ""):
         async with safe_typing(ctx):
             msg = await ctx.thread.note(ctx.message, persistent=True)
             await msg.pin()
-        await self.bot.api.create_note(recipient=ctx.thread.recipient, message=ctx.message, message_id=msg.id)
+        await self.bot.api.create_note(
+            recipient=ctx.thread.recipient, message=ctx.message, message_id=msg.id
+        )
+        # Acknowledge and clean up the invoking command message
+        sent_emoji, _ = await self.bot.retrieve_emoji()
+        await self.bot.add_reaction(ctx.message, sent_emoji)
+        try:
+            await ctx.message.delete(delay=3)
+        except (discord.Forbidden, discord.NotFound):
+            pass
 
     @commands.command()
     @checks.has_permissions(PermissionLevel.SUPPORTER)
@@ -1568,6 +1762,29 @@ async def edit(self, ctx, message_id: Optional[int] = None, *, message: str):
     @checks.has_permissions(PermissionLevel.REGULAR)
     async def selfcontact(self, ctx):
         """Creates a thread with yourself"""
+        # Check if user already has a thread
+        existing_thread = await self.bot.threads.find(recipient=ctx.author)
+        if existing_thread:
+            if existing_thread.snoozed:
+                # Unsnooze the thread
+                msg = await ctx.send("ℹ️ You had a snoozed thread. Unsnoozing now...")
+                await existing_thread.restore_from_snooze()
+                self.bot.threads.cache[existing_thread.id] = existing_thread
+                try:
+                    await msg.delete(delay=10)
+                except (discord.Forbidden, discord.NotFound):
+                    pass
+                return
+            else:
+                # Thread already exists and is active
+                embed = discord.Embed(
+                    title="Thread not created",
+                    description=f"A thread for you already exists in {existing_thread.channel.mention}.",
+                    color=self.bot.error_color,
+                )
+                await ctx.send(embed=embed, delete_after=10)
+                return
+
         await ctx.invoke(self.contact, users=[ctx.author])
 
     @commands.command(usage="<user> [category] [options]")
@@ -1576,7 +1793,12 @@ async def contact(
         self,
         ctx,
         users: commands.Greedy[
-            Union[Literal["silent", "silently"], discord.Member, discord.User, discord.Role]
+            Union[
+                Literal["silent", "silently"],
+                discord.Member,
+                discord.User,
+                discord.Role,
+            ]
         ],
         *,
         category: SimilarCategoryConverter = None,
@@ -1626,9 +1848,14 @@ async def contact(
                 users += u.members
                 users.remove(u)
 
+        snoozed_users = []
         for u in list(users):
             exists = await self.bot.threads.find(recipient=u)
             if exists:
+                # Check if thread is snoozed
+                if exists.snoozed:
+                    snoozed_users.append(u)
+                    continue
                 errors.append(f"A thread for {u} already exists.")
                 if exists.channel:
                     errors[-1] += f" in {exists.channel.mention}"
@@ -1639,9 +1866,28 @@ async def contact(
                 users.remove(u)
             elif await self.bot.is_blocked(u):
                 ref = f"{u.mention} is" if ctx.author != u else "You are"
-                errors.append(f"{ref} currently blocked from contacting {self.bot.user.name}.")
+                errors.append(
+                    f"{ref} currently blocked from contacting {self.bot.user.name}."
+                )
                 users.remove(u)
 
+        # Handle snoozed users - unsnooze them and return early
+        if snoozed_users:
+            for u in snoozed_users:
+                thread = await self.bot.threads.find(recipient=u)
+                if thread and thread.snoozed:
+                    msg = await ctx.send(
+                        f"ℹ️ {u.mention} had a snoozed thread. Unsnoozing now..."
+                    )
+                    await thread.restore_from_snooze()
+                    self.bot.threads.cache[thread.id] = thread
+                    try:
+                        await msg.delete(delay=10)
+                    except (discord.Forbidden, discord.NotFound):
+                        pass
+            # Don't try to create a new thread - we just unsnoozed existing ones
+            return
+
         if len(users) > 5:
             errors.append("Group conversations only support 5 users.")
             users = []
@@ -1654,11 +1900,14 @@ async def contact(
                 title = None
 
             if manual_trigger:  # not react to contact
-                embed = discord.Embed(title=title, color=self.bot.error_color, description="\n".join(errors))
+                embed = discord.Embed(
+                    title=title,
+                    color=self.bot.error_color,
+                    description="\n".join(errors),
+                )
                 await ctx.send(embed=embed, delete_after=10)
 
             if not users:
-                # end
                 return
 
         creator = ctx.author if manual_trigger else users[0]
@@ -1674,7 +1923,10 @@ async def contact(
         if thread.cancelled:
             return
 
-        if self.bot.config["dm_disabled"] in (DMDisabled.NEW_THREADS, DMDisabled.ALL_THREADS):
+        if self.bot.config["dm_disabled"] in (
+            DMDisabled.NEW_THREADS,
+            DMDisabled.ALL_THREADS,
+        ):
             logger.info("Contacting user %s when Modmail DM is disabled.", users[0])
 
         if not silent and not self.bot.config.get("thread_contact_silently"):
@@ -1693,7 +1945,8 @@ async def contact(
             if self.bot.config["show_timestamp"]:
                 em.timestamp = discord.utils.utcnow()
             em.set_footer(
-                text=f"{creator}", icon_url=creator.display_avatar.url if creator.display_avatar else None
+                text=f"{creator}",
+                icon_url=creator.display_avatar.url if creator.display_avatar else None,
             )
 
             for u in users:
@@ -1714,8 +1967,10 @@ async def contact(
         if manual_trigger:
             sent_emoji, _ = await self.bot.retrieve_emoji()
             await self.bot.add_reaction(ctx.message, sent_emoji)
-            await asyncio.sleep(5)
-            await ctx.message.delete()
+            try:
+                await ctx.message.delete(delay=5)
+            except (discord.Forbidden, discord.NotFound):
+                pass
 
     @commands.group(invoke_without_command=True)
     @checks.has_permissions(PermissionLevel.MODERATOR)
@@ -1763,7 +2018,11 @@ async def blocked(self, ctx):
             if role:
                 roles.append((role.mention, reason))
 
-        user_embeds = [discord.Embed(title="Blocked Users", color=self.bot.main_color, description="")]
+        user_embeds = [
+            discord.Embed(
+                title="Blocked Users", color=self.bot.main_color, description=""
+            )
+        ]
 
         if users:
             embed = user_embeds[0]
@@ -1786,7 +2045,11 @@ async def blocked(self, ctx):
             for n, em in enumerate(user_embeds):
                 em.title = f"{em.title} [{n + 1}]"
 
-        role_embeds = [discord.Embed(title="Blocked Roles", color=self.bot.main_color, description="")]
+        role_embeds = [
+            discord.Embed(
+                title="Blocked Roles", color=self.bot.main_color, description=""
+            )
+        ]
 
         if roles:
             embed = role_embeds[-1]
@@ -1980,7 +2243,10 @@ async def unblock(self, ctx, *, user_or_role: Union[User, Role] = None):
         mention = getattr(user_or_role, "mention", f"`{user_or_role.id}`")
         name = getattr(user_or_role, "name", f"`{user_or_role.id}`")
 
-        if not isinstance(user_or_role, discord.Role) and str(user_or_role.id) in self.bot.blocked_users:
+        if (
+            not isinstance(user_or_role, discord.Role)
+            and str(user_or_role.id) in self.bot.blocked_users
+        ):
             msg = self.bot.blocked_users.pop(str(user_or_role.id)) or ""
             await self.bot.config.update()
 
@@ -2005,7 +2271,10 @@ async def unblock(self, ctx, *, user_or_role: Union[User, Role] = None):
                     color=self.bot.main_color,
                     description=f"{mention} is no longer blocked.",
                 )
-        elif isinstance(user_or_role, discord.Role) and str(user_or_role.id) in self.bot.blocked_roles:
+        elif (
+            isinstance(user_or_role, discord.Role)
+            and str(user_or_role.id) in self.bot.blocked_roles
+        ):
             msg = self.bot.blocked_roles.pop(str(user_or_role.id)) or ""
             await self.bot.config.update()
 
@@ -2016,7 +2285,9 @@ async def unblock(self, ctx, *, user_or_role: Union[User, Role] = None):
             )
         else:
             embed = discord.Embed(
-                title="Error", description=f"{mention} is not blocked.", color=self.bot.error_color
+                title="Error",
+                description=f"{mention} is not blocked.",
+                color=self.bot.error_color,
             )
 
         return await ctx.send(embed=embed)
@@ -2069,12 +2340,18 @@ async def repair(self, ctx):
 
         # Search cache for channel
         user_id, thread = next(
-            ((k, v) for k, v in self.bot.threads.cache.items() if v.channel == ctx.channel),
+            (
+                (k, v)
+                for k, v in self.bot.threads.cache.items()
+                if v.channel == ctx.channel
+            ),
             (-1, None),
         )
         if thread is not None:
             logger.debug("Found thread with tempered ID.")
-            await ctx.channel.edit(reason="Fix broken Modmail thread", topic=f"User ID: {user_id}")
+            await ctx.channel.edit(
+                reason="Fix broken Modmail thread", topic=f"User ID: {user_id}"
+            )
             return await self.bot.add_reaction(ctx.message, sent_emoji)
 
         # find genesis message to retrieve User ID
@@ -2102,8 +2379,12 @@ async def repair(self, ctx):
                             self.bot.threads, recipient, ctx.channel, other_recipients
                         )
                     thread.ready = True
-                    logger.info("Setting current channel's topic to User ID and created new thread.")
-                    await ctx.channel.edit(reason="Fix broken Modmail thread", topic=f"User ID: {user_id}")
+                    logger.info(
+                        "Setting current channel's topic to User ID and created new thread."
+                    )
+                    await ctx.channel.edit(
+                        reason="Fix broken Modmail thread", topic=f"User ID: {user_id}"
+                    )
                     return await self.bot.add_reaction(ctx.message, sent_emoji)
 
         else:
@@ -2116,7 +2397,10 @@ async def repair(self, ctx):
             users = set(
                 filter(
                     lambda member: member.name == m.group(1)
-                    and (member.discriminator == "0" or member.discriminator == m.group(2)),
+                    and (
+                        member.discriminator == "0"
+                        or member.discriminator == m.group(2)
+                    ),
                     ctx.guild.members,
                 )
             )
@@ -2154,9 +2438,13 @@ async def repair(self, ctx):
                         self.bot.threads, recipient, ctx.channel, other_recipients
                     )
                 thread.ready = True
-                logger.info("Setting current channel's topic to User ID and created new thread.")
+                logger.info(
+                    "Setting current channel's topic to User ID and created new thread."
+                )
                 await ctx.channel.edit(
-                    reason="Fix broken Modmail thread", name=name, topic=f"User ID: {user.id}"
+                    reason="Fix broken Modmail thread",
+                    name=name,
+                    topic=f"User ID: {user.id}",
                 )
                 return await self.bot.add_reaction(ctx.message, sent_emoji)
 
@@ -2268,35 +2556,146 @@ async def isenable(self, ctx):
     @checks.thread_only()
     async def snooze(self, ctx, *, duration: UserFriendlyTime = None):
         """
-        Snooze this thread: deletes the channel, keeps the ticket open in DM, and restores it when the user replies or a moderator unsnoozes it.
-        Optionally specify a duration, e.g. 'snooze 2d' for 2 days.
-        Uses config: max_snooze_time, snooze_title, snooze_text
+        Snooze this thread. Behavior depends on config:
+        - delete (default): deletes the channel and restores it later
+        - move: moves the channel to the configured snoozed category
+            Optionally specify a duration, e.g. 'snooze 2d' for 2 days.
+            Uses config: snooze_default_duration, snooze_title, snooze_text
         """
         thread = ctx.thread
         if thread.snoozed:
             await ctx.send("This thread is already snoozed.")
-            logging.info(f"[SNOOZE] Thread for {getattr(thread.recipient, 'id', None)} already snoozed.")
+            logging.info(
+                f"[SNOOZE] Thread for {getattr(thread.recipient, 'id', None)} already snoozed."
+            )
             return
-        max_snooze = self.bot.config.get("max_snooze_time")
-        if max_snooze is None:
-            max_snooze = 604800
-        max_snooze = int(max_snooze)
+        # Default snooze duration with safe fallback
+        try:
+            default_snooze = int(self.bot.config.get("snooze_default_duration", 604800))
+        except (ValueError, TypeError):
+            default_snooze = 604800
         if duration:
             snooze_for = int((duration.dt - duration.now).total_seconds())
-            if snooze_for > max_snooze:
-                snooze_for = max_snooze
+            snooze_for = min(snooze_for, default_snooze)
         else:
-            snooze_for = max_snooze
+            snooze_for = default_snooze
+
+        # Capacity pre-check: if behavior is move, ensure snoozed category has room (<49 channels)
+        behavior = (self.bot.config.get("snooze_behavior") or "delete").lower()
+        if behavior == "move":
+            snoozed_cat_id = self.bot.config.get("snoozed_category_id")
+            target_category = None
+            if snoozed_cat_id:
+                try:
+                    target_category = self.bot.modmail_guild.get_channel(
+                        int(snoozed_cat_id)
+                    )
+                except Exception:
+                    target_category = None
+            # Auto-create snoozed category if missing
+            if not isinstance(target_category, discord.CategoryChannel):
+                try:
+                    logging.info(
+                        "Auto-creating snoozed category for move-based snoozing."
+                    )
+                    # Hide category by default; only bot can view/manage
+                    overwrites = {
+                        self.bot.modmail_guild.default_role: discord.PermissionOverwrite(
+                            view_channel=False
+                        )
+                    }
+                    bot_member = self.bot.modmail_guild.me
+                    if bot_member is not None:
+                        overwrites[bot_member] = discord.PermissionOverwrite(
+                            view_channel=True,
+                            send_messages=True,
+                            read_message_history=True,
+                            manage_channels=True,
+                            manage_messages=True,
+                            attach_files=True,
+                            embed_links=True,
+                            add_reactions=True,
+                        )
+                    target_category = await self.bot.modmail_guild.create_category(
+                        name="Snoozed Threads",
+                        overwrites=overwrites,
+                        reason="Auto-created snoozed category for move-based snoozing",
+                    )
+                    try:
+                        await self.bot.config.set(
+                            "snoozed_category_id", target_category.id
+                        )
+                        await self.bot.config.update()
+                    except Exception as e:
+                        logging.warning("Failed to persist snoozed_category_id: %s", e)
+                        try:
+                            await ctx.send(
+                                "⚠️ Created snoozed category but failed to save it to config. Please set `snoozed_category_id` manually."
+                            )
+                        except Exception as e:
+                            logging.info(
+                                "Failed to notify about snoozed category persistence issue: %s",
+                                e,
+                            )
+                    await ctx.send(
+                        embed=discord.Embed(
+                            title="Snoozed category created",
+                            description=(
+                                f"Created category {target_category.mention if hasattr(target_category, 'mention') else target_category.name} "
+                                "and set it as `snoozed_category_id`."
+                            ),
+                            color=self.bot.main_color,
+                        )
+                    )
+                except Exception as e:
+                    await ctx.send(
+                        embed=discord.Embed(
+                            title="Could not create snoozed category",
+                            description=(
+                                "I couldn't create a category automatically. Please ensure I have Manage Channels "
+                                "permission, or set `snoozed_category_id` manually."
+                            ),
+                            color=self.bot.error_color,
+                        )
+                    )
+                    logging.warning("Failed to auto-create snoozed category: %s", e)
+            # Capacity check after ensuring category exists
+            if isinstance(target_category, discord.CategoryChannel):
+                try:
+                    if len(target_category.channels) >= 49:
+                        await ctx.send(
+                            embed=discord.Embed(
+                                title="Snooze unavailable",
+                                description=(
+                                    "The configured snoozed category is full (49 channels). "
+                                    "Unsnooze or move some channels out before snoozing more."
+                                ),
+                                color=self.bot.error_color,
+                            )
+                        )
+                        return
+                except Exception as e:
+                    logging.debug(
+                        "Failed to check snoozed category channel count: %s", e
+                    )
 
-        # Storing snooze_start and snooze_for in the log entry
+        # Store snooze_until timestamp for reliable auto-unsnooze
         now = datetime.now(timezone.utc)
+        snooze_until = now + timedelta(seconds=snooze_for)
         await self.bot.api.logs.update_one(
             {"recipient.id": str(thread.id)},
-            {"$set": {"snooze_start": now.isoformat(), "snooze_for": snooze_for}},
+            {
+                "$set": {
+                    "snooze_start": now.isoformat(),
+                    "snooze_for": snooze_for,
+                    "snooze_until": snooze_until.isoformat(),
+                }
+            },
         )
         embed = discord.Embed(
             title=self.bot.config.get("snooze_title") or "Thread Snoozed",
-            description=self.bot.config.get("snooze_text") or "This thread has been snoozed.",
+            description=self.bot.config.get("snooze_text")
+            or "This thread has been snoozed.",
             color=self.bot.error_color,
         )
         await ctx.send(embed=embed)
@@ -2308,7 +2707,9 @@ async def snooze(self, ctx, *, duration: UserFriendlyTime = None):
             self.bot.threads.cache[thread.id] = thread
         else:
             await ctx.send("Failed to snooze this thread.")
-            logging.error(f"[SNOOZE] Failed to snooze thread for {getattr(thread.recipient, 'id', None)}.")
+            logging.error(
+                f"[SNOOZE] Failed to snooze thread for {getattr(thread.recipient, 'id', None)}."
+            )
 
     @commands.command()
     @checks.has_permissions(PermissionLevel.SUPPORTER)
@@ -2328,12 +2729,21 @@ async def unsnooze(self, ctx, *, user: str = None):
                 try:
                     user_obj = await self.bot.get_or_fetch_user(user_id)
                 except Exception:
+                    logger.debug(
+                        "Failed fetching user during unsnooze; falling back to partial object (%s).",
+                        user_id,
+                        exc_info=True,
+                    )
                     user_obj = discord.Object(user_id)
             if user_obj:
                 thread = await self.bot.threads.find(recipient=user_obj)
             if not thread:
-                await ctx.send(f"[DEBUG] No thread found for user {user} (obj: {user_obj}).")
-                logging.warning(f"[UNSNOOZE] No thread found for user {user} (obj: {user_obj})")
+                await ctx.send(
+                    f"[DEBUG] No thread found for user {user} (obj: {user_obj})."
+                )
+                logging.warning(
+                    f"[UNSNOOZE] No thread found for user {user} (obj: {user_obj})"
+                )
                 return
         elif hasattr(ctx, "thread"):
             thread = ctx.thread
@@ -2343,12 +2753,16 @@ async def unsnooze(self, ctx, *, user: str = None):
             return
         if not thread.snoozed:
             await ctx.send("This thread is not snoozed.")
-            logging.info(f"[UNSNOOZE] Thread for {getattr(thread.recipient, 'id', None)} is not snoozed.")
+            logging.info(
+                f"[UNSNOOZE] Thread for {getattr(thread.recipient, 'id', None)} is not snoozed."
+            )
             return
 
         # Manually fetch snooze_data if the thread object doesn't have it
         if not thread.snooze_data:
-            log_entry = await self.bot.api.logs.find_one({"recipient.id": str(thread.id), "snoozed": True})
+            log_entry = await self.bot.api.logs.find_one(
+                {"recipient.id": str(thread.id), "snoozed": True}
+            )
             if log_entry:
                 thread.snooze_data = log_entry.get("snooze_data")
 
@@ -2356,9 +2770,12 @@ async def unsnooze(self, ctx, *, user: str = None):
         if ok:
             self.bot.threads.cache[thread.id] = thread
             await ctx.send(
-                self.bot.config.get("unsnooze_text") or "This thread has been unsnoozed and restored."
+                self.bot.config.get("unsnooze_text")
+                or "This thread has been unsnoozed and restored."
+            )
+            logging.info(
+                f"[UNSNOOZE] Thread for {getattr(thread.recipient, 'id', None)} unsnoozed."
             )
-            logging.info(f"[UNSNOOZE] Thread for {getattr(thread.recipient, 'id', None)} unsnoozed.")
         else:
             await ctx.send("Failed to unsnooze this thread.")
             logging.error(
@@ -2371,7 +2788,9 @@ async def snoozed(self, ctx):
         """
         List all currently snoozed threads/users.
         """
-        snoozed_threads = [thread for thread in self.bot.threads.cache.values() if thread.snoozed]
+        snoozed_threads = [
+            thread for thread in self.bot.threads.cache.values() if thread.snoozed
+        ]
         if not snoozed_threads:
             await ctx.send("No threads are currently snoozed.")
             return
@@ -2394,13 +2813,17 @@ async def snoozed(self, ctx):
                         since_dt = datetime.fromisoformat(since)
                         since_str = f"<t:{int(since_dt.timestamp())}:R>"  # Discord relative timestamp
                     except (ValueError, TypeError) as e:
-                        logging.warning(f"[SNOOZED] Invalid snooze_start for {user_id}: {since} ({e})")
+                        logging.warning(
+                            f"[SNOOZED] Invalid snooze_start for {user_id}: {since} ({e})"
+                        )
                 else:
                     logging.warning(f"[SNOOZED] Missing snooze_start for {user_id}")
 
                 if duration and since_str != "?":
                     try:
-                        until_dt = datetime.fromisoformat(since) + timedelta(seconds=int(duration))
+                        until_dt = datetime.fromisoformat(since) + timedelta(
+                            seconds=int(duration)
+                        )
                         until_str = f"<t:{int(until_dt.timestamp())}:R>"
                     except (ValueError, TypeError) as e:
                         logging.warning(
@@ -2412,32 +2835,32 @@ async def snoozed(self, ctx):
         await ctx.send("Snoozed threads:\n" + "\n".join(lines))
 
     async def cog_load(self):
-        self.bot.loop.create_task(self.snooze_auto_unsnooze_task())
+        self.snooze_auto_unsnooze.start()
+
+    @tasks.loop(seconds=10)
+    async def snooze_auto_unsnooze(self):
+        now = datetime.now(timezone.utc)
+        snoozed = await self.bot.api.logs.find({"snoozed": True}).to_list(None)
+        for entry in snoozed:
+            snooze_until = entry.get("snooze_until")
+            if snooze_until:
+                try:
+                    until_dt = datetime.fromisoformat(snooze_until)
+                    if now >= until_dt:
+                        thread = await self.bot.threads.find(
+                            recipient_id=int(entry["recipient"]["id"])
+                        )
+                        if thread and thread.snoozed:
+                            await thread.restore_from_snooze()
+                except (ValueError, TypeError) as e:
+                    logger.debug(
+                        "Failed parsing snooze_until timestamp for auto-unsnooze loop: %s",
+                        e,
+                    )
 
-    async def snooze_auto_unsnooze_task(self):
+    @snooze_auto_unsnooze.before_loop
+    async def _snooze_auto_unsnooze_before(self):
         await self.bot.wait_until_ready()
-        while True:
-            now = datetime.now(timezone.utc)
-            snoozed = await self.bot.api.logs.find({"snoozed": True}).to_list(None)
-            for entry in snoozed:
-                start = entry.get("snooze_start")
-                snooze_for = entry.get("snooze_for")
-                if not start:
-                    continue
-                start_dt = datetime.fromisoformat(start)
-                if snooze_for is not None:
-                    duration = int(snooze_for)
-                else:
-                    max_snooze = self.bot.config.get("max_snooze_time")
-                    if max_snooze is None:
-                        max_snooze = 604800
-                    duration = int(max_snooze)
-                if (now - start_dt).total_seconds() > duration:
-                    # Auto-unsnooze
-                    thread = await self.bot.threads.find(recipient_id=int(entry["recipient"]["id"]))
-                    if thread and thread.snoozed:
-                        await thread.restore_from_snooze()
-            await asyncio.sleep(60)
 
     async def process_dm_modmail(self, message: discord.Message) -> None:
         # ... existing code ...
diff --git a/cogs/plugins.py b/cogs/plugins.py
index c7dceb7283..f3269b5ae1 100644
--- a/cogs/plugins.py
+++ b/cogs/plugins.py
@@ -52,7 +52,9 @@ def __init__(self, user, repo=None, name=None, branch=None):
     def path(self):
         if self.local:
             return PurePath("plugins") / "@local" / self.name
-        return PurePath("plugins") / self.user / self.repo / f"{self.name}-{self.branch}"
+        return (
+            PurePath("plugins") / self.user / self.repo / f"{self.name}-{self.branch}"
+        )
 
     @property
     def abs_path(self):
@@ -147,10 +149,14 @@ async def initial_load_plugins(self):
                     # For backwards compat
                     plugin = Plugin.from_string(plugin_name)
                 except InvalidPluginError:
-                    logger.error("Failed to parse plugin name: %s.", plugin_name, exc_info=True)
+                    logger.error(
+                        "Failed to parse plugin name: %s.", plugin_name, exc_info=True
+                    )
                     continue
 
-                logger.info("Migrated legacy plugin name: %s, now %s.", plugin_name, str(plugin))
+                logger.info(
+                    "Migrated legacy plugin name: %s, now %s.", plugin_name, str(plugin)
+                )
                 self.bot.config["plugins"].append(str(plugin))
 
             try:
@@ -202,7 +208,9 @@ async def download_plugin(self, plugin, force=False):
                     if raw == "Not Found":
                         raise InvalidPluginError("Plugin not found")
                     else:
-                        raise InvalidPluginError("Invalid download received, non-bytes object")
+                        raise InvalidPluginError(
+                            "Invalid download received, non-bytes object"
+                        )
 
             plugin_io = io.BytesIO(raw)
             if not plugin.cache_path.parent.exists():
@@ -234,7 +242,9 @@ async def load_plugin(self, plugin):
         if req_txt.exists():
             # Install PIP requirements
 
-            venv = hasattr(sys, "real_prefix") or hasattr(sys, "base_prefix")  # in a virtual env
+            venv = hasattr(sys, "real_prefix") or hasattr(
+                sys, "base_prefix"
+            )  # in a virtual env
             user_install = " --user" if not venv else ""
             proc = await asyncio.create_subprocess_shell(
                 f'"{sys.executable}" -m pip install --upgrade{user_install} -r {req_txt} -q -q',
@@ -251,8 +261,14 @@ async def load_plugin(self, plugin):
 
             if stderr:
                 logger.debug("[stderr]\n%s.", stderr.decode())
-                logger.error("Failed to download requirements for %s.", plugin.ext_string, exc_info=True)
-                raise InvalidPluginError(f"Unable to download requirements: ```\n{stderr.decode()}\n```")
+                logger.error(
+                    "Failed to download requirements for %s.",
+                    plugin.ext_string,
+                    exc_info=True,
+                )
+                raise InvalidPluginError(
+                    f"Unable to download requirements: ```\n{stderr.decode()}\n```"
+                )
 
             if os.path.exists(USER_SITE):
                 sys.path.insert(0, USER_SITE)
@@ -361,7 +377,10 @@ async def plugins_add(self, ctx, *, plugin_name: str):
             return
 
         if str(plugin) in self.bot.config["plugins"]:
-            embed = discord.Embed(description="This plugin is already installed.", color=self.bot.error_color)
+            embed = discord.Embed(
+                description="This plugin is already installed.",
+                color=self.bot.error_color,
+            )
             return await ctx.send(embed=embed)
 
         if plugin.name in self.bot.cogs:
@@ -444,7 +463,9 @@ async def plugins_remove(self, ctx, *, plugin_name: str):
             return
 
         if str(plugin) not in self.bot.config["plugins"]:
-            embed = discord.Embed(description="Plugin is not installed.", color=self.bot.error_color)
+            embed = discord.Embed(
+                description="Plugin is not installed.", color=self.bot.error_color
+            )
             return await ctx.send(embed=embed)
 
         if self.bot.config.get("enable_plugins"):
@@ -470,7 +491,8 @@ async def plugins_remove(self, ctx, *, plugin_name: str):
                 pass  # dir not empty
 
         embed = discord.Embed(
-            description="The plugin is successfully uninstalled.", color=self.bot.main_color
+            description="The plugin is successfully uninstalled.",
+            color=self.bot.main_color,
         )
         await ctx.send(embed=embed)
 
@@ -481,12 +503,15 @@ async def update_plugin(self, ctx, plugin_name):
             return
 
         if str(plugin) not in self.bot.config["plugins"]:
-            embed = discord.Embed(description="Plugin is not installed.", color=self.bot.error_color)
+            embed = discord.Embed(
+                description="Plugin is not installed.", color=self.bot.error_color
+            )
             return await ctx.send(embed=embed)
 
         async with safe_typing(ctx):
             embed = discord.Embed(
-                description=f"Successfully updated {plugin.name}.", color=self.bot.main_color
+                description=f"Successfully updated {plugin.name}.",
+                color=self.bot.main_color,
             )
             await self.download_plugin(plugin, force=True)
             if self.bot.config.get("enable_plugins"):
@@ -503,7 +528,9 @@ async def update_plugin(self, ctx, plugin_name):
                         color=self.bot.error_color,
                     )
                     self.bot.config["plugins"].remove(str(plugin))
-                    logger.debug("Failed to update %s. Removed plugin from config.", plugin)
+                    logger.debug(
+                        "Failed to update %s. Removed plugin from config.", plugin
+                    )
                 else:
                     logger.debug("Updated %s.", plugin)
             else:
@@ -543,7 +570,9 @@ async def plugins_reset(self, ctx):
                 continue
             logger.error("Unloading plugin: %s.", ext)
             try:
-                plugin = next((p for p in self.loaded_plugins if p.ext_string == ext), None)
+                plugin = next(
+                    (p for p in self.loaded_plugins if p.ext_string == ext), None
+                )
                 if plugin:
                     await self.unload_plugin(plugin)
                     self.loaded_plugins.remove(plugin)
@@ -570,7 +599,8 @@ async def plugins_reset(self, ctx):
                 logger.warning("Removing %s.", entry.name)
 
         embed = discord.Embed(
-            description="Successfully purged all plugins from the bot.", color=self.bot.main_color
+            description="Successfully purged all plugins from the bot.",
+            color=self.bot.main_color,
         )
         return await ctx.send(embed=embed)
 
@@ -598,7 +628,8 @@ async def plugins_loaded(self, ctx):
 
         if not self.loaded_plugins:
             embed = discord.Embed(
-                description="There are no plugins currently loaded.", color=self.bot.error_color
+                description="There are no plugins currently loaded.",
+                color=self.bot.error_color,
             )
             return await ctx.send(embed=embed)
 
@@ -617,14 +648,20 @@ async def plugins_loaded(self, ctx):
 
         embeds = []
         for page in pages:
-            embed = discord.Embed(title="Loaded plugins:", description=page, color=self.bot.main_color)
+            embed = discord.Embed(
+                title="Loaded plugins:", description=page, color=self.bot.main_color
+            )
             embeds.append(embed)
         paginator = EmbedPaginatorSession(ctx, *embeds)
         await paginator.run()
 
-    @plugins.group(invoke_without_command=True, name="registry", aliases=["list", "info"])
+    @plugins.group(
+        invoke_without_command=True, name="registry", aliases=["list", "info"]
+    )
     @checks.has_permissions(PermissionLevel.OWNER)
-    async def plugins_registry(self, ctx, *, plugin_name: typing.Union[int, str] = None):
+    async def plugins_registry(
+        self, ctx, *, plugin_name: typing.Union[int, str] = None
+    ):
         """
         Shows a list of all approved plugins.
 
@@ -655,7 +692,9 @@ async def plugins_registry(self, ctx, *, plugin_name: typing.Union[int, str] = N
             if index >= len(registry):
                 index = len(registry) - 1
         else:
-            index = next((i for i, (n, _) in enumerate(registry) if plugin_name == n), 0)
+            index = next(
+                (i for i, (n, _) in enumerate(registry) if plugin_name == n), 0
+            )
 
         if not index and plugin_name is not None:
             embed = discord.Embed(
@@ -666,7 +705,10 @@ async def plugins_registry(self, ctx, *, plugin_name: typing.Union[int, str] = N
             matches = get_close_matches(plugin_name, self.registry.keys())
 
             if matches:
-                embed.add_field(name="Perhaps you meant:", value="\n".join(f"`{m}`" for m in matches))
+                embed.add_field(
+                    name="Perhaps you meant:",
+                    value="\n".join(f"`{m}`" for m in matches),
+                )
 
             return await ctx.send(embed=embed)
 
@@ -684,9 +726,13 @@ async def plugins_registry(self, ctx, *, plugin_name: typing.Union[int, str] = N
                 title=details["repository"],
             )
 
-            embed.add_field(name="Installation", value=f"```{self.bot.prefix}plugins add {name}```")
+            embed.add_field(
+                name="Installation", value=f"```{self.bot.prefix}plugins add {name}```"
+            )
 
-            embed.set_author(name=details["title"], icon_url=details.get("icon_url"), url=plugin.link)
+            embed.set_author(
+                name=details["title"], icon_url=details.get("icon_url"), url=plugin.link
+            )
 
             if details.get("thumbnail_url"):
                 embed.set_thumbnail(url=details.get("thumbnail_url"))
@@ -732,7 +778,9 @@ async def plugins_registry_compact(self, ctx):
 
             plugin = Plugin(user, repo, plugin_name, branch)
 
-            desc = discord.utils.escape_markdown(details["description"].replace("\n", ""))
+            desc = discord.utils.escape_markdown(
+                details["description"].replace("\n", "")
+            )
 
             name = f"[`{plugin.name}`]({plugin.link})"
             fmt = f"{name} - {desc}"
@@ -761,7 +809,9 @@ async def plugins_registry_compact(self, ctx):
             embed = discord.Embed(color=self.bot.main_color, description=page)
             embed.set_author(
                 name="Plugin Registry",
-                icon_url=self.bot.user.display_avatar.url if self.bot.user.display_avatar else None,
+                icon_url=self.bot.user.display_avatar.url
+                if self.bot.user.display_avatar
+                else None,
             )
             embeds.append(embed)
 
diff --git a/cogs/threadmenu.py b/cogs/threadmenu.py
new file mode 100644
index 0000000000..24c2e2abd1
--- /dev/null
+++ b/cogs/threadmenu.py
@@ -0,0 +1,832 @@
+import json
+import asyncio
+from copy import copy as _copy
+
+import discord
+from discord.ext import commands
+
+from core import checks
+from core.models import PermissionLevel
+
+
+class ThreadCreationMenuCore(commands.Cog):
+    """Core-integrated thread menu configuration and management.
+
+    This Cog exposes the same commands as the legacy plugin to manage menu options,
+    but stores settings in core config (no plugin DB).
+    """
+
+    def __init__(self, bot):
+        self.bot = bot
+
+    # ----- helpers -----
+    def _get_conf(self) -> dict:
+        return {
+            "enabled": bool(self.bot.config.get("thread_creation_menu_enabled")),
+            "options": self.bot.config.get("thread_creation_menu_options") or {},
+            "submenus": self.bot.config.get("thread_creation_menu_submenus") or {},
+            "timeout": int(self.bot.config.get("thread_creation_menu_timeout") or 20),
+            "close_on_timeout": bool(self.bot.config.get("thread_creation_menu_close_on_timeout")),
+            "anonymous_menu": bool(self.bot.config.get("thread_creation_menu_anonymous_menu")),
+            "embed_text": self.bot.config.get("thread_creation_menu_embed_text")
+            or "Please select an option.",
+            "dropdown_placeholder": self.bot.config.get("thread_creation_menu_dropdown_placeholder")
+            or "Select an option to contact the staff team.",
+            "embed_title": self.bot.config.get("thread_creation_menu_embed_title"),
+            "embed_footer": self.bot.config.get("thread_creation_menu_embed_footer"),
+            "embed_thumbnail_url": self.bot.config.get("thread_creation_menu_embed_thumbnail_url"),
+            "embed_footer_icon_url": self.bot.config.get("thread_creation_menu_embed_footer_icon_url"),
+            "embed_color": self.bot.config.get("thread_creation_menu_embed_color"),
+        }
+
+    async def _save_conf(self, conf: dict):
+        await self.bot.config.set("thread_creation_menu_enabled", conf.get("enabled", False))
+        await self.bot.config.set("thread_creation_menu_options", conf.get("options", {}), convert=False)
+        await self.bot.config.set("thread_creation_menu_submenus", conf.get("submenus", {}), convert=False)
+        await self.bot.config.set("thread_creation_menu_timeout", conf.get("timeout", 20))
+        await self.bot.config.set(
+            "thread_creation_menu_close_on_timeout", conf.get("close_on_timeout", False)
+        )
+        await self.bot.config.set("thread_creation_menu_anonymous_menu", conf.get("anonymous_menu", False))
+        await self.bot.config.set(
+            "thread_creation_menu_embed_text", conf.get("embed_text", "Please select an option.")
+        )
+        await self.bot.config.set(
+            "thread_creation_menu_dropdown_placeholder",
+            conf.get("dropdown_placeholder", "Select an option to contact the staff team."),
+        )
+        await self.bot.config.set("thread_creation_menu_embed_title", conf.get("embed_title"))
+        await self.bot.config.set("thread_creation_menu_embed_footer", conf.get("embed_footer"))
+        await self.bot.config.set("thread_creation_menu_embed_thumbnail_url", conf.get("embed_thumbnail_url"))
+        await self.bot.config.set(
+            "thread_creation_menu_embed_footer_icon_url", conf.get("embed_footer_icon_url")
+        )
+        if conf.get("embed_color"):
+            try:
+                await self.bot.config.set("thread_creation_menu_embed_color", conf.get("embed_color"))
+            except Exception:
+                pass
+        await self.bot.config.update()
+
+    # ----- commands -----
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @commands.group(invoke_without_command=True)
+    async def threadmenu(self, ctx):
+        """Thread-creation menu settings (core)."""
+        await ctx.send_help(ctx.command)
+
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu.command(name="toggle")
+    async def threadmenu_toggle(self, ctx):
+        """Enable or disable the thread-creation menu.
+
+        Toggles the global on/off state. When disabled, users won't see
+        or be able to use the interactive thread creation select menu.
+        """
+        conf = self._get_conf()
+        conf["enabled"] = not conf["enabled"]
+        await self._save_conf(conf)
+        await ctx.send(f"Thread-creation menu is now {'enabled' if conf['enabled'] else 'disabled'}.")
+
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu.command(name="show")
+    async def threadmenu_show(self, ctx):
+        """Show all current main-menu options.
+
+        Lists every option (label + description) configured in the root
+        (non-submenu) select menu so you can review what users will see.
+        """
+        conf = self._get_conf()
+        if not conf["options"]:
+            return await ctx.send("There are no options in the main menu.")
+        embed = discord.Embed(title="Main menu", color=discord.Color.blurple())
+        for v in conf["options"].values():
+            embed.add_field(name=v["label"], value=v["description"], inline=False)
+        await ctx.send(embed=embed)
+
+    # ----- options -----
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu.group(name="option", invoke_without_command=True)
+    async def threadmenu_option(self, ctx):
+        """Manage main-menu options (add/remove/edit/show).
+
+        Use subcommands:
+        - add: interactive wizard to create an option
+        - remove <label>: delete an option
+        - edit <label>: interactively modify an option
+        - show <label>: display full details (type, command/submenu, emoji)
+        """
+        await ctx.send_help(ctx.command)
+
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu_option.command(name="show")
+    async def threadmenu_option_show(self, ctx, *, label: str):
+        """Show detailed information about a main-menu option."""
+        conf = self._get_conf()
+        key = label.lower().replace(" ", "_")
+        if key not in conf["options"]:
+            return await ctx.send("That label does not exist.")
+        v = conf["options"][key]
+        embed = discord.Embed(title=v["label"], color=discord.Color.blurple())
+        embed.add_field(name="Description", value=v["description"], inline=False)
+        embed.add_field(name="Emoji", value=v["emoji"], inline=False)
+        embed.add_field(name="Type", value=v["type"], inline=False)
+        embed.add_field(
+            name=("Command" if v["type"] == "command" else "Submenu"), value=v["callback"], inline=False
+        )
+        # Show category if set
+        cat_id = v.get("category_id")
+        if cat_id:
+            guild = self.bot.modmail_guild or ctx.guild
+            category = guild and guild.get_channel(cat_id)
+            cat_name = getattr(category, "name", "Unknown/Deleted")
+            embed.add_field(name="Category", value=f"{cat_name} (ID: {cat_id})", inline=False)
+        else:
+            embed.add_field(name="Category", value="Default (main category)", inline=False)
+        await ctx.send(embed=embed)
+
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu_option.command(name="add")
+    async def threadmenu_option_add(self, ctx):
+        """Interactive wizard to add a main-menu option."""
+        conf = self._get_conf()
+
+        def check(m):
+            return m.author == ctx.author and m.channel == ctx.channel
+
+        def typecheck(m):
+            return (
+                m.author == ctx.author
+                and m.channel == ctx.channel
+                and m.content.lower()
+                in [
+                    "command",
+                    "submenu",
+                ]
+            )
+
+        if len(conf["options"]) >= 25:
+            return await ctx.send("You can only have a maximum of 25 options due to discord limitations.")
+
+        await ctx.send(
+            "You can type `skip` for non-required steps or `cancel` to cancel the process at any time."
+        )
+        await ctx.send("What is the label of the option?")
+        label = (await self.bot.wait_for("message", check=check)).content
+        sanitized_label = label.lower().replace(" ", "_")
+
+        if label.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+
+        if sanitized_label in conf["options"]:
+            await ctx.send("That option already exists. Use `threadmenu edit` to edit it.")
+            return
+
+        await ctx.send("What is the description of the option? (not required)")
+        description = (await self.bot.wait_for("message", check=check)).content
+
+        if description.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+
+        if len(description) > 100:
+            return await ctx.send(
+                "The description must be less than 100 characters due to discord limitations."
+            )
+
+        if description.lower() == "skip":
+            description = None
+
+        await ctx.send("What is the emoji of the option? (not required)")
+        emoji = (await self.bot.wait_for("message", check=check)).content
+
+        if emoji.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+
+        if emoji.lower() == "skip":
+            emoji = None
+
+        await ctx.send("What is the type of the option? (command/submenu)")
+        type_ = (await self.bot.wait_for("message", check=typecheck)).content.lower()
+
+        if type_ == "cancel":
+            return await ctx.send("Cancelled.")
+
+        if type_ == "command":
+            await ctx.send("What is the command to run for the option?")
+        else:
+            await ctx.send("What is the label of the submenu for the option?")
+        callback = (await self.bot.wait_for("message", check=check)).content
+        if type_ != "command":
+            callback = callback.lower().replace(" ", "_")
+
+        if callback.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+
+        if type_ == "submenu" and callback not in conf["submenus"]:
+            return await ctx.send("That submenu does not exist. Use `threadmenu submenu create` to add it.")
+
+        # Optional: category where the thread should be created when this option is chosen
+        await ctx.send(
+            "Optionally provide a category for threads created via this option (mention, ID, or name).\n"
+            "Type `default` to use the main category."
+        )
+        category_msg = await self.bot.wait_for("message", check=check)
+        category_raw = category_msg.content.strip()
+        category_id: int | None = None
+        if category_raw.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+        if category_raw.lower() not in {"", "default", "none", "skip"}:
+            guild = self.bot.modmail_guild or ctx.guild
+            resolved = None
+            try:
+                # Try ID
+                if category_raw.isdigit():
+                    resolved = guild.get_channel(int(category_raw)) if guild else None
+                # Try mention <#id> is not valid for categories; fall back to name search
+                if not resolved and guild:
+                    resolved = discord.utils.find(
+                        lambda c: isinstance(c, discord.CategoryChannel)
+                        and c.name.lower() == category_raw.lower(),
+                        guild.categories,
+                    )
+            except Exception:
+                resolved = None
+            if isinstance(resolved, discord.CategoryChannel):
+                category_id = resolved.id
+            else:
+                await ctx.send(
+                    "Couldn't resolve that category. I'll default to the main category for this option."
+                )
+
+        conf["options"][sanitized_label] = {
+            "label": label,
+            "description": description,
+            "emoji": emoji,
+            "type": type_,
+            "callback": callback,
+            "category_id": category_id,
+        }
+        await self._save_conf(conf)
+        await ctx.send("Option added.")
+
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu_option.command(name="remove")
+    async def threadmenu_option_remove(self, ctx, *, label: str):
+        """Remove a main-menu option by label."""
+        conf = self._get_conf()
+        key = label.lower().replace(" ", "_")
+        if key not in conf["options"]:
+            return await ctx.send("That option does not exist.")
+        del conf["options"][key]
+        await self._save_conf(conf)
+        await ctx.send("Option removed.")
+
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu_option.command(name="edit")
+    async def threadmenu_option_edit(self, ctx, *, label: str):
+        """Interactive wizard to edit a main-menu option."""
+        conf = self._get_conf()
+        key = label.lower().replace(" ", "_")
+        if key not in conf["options"]:
+            return await ctx.send("That option does not exist.")
+
+        def check(m):
+            return m.author == ctx.author and m.channel == ctx.channel
+
+        def typecheck(m):
+            return (
+                m.author == ctx.author
+                and m.channel == ctx.channel
+                and m.content.lower()
+                in [
+                    "command",
+                    "submenu",
+                ]
+            )
+
+        await ctx.send(
+            "You can type `skip` for non-required steps (uses previous value) or `cancel` to cancel the process at any time."
+            "Use `none` to clear the value for non-required steps."
+        )
+        await ctx.send("What is the new description of the option? (not required)")
+        description = (await self.bot.wait_for("message", check=check)).content
+        if description.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+
+        old_description = conf["options"][key]["description"]
+
+        if description.lower() == "skip":
+            description = old_description
+        elif description.lower() == "none":
+            description = None
+        else:
+            if len(description) > 100:
+                return await ctx.send(
+                    "The description must be less than 100 characters due to discord limitations."
+                )
+
+        await ctx.send("What is the new emoji of the option?")
+        emoji = (await self.bot.wait_for("message", check=check)).content
+        if emoji.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+
+        old_emoji = conf["options"][key].get("emoji")
+
+        if emoji.lower() == "skip":
+            emoji = old_emoji
+        elif emoji.lower() == "none":
+            emoji = None
+
+        await ctx.send("What is the new type of the option? (command/submenu)")
+        type_ = (await self.bot.wait_for("message", check=typecheck)).content.lower()
+        if type_ == "cancel":
+            return await ctx.send("Cancelled.")
+
+        if type_ == "command":
+            await ctx.send("What is the new command to run for the option?")
+        else:
+            await ctx.send("What is the new label of the new submenu for the option?")
+        callback = (await self.bot.wait_for("message", check=check)).content
+        if type_ != "command":
+            callback = callback.lower().replace(" ", "_")
+        if callback.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+        if type_ == "submenu" and callback not in conf["submenus"]:
+            return await ctx.send("That submenu does not exist. Use `threadmenu submenu create` to add it.")
+
+        # Category edit (optional)
+        await ctx.send(
+            "Optionally provide a new category for this option (mention, ID, or name).\n"
+            "Send `skip` to keep current setting; send `default` or `none` to clear."
+        )
+        cat_msg = await self.bot.wait_for("message", check=check)
+        cat_raw = cat_msg.content.strip()
+        if cat_raw.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+
+        current = conf["options"][key].get("category_id")
+        new_category_id = current
+        if cat_raw.lower() in {"default", "none"}:
+            new_category_id = None
+        elif cat_raw.lower() in {"", "skip"}:
+            new_category_id = current
+        else:
+            guild = self.bot.modmail_guild or ctx.guild
+            resolved = None
+            try:
+                if cat_raw.isdigit():
+                    resolved = guild.get_channel(int(cat_raw)) if guild else None
+                if not resolved and guild:
+                    resolved = discord.utils.find(
+                        lambda c: isinstance(c, discord.CategoryChannel)
+                        and c.name.lower() == cat_raw.lower(),
+                        guild.categories,
+                    )
+            except Exception:
+                resolved = None
+            if isinstance(resolved, discord.CategoryChannel):
+                new_category_id = resolved.id
+            else:
+                await ctx.send("Couldn't resolve that category. Keeping previous setting.")
+
+        old_label = conf["options"][key]["label"]
+        new_description = None
+        if description.lower() == "skip":
+            new_description = conf["options"][key]["description"]
+        conf["options"][key] = {
+            "label": old_label,
+            "description": description,
+            "emoji": emoji,
+            "type": type_,
+            "callback": callback,
+            "category_id": new_category_id,
+        }
+        await self._save_conf(conf)
+        await ctx.send("Option edited.")
+
+    # ----- submenus -----
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu.group(name="submenu", invoke_without_command=True)
+    async def threadmenu_submenu(self, ctx):
+        """Manage submenus (create/delete/list/show and options within).
+
+        Submenus let you branch the initial select menu into additional
+        categorized option groups. Use `submenu option` subcommands to
+        manage the nested options.
+        """
+        await ctx.send_help(ctx.command)
+
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu_submenu.command(name="create")
+    async def threadmenu_submenu_create(self, ctx, *, label: str):
+        """Create an empty submenu that can hold nested options."""
+        conf = self._get_conf()
+        key = label.lower().replace(" ", "_")
+        if key in conf["submenus"]:
+            return await ctx.send(
+                "That submenu already exists. Please use a unique label or use `threadmenu submenu delete` to delete it."
+            )
+        conf["submenus"][key] = {}
+        await self._save_conf(conf)
+        await ctx.send("Submenu created.")
+
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu_submenu.command(name="delete")
+    async def threadmenu_submenu_delete(self, ctx, *, label: str):
+        """Delete a submenu and all its options."""
+        conf = self._get_conf()
+        key = label.lower().replace(" ", "_")
+        if key not in conf["submenus"]:
+            return await ctx.send("That submenu does not exist.")
+        del conf["submenus"][key]
+        await self._save_conf(conf)
+        await ctx.send("Submenu deleted.")
+
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu_submenu.command(name="list")
+    async def threadmenu_submenu_list(self, ctx):
+        """List all submenu keys currently configured."""
+        conf = self._get_conf()
+        if not conf["submenus"]:
+            return await ctx.send("There are no submenus.")
+        submenu_list = "Submenus:\n" + ("\n".join(conf["submenus"].keys()))
+        if len(submenu_list) > 2000:
+            submenu_list = submenu_list[:1997] + "..."
+        await ctx.send(submenu_list)
+
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu_submenu.command(name="show")
+    async def threadmenu_submenu_show(self, ctx, *, label: str):
+        """Show the options configured inside a submenu."""
+        conf = self._get_conf()
+        key = label.lower().replace(" ", "_")
+        if key not in conf["submenus"]:
+            return await ctx.send("That submenu does not exist. Use `threadmenu submenu create` to add it.")
+        if not conf["submenus"][key]:
+            return await ctx.send(f"There are no options in {key}")
+        embed = discord.Embed(title=key, color=discord.Color.blurple())
+        for v in conf["submenus"][key].values():
+            embed.add_field(name=v["label"], value=v["description"], inline=False)
+        await ctx.send(embed=embed)
+
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu_submenu.group(name="option", invoke_without_command=True)
+    async def threadmenu_submenu_option(self, ctx):
+        """Manage options within a specific submenu (add/remove/edit)."""
+        await ctx.send_help(ctx.command)
+
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu_submenu_option.command(name="add")
+    async def threadmenu_submenu_option_add(self, ctx, *, submenu: str):
+        """Interactive wizard to add an option inside a submenu."""
+        conf = self._get_conf()
+        submenu = submenu.lower().replace(" ", "_")
+        if submenu not in conf["submenus"]:
+            return await ctx.send("That submenu does not exist.")
+
+        def check(m):
+            return m.author == ctx.author and m.channel == ctx.channel
+
+        def typecheck(m):
+            return (
+                m.author == ctx.author
+                and m.channel == ctx.channel
+                and m.content.lower()
+                in [
+                    "command",
+                    "submenu",
+                ]
+            )
+
+        if len(conf["submenus"][submenu]) >= 24:
+            return await ctx.send("You can only have a maximum of 24 options due to discord limitations.")
+
+        await ctx.send(
+            "You can type `skip` for non-required steps or `cancel` to cancel the process at any time."
+        )
+        await ctx.send("What is the label of the option?")
+        label = (await self.bot.wait_for("message", check=check)).content
+        sanitized_label = label.lower().replace(" ", "_")
+
+        if label.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+        if label.lower() == "main menu":
+            return await ctx.send("You cannot use that label.")
+        if sanitized_label in conf["submenus"][submenu]:
+            await ctx.send("That option already exists. Use `threadmenu submenu edit` to edit it.")
+            return
+
+        await ctx.send("What is the description of the option? (not required)")
+        description = (await self.bot.wait_for("message", check=check)).content
+        if description.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+        if len(description) > 100:
+            return await ctx.send(
+                "The description must be less than 100 characters due to discord limitations."
+            )
+
+        if description.lower() == "skip":
+            description = None
+
+        await ctx.send("What is the emoji of the option? (not required)")
+        emoji = (await self.bot.wait_for("message", check=check)).content
+        if emoji.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+
+        if emoji.lower() == "skip":
+            emoji = None
+
+        await ctx.send("What is the type for the option? (command/submenu)")
+        type_ = (await self.bot.wait_for("message", check=typecheck)).content.lower()
+        if type_ == "cancel":
+            return await ctx.send("Cancelled.")
+
+        if type_ == "command":
+            await ctx.send("What is the command to run for the option?")
+        else:
+            await ctx.send("What is the label of the submenu for the option?")
+        callback = (await self.bot.wait_for("message", check=check)).content
+        if type_ != "command":
+            callback = callback.lower().replace(" ", "_")
+        if type_ == "submenu" and callback not in conf["submenus"]:
+            return await ctx.send("That submenu does not exist. Use `threadmenu submenu create` to add it.")
+
+        # Optional category for submenu option
+        await ctx.send(
+            "Optionally provide a category for threads created via this submenu option (mention, ID, or name).\n"
+            "Type `default` to use the main category."
+        )
+        category_msg = await self.bot.wait_for("message", check=check)
+        category_raw = category_msg.content.strip()
+        category_id: int | None = None
+        if category_raw.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+        if category_raw.lower() not in {"", "default", "none", "skip"}:
+            guild = self.bot.modmail_guild or ctx.guild
+            resolved = None
+            try:
+                if category_raw.isdigit():
+                    resolved = guild.get_channel(int(category_raw)) if guild else None
+                if not resolved and guild:
+                    resolved = discord.utils.find(
+                        lambda c: isinstance(c, discord.CategoryChannel)
+                        and c.name.lower() == category_raw.lower(),
+                        guild.categories,
+                    )
+            except Exception:
+                resolved = None
+            if isinstance(resolved, discord.CategoryChannel):
+                category_id = resolved.id
+            else:
+                await ctx.send(
+                    "Couldn't resolve that category. I'll default to the main category for this submenu option."
+                )
+
+        conf["submenus"][submenu][sanitized_label] = {
+            "label": label,
+            "description": description,
+            "emoji": emoji,
+            "type": type_,
+            "callback": callback,
+            "category_id": category_id,
+        }
+        await self._save_conf(conf)
+        await ctx.send("Option added.")
+
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu_submenu_option.command(name="remove")
+    async def threadmenu_submenu_option_remove(self, ctx, *, submenu: str):
+        """Remove an option from a submenu via an interactive prompt."""
+        conf = self._get_conf()
+        submenu = submenu.lower().replace(" ", "_")
+        if submenu not in conf["submenus"]:
+            return await ctx.send("That submenu does not exist.")
+
+        def check(m):
+            return m.author == ctx.author and m.channel == ctx.channel
+
+        await ctx.send("You can send `cancel` at any time to cancel the process.")
+        await ctx.send("What is the label of the option to remove?")
+        label = (await self.bot.wait_for("message", check=check)).content
+        key = label.lower().replace(" ", "_")
+        if label.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+        if key not in conf["submenus"][submenu]:
+            return await ctx.send("That option does not exist.")
+
+        del conf["submenus"][submenu][key]
+        await self._save_conf(conf)
+        await ctx.send("Option removed.")
+
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu_submenu_option.command(name="edit")
+    async def threadmenu_submenu_option_edit(self, ctx, *, submenu: str):
+        """Interactive wizard to edit a submenu option."""
+        conf = self._get_conf()
+        submenu = submenu.lower().replace(" ", "_")
+        if submenu not in conf["submenus"]:
+            return await ctx.send("That submenu does not exist. Use `threadmenu submenu create` to add it.")
+
+        def check(m):
+            return m.author == ctx.author and m.channel == ctx.channel
+
+        def typecheck(m):
+            return (
+                m.author == ctx.author
+                and m.channel == ctx.channel
+                and m.content.lower()
+                in [
+                    "command",
+                    "submenu",
+                ]
+            )
+
+        await ctx.send(
+            "You can type `skip` for non-required steps (uses previous value) or `cancel` to cancel the process at any time."
+            "Use `none` to clear the value for non-required steps."
+        )
+        await ctx.send("What is the label of the option to edit?")
+        label = (await self.bot.wait_for("message", check=check)).content
+        key = label.lower().replace(" ", "_")
+        if label.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+        if key not in conf["submenus"][submenu]:
+            return await ctx.send("That label does not exist.")
+
+        await ctx.send("What is the new description of the option? (not required)")
+        description = (await self.bot.wait_for("message", check=check)).content
+        if description.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+
+        old_description = conf["options"][key]["description"]
+
+        if description.lower() == "skip":
+            description = old_description
+        elif description.lower() == "none":
+            description = None
+        else:
+            if len(description) > 100:
+                return await ctx.send(
+                    "The description must be less than 100 characters due to discord limitations."
+                )
+
+        await ctx.send("What is the new emoji of the option? (not required)")
+        emoji = (await self.bot.wait_for("message", check=check)).content
+        if emoji.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+
+        old_emoji = conf["options"][key].get("emoji")
+
+        if emoji.lower() == "skip":
+            emoji = old_emoji
+        elif emoji.lower() == "none":
+            emoji = None
+
+        await ctx.send("What is the new type for the option? (command/submenu)")
+        type_ = (await self.bot.wait_for("message", check=typecheck)).content.lower()
+        if type_ == "cancel":
+            return await ctx.send("Cancelled.")
+
+        if type_ == "command":
+            await ctx.send("What is the command to run for the option?")
+        else:
+            await ctx.send("What is the label of the submenu for the option?")
+        callback = (await self.bot.wait_for("message", check=check)).content
+        if type_ != "command":
+            callback = callback.lower().replace(" ", "_")
+        if callback.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+        if type_ == "submenu" and callback not in conf["submenus"]:
+            return await ctx.send("That submenu does not exist.")
+
+        # Category edit (optional)
+        await ctx.send(
+            "Optionally provide a new category for this submenu option (mention, ID, or name).\n"
+            "Send `skip` to keep current setting; send `default` or `none` to clear."
+        )
+        cat_msg = await self.bot.wait_for("message", check=check)
+        cat_raw = cat_msg.content.strip()
+        if cat_raw.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+        current = conf["submenus"][submenu][key].get("category_id")
+        new_category_id = current
+        if cat_raw.lower() in {"default", "none"}:
+            new_category_id = None
+        elif cat_raw.lower() in {"", "skip"}:
+            new_category_id = current
+        else:
+            guild = self.bot.modmail_guild or ctx.guild
+            resolved = None
+            try:
+                if cat_raw.isdigit():
+                    resolved = guild.get_channel(int(cat_raw)) if guild else None
+                if not resolved and guild:
+                    resolved = discord.utils.find(
+                        lambda c: isinstance(c, discord.CategoryChannel)
+                        and c.name.lower() == cat_raw.lower(),
+                        guild.categories,
+                    )
+            except Exception:
+                resolved = None
+            if isinstance(resolved, discord.CategoryChannel):
+                new_category_id = resolved.id
+            else:
+                await ctx.send("Couldn't resolve that category. Keeping previous setting.")
+
+        conf["submenus"][submenu][key]["description"] = description
+        conf["submenus"][submenu][key]["emoji"] = emoji
+        conf["submenus"][submenu][key]["type"] = type_
+        conf["submenus"][submenu][key]["callback"] = callback
+        conf["submenus"][submenu][key]["category_id"] = new_category_id
+        await self._save_conf(conf)
+        await ctx.send("Option edited.")
+
+    # ----- import/export -----
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu.command(name="dump_config")
+    async def threadmenu_dump_config(self, ctx):
+        """Dump the current core thread menu config to a file."""
+        conf = self._get_conf()
+        with open("thread_creation_menu_config.json", "w", encoding="utf-8") as f:
+            json.dump(conf, f, indent=4)
+        await ctx.send(file=discord.File("thread_creation_menu_config.json"))
+
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu.command(name="reset")
+    async def threadmenu_reset(self, ctx):
+        """Reset ALL thread-creation menu settings to their defaults.
+
+        This clears options and submenus and restores every key starting with
+        `thread_creation_menu_` back to the default values. Confirmation required.
+        This action is irreversible.
+        """
+        warning = (
+            "This will clear ALL thread menu options, submenus, and related settings and restore defaults.\n"
+            "This action is irreversible. Type `confirm` within 30 seconds to proceed, or anything else to cancel."
+        )
+        await ctx.send(warning)
+
+        def check(m: discord.Message) -> bool:
+            return m.author == ctx.author and m.channel == ctx.channel
+
+        try:
+            reply = await self.bot.wait_for("message", check=check, timeout=30)
+        except asyncio.TimeoutError:
+            return await ctx.send("Timed out — reset cancelled.")
+
+        if reply.content.strip().lower() != "confirm":
+            return await ctx.send("Reset cancelled.")
+
+        # Reset all `thread_creation_menu_` keys to defaults
+        defaults = getattr(self.bot.config, "defaults", {})
+        keys = [k for k in defaults.keys() if k.startswith("thread_creation_menu_")]
+
+        # Ensure we handle mappings without unwanted conversion
+        for k in keys:
+            v = defaults[k]
+            if k in {"thread_creation_menu_options", "thread_creation_menu_submenus"}:
+                await self.bot.config.set(k, v, convert=False)
+            else:
+                await self.bot.config.set(k, v)
+
+        # Also disable the menu explicitly for clarity
+        await self.bot.config.set("thread_creation_menu_enabled", False)
+        await self.bot.config.update()
+
+        await ctx.send(
+            f"Thread-creation menu configuration has been reset to defaults (reset {len(keys)} keys)."
+        )
+
+    @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
+    @threadmenu.command(name="load_config")
+    async def threadmenu_load_config(self, ctx):
+        """Load the thread menu config from an attached file."""
+        if not ctx.message.attachments:
+            return await ctx.send("You must attach a json file to load the config from.")
+        b = await ctx.message.attachments[0].read()
+        json_data = b.decode("utf-8")
+        try:
+            data = json.loads(json_data)
+        except json.decoder.JSONDecodeError:
+            return await ctx.send("Invalid json file.")
+
+        # minimal validation
+        required = {
+            "enabled",
+            "options",
+            "submenus",
+            "timeout",
+            "close_on_timeout",
+            "anonymous_menu",
+            "embed_text",
+            "dropdown_placeholder",
+        }
+        if not required.issubset(set(data.keys())):
+            return await ctx.send("Config file missing required keys.")
+
+        await self._save_conf(data)
+        await ctx.send("Successfully loaded config into core.")
+
+
+async def setup(bot):
+    await bot.add_cog(ThreadCreationMenuCore(bot))
diff --git a/cogs/utility.py b/cogs/utility.py
index aa6c6881e9..a138ea588f 100644
--- a/cogs/utility.py
+++ b/cogs/utility.py
@@ -1,4 +1,4 @@
-from core.utils import trigger_typing, truncate, safe_typing
+from core.utils import trigger_typing, truncate
 import asyncio
 import inspect
 import os
@@ -13,6 +13,7 @@
 from subprocess import PIPE
 from textwrap import indent
 from typing import Union
+import typing
 
 import discord
 from discord.enums import ActivityType, Status
@@ -31,7 +32,7 @@
     UnseenFormatter,
     getLogger,
 )
-from core.utils import trigger_typing, truncate, DummyParam
+from core.utils import DummyParam
 from core.paginator import EmbedPaginatorSession, MessagePaginatorSession
 
 
@@ -68,7 +69,9 @@ async def format_cog_help(self, cog, *, no_cog=False):
             else:
                 format_ = f"`[{perm_level}] {prefix + cmd.qualified_name}` "
 
-            format_ += f"- {cmd.short_doc}\n" if cmd.short_doc else "- *No description.*\n"
+            format_ += (
+                f"- {cmd.short_doc}\n" if cmd.short_doc else "- *No description.*\n"
+            )
             if not format_.strip():
                 continue
             if len(format_) + len(formats[-1]) >= 1024:
@@ -90,9 +93,16 @@ async def format_cog_help(self, cog, *, no_cog=False):
 
             embed.add_field(name="Commands", value=format_ or "No commands.")
 
-            name = cog.qualified_name + " - Help" if not no_cog else "Miscellaneous Commands"
+            name = (
+                cog.qualified_name + " - Help"
+                if not no_cog
+                else "Miscellaneous Commands"
+            )
             embed.set_author(
-                name=name, icon_url=bot.user.display_avatar.url if bot.user.display_avatar else None
+                name=name,
+                icon_url=bot.user.display_avatar.url
+                if bot.user.display_avatar
+                else None,
             )
 
             embed.set_footer(
@@ -103,12 +113,18 @@ async def format_cog_help(self, cog, *, no_cog=False):
 
         if len(embeds) > 1:
             for n, em in enumerate(embeds):
-                em.set_author(name=f"{em.author.name} [{n + 1}]", icon_url=em.author.icon_url)
+                em.set_author(
+                    name=f"{em.author.name} [{n + 1}]", icon_url=em.author.icon_url
+                )
 
         return embeds
 
     def process_help_msg(self, help_: str):
-        return help_.format(prefix=self.context.clean_prefix) if help_ else "No help message."
+        return (
+            help_.format(prefix=self.context.clean_prefix)
+            if help_
+            else "No help message."
+        )
 
     async def send_bot_help(self, mapping):
         embeds = []
@@ -118,7 +134,11 @@ async def send_bot_help(self, mapping):
         bot = self.context.bot
 
         # always come first
-        default_cogs = [bot.get_cog("Modmail"), bot.get_cog("Utility"), bot.get_cog("Plugins")]
+        default_cogs = [
+            bot.get_cog("Modmail"),
+            bot.get_cog("Utility"),
+            bot.get_cog("Plugins"),
+        ]
 
         default_cogs.extend(c for c in cogs if c not in default_cogs)
 
@@ -127,12 +147,16 @@ async def send_bot_help(self, mapping):
         if no_cog_commands:
             embeds.extend(await self.format_cog_help(no_cog_commands, no_cog=True))
 
-        session = EmbedPaginatorSession(self.context, *embeds, destination=self.get_destination())
+        session = EmbedPaginatorSession(
+            self.context, *embeds, destination=self.get_destination()
+        )
         return await session.run()
 
     async def send_cog_help(self, cog):
         embeds = await self.format_cog_help(cog)
-        session = EmbedPaginatorSession(self.context, *embeds, destination=self.get_destination())
+        session = EmbedPaginatorSession(
+            self.context, *embeds, destination=self.get_destination()
+        )
         return await session.run()
 
     async def _get_help_embed(self, topic):
@@ -190,7 +214,9 @@ async def send_error_message(self, error):
         command = self.context.kwargs.get("command")
         val = self.context.bot.snippets.get(command)
         if val is not None:
-            embed = discord.Embed(title=f"{command} is a snippet.", color=self.context.bot.main_color)
+            embed = discord.Embed(
+                title=f"{command} is a snippet.", color=self.context.bot.main_color
+            )
             embed.add_field(name=f"`{command}` will send:", value=val, inline=False)
 
             snippet_aliases = []
@@ -200,7 +226,9 @@ async def send_error_message(self, error):
 
             if snippet_aliases:
                 embed.add_field(
-                    name="Aliases to this snippet:", value=",".join(snippet_aliases), inline=False
+                    name="Aliases to this snippet:",
+                    value=",".join(snippet_aliases),
+                    inline=False,
                 )
 
             return await self.get_destination().send(embed=embed)
@@ -221,7 +249,10 @@ async def send_error_message(self, error):
                 await self.context.bot.config.update()
             else:
                 if len(values) == 1:
-                    embed = discord.Embed(title=f"{command} is an alias.", color=self.context.bot.main_color)
+                    embed = discord.Embed(
+                        title=f"{command} is an alias.",
+                        color=self.context.bot.main_color,
+                    )
                     embed.add_field(name=f"`{command}` points to:", value=values[0])
                 else:
                     embed = discord.Embed(
@@ -251,7 +282,9 @@ async def send_error_message(self, error):
 
         closest = get_close_matches(command, choices)
         if closest:
-            embed.add_field(name="Perhaps you meant:", value="\n".join(f"`{x}`" for x in closest))
+            embed.add_field(
+                name="Perhaps you meant:", value="\n".join(f"`{x}`" for x in closest)
+            )
         else:
             embed.title = "Cannot find command or category"
             embed.set_footer(
@@ -322,13 +355,21 @@ async def changelog(self, ctx, version: str.lower = ""):
     @utils.trigger_typing
     async def about(self, ctx):
         """Shows information about this bot."""
-        embed = discord.Embed(color=self.bot.main_color, timestamp=discord.utils.utcnow())
+        embed = discord.Embed(
+            color=self.bot.main_color, timestamp=discord.utils.utcnow()
+        )
         embed.set_author(
             name="Modmail - About",
-            icon_url=self.bot.user.display_avatar.url if self.bot.user.display_avatar else None,
+            icon_url=self.bot.user.display_avatar.url
+            if self.bot.user.display_avatar
+            else None,
             url="https://discord.gg/F34cRU8",
         )
-        embed.set_thumbnail(url=self.bot.user.display_avatar.url if self.bot.user.display_avatar else None)
+        embed.set_thumbnail(
+            url=self.bot.user.display_avatar.url
+            if self.bot.user.display_avatar
+            else None
+        )
 
         desc = "This is an open source Discord bot that serves as a means for "
         desc += "members to easily communicate with server administrators in "
@@ -345,7 +386,11 @@ async def about(self, ctx):
         latest = changelog.latest_version
 
         if self.bot.version.is_prerelease:
-            stable = next(filter(lambda v: not Version(v.version).is_prerelease, changelog.versions))
+            stable = next(
+                filter(
+                    lambda v: not Version(v.version).is_prerelease, changelog.versions
+                )
+            )
             footer = f"You are on the prerelease version • the latest version is v{stable.version}."
         elif self.bot.version < Version(latest.version):
             footer = f"A newer version is available v{latest.version}."
@@ -457,7 +502,9 @@ async def debug_hastebin(self, ctx):
             logs = BytesIO(f.read().strip())
 
         try:
-            async with self.bot.session.post(haste_url + "/documents", data=logs) as resp:
+            async with self.bot.session.post(
+                haste_url + "/documents", data=logs
+            ) as resp:
                 data = await resp.json()
                 try:
                     key = data["key"]
@@ -487,7 +534,9 @@ async def debug_clear(self, ctx):
         with open(self.bot.log_file_path, "w"):
             pass
         await ctx.send(
-            embed=discord.Embed(color=self.bot.main_color, description="Cached logs are now cleared.")
+            embed=discord.Embed(
+                color=self.bot.main_color, description="Cached logs are now cleared."
+            )
         )
 
     @commands.command(aliases=["presence"])
@@ -536,7 +585,9 @@ async def activity(self, ctx, activity_type: str.lower, *, message: str = ""):
         except KeyError:
             raise commands.MissingRequiredArgument(DummyParam("activity"))
 
-        activity, _ = await self.set_presence(activity_type=activity_type, activity_message=message)
+        activity, _ = await self.set_presence(
+            activity_type=activity_type, activity_message=message
+        )
 
         self.bot.config["activity_type"] = activity.type.value
         self.bot.config["activity_message"] = activity.name
@@ -550,7 +601,9 @@ async def activity(self, ctx, activity_type: str.lower, *, message: str = ""):
         else:
             msg += f"{activity.name}."
 
-        embed = discord.Embed(title="Activity Changed", description=msg, color=self.bot.main_color)
+        embed = discord.Embed(
+            title="Activity Changed", description=msg, color=self.bot.main_color
+        )
         return await ctx.send(embed=embed)
 
     @commands.command()
@@ -587,10 +640,14 @@ async def status(self, ctx, *, status_type: str.lower):
         await self.bot.config.update()
 
         msg = f"Status set to: {status.value}."
-        embed = discord.Embed(title="Status Changed", description=msg, color=self.bot.main_color)
+        embed = discord.Embed(
+            title="Status Changed", description=msg, color=self.bot.main_color
+        )
         return await ctx.send(embed=embed)
 
-    async def set_presence(self, *, status=None, activity_type=None, activity_message=None):
+    async def set_presence(
+        self, *, status=None, activity_type=None, activity_message=None
+    ):
         if status is None:
             status = self.bot.config.get("status")
 
@@ -598,9 +655,13 @@ async def set_presence(self, *, status=None, activity_type=None, activity_messag
             activity_type = self.bot.config.get("activity_type")
 
         url = None
-        activity_message = (activity_message or self.bot.config["activity_message"]).strip()
+        activity_message = (
+            activity_message or self.bot.config["activity_message"]
+        ).strip()
         if activity_type is not None and not activity_message:
-            logger.warning('No activity message found whilst activity is provided, defaults to "Modmail".')
+            logger.warning(
+                'No activity message found whilst activity is provided, defaults to "Modmail".'
+            )
             activity_message = "Modmail"
 
         if activity_type == ActivityType.listening:
@@ -619,7 +680,9 @@ async def set_presence(self, *, status=None, activity_type=None, activity_messag
         if activity_type == ActivityType.custom:
             activity = discord.CustomActivity(name=activity_message)
         elif activity_type is not None:
-            activity = discord.Activity(type=activity_type, name=activity_message, url=url)
+            activity = discord.Activity(
+                type=activity_type, name=activity_message, url=url
+            )
         else:
             activity = None
         await self.bot.change_presence(activity=activity, status=status)
@@ -670,7 +733,9 @@ async def ping(self, ctx):
 
     @commands.command()
     @checks.has_permissions(PermissionLevel.ADMINISTRATOR)
-    async def mention(self, ctx, *user_or_role: Union[discord.Role, discord.Member, str]):
+    async def mention(
+        self, ctx, *user_or_role: Union[discord.Role, discord.Member, str]
+    ):
         """
         Change what the bot mentions at the start of each thread.
 
@@ -693,7 +758,9 @@ async def mention(self, ctx, *user_or_role: Union[discord.Role, discord.Member,
         current = self.bot.config["mention"]
         if not user_or_role:
             embed = discord.Embed(
-                title="Current mention:", color=self.bot.main_color, description=str(current)
+                title="Current mention:",
+                color=self.bot.main_color,
+                description=str(current),
             )
         elif (
             len(user_or_role) == 1
@@ -718,7 +785,10 @@ async def mention(self, ctx, *user_or_role: Union[discord.Role, discord.Member,
             mention = []
             everyone = ("all", "everyone")
             for m in user_or_role:
-                if not isinstance(m, (discord.Role, discord.Member)) and m not in everyone:
+                if (
+                    not isinstance(m, (discord.Role, discord.Member))
+                    and m not in everyone
+                ):
                     raise commands.BadArgument(f'Role or Member "{m}" not found.')
                 elif m == ctx.guild.default_role or m in everyone:
                     mention.append("@everyone")
@@ -746,7 +816,9 @@ async def prefix(self, ctx, *, prefix=None):
         """
 
         current = self.bot.prefix
-        embed = discord.Embed(title="Current prefix", color=self.bot.main_color, description=f"{current}")
+        embed = discord.Embed(
+            title="Current prefix", color=self.bot.main_color, description=f"{current}"
+        )
 
         if prefix is None:
             await ctx.send(embed=embed)
@@ -783,7 +855,9 @@ async def config_options(self, ctx):
         """Return a list of valid configuration names you can change."""
         embeds = []
         for names in zip_longest(*(iter(sorted(self.bot.config.public_keys)),) * 15):
-            description = "\n".join(f"`{name}`" for name in takewhile(lambda x: x is not None, names))
+            description = "\n".join(
+                f"`{name}`" for name in takewhile(lambda x: x is not None, names)
+            )
             embed = discord.Embed(
                 title="Available configuration keys:",
                 color=self.bot.main_color,
@@ -810,14 +884,50 @@ async def config_set(self, ctx, key: str.lower, *, value: str):
                     color=self.bot.main_color,
                     description=f"Set `{key}` to `{self.bot.config[key]}`.",
                 )
+                # If turning on move-based snoozing, remind to set snoozed_category_id
+                if key == "snooze_behavior":
+                    behavior = (
+                        str(self.bot.config.get("snooze_behavior", convert=False))
+                        .strip()
+                        .lower()
+                        .strip('"')
+                    )
+                    if behavior == "move":
+                        cat_id = self.bot.config.get(
+                            "snoozed_category_id", convert=False
+                        )
+                        valid = False
+                        if cat_id:
+                            try:
+                                cat_obj = self.bot.modmail_guild.get_channel(
+                                    int(str(cat_id))
+                                )
+                                valid = isinstance(cat_obj, discord.CategoryChannel)
+                            except Exception:
+                                valid = False
+                        if not valid:
+                            example = f"`{self.bot.prefix}config set snoozed_category_id <category_id>`"
+                            embed.add_field(
+                                name="Action required",
+                                value=(
+                                    "You set `snooze_behavior` to `move`. Please set `snoozed_category_id` "
+                                    "to the category where snoozed threads should be moved.\n"
+                                    f"For example: {example}"
+                                ),
+                                inline=False,
+                            )
             except InvalidConfigError as exc:
                 embed = exc.embed
         else:
             embed = discord.Embed(
-                title="Error", color=self.bot.error_color, description=f"{key} is an invalid key."
+                title="Error",
+                color=self.bot.error_color,
+                description=f"{key} is an invalid key.",
             )
             valid_keys = [f"`{k}`" for k in sorted(keys)]
-            embed.add_field(name="Valid keys", value=truncate(", ".join(valid_keys), 1024))
+            embed.add_field(
+                name="Valid keys", value=truncate(", ".join(valid_keys), 1024)
+            )
 
         return await ctx.send(embed=embed)
 
@@ -836,7 +946,9 @@ async def config_remove(self, ctx, *, key: str.lower):
             )
         else:
             embed = discord.Embed(
-                title="Error", color=self.bot.error_color, description=f"{key} is an invalid key."
+                title="Error",
+                color=self.bot.error_color,
+                description=f"{key} is an invalid key.",
             )
             valid_keys = [f"`{k}`" for k in sorted(keys)]
             embed.add_field(name="Valid keys", value=", ".join(valid_keys))
@@ -859,7 +971,9 @@ async def config_get(self, ctx, *, key: str.lower = None):
                 embed = discord.Embed(color=self.bot.main_color, description=desc)
                 embed.set_author(
                     name="Config variable",
-                    icon_url=self.bot.user.display_avatar.url if self.bot.user.display_avatar else None,
+                    icon_url=self.bot.user.display_avatar.url
+                    if self.bot.user.display_avatar
+                    else None,
                 )
 
             else:
@@ -873,21 +987,52 @@ async def config_get(self, ctx, *, key: str.lower = None):
                 )
 
         else:
-            embed = discord.Embed(
-                color=self.bot.main_color,
-                description="Here is a list of currently set configuration variable(s).",
-            )
-            embed.set_author(
-                name="Current config(s):",
-                icon_url=self.bot.user.display_avatar.url if self.bot.user.display_avatar else None,
+            # Build one or more embeds, each with up to 25 fields
+            base_desc = "Here is a list of currently set configuration variable(s)."
+            author_name = "Current config(s):"
+            icon = (
+                self.bot.user.display_avatar.url
+                if self.bot.user.display_avatar
+                else None
             )
-            config = self.bot.config.filter_default(self.bot.config)
 
-            for name, value in config.items():
-                if name in self.bot.config.public_keys:
-                    embed.add_field(name=name, value=f"`{value}`", inline=False)
+            config = self.bot.config.filter_default(self.bot.config)
+            items = [
+                (name, value)
+                for name, value in config.items()
+                if name in self.bot.config.public_keys
+            ]
 
-        return await ctx.send(embed=embed)
+            embeds: list[discord.Embed] = []
+            chunk: list[tuple[str, typing.Any]] = []
+            for pair in items:
+                chunk.append(pair)
+                if len(chunk) == 15:
+                    e = discord.Embed(color=self.bot.main_color, description=base_desc)
+                    e.set_author(name=author_name, icon_url=icon)
+                    for name, value in chunk:
+                        e.add_field(name=name, value=f"`{value}`", inline=False)
+                    embeds.append(e)
+                    chunk = []
+
+            if chunk:
+                e = discord.Embed(color=self.bot.main_color, description=base_desc)
+                e.set_author(name=author_name, icon_url=icon)
+                for name, value in chunk:
+                    e.add_field(name=name, value=f"`{value}`", inline=False)
+                embeds.append(e)
+
+        # Send one or many embeds depending on count.
+        # In the single-key branch above, variable 'embed' exists; in this multi branch, we only use 'embeds'.
+        if key:
+            return await ctx.send(embed=embed)
+        else:
+            if not embeds:
+                return await ctx.send("No public configuration keys are set.")
+            # Use the existing paginator consistently
+            paginator = EmbedPaginatorSession(ctx, *embeds)
+            await paginator.run()
+            return
 
     @config.command(name="help", aliases=["info"])
     @checks.has_permissions(PermissionLevel.OWNER)
@@ -907,7 +1052,10 @@ async def config_help(self, ctx, key: str.lower = None):
                 description=f"`{key}` is an invalid key.",
             )
             if closest:
-                embed.add_field(name="Perhaps you meant:", value="\n".join(f"`{x}`" for x in closest))
+                embed.add_field(
+                    name="Perhaps you meant:",
+                    value="\n".join(f"`{x}`" for x in closest),
+                )
             return await ctx.send(embed=embed)
 
         config_help = self.bot.config.config_help
@@ -930,7 +1078,9 @@ def fmt(val):
                 index = i
             embed = discord.Embed(title=f"{current_key}", color=self.bot.main_color)
             embed.add_field(name="Default:", value=fmt(info["default"]), inline=False)
-            embed.add_field(name="Information:", value=fmt(info["description"]), inline=False)
+            embed.add_field(
+                name="Information:", value=fmt(info["description"]), inline=False
+            )
             if info["examples"]:
                 example_text = ""
                 for example in info["examples"]:
@@ -979,7 +1129,9 @@ async def alias(self, ctx, *, name: str.lower = None):
         if name is not None:
             val = self.bot.aliases.get(name)
             if val is None:
-                embed = utils.create_not_found_embed(name, self.bot.aliases.keys(), "Alias")
+                embed = utils.create_not_found_embed(
+                    name, self.bot.aliases.keys(), "Alias"
+                )
                 return await ctx.send(embed=embed)
 
             values = utils.parse_alias(val)
@@ -991,14 +1143,18 @@ async def alias(self, ctx, *, name: str.lower = None):
                     description=f"Alias `{name}` is invalid, this alias will now be deleted."
                     "This alias will now be deleted.",
                 )
-                embed.add_field(name=f"{name}` used to be:", value=utils.truncate(val, 1024))
+                embed.add_field(
+                    name=f"{name}` used to be:", value=utils.truncate(val, 1024)
+                )
                 self.bot.aliases.pop(name)
                 await self.bot.config.update()
                 return await ctx.send(embed=embed)
 
             if len(values) == 1:
                 embed = discord.Embed(
-                    title=f'Alias - "{name}":', description=values[0], color=self.bot.main_color
+                    title=f'Alias - "{name}":',
+                    description=values[0],
+                    color=self.bot.main_color,
                 )
                 return await ctx.send(embed=embed)
 
@@ -1016,10 +1172,16 @@ async def alias(self, ctx, *, name: str.lower = None):
 
         if not self.bot.aliases:
             embed = discord.Embed(
-                color=self.bot.error_color, description="You dont have any aliases at the moment."
+                color=self.bot.error_color,
+                description="You dont have any aliases at the moment.",
+            )
+            embed.set_footer(
+                text=f'Do "{self.bot.prefix}help alias" for more commands.'
+            )
+            embed.set_author(
+                name="Aliases",
+                icon_url=self.bot.get_guild_icon(guild=ctx.guild, size=128),
             )
-            embed.set_footer(text=f'Do "{self.bot.prefix}help alias" for more commands.')
-            embed.set_author(name="Aliases", icon_url=self.bot.get_guild_icon(guild=ctx.guild, size=128))
             return await ctx.send(embed=embed)
 
         embeds = []
@@ -1028,7 +1190,8 @@ async def alias(self, ctx, *, name: str.lower = None):
             description = utils.format_description(i, names)
             embed = discord.Embed(color=self.bot.main_color, description=description)
             embed.set_author(
-                name="Command Aliases", icon_url=self.bot.get_guild_icon(guild=ctx.guild, size=128)
+                name="Command Aliases",
+                icon_url=self.bot.get_guild_icon(guild=ctx.guild, size=128),
             )
             embeds.append(embed)
 
@@ -1048,7 +1211,9 @@ async def alias_raw(self, ctx, *, name: str.lower):
 
         val = utils.truncate(utils.escape_code_block(val), 2048 - 7)
         embed = discord.Embed(
-            title=f'Raw alias - "{name}":', description=f"```\n{val}```", color=self.bot.main_color
+            title=f'Raw alias - "{name}":',
+            description=f"```\n{val}```",
+            color=self.bot.main_color,
         )
 
         return await ctx.send(embed=embed)
@@ -1066,7 +1231,9 @@ async def make_alias(self, name, value, action):
 
         if len(values) > 25:
             embed = discord.Embed(
-                title="Error", description="Too many steps, max=25.", color=self.bot.error_color
+                title="Error",
+                description="Too many steps, max=25.",
+                color=self.bot.error_color,
             )
             return embed
 
@@ -1077,7 +1244,9 @@ async def make_alias(self, name, value, action):
         embed = discord.Embed(title=f"{action} alias", color=self.bot.main_color)
 
         if not multiple_alias:
-            embed.add_field(name=f"`{name}` points to:", value=utils.truncate(values[0], 1024))
+            embed.add_field(
+                name=f"`{name}` points to:", value=utils.truncate(values[0], 1024)
+            )
         else:
             embed.description = f"`{name}` now points to the following steps:"
 
@@ -1252,7 +1421,9 @@ def _parse_level(name):
 
     @permissions.command(name="override")
     @checks.has_permissions(PermissionLevel.OWNER)
-    async def permissions_override(self, ctx, command_name: str.lower, *, level_name: str):
+    async def permissions_override(
+        self, ctx, command_name: str.lower, *, level_name: str
+    ):
         """
         Change a permission level for a specific command.
 
@@ -1291,7 +1462,9 @@ async def permissions_override(self, ctx, command_name: str.lower, *, level_name
                 command.qualified_name,
                 level.name,
             )
-            self.bot.config["override_command_level"][command.qualified_name] = level.name
+            self.bot.config["override_command_level"][command.qualified_name] = (
+                level.name
+            )
 
             await self.bot.config.update()
             embed = discord.Embed(
@@ -1364,7 +1537,9 @@ async def permissions_add(
                 if key is not None:
                     logger.info("Granting %s access to Modmail category.", key.name)
                     try:
-                        await self.bot.main_category.set_permissions(key, read_messages=True)
+                        await self.bot.main_category.set_permissions(
+                            key, read_messages=True
+                        )
                     except discord.Forbidden:
                         warn = discord.Embed(
                             title="Missing Permissions",
@@ -1413,7 +1588,9 @@ async def permissions_remove(
 
         Do not ping `@everyone` for granting permission to everyone, use "everyone" or "all" instead.
         """
-        if type_ not in {"command", "level", "override"} or (type_ != "override" and user_or_role is None):
+        if type_ not in {"command", "level", "override"} or (
+            type_ != "override" and user_or_role is None
+        ):
             return await ctx.send_help(ctx.command)
 
         if type_ == "override":
@@ -1480,9 +1657,13 @@ async def permissions_remove(
                         )
                         await ctx.send(embed=warn)
                 elif isinstance(user_or_role, discord.Role):
-                    logger.info("Denying %s access to Modmail category.", user_or_role.name)
+                    logger.info(
+                        "Denying %s access to Modmail category.", user_or_role.name
+                    )
                     try:
-                        await self.bot.main_category.set_permissions(user_or_role, overwrite=None)
+                        await self.bot.main_category.set_permissions(
+                            user_or_role, overwrite=None
+                        )
                     except discord.Forbidden:
                         warn = discord.Embed(
                             title="Missing Permissions",
@@ -1496,9 +1677,13 @@ async def permissions_remove(
                 else:
                     member = self.bot.modmail_guild.get_member(value)
                     if member is not None and member != self.bot.modmail_guild.me:
-                        logger.info("Denying %s access to Modmail category.", member.name)
+                        logger.info(
+                            "Denying %s access to Modmail category.", member.name
+                        )
                         try:
-                            await self.bot.main_category.set_permissions(member, overwrite=None)
+                            await self.bot.main_category.set_permissions(
+                                member, overwrite=None
+                            )
                         except discord.Forbidden:
                             warn = discord.Embed(
                                 title="Missing Permissions",
@@ -1558,7 +1743,11 @@ def _get_perm(self, ctx, name, type_):
     @permissions.command(name="get", usage="[@user] or [command/level/override] [name]")
     @checks.has_permissions(PermissionLevel.OWNER)
     async def permissions_get(
-        self, ctx, user_or_role: Union[discord.Role, utils.User, str], *, name: str = None
+        self,
+        ctx,
+        user_or_role: Union[discord.Role, utils.User, str],
+        *,
+        name: str = None,
     ):
         """
         View the currently-set permissions.
@@ -1608,10 +1797,18 @@ async def permissions_get(
                 if value in permissions:
                     levels.append(level.name)
 
-            mention = getattr(user_or_role, "name", getattr(user_or_role, "id", user_or_role))
-            desc_cmd = ", ".join(map(lambda x: f"`{x}`", cmds)) if cmds else "No permission entries found."
+            mention = getattr(
+                user_or_role, "name", getattr(user_or_role, "id", user_or_role)
+            )
+            desc_cmd = (
+                ", ".join(map(lambda x: f"`{x}`", cmds))
+                if cmds
+                else "No permission entries found."
+            )
             desc_level = (
-                ", ".join(map(lambda x: f"`{x}`", levels)) if levels else "No permission entries found."
+                ", ".join(map(lambda x: f"`{x}`", levels))
+                if levels
+                else "No permission entries found."
             )
 
             embeds = [
@@ -1636,7 +1833,9 @@ async def permissions_get(
                     for command in self.bot.walk_commands():
                         if command not in done:
                             done.add(command)
-                            level = self.bot.config["override_command_level"].get(command.qualified_name)
+                            level = self.bot.config["override_command_level"].get(
+                                command.qualified_name
+                            )
                             if level is not None:
                                 overrides[command.qualified_name] = level
 
@@ -1650,15 +1849,23 @@ async def permissions_get(
                             )
                         )
                     else:
-                        for items in zip_longest(*(iter(sorted(overrides.items())),) * 15):
+                        for items in zip_longest(
+                            *(iter(sorted(overrides.items())),) * 15
+                        ):
                             description = "\n".join(
                                 ": ".join((f"`{name}`", level))
-                                for name, level in takewhile(lambda x: x is not None, items)
+                                for name, level in takewhile(
+                                    lambda x: x is not None, items
+                                )
+                            )
+                            embed = discord.Embed(
+                                color=self.bot.main_color, description=description
                             )
-                            embed = discord.Embed(color=self.bot.main_color, description=description)
                             embed.set_author(
                                 name="Permission Overrides",
-                                icon_url=self.bot.get_guild_icon(guild=ctx.guild, size=128),
+                                icon_url=self.bot.get_guild_icon(
+                                    guild=ctx.guild, size=128
+                                ),
                             )
                             embeds.append(embed)
 
@@ -1708,7 +1915,9 @@ async def permissions_get(
                     return await ctx.send(embed=embed)
 
                 if user_or_role == "command":
-                    embeds.append(self._get_perm(ctx, command.qualified_name, "command"))
+                    embeds.append(
+                        self._get_perm(ctx, command.qualified_name, "command")
+                    )
                 else:
                     embeds.append(self._get_perm(ctx, level.name, "level"))
             else:
@@ -1717,7 +1926,9 @@ async def permissions_get(
                     for command in self.bot.walk_commands():
                         if command not in done:
                             done.add(command)
-                            embeds.append(self._get_perm(ctx, command.qualified_name, "command"))
+                            embeds.append(
+                                self._get_perm(ctx, command.qualified_name, "command")
+                            )
                 else:
                     for perm_level in PermissionLevel:
                         embeds.append(self._get_perm(ctx, perm_level.name, "level"))
@@ -1759,9 +1970,13 @@ async def oauth_whitelist(self, ctx, target: Union[discord.Role, utils.User]):
         embed.title = "Success"
 
         if not hasattr(target, "mention"):
-            target = self.bot.get_user(target.id) or self.bot.modmail_guild.get_role(target.id)
+            target = self.bot.get_user(target.id) or self.bot.modmail_guild.get_role(
+                target.id
+            )
 
-        embed.description = f"{'Un-w' if removed else 'W'}hitelisted {target.mention} to view logs."
+        embed.description = (
+            f"{'Un-w' if removed else 'W'}hitelisted {target.mention} to view logs."
+        )
 
         await ctx.send(embed=embed)
 
@@ -1785,8 +2000,12 @@ async def oauth_show(self, ctx):
         embed = discord.Embed(color=self.bot.main_color)
         embed.title = "Oauth Whitelist"
 
-        embed.add_field(name="Users", value=" ".join(u.mention for u in users) or "None")
-        embed.add_field(name="Roles", value=" ".join(r.mention for r in roles) or "None")
+        embed.add_field(
+            name="Users", value=" ".join(u.mention for u in users) or "None"
+        )
+        embed.add_field(
+            name="Roles", value=" ".join(r.mention for r in roles) or "None"
+        )
 
         await ctx.send(embed=embed)
 
@@ -1844,7 +2063,9 @@ async def autotrigger_add(self, ctx, keyword, *, command):
     async def autotrigger_edit(self, ctx, keyword, *, command):
         """Edits a pre-existing trigger to automatically trigger an alias-like command"""
         if keyword not in self.bot.auto_triggers:
-            embed = utils.create_not_found_embed(keyword, self.bot.auto_triggers.keys(), "Autotrigger")
+            embed = utils.create_not_found_embed(
+                keyword, self.bot.auto_triggers.keys(), "Autotrigger"
+            )
         else:
             # command validation
             valid = False
@@ -1963,7 +2184,9 @@ async def github(self, ctx):
         data = await self.bot.api.get_user_info()
 
         if data:
-            embed = discord.Embed(title="GitHub", description="Current User", color=self.bot.main_color)
+            embed = discord.Embed(
+                title="GitHub", description="Current User", color=self.bot.main_color
+            )
             user = data["user"]
             embed.set_author(
                 name=user["username"],
@@ -1973,7 +2196,11 @@ async def github(self, ctx):
             embed.set_thumbnail(url=user["avatar_url"] if user["avatar_url"] else None)
             await ctx.send(embed=embed)
         else:
-            await ctx.send(embed=discord.Embed(title="Invalid Github Token", color=self.bot.error_color))
+            await ctx.send(
+                embed=discord.Embed(
+                    title="Invalid Github Token", color=self.bot.error_color
+                )
+            )
 
     @commands.command()
     @checks.has_permissions(PermissionLevel.OWNER)
@@ -1995,7 +2222,9 @@ async def update(self, ctx, *, flag: str = ""):
         )
 
         if self.bot.version >= Version(latest.version) and flag.lower() != "force":
-            embed = discord.Embed(title="Already up to date", description=desc, color=self.bot.main_color)
+            embed = discord.Embed(
+                title="Already up to date", description=desc, color=self.bot.main_color
+            )
 
             data = await self.bot.api.get_user_info()
             if data:
@@ -2039,7 +2268,9 @@ async def update(self, ctx, *, flag: str = ""):
                 if commit_data and commit_data.get("html_url"):
                     embed = discord.Embed(color=self.bot.main_color)
 
-                    embed.set_footer(text=f"Updating Modmail v{self.bot.version} -> v{latest.version}")
+                    embed.set_footer(
+                        text=f"Updating Modmail v{self.bot.version} -> v{latest.version}"
+                    )
 
                     embed.set_author(
                         name=user["username"] + " - Updating bot",
@@ -2053,7 +2284,9 @@ async def update(self, ctx, *, flag: str = ""):
 
                     html_url = commit_data["html_url"]
                     short_sha = commit_data["sha"][:6]
-                    embed.add_field(name="Merge Commit", value=f"[`{short_sha}`]({html_url})")
+                    embed.add_field(
+                        name="Merge Commit", value=f"[`{short_sha}`]({html_url})"
+                    )
                 else:
                     embed = discord.Embed(
                         title="Already up to date",
@@ -2080,7 +2313,11 @@ async def update(self, ctx, *, flag: str = ""):
                 res = res.decode("utf-8").rstrip()
 
                 if err and not res:
-                    embed = discord.Embed(title="Update failed", description=err, color=self.bot.error_color)
+                    embed = discord.Embed(
+                        title="Update failed",
+                        description=err,
+                        color=self.bot.error_color,
+                    )
                     await ctx.send(embed=embed)
 
                 elif res != "Already up to date.":
@@ -2090,7 +2327,10 @@ async def update(self, ctx, *, flag: str = ""):
                         title="Bot has been updated",
                         color=self.bot.main_color,
                     )
-                    embed.set_footer(text=f"Updating Modmail v{self.bot.version} " f"-> v{latest.version}")
+                    embed.set_footer(
+                        text=f"Updating Modmail v{self.bot.version} "
+                        f"-> v{latest.version}"
+                    )
                     embed.description = latest.description
                     for name, value in latest.fields.items():
                         embed.add_field(name=name, value=truncate(value, 200))
@@ -2134,7 +2374,7 @@ async def eval_(self, ctx, *, body: str):
         body = utils.cleanup_code(body)
         stdout = StringIO()
 
-        to_compile = f'async def func():\n{indent(body, "  ")}'
+        to_compile = f"async def func():\n{indent(body, '  ')}"
 
         def paginate(text: str):
             """Simple generator that paginates text."""
diff --git a/core/_color_data.py b/core/_color_data.py
index 13ec45620e..61f27642cd 100644
--- a/core/_color_data.py
+++ b/core/_color_data.py
@@ -42,7 +42,9 @@
 }
 
 # Normalize name to "discord:<name>" to avoid name collisions.
-DISCORD_COLORS_NORM = {"discord:" + name: value for name, value in DISCORD_COLORS.items()}
+DISCORD_COLORS_NORM = {
+    "discord:" + name: value for name, value in DISCORD_COLORS.items()
+}
 
 
 # These colors are from Tableau
diff --git a/core/changelog.py b/core/changelog.py
index 465479bf17..d871670984 100644
--- a/core/changelog.py
+++ b/core/changelog.py
@@ -53,7 +53,9 @@ def __init__(self, bot, branch: str, version: str, lines: str):
         self.version = version.lstrip("vV")
         self.lines = lines.strip()
         self.fields = {}
-        self.changelog_url = f"https://github.com/modmail-dev/modmail/blob/{branch}/CHANGELOG.md"
+        self.changelog_url = (
+            f"https://github.com/modmail-dev/modmail/blob/{branch}/CHANGELOG.md"
+        )
         self.description = ""
         self.parse()
 
@@ -65,7 +67,9 @@ def parse(self) -> None:
         Parse the lines and split them into `description` and `fields`.
         """
         self.description = re.match(self.DESCRIPTION_REGEX, self.lines, re.DOTALL)
-        self.description = self.description.group(1).strip() if self.description is not None else ""
+        self.description = (
+            self.description.group(1).strip() if self.description is not None else ""
+        )
 
         matches = re.finditer(self.ACTION_REGEX, self.lines, re.DOTALL)
         for m in matches:
@@ -90,7 +94,9 @@ def embed(self) -> Embed:
         embed = Embed(color=self.bot.main_color, description=self.description)
         embed.set_author(
             name=f"v{self.version} - Changelog",
-            icon_url=self.bot.user.display_avatar.url if self.bot.user.display_avatar else None,
+            icon_url=self.bot.user.display_avatar.url
+            if self.bot.user.display_avatar
+            else None,
             url=self.url,
         )
 
@@ -98,7 +104,11 @@ def embed(self) -> Embed:
             embed.add_field(name=name, value=truncate(value, 1024), inline=False)
         embed.set_footer(text=f"Current version: v{self.bot.version}")
 
-        embed.set_thumbnail(url=self.bot.user.display_avatar.url if self.bot.user.display_avatar else None)
+        embed.set_thumbnail(
+            url=self.bot.user.display_avatar.url
+            if self.bot.user.display_avatar
+            else None
+        )
         return embed
 
 
@@ -137,7 +147,9 @@ def __init__(self, bot, branch: str, text: str):
         self.bot = bot
         self.text = text
         logger.debug("Fetching changelog from GitHub.")
-        self.versions = [Version(bot, branch, *m) for m in self.VERSION_REGEX.findall(text)]
+        self.versions = [
+            Version(bot, branch, *m) for m in self.VERSION_REGEX.findall(text)
+        ]
 
     @property
     def latest_version(self) -> Version:
@@ -186,7 +198,10 @@ async def from_url(cls, bot, url: str = "") -> "Changelog":
         if branch not in ("master", "development"):
             branch = "master"
 
-        url = url or f"https://raw.githubusercontent.com/modmail-dev/modmail/{branch}/CHANGELOG.md"
+        url = (
+            url
+            or f"https://raw.githubusercontent.com/modmail-dev/modmail/{branch}/CHANGELOG.md"
+        )
 
         async with await bot.session.get(url) as resp:
             return cls(bot, branch, await resp.text())
diff --git a/core/clients.py b/core/clients.py
index 459ee2ea6b..3b07e88efa 100644
--- a/core/clients.py
+++ b/core/clients.py
@@ -124,7 +124,9 @@ async def request(
             headers.update(self.headers)
         else:
             headers = self.headers
-        async with self.session.request(method, url, headers=headers, json=payload) as resp:
+        async with self.session.request(
+            method, url, headers=headers, json=payload
+        ) as resp:
             if return_response:
                 if read_before_return:
                     await resp.read()
@@ -133,7 +135,9 @@ async def request(
             return await self._get_response_data(resp)
 
     @staticmethod
-    async def _get_response_data(response: ClientResponse) -> Union[Dict[str, Any], str]:
+    async def _get_response_data(
+        response: ClientResponse,
+    ) -> Union[Dict[str, Any], str]:
         """
         Internal method to convert the response data to `dict` if the data is a
         json object, or to `str` (raw response) if the data is not a valid json.
@@ -157,7 +161,9 @@ def filter_valid(self, data) -> Dict[str, Any]:
         Dict[str, Any]
             Filtered `data` to keep only the accepted pairs.
         """
-        valid_keys = self.bot.config.valid_keys.difference(self.bot.config.protected_keys)
+        valid_keys = self.bot.config.valid_keys.difference(
+            self.bot.config.protected_keys
+        )
         return {k: v for k, v in data.items() if k in valid_keys}
 
     async def update_repository(self, sha: str = None) -> Dict[str, Any]:
@@ -335,7 +341,9 @@ async def request(
             `str` if the returned data is not a valid json data,
             the raw response.
         """
-        async with self.session.request(method, url, headers=headers, json=payload) as resp:
+        async with self.session.request(
+            method, url, headers=headers, json=payload
+        ) as resp:
             if return_response:
                 return resp
             try:
@@ -374,7 +382,9 @@ async def get_log(self, channel_id: Union[str, int]) -> dict:
     async def get_log_link(self, channel_id: Union[str, int]) -> str:
         return NotImplemented
 
-    async def create_log_entry(self, recipient: Member, channel: TextChannel, creator: Member) -> str:
+    async def create_log_entry(
+        self, recipient: Member, channel: TextChannel, creator: Member
+    ) -> str:
         return NotImplemented
 
     async def delete_log_entry(self, key: str) -> bool:
@@ -408,7 +418,9 @@ async def search_closed_by(self, user_id: Union[int, str]):
     async def search_by_text(self, text: str, limit: Optional[int]):
         return NotImplemented
 
-    async def create_note(self, recipient: Member, message: Message, message_id: Union[int, str]):
+    async def create_note(
+        self, recipient: Member, message: Message, message_id: Union[int, str]
+    ):
         return NotImplemented
 
     async def find_notes(self, recipient: Member):
@@ -476,7 +488,11 @@ async def setup_indexes(self):
             logger.info('Creating "text" index for logs collection.')
             logger.info("Name: %s", index_name)
             await coll.create_index(
-                [("messages.content", "text"), ("messages.author.name", "text"), ("key", "text")]
+                [
+                    ("messages.content", "text"),
+                    ("messages.author.name", "text"),
+                    ("key", "text"),
+                ]
             )
         logger.debug("Successfully configured and verified database indexes.")
 
@@ -500,7 +516,9 @@ async def validate_database_connection(self, *, ssl_retry=True):
                     'run "Certificate.command" on MacOS, '
                     'and check certifi is up to date "pip3 install --upgrade certifi".'
                 )
-                self.db = AsyncIOMotorClient(mongo_uri, tlsAllowInvalidCertificates=True).modmail_bot
+                self.db = AsyncIOMotorClient(
+                    mongo_uri, tlsAllowInvalidCertificates=True
+                ).modmail_bot
                 return await self.validate_database_connection(ssl_retry=False)
             if "ServerSelectionTimeoutError" in message:
                 logger.critical(
@@ -540,11 +558,17 @@ async def find_log_entry(self, key: str) -> list:
         return await self.logs.find(query, projection).to_list(None)
 
     async def get_latest_user_logs(self, user_id: Union[str, int]):
-        query = {"recipient.id": str(user_id), "guild_id": str(self.bot.guild_id), "open": False}
+        query = {
+            "recipient.id": str(user_id),
+            "guild_id": str(self.bot.guild_id),
+            "open": False,
+        }
         projection = {"messages": {"$slice": 5}}
         logger.debug("Retrieving user %s latest logs.", user_id)
 
-        return await self.logs.find_one(query, projection, limit=1, sort=[("closed_at", -1)])
+        return await self.logs.find_one(
+            query, projection, limit=1, sort=[("closed_at", -1)]
+        )
 
     async def get_responded_logs(self, user_id: Union[str, int]) -> list:
         query = {
@@ -575,7 +599,9 @@ async def get_log_link(self, channel_id: Union[str, int]) -> str:
             prefix = ""
         return f"{self.bot.config['log_url'].strip('/')}{'/' + prefix if prefix else ''}/{doc['key']}"
 
-    async def create_log_entry(self, recipient: Member, channel: TextChannel, creator: Member) -> str:
+    async def create_log_entry(
+        self, recipient: Member, channel: TextChannel, creator: Member
+    ) -> str:
         key = secrets.token_hex(6)
 
         await self.logs.insert_one(
@@ -592,14 +618,18 @@ async def create_log_entry(self, recipient: Member, channel: TextChannel, creato
                     "id": str(recipient.id),
                     "name": recipient.name,
                     "discriminator": recipient.discriminator,
-                    "avatar_url": recipient.display_avatar.url if recipient.display_avatar else None,
+                    "avatar_url": recipient.display_avatar.url
+                    if recipient.display_avatar
+                    else None,
                     "mod": False,
                 },
                 "creator": {
                     "id": str(creator.id),
                     "name": creator.name,
                     "discriminator": creator.discriminator,
-                    "avatar_url": creator.display_avatar.url if creator.display_avatar else None,
+                    "avatar_url": creator.display_avatar.url
+                    if creator.display_avatar
+                    else None,
                     "mod": isinstance(creator, Member),
                 },
                 "closer": None,
@@ -626,16 +656,22 @@ async def get_config(self) -> dict:
 
     async def update_config(self, data: dict):
         toset = self.bot.config.filter_valid(data)
-        unset = self.bot.config.filter_valid({k: 1 for k in self.bot.config.all_keys if k not in data})
+        unset = self.bot.config.filter_valid(
+            {k: 1 for k in self.bot.config.all_keys if k not in data}
+        )
 
         if toset and unset:
             return await self.db.config.update_one(
                 {"bot_id": self.bot.user.id}, {"$set": toset, "$unset": unset}
             )
         if toset:
-            return await self.db.config.update_one({"bot_id": self.bot.user.id}, {"$set": toset})
+            return await self.db.config.update_one(
+                {"bot_id": self.bot.user.id}, {"$set": toset}
+            )
         if unset:
-            return await self.db.config.update_one({"bot_id": self.bot.user.id}, {"$unset": unset})
+            return await self.db.config.update_one(
+                {"bot_id": self.bot.user.id}, {"$unset": unset}
+            )
 
     async def edit_message(self, message_id: Union[int, str], new_content: str) -> None:
         await self.logs.update_one(
@@ -661,7 +697,9 @@ async def append_log(
                 "id": str(message.author.id),
                 "name": message.author.name,
                 "discriminator": message.author.discriminator,
-                "avatar_url": message.author.display_avatar.url if message.author.display_avatar else None,
+                "avatar_url": message.author.display_avatar.url
+                if message.author.display_avatar
+                else None,
                 "mod": not isinstance(message.channel, DMChannel),
             },
             "content": message.content,
@@ -679,7 +717,9 @@ async def append_log(
         }
 
         return await self.logs.find_one_and_update(
-            {"channel_id": channel_id}, {"$push": {"messages": data}}, return_document=True
+            {"channel_id": channel_id},
+            {"$push": {"messages": data}},
+            return_document=True,
         )
 
     async def post_log(self, channel_id: Union[int, str], data: dict) -> dict:
@@ -689,7 +729,11 @@ async def post_log(self, channel_id: Union[int, str], data: dict) -> dict:
 
     async def search_closed_by(self, user_id: Union[int, str]):
         return await self.logs.find(
-            {"guild_id": str(self.bot.guild_id), "open": False, "closer.id": str(user_id)},
+            {
+                "guild_id": str(self.bot.guild_id),
+                "open": False,
+                "closer.id": str(user_id),
+            },
             {"messages": {"$slice": 5}},
         ).to_list(None)
 
@@ -703,7 +747,9 @@ async def search_by_text(self, text: str, limit: Optional[int]):
             {"messages": {"$slice": 5}},
         ).to_list(limit)
 
-    async def create_note(self, recipient: Member, message: Message, message_id: Union[int, str]):
+    async def create_note(
+        self, recipient: Member, message: Message, message_id: Union[int, str]
+    ):
         await self.db.notes.insert_one(
             {
                 "recipient": str(recipient.id),
@@ -712,7 +758,9 @@ async def create_note(self, recipient: Member, message: Message, message_id: Uni
                     "name": message.author.name,
                     "discriminator": message.author.discriminator,
                     "avatar_url": (
-                        message.author.display_avatar.url if message.author.display_avatar else None
+                        message.author.display_avatar.url
+                        if message.author.display_avatar
+                        else None
                     ),
                 },
                 "message": message.content,
@@ -725,13 +773,17 @@ async def find_notes(self, recipient: Member):
 
     async def update_note_ids(self, ids: dict):
         for object_id, message_id in ids.items():
-            await self.db.notes.update_one({"_id": object_id}, {"$set": {"message_id": message_id}})
+            await self.db.notes.update_one(
+                {"_id": object_id}, {"$set": {"message_id": message_id}}
+            )
 
     async def delete_note(self, message_id: Union[int, str]):
         await self.db.notes.delete_one({"message_id": str(message_id)})
 
     async def edit_note(self, message_id: Union[int, str], message: str):
-        await self.db.notes.update_one({"message_id": str(message_id)}, {"$set": {"message": message}})
+        await self.db.notes.update_one(
+            {"message_id": str(message_id)}, {"$set": {"message": message}}
+        )
 
     def get_plugin_partition(self, cog):
         cls_name = cog.__class__.__name__
diff --git a/core/config.py b/core/config.py
index a704443bb1..b322766b79 100644
--- a/core/config.py
+++ b/core/config.py
@@ -70,6 +70,7 @@ class ConfigManager:
         "thread_creation_self_contact_response": "You have opened a Modmail thread.",
         "thread_creation_contact_response": "{creator.name} has opened a Modmail thread.",
         "thread_creation_title": "Thread Created",
+        "thread_creation_send_dm_embed": True,
         "thread_close_footer": "Replying will create a new thread",
         "thread_close_title": "Thread Closed",
         "thread_close_response": "{closer.mention} has closed this Modmail thread.",
@@ -135,11 +136,34 @@ class ConfigManager:
         "thread_min_characters_response": "Your message is too short to create a thread. Please provide more details.",
         "thread_min_characters_footer": "Minimum {min_characters} characters required.",
         # --- SNOOZE FEATURE CONFIG ---
-        "max_snooze_time": 604800,  # in seconds, default 7 days
+        "snooze_default_duration": 604800,  # in seconds, default 7 days
         "snooze_title": "Thread Snoozed",
         "snooze_text": "This thread has been snoozed. The channel will be restored when the user replies or a moderator unsnoozes it.",
         "unsnooze_text": "This thread has been unsnoozed and restored.",
         "unsnooze_notify_channel": "thread",  # Can be a channel ID or 'thread' for the thread's own channel
+        # snooze behavior
+        "snooze_behavior": "delete",  # 'delete' to delete channel, 'move' to move channel to snoozed_category_id
+        "snoozed_category_id": None,  # Category ID to move snoozed channels into when snooze_behavior == 'move'
+        # attachments persistence for delete-behavior snooze
+        "snooze_store_attachments": False,  # when True, store image attachments as base64 in snooze_data
+        "snooze_attachment_max_bytes": 4_194_304,  # 4 MiB per attachment cap to avoid Mongo 16MB limit
+        "unsnooze_history_limit": None,  # Limit number of messages replayed when unsnoozing (None = all messages)
+        # --- THREAD CREATION MENU ---
+        "thread_creation_menu_timeout": 30,  # Default interaction timeout for the thread-creation menu (in seconds)
+        "thread_creation_menu_close_on_timeout": False,
+        "thread_creation_menu_anonymous_menu": False,
+        "thread_creation_menu_embed_text": "Please select an option.",
+        "thread_creation_menu_dropdown_placeholder": "Select an option to contact the staff team.",
+        "thread_creation_menu_selection_log": True,  # log selected option in newly created thread channel
+        "thread_creation_menu_precreate_channel": False,
+        # thread-creation menu embed customization
+        "thread_creation_menu_embed_title": None,
+        "thread_creation_menu_embed_footer": None,
+        "thread_creation_menu_embed_thumbnail_url": None,
+        "thread_creation_menu_embed_image_url": None,
+        "thread_creation_menu_embed_large_image": False,
+        "thread_creation_menu_embed_footer_icon_url": None,
+        "thread_creation_menu_embed_color": str(discord.Color.green()),
     }
 
     private_keys = {
@@ -161,6 +185,10 @@ class ConfigManager:
         "notification_squad": {},
         "subscriptions": {},
         "closures": {},
+        # Thread creation menu
+        "thread_creation_menu_enabled": False,
+        "thread_creation_menu_options": {},  # main menu options mapping key -> {label, description, emoji, type, callback}
+        "thread_creation_menu_submenus": {},  # submenu name -> submenu options (same structure as options)
         # misc
         "plugins": [],
         "aliases": {},
@@ -196,9 +224,23 @@ class ConfigManager:
         "data_collection": True,
     }
 
-    colors = {"mod_color", "recipient_color", "main_color", "error_color"}
+    colors = {
+        "mod_color",
+        "recipient_color",
+        "main_color",
+        "error_color",
+        "thread_creation_menu_embed_color",
+    }
+
+    time_deltas = {
+        "account_age",
+        "guild_age",
+        "thread_auto_close",
+        "thread_cooldown",
+        "log_expiration",
+    }
 
-    time_deltas = {"account_age", "guild_age", "thread_auto_close", "thread_cooldown", "log_expiration"}
+    duration_seconds = {"snooze_default_duration"}
 
     booleans = {
         "use_user_id_channel_name",
@@ -239,6 +281,16 @@ class ConfigManager:
         "use_hoisted_top_role",
         "enable_presence_intent",
         "registry_plugins_only",
+        # snooze
+        "snooze_store_attachments",
+        # thread creation menu booleans
+        "thread_creation_send_dm_embed",
+        "thread_creation_menu_enabled",
+        "thread_creation_menu_close_on_timeout",
+        "thread_creation_menu_anonymous_menu",
+        "thread_creation_menu_selection_log",
+        "thread_creation_menu_precreate_channel",
+        "thread_creation_menu_embed_large_image",
     }
 
     enums = {
@@ -265,19 +317,34 @@ def populate_cache(self) -> dict:
         data = deepcopy(self.defaults)
 
         # populate from env var and .env file
-        data.update({k.lower(): v for k, v in os.environ.items() if k.lower() in self.all_keys})
-        config_json = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "config.json")
+        data.update(
+            {k.lower(): v for k, v in os.environ.items() if k.lower() in self.all_keys}
+        )
+        config_json = os.path.join(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "config.json"
+        )
         if os.path.exists(config_json):
             logger.debug("Loading envs from config.json.")
             with open(config_json, "r", encoding="utf-8") as f:
                 # Config json should override env vars
                 try:
-                    data.update({k.lower(): v for k, v in json.load(f).items() if k.lower() in self.all_keys})
+                    data.update(
+                        {
+                            k.lower(): v
+                            for k, v in json.load(f).items()
+                            if k.lower() in self.all_keys
+                        }
+                    )
                 except json.JSONDecodeError:
-                    logger.critical("Failed to load config.json env values.", exc_info=True)
+                    logger.critical(
+                        "Failed to load config.json env values.", exc_info=True
+                    )
+
         self._cache = data
 
-        config_help_json = os.path.join(os.path.dirname(os.path.abspath(__file__)), "config_help.json")
+        config_help_json = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), "config_help.json"
+        )
         with open(config_help_json, "r", encoding="utf-8") as f:
             self.config_help = dict(sorted(json.load(f).items()))
 
@@ -360,6 +427,14 @@ def get(self, key: str, *, convert: bool = True) -> typing.Any:
                 logger.warning("Invalid %s %s.", key, value)
                 value = self.remove(key)
 
+        elif key in self.duration_seconds:
+            if not isinstance(value, int):
+                try:
+                    value = int(value)
+                except (ValueError, TypeError):
+                    logger.warning("Invalid %s %s.", key, value)
+                    value = self.remove(key)
+
         elif key in self.force_str:
             # Temporary: as we saved in int previously, leading to int32 overflow,
             #            this is transitioning IDs to strings
@@ -388,6 +463,10 @@ async def set(self, key: str, item: typing.Any, convert=True) -> None:
         if not convert:
             return self.__setitem__(key, item)
 
+        if "channel" in key or "category" in key:
+            if isinstance(item, str) and item not in {"thread", "NONE"}:
+                item = item.strip("<#>")
+
         if key in self.colors:
             try:
                 hex_ = str(item)
@@ -419,7 +498,9 @@ async def set(self, key: str, item: typing.Any, convert=True) -> None:
             except isodate.ISO8601Error:
                 try:
                     converter = UserFriendlyTime()
-                    time = await converter.convert(None, item, now=discord.utils.utcnow())
+                    time = await converter.convert(
+                        None, item, now=discord.utils.utcnow()
+                    )
                     if time.arg:
                         raise ValueError
                 except BadArgument as exc:
@@ -440,6 +521,27 @@ async def set(self, key: str, item: typing.Any, convert=True) -> None:
             except ValueError:
                 raise InvalidConfigError("Must be a yes/no value.")
 
+        elif key in self.duration_seconds:
+            if isinstance(item, int):
+                return self.__setitem__(key, item)
+            try:
+                converter = UserFriendlyTime()
+                time = await converter.convert(
+                    None, str(item), now=discord.utils.utcnow()
+                )
+                if time.arg:
+                    raise ValueError
+            except BadArgument as exc:
+                raise InvalidConfigError(*exc.args)
+            except Exception as e:
+                logger.debug(e)
+                raise InvalidConfigError(
+                    "Unrecognized time, please use a duration like '5 days' or '2 hours'."
+                )
+            now = discord.utils.utcnow()
+            duration_seconds = int((time.dt - now).total_seconds())
+            return self.__setitem__(key, duration_seconds)
+
         elif key in self.enums:
             if isinstance(item, self.enums[key]):
                 # value is an enum type
@@ -461,7 +563,9 @@ def items(self) -> typing.Iterable:
         return self._cache.items()
 
     @classmethod
-    def filter_valid(cls, data: typing.Dict[str, typing.Any]) -> typing.Dict[str, typing.Any]:
+    def filter_valid(
+        cls, data: typing.Dict[str, typing.Any]
+    ) -> typing.Dict[str, typing.Any]:
         return {
             k.lower(): v
             for k, v in data.items()
@@ -469,7 +573,9 @@ def filter_valid(cls, data: typing.Dict[str, typing.Any]) -> typing.Dict[str, ty
         }
 
     @classmethod
-    def filter_default(cls, data: typing.Dict[str, typing.Any]) -> typing.Dict[str, typing.Any]:
+    def filter_default(
+        cls, data: typing.Dict[str, typing.Any]
+    ) -> typing.Dict[str, typing.Any]:
         # TODO: use .get to prevent errors
         filtered = {}
         for k, v in data.items():
diff --git a/core/config_help.json b/core/config_help.json
index 462e4e1c03..b5832935c7 100644
--- a/core/config_help.json
+++ b/core/config_help.json
@@ -492,6 +492,18 @@
       "See also: `thread_creation_response`, `thread_creation_footer`, `thread_close_title`."
     ]
   },
+  "thread_creation_send_dm_embed": {
+    "default": "Yes",
+    "description": "When set to `yes`, the bot will send an embed message to the recipient notifying them that a new thread was created. Set to `no` to suppress the initial DM embed. When suppressed and `recipient_thread_close` is enabled, the close emoji will be added to the user's original message instead so they may still close the thread.",
+    "examples": [
+      "`{prefix}config set thread_creation_send_dm_embed no`",
+      "`{prefix}config set thread_creation_send_dm_embed yes`"
+    ],
+    "notes": [
+      "Useful if you prefer not to send an extra DM to recipients when creating threads.",
+      "See also: `recipient_thread_close`, `thread_creation_response`, `thread_creation_title`."
+    ]
+  },
   "thread_close_footer": {
     "default": "\"Replying will create a new thread\"",
     "description": "This is the message embed footer sent to the recipient upon the closure of a thread.",
@@ -1266,15 +1278,16 @@
       "See also: `thread_min_characters`, `thread_min_characters_title`, `thread_min_characters_response`."
     ]
   },
-  "max_snooze_time": {
+  "snooze_default_duration": {
     "default": "604800 (7 days in seconds)",
-    "description": "The maximum duration in seconds that a thread can be snoozed. When a thread is snoozed, it is temporarily hidden until the user replies or a moderator unsnoozes it.",
+    "description": "The default duration that a thread will be snoozed when no duration is specified. When a thread is snoozed, it is temporarily hidden until the user replies or a moderator unsnoozes it.",
     "examples": [
-      "`{prefix}config set max_snooze_time 86400` (1 day)",
-      "`{prefix}config set max_snooze_time 1209600` (14 days)"
+      "`{prefix}config set snooze_default_duration 7 days`",
+      "`{prefix}config set snooze_default_duration 2 hours`",
+      "`{prefix}config set snooze_default_duration 86400` (raw seconds also accepted)"
     ],
     "notes": [
-      "The value must be specified in seconds.",
+      "Accepts user-friendly time like '5 days', '2 hours', or raw seconds.",
       "See also: `snooze_title`, `snooze_text`, `unsnooze_text`, `unsnooze_notify_channel`."
     ]
   },
@@ -1285,7 +1298,7 @@
       "`{prefix}config set snooze_title Thread Paused`"
     ],
     "notes": [
-      "See also: `snooze_text`, `unsnooze_title`, `max_snooze_time`."
+      "See also: `snooze_text`, `unsnooze_title`, `snooze_default_duration`."
     ]
   },
   "snooze_text": {
@@ -1296,7 +1309,7 @@
     ],
     "notes": [
       "Discord flavoured markdown is fully supported in `snooze_text`.",
-      "See also: `snooze_title`, `unsnooze_text`, `max_snooze_time`."
+      "See also: `snooze_title`, `unsnooze_text`, `snooze_default_duration`."
     ]
   },
   "unsnooze_text": {
@@ -1307,7 +1320,7 @@
     ],
     "notes": [
       "Discord flavoured markdown is fully supported in `unsnooze_text`.",
-      "See also: `snooze_text`, `unsnooze_notify_channel`, `max_snooze_time`."
+      "See also: `snooze_text`, `unsnooze_notify_channel`, `snooze_default_duration`."
     ]
   },
   "unsnooze_notify_channel": {
@@ -1320,7 +1333,265 @@
     "notes": [
       "If set to \"thread\", the notification will be sent in the thread channel itself.",
       "If set to a channel ID, the notification will be sent to that specific channel.",
-      "See also: `unsnooze_text`, `max_snooze_time`."
+      "See also: `unsnooze_text`, `snooze_default_duration`."
+    ]
+  },
+  "snooze_behavior": {
+    "default": "\"delete\"",
+    "description": "Controls how snoozing behaves. 'delete' removes the thread channel and restores it later; 'move' moves the channel into the 'snoozed_category_id' without deleting it.",
+    "examples": [
+      "`{prefix}config set snooze_behavior delete`",
+      "`{prefix}config set snooze_behavior move`"
+    ],
+    "notes": [
+      "When set to 'move', set `snoozed_category_id` to a valid Category ID.",
+      "When unsnoozed, channels moved will return to their original category and position when possible; if original no longer exists they will be moved under `main_category_id`."
+    ]
+  },
+  "snoozed_category_id": {
+    "default": "None",
+    "description": "The category ID where snoozed threads are moved when `snooze_behavior` is set to 'move'.",
+    "examples": [
+      "`{prefix}config set snoozed_category_id 123456789012345678`"
+    ],
+    "notes": [
+      "Only used when `snooze_behavior` is 'move'.",
+      "If not set or invalid, the channel will remain in its current category or the bot will fall back to deleting on failure."
+    ]
+  },
+  "snooze_store_attachments": {
+    "default": "No",
+    "description": "When enabled and `snooze_behavior` is 'delete', image attachments are stored as base64 within the snooze data so they can be re-uploaded on unsnooze, preserving media even if the original channel was deleted.",
+    "examples": [
+      "`{prefix}config set snooze_store_attachments yes`",
+      "`{prefix}config set snooze_store_attachments no`"
+    ],
+    "notes": [
+      "Only applies to delete-behavior snoozes. In move-behavior, attachments remain in the channel history.",
+      "To avoid exceeding Mongo's 16MB document size, consider also adjusting `snooze_attachment_max_bytes`."
+    ]
+  },
+  "snooze_attachment_max_bytes": {
+    "default": "4194304 (4 MiB)",
+    "description": "Maximum size per attachment to store as base64 when `snooze_store_attachments` is enabled.",
+    "examples": [
+      "`{prefix}config set snooze_attachment_max_bytes 2097152` (2 MiB)",
+      "`{prefix}config set snooze_attachment_max_bytes 0` (disable size check; not recommended)"
+    ],
+    "notes": [
+      "This cap helps prevent hitting MongoDB's 16MB per-document limit when storing large attachments.",
+      "Non-image files are not stored as base64 and will be preserved as their original URLs if available."
+    ]
+  },
+  "unsnooze_history_limit": {
+    "default": "None (all messages replayed)",
+    "description": "Limits the number of messages replayed when a thread is unsnoozed. When set, only the last N messages will be displayed in the restored channel.",
+    "examples": [
+      "`{prefix}config set unsnooze_history_limit 50`",
+      "`{prefix}config set unsnooze_history_limit 100`"
+    ],
+    "notes": [
+      "All messages remain stored in the database regardless of this limit.",
+      "Set to None or delete this config to replay all messages when unsnoozing.",
+      "See also: `snooze_behavior`, `unsnooze_text`."
+    ]
+  },
+  "thread_creation_menu_enabled": {
+    "default": "Disabled",
+    "description": "Enables the thread creation menu which asks users to pick an option before the Modmail thread channel is created.",
+    "examples": [
+      "`{prefix}config set thread_creation_menu_enabled yes`"
+    ],
+    "notes": [
+      "When enabled and at least one option is configured, incoming user DMs are paused until a selection is made.",
+      "If the menu times out without a selection and `thread_creation_menu_close_on_timeout` is enabled, the thread is aborted silently.",
+      "See also: `thread_creation_menu_options`, `thread_creation_menu_timeout`."
+    ]
+  },
+  "thread_creation_menu_options": {
+    "default": "Empty (no options)",
+    "description": "Mapping of menu option keys to their data (label, description, emoji, type, callback). A non-empty mapping is required to display the menu.",
+    "examples": [
+  "`{prefix}threadmenu option add` (interactive wizard)",
+  "`{prefix}threadmenu show`"
+    ],
+    "notes": [
+      "Type can be 'command' (executes a command after creation) or 'submenu' (opens a submenu).",
+      "Submenu callbacks must reference keys stored in `thread_creation_menu_submenus`.",
+      "See also: `thread_creation_menu_submenus`."
+    ]
+  },
+  "thread_creation_menu_submenus": {
+    "default": "Empty (no submenus)",
+    "description": "Mapping of submenu keys to submenu option mappings, identical structure to `thread_creation_menu_options` allowing nested selection.",
+    "examples": [
+  "`{prefix}threadmenu submenu create Appeals`",
+  "`{prefix}threadmenu submenu option add Appeals`"
+    ],
+    "notes": [
+      "Submenus allow categorizing options beyond the 25 main menu limit (each submenu limited by Discord select menu rules).",
+      "See also: `thread_creation_menu_options`."
+    ]
+  },
+  "thread_creation_menu_timeout": {
+    "default": "30 (seconds)",
+    "description": "Number of seconds to wait for a user to pick a menu option before timing out.",
+    "examples": [
+  "`{prefix}config set thread_creation_menu_timeout 30`"
+    ],
+    "notes": [
+      "If the timeout is reached, `thread_creation_menu_close_on_timeout` controls whether the attempt is aborted or the user is asked to message again.",
+      "See also: `thread_creation_menu_close_on_timeout`."
+    ]
+  },
+  "thread_creation_menu_close_on_timeout": {
+    "default": "No",
+    "description": "Silently aborts thread creation if the user does not select an option before the timeout expires.",
+    "examples": [
+  "`{prefix}config set thread_creation_menu_close_on_timeout yes`"
+    ],
+    "notes": [
+      "If disabled, the user receives a message telling them to send a new DM to start again.",
+      "See also: `thread_creation_menu_timeout`."
+    ]
+  },
+  "thread_creation_menu_anonymous_menu": {
+    "default": "No",
+    "description": "If enabled, the initial menu prompt relayed to staff (after creation) is anonymized; only selection details are logged, not the original prompt message author context.",
+    "examples": [
+  "`{prefix}config set thread_creation_menu_anonymous_menu yes`"
+    ],
+    "notes": [
+      "Does not affect the DM the user sees, only how it's displayed/logged internally.",
+      "See also: `thread_creation_menu_selection_log`."
+    ]
+  },
+  "thread_creation_menu_embed_text": {
+    "default": "\"Please select an option.\"",
+    "description": "Text shown in the embed above the selection dropdown in the user's DM.",
+    "examples": [
+  "`{prefix}config set thread_creation_menu_embed_text Please choose a department`"
+    ],
+    "notes": [
+      "Keep this concise; users cannot proceed until choosing.",
+      "See also: `thread_creation_menu_dropdown_placeholder`."
+    ]
+  },
+  "thread_creation_menu_dropdown_placeholder": {
+    "default": "\"Select an option to contact the staff team.\"",
+    "description": "Placeholder text displayed in the dropdown before selection.",
+    "examples": [
+  "`{prefix}config set thread_creation_menu_dropdown_placeholder Pick a topic...`"
+    ],
+    "notes": [
+      "Appears grayed out inside the select component.",
+      "See also: `thread_creation_menu_embed_text`."
+    ]
+  },
+  "thread_creation_menu_selection_log": {
+    "default": "Yes",
+    "description": "Logs the chosen menu option (label, type, callback) as a message in the newly created thread channel for moderator visibility.",
+    "examples": [
+      "`{prefix}config set thread_creation_menu_selection_log no`"
+    ],
+    "notes": [
+      "When disabled, the staff will not see an automatic message with the selection details though commands may still act.",
+      "See also: `thread_creation_menu_enabled`, `thread_creation_menu_options`."
+    ]
+  },
+  "thread_creation_menu_precreate_channel": {
+    "default": "No",
+    "description": "When enabled, a thread channel is created immediately upon the user's first DM even if the thread creation menu is enabled. The menu is still shown but selection becomes optional and happens after channel creation.",
+    "examples": [
+      "`{prefix}config set thread_creation_menu_precreate_channel yes`"
+    ],
+    "notes": [
+      "If a user never selects an option the thread remains open in the default/main category.",
+      "Category-specific option selections will move the channel afterward if a category_id is configured on the option.",
+      "Confirmation (`confirm_thread_creation`) is only applied in the deferred mode; enabling precreate bypasses the confirm step for menu flows.",
+      "See also: `thread_creation_menu_enabled`, `thread_creation_menu_options`, `confirm_thread_creation`."
+    ]
+  },
+  "thread_creation_menu_embed_title": {
+    "default": "Empty (no title)",
+    "description": "Optional title at the top of the thread-creation menu embed in the user's DM.",
+    "examples": [
+      "`{prefix}config set thread_creation_menu_embed_title Contact the staff team`",
+      "`{prefix}config delete thread_creation_menu_embed_title` (clear)"
+    ],
+    "notes": [
+      "See also: `thread_creation_menu_embed_text`."
+    ]
+  },
+  "thread_creation_menu_embed_footer": {
+    "default": "Empty (no footer)",
+    "description": "Optional footer text at the bottom of the menu embed.",
+    "examples": [
+      "`{prefix}config set thread_creation_menu_embed_footer Please choose the most relevant option`",
+      "`{prefix}config delete thread_creation_menu_embed_footer` (clear)"
+    ],
+    "notes": [
+      "You can also configure an optional footer icon via `thread_creation_menu_embed_footer_icon_url`."
+    ]
+  },
+  "thread_creation_menu_embed_footer_icon_url": {
+    "default": "Empty (no icon)",
+    "description": "Optional URL for the small footer icon displayed next to the footer text.",
+    "examples": [
+      "`{prefix}config set thread_creation_menu_embed_footer_icon_url https://example.com/icon.png`",
+      "`{prefix}config delete thread_creation_menu_embed_footer_icon_url` (clear)"
+    ],
+    "notes": [
+      "Use a direct image URL (PNG/JPEG/GIF)."
+    ]
+  },
+  "thread_creation_menu_embed_thumbnail_url": {
+    "default": "Empty (no thumbnail)",
+    "description": "Optional thumbnail image shown in the top-right of the menu embed.",
+    "examples": [
+      "`{prefix}config set thread_creation_menu_embed_thumbnail_url https://example.com/logo.png`",
+      "`{prefix}config delete thread_creation_menu_embed_thumbnail_url` (clear)"
+    ],
+    "notes": [
+      "Use a direct image URL; recommended square image.",
+      "Consider file size/CDN reliability so it loads quickly for users."
+    ]
+  },
+  "thread_creation_menu_embed_image_url": {
+    "default": "Empty (no image)",
+    "description": "Optional large hero image displayed in the body of the menu embed. If set, this image is shown prominently and takes precedence over the thumbnail.",
+    "examples": [
+      "`{prefix}config set thread_creation_menu_embed_image_url https://example.com/banner.png`",
+      "`{prefix}config delete thread_creation_menu_embed_image_url` (clear)"
+    ],
+    "notes": [
+      "Use a direct image URL (PNG/JPEG/GIF).",
+      "When both a thumbnail and image URL are set, the image URL is used as the large embed image while the thumbnail may still be shown in the top-right.",
+      "See also: `thread_creation_menu_embed_thumbnail_url`, `thread_creation_menu_embed_large_image`."
+    ]
+  },
+  "thread_creation_menu_embed_large_image": {
+    "default": "No",
+    "description": "Promotes the thumbnail to a large hero image when no `thread_creation_menu_embed_image_url` is set. Useful if you want a big image without specifying a separate URL.",
+    "examples": [
+      "`{prefix}config set thread_creation_menu_embed_large_image yes`",
+      "`{prefix}config set thread_creation_menu_embed_large_image no`"
+    ],
+    "notes": [
+      "Only applies when `thread_creation_menu_embed_image_url` is not set.",
+      "If both are provided, the explicit image URL takes precedence.",
+      "See also: `thread_creation_menu_embed_thumbnail_url`, `thread_creation_menu_embed_image_url`."
+    ]
+  },
+  "thread_creation_menu_embed_color": {
+    "default": "Green (hex for Discord Color.green)",
+    "description": "Color for the menu embed's side strip. Accepts hex (e.g. #5865F2) or one of the supported color names.",
+    "examples": [
+      "`{prefix}config set thread_creation_menu_embed_color #5865F2`",
+      "`{prefix}config set thread_creation_menu_embed_color blurple`"
+    ],
+    "notes": [
+      "Color names map to the built-in palette (e.g., 'red', 'green', 'blurple')."
     ]
   }
 }
\ No newline at end of file
diff --git a/core/models.py b/core/models.py
index 611db375f0..e8418ef758 100644
--- a/core/models.py
+++ b/core/models.py
@@ -30,15 +30,15 @@
 class ModmailLogger(logging.Logger):
     @staticmethod
     def _debug_(*msgs):
-        return f'{Fore.CYAN}{" ".join(msgs)}{Style.RESET_ALL}'
+        return f"{Fore.CYAN}{' '.join(msgs)}{Style.RESET_ALL}"
 
     @staticmethod
     def _info_(*msgs):
-        return f'{Fore.LIGHTMAGENTA_EX}{" ".join(msgs)}{Style.RESET_ALL}'
+        return f"{Fore.LIGHTMAGENTA_EX}{' '.join(msgs)}{Style.RESET_ALL}"
 
     @staticmethod
     def _error_(*msgs):
-        return f'{Fore.RED}{" ".join(msgs)}{Style.RESET_ALL}'
+        return f"{Fore.RED}{' '.join(msgs)}{Style.RESET_ALL}"
 
     def debug(self, msg, *args, **kwargs):
         if self.isEnabledFor(logging.DEBUG):
@@ -70,7 +70,10 @@ def line(self, level="info"):
         if self.isEnabledFor(level):
             self._log(
                 level,
-                Fore.BLACK + Style.BRIGHT + "-------------------------" + Style.RESET_ALL,
+                Fore.BLACK
+                + Style.BRIGHT
+                + "-------------------------"
+                + Style.RESET_ALL,
                 [],
             )
 
@@ -95,7 +98,9 @@ def __init__(
         time_format: str = "%Y-%m-%dT%H:%M:%S",
         msec_format: str = "%s.%03dZ",
     ):
-        self.fmt_dict: Dict[str, str] = fmt_dict if fmt_dict is not None else {"message": "message"}
+        self.fmt_dict: Dict[str, str] = (
+            fmt_dict if fmt_dict is not None else {"message": "message"}
+        )
         self.default_time_format: str = time_format
         self.default_msec_format: str = msec_format
         self.datefmt: Optional[str] = None
@@ -111,7 +116,10 @@ def formatMessage(self, record) -> Dict[str, str]:
         Overwritten to return a dictionary of the relevant LogRecord attributes instead of a string.
         KeyError is raised if an unknown attribute is provided in the fmt_dict.
         """
-        return {fmt_key: record.__dict__[fmt_val] for fmt_key, fmt_val in self.fmt_dict.items()}
+        return {
+            fmt_key: record.__dict__[fmt_val]
+            for fmt_key, fmt_val in self.fmt_dict.items()
+        }
 
     def format(self, record) -> str:
         """
@@ -149,7 +157,8 @@ def format(self, record):
 
 
 log_stream_formatter = logging.Formatter(
-    "%(asctime)s %(name)s[%(lineno)d] - %(levelname)s: %(message)s", datefmt="%m/%d/%y %H:%M:%S"
+    "%(asctime)s %(name)s[%(lineno)d] - %(levelname)s: %(message)s",
+    datefmt="%m/%d/%y %H:%M:%S",
 )
 
 log_file_formatter = FileFormatter(
@@ -221,7 +230,9 @@ def create_log_handler(
     depending on the `rotating` value.
     """
     if filename is None and rotating:
-        raise ValueError("`filename` must be set to instantiate a `RotatingFileHandler`.")
+        raise ValueError(
+            "`filename` must be set to instantiate a `RotatingFileHandler`."
+        )
 
     if filename is None:
         handler = StreamHandler(stream=sys.stdout, **kwargs)
@@ -231,7 +242,12 @@ def create_log_handler(
         formatter = log_file_formatter
     else:
         handler = RotatingFileHandler(
-            filename, mode=mode, encoding=encoding, maxBytes=maxBytes, backupCount=backupCount, **kwargs
+            filename,
+            mode=mode,
+            encoding=encoding,
+            maxBytes=maxBytes,
+            backupCount=backupCount,
+            **kwargs,
         )
         formatter = log_file_formatter
 
@@ -264,7 +280,10 @@ def getLogger(name=None) -> ModmailLogger:
 def configure_logging(bot) -> None:
     global ch_debug, log_level, ch
 
-    stream_log_format, file_log_format = bot.config["stream_log_format"], bot.config["file_log_format"]
+    stream_log_format, file_log_format = (
+        bot.config["stream_log_format"],
+        bot.config["file_log_format"],
+    )
     if stream_log_format == "json":
         ch.setFormatter(json_formatter)
 
@@ -318,8 +337,13 @@ def configure_logging(bot) -> None:
     non_verbose_log_level = max(d_level, logging.INFO)
     stream_handler = create_log_handler(level=non_verbose_log_level)
     if non_verbose_log_level != d_level:
-        logger.info("Discord logging level (stdout): %s.", logging.getLevelName(non_verbose_log_level))
-        logger.info("Discord logging level (logfile): %s.", logging.getLevelName(d_level))
+        logger.info(
+            "Discord logging level (stdout): %s.",
+            logging.getLevelName(non_verbose_log_level),
+        )
+        logger.info(
+            "Discord logging level (logfile): %s.", logging.getLevelName(d_level)
+        )
     else:
         logger.info("Discord logging level: %s.", logging.getLevelName(d_level))
     d_logger.addHandler(stream_handler)
@@ -336,7 +360,9 @@ def __init__(self, msg, *args):
     @property
     def embed(self):
         # Single reference of Color.red()
-        return discord.Embed(title="Error", description=self.msg, color=discord.Color.red())
+        return discord.Embed(
+            title="Error", description=self.msg, color=discord.Color.red()
+        )
 
 
 class _Default:
@@ -403,7 +429,9 @@ async def convert(self, ctx, argument):
                     if isinstance(c, discord.CategoryChannel)
                 }
 
-            result = get_close_matches(argument.casefold(), categories.keys(), n=1, cutoff=0.75)
+            result = get_close_matches(
+                argument.casefold(), categories.keys(), n=1, cutoff=0.75
+            )
             if result:
                 result = categories[result[0]]
 
diff --git a/core/paginator.py b/core/paginator.py
index 48222d283e..119b834638 100644
--- a/core/paginator.py
+++ b/core/paginator.py
@@ -299,14 +299,20 @@ async def callback(self, interaction: Interaction):
 
 
 class PageSelect(Select):
-    def __init__(self, handler: PaginatorSession, pages: typing.List[typing.Tuple[str]]):
+    def __init__(
+        self, handler: PaginatorSession, pages: typing.List[typing.Tuple[str]]
+    ):
         self.handler = handler
         options = []
         for n, (label, description) in enumerate(pages):
-            options.append(discord.SelectOption(label=label, description=description, value=str(n)))
+            options.append(
+                discord.SelectOption(label=label, description=description, value=str(n))
+            )
 
         options = options[:25]  # max 25 options
-        super().__init__(placeholder="Select a page", min_values=1, max_values=1, options=options)
+        super().__init__(
+            placeholder="Select a page", min_values=1, max_values=1, options=options
+        )
 
     async def callback(self, interaction: Interaction):
         page = int(self.values[0])
@@ -345,7 +351,9 @@ def __init__(self, ctx: commands.Context, *embeds, **options):
                         create_select = False
 
                 if embed.description:
-                    description = embed.description[:40].replace("*", "").replace("`", "").strip()
+                    description = (
+                        embed.description[:40].replace("*", "").replace("`", "").strip()
+                    )
                     if len(embed.description) > 40:
                         description += "..."
                 else:
@@ -353,7 +361,9 @@ def __init__(self, ctx: commands.Context, *embeds, **options):
                 select_options.append((title, description))
 
             if create_select:
-                if len(set(x[0] for x in select_options)) != 1:  # must have unique authors
+                if (
+                    len(set(x[0] for x in select_options)) != 1
+                ):  # must have unique authors
                     self.select_menu = PageSelect(self, select_options)
 
     def add_page(self, item: Embed) -> None:
@@ -370,7 +380,9 @@ def _show_page(self, page):
 
 
 class MessagePaginatorSession(PaginatorSession):
-    def __init__(self, ctx: commands.Context, *messages, embed: Embed = None, **options):
+    def __init__(
+        self, ctx: commands.Context, *messages, embed: Embed = None, **options
+    ):
         self.embed = embed
         self.footer_text = self.embed.footer.text if embed is not None else None
         super().__init__(ctx, *messages, **options)
@@ -383,12 +395,14 @@ def add_page(self, item: str) -> None:
 
     def _set_footer(self):
         if self.embed is not None:
-            footer_text = f"Page {self.current+1} of {len(self.pages)}"
+            footer_text = f"Page {self.current + 1} of {len(self.pages)}"
             if self.footer_text:
                 footer_text = footer_text + " • " + self.footer_text
 
             if self.embed.footer.icon:
-                icon_url = self.embed.footer.icon.url if self.embed.footer.icon else None
+                icon_url = (
+                    self.embed.footer.icon.url if self.embed.footer.icon else None
+                )
             else:
                 icon_url = None
 
diff --git a/core/thread.py b/core/thread.py
index d380552694..fdf628797b 100644
--- a/core/thread.py
+++ b/core/thread.py
@@ -1,6 +1,6 @@
 import asyncio
-import base64
 import copy
+import base64
 import functools
 import io
 import re
@@ -14,12 +14,13 @@
 import isodate
 
 import discord
+from discord.ext import commands
 from discord.ext.commands import MissingRequiredArgument, CommandError
 from lottie.importers import importers as l_importers
 from lottie.exporters import exporters as l_exporters
 
-from core.models import DMDisabled, DummyMessage, getLogger
-from core.time import human_timedelta
+from core.models import DMDisabled, DummyMessage, PermissionLevel, getLogger
+from core import checks
 from core.utils import (
     is_image_url,
     parse_channel_topic,
@@ -33,7 +34,6 @@
     DenyButton,
     ConfirmThreadCreationView,
     DummyParam,
-    extract_forwarded_content,
 )
 
 logger = getLogger(__name__)
@@ -47,7 +47,9 @@ def __init__(
         manager: "ThreadManager",
         recipient: typing.Union[discord.Member, discord.User, int],
         channel: typing.Union[discord.DMChannel, discord.TextChannel] = None,
-        other_recipients: typing.List[typing.Union[discord.Member, discord.User]] = None,
+        other_recipients: typing.List[
+            typing.Union[discord.Member, discord.User]
+        ] = None,
     ):
         self.manager = manager
         self.bot = manager.bot
@@ -67,10 +69,17 @@ def __init__(
         self.close_task = None
         self.auto_close_task = None
         self._cancelled = False
+        self._dm_menu_msg_id = None
+        self._dm_menu_channel_id = None
         # --- SNOOZE STATE ---
         self.snoozed = False  # True if thread is snoozed
-        self.snooze_data = None  # Dict with channel/category/position/messages for restoration
+        self.snooze_data = (
+            None  # Dict with channel/category/position/messages for restoration
+        )
         self.log_key = None  # Ensure log_key always exists
+        # --- UNSNOOZE COMMAND QUEUE ---
+        self._unsnoozing = False  # True while restore_from_snooze is running
+        self._command_queue = []  # Queue of (ctx, command) tuples; close commands always last
 
     def __repr__(self):
         return f'Thread(recipient="{self.recipient or self.id}", channel={self.channel.id}, other_recipients={len(self._other_recipients)})'
@@ -83,14 +92,17 @@ def __eq__(self, other):
     async def wait_until_ready(self) -> None:
         """Blocks execution until the thread is fully set up."""
         # timeout after 30 seconds
-        task = self.bot.loop.create_task(asyncio.wait_for(self._ready_event.wait(), timeout=25))
+        task = self.bot.loop.create_task(
+            asyncio.wait_for(self._ready_event.wait(), timeout=25)
+        )
         self.wait_tasks.append(task)
         try:
             await task
         except asyncio.TimeoutError:
-            pass
-
-        self.wait_tasks.remove(task)
+            logger.warning("Waiting for thread setup timed out.")
+        finally:
+            if task in self.wait_tasks:
+                self.wait_tasks.remove(task)
 
     @property
     def id(self) -> int:
@@ -113,10 +125,19 @@ def ready(self) -> bool:
         return self._ready_event.is_set()
 
     @ready.setter
-    def ready(self, flag: bool):
+    def ready(self, flag: bool) -> None:
+        """Set the ready state and dispatch thread_create when transitioning to ready.
+
+        Some legacy code paths set thread.ready = True/False. This setter preserves that API by
+        updating the internal event and emitting the creation event when entering the ready state.
+        """
         if flag:
-            self._ready_event.set()
-            self.bot.dispatch("thread_create", self)
+            if not self._ready_event.is_set():
+                self._ready_event.set()
+                try:
+                    self.bot.dispatch("thread_create", self)
+                except Exception as e:
+                    logger.warning("Error dispatching thread_create: %s", e)
         else:
             self._ready_event.clear()
 
@@ -133,13 +154,40 @@ def cancelled(self, flag: bool):
 
     async def snooze(self, moderator=None, command_used=None, snooze_for=None):
         """
-        Save channel/category/position/messages to DB, mark as snoozed, delete channel.
+        Save channel/category/position/messages to DB, mark as snoozed.
+        Behavior is configurable:
+        - delete (default): delete the channel and store all data for full restore later
+        - move: move channel to a configured snoozed category and hide it (keeps channel alive)
         """
         if self.snoozed:
             return False  # Already snoozed
         channel = self.channel
         if not isinstance(channel, discord.TextChannel):
             return False
+        # If using move-based snooze, hard-cap snoozed category to 49 channels
+        behavior_pre = (self.bot.config.get("snooze_behavior") or "delete").lower()
+        if behavior_pre == "move":
+            snoozed_cat_id = self.bot.config.get("snoozed_category_id")
+            target_category = None
+            if snoozed_cat_id:
+                try:
+                    target_category = self.bot.modmail_guild.get_channel(
+                        int(snoozed_cat_id)
+                    )
+                except Exception:
+                    target_category = None
+            if isinstance(target_category, discord.CategoryChannel):
+                try:
+                    if len(target_category.channels) >= 49:
+                        logger.warning(
+                            "Snoozed category (%s) is full (>=49 channels). Blocking snooze for thread %s.",
+                            target_category.id,
+                            self.id,
+                        )
+                        return False
+                except Exception:
+                    # If we cannot determine channel count, proceed; downstream will handle errors
+                    pass
         # Ensure self.log_key is set before snoozing
         if not self.log_key:
             # Try to fetch from DB using channel_id
@@ -160,7 +208,9 @@ async def snooze(self, moderator=None, command_used=None, snooze_for=None):
             "topic": channel.topic,
             "slowmode_delay": channel.slowmode_delay,
             "nsfw": channel.nsfw,
-            "overwrites": [(role.id, perm._values) for role, perm in channel.overwrites.items()],
+            "overwrites": [
+                (role.id, perm._values) for role, perm in channel.overwrites.items()
+            ],
             "messages": [
                 {
                     "author_id": m.author.id,
@@ -174,24 +224,32 @@ async def snooze(self, moderator=None, command_used=None, snooze_for=None):
                             m.embeds
                             and getattr(m.embeds[0], "author", None)
                             and (
-                                getattr(m.embeds[0].author, "name", "").startswith("📝 Note")
-                                or getattr(m.embeds[0].author, "name", "").startswith("📝 Persistent Note")
+                                getattr(m.embeds[0].author, "name", "").startswith(
+                                    "📝 Note"
+                                )
+                                or getattr(m.embeds[0].author, "name", "").startswith(
+                                    "📝 Persistent Note"
+                                )
                             )
                         )
                         else None
                     ),
-                    "author_name": getattr(m.author, "name", None),
+                    "author_name": (
+                        getattr(m.embeds[0].author, "name", "").split(" (")[0]
+                        if m.embeds and m.embeds[0].author and m.author == self.bot.user
+                        else getattr(m.author, "name", None)
+                        if m.author != self.bot.user
+                        else None
+                    ),
+                    "author_avatar": (
+                        getattr(m.embeds[0].author, "icon_url", None)
+                        if m.embeds and m.embeds[0].author and m.author == self.bot.user
+                        else m.author.display_avatar.url
+                        if m.author != self.bot.user
+                        else None
+                    ),
                 }
                 async for m in channel.history(limit=None, oldest_first=True)
-                if not (
-                    m.embeds
-                    and getattr(m.embeds[0], "author", None)
-                    and (
-                        getattr(m.embeds[0].author, "name", "").startswith("📝 Note")
-                        or getattr(m.embeds[0].author, "name", "").startswith("📝 Persistent Note")
-                    )
-                )
-                and getattr(m, "type", None) not in ("internal", "note")
             ],
             "snoozed_by": getattr(moderator, "name", None) if moderator else None,
             "snooze_command": command_used,
@@ -213,76 +271,483 @@ async def snooze(self, moderator=None, command_used=None, snooze_for=None):
         import logging
 
         logging.info(f"[SNOOZE] DB update result: {result.modified_count}")
-        # Delete channel
-        await channel.delete(reason="Thread snoozed by moderator")
-        self._channel = None
+
+        behavior = behavior_pre
+        if behavior == "move":
+            # Move the channel to the snoozed category (if configured) and optionally apply a prefix
+            snoozed_cat_id = self.bot.config.get("snoozed_category_id")
+            target_category = None
+            guild = self.bot.modmail_guild
+            if snoozed_cat_id:
+                try:
+                    target_category = guild.get_channel(int(snoozed_cat_id))
+                except Exception:
+                    target_category = None
+            # If no valid snooze category is configured, create one automatically
+            if not isinstance(target_category, discord.CategoryChannel):
+                try:
+                    # By default, hide the snoozed category from everyone and allow only the bot to see it
+                    overwrites = {
+                        guild.default_role: discord.PermissionOverwrite(
+                            view_channel=False
+                        )
+                    }
+                    bot_member = guild.me
+                    if bot_member is not None:
+                        overwrites[bot_member] = discord.PermissionOverwrite(
+                            view_channel=True,
+                            send_messages=True,
+                            read_message_history=True,
+                            manage_channels=True,
+                            manage_messages=True,
+                            attach_files=True,
+                            embed_links=True,
+                            add_reactions=True,
+                        )
+
+                    target_category = await guild.create_category(
+                        name="Snoozed Threads",
+                        overwrites=overwrites,
+                        reason="Auto-created snoozed category for move-based snoozing",
+                    )
+                    # Persist the newly created category ID into config for future runs
+                    try:
+                        await self.bot.config.set(
+                            "snoozed_category_id", target_category.id
+                        )
+                        await self.bot.config.update()
+                    except Exception:
+                        logger.warning(
+                            "Failed to persist snoozed_category_id after auto-creation."
+                        )
+                except Exception as e:
+                    logger.warning(
+                        "Failed to auto-create snoozed category (%s). Falling back to current category.",
+                        e,
+                    )
+                    target_category = channel.category
+            try:
+                # Move and sync permissions so the channel inherits the hidden snoozed-category perms
+                await channel.edit(
+                    category=target_category,
+                    reason="Thread snoozed (moved)",
+                    sync_permissions=True,
+                )
+                # Keep channel reference; just moved
+                self._channel = channel
+                # mark in snooze data that this was a move-based snooze
+                self.snooze_data["moved"] = True
+            except Exception as e:
+                logger.warning(
+                    "Failed to move channel to snoozed category: %s. Falling back to delete.",
+                    e,
+                )
+                await channel.delete(
+                    reason="Thread snoozed by moderator (fallback delete)"
+                )
+                self._channel = None
+        else:
+            # Delete channel
+            await channel.delete(reason="Thread snoozed by moderator")
+            self._channel = None
         return True
 
     async def restore_from_snooze(self):
         """
-        Recreate channel in original category/position, replay messages, mark as not snoozed.
+        Restore a snoozed thread.
+        - If channel was deleted (delete behavior), recreate and replay messages.
+        - If channel was moved (move behavior), move back to original category and position.
+        Mark as not snoozed and clear snooze data.
         """
+        # Prevent concurrent unsnooze operations
+        if self._unsnoozing:
+            logger.warning(
+                f"Unsnooze already in progress for thread {self.id}, skipping duplicate call"
+            )
+            return False
+
+        # Mark that unsnooze is in progress
+        self._unsnoozing = True
+
         if not self.snooze_data or not isinstance(self.snooze_data, dict):
             import logging
 
             logging.warning(
                 f"[UNSNOOZE] Tried to restore thread {self.id} but snooze_data is None or not a dict."
             )
+            self._unsnoozing = False
             return False
-        # Now safe to access self.snooze_data
+
+        # Cache some fields we need later (before we potentially clear snooze_data)
         snoozed_by = self.snooze_data.get("snoozed_by")
         snooze_command = self.snooze_data.get("snooze_command")
+
         guild = self.bot.modmail_guild
-        category = guild.get_channel(self.snooze_data["category_id"])
-        overwrites = {}
-        for role_id, perm_values in self.snooze_data["overwrites"]:
-            role = guild.get_role(role_id) or guild.get_member(role_id)
-            if role:
-                overwrites[role] = discord.PermissionOverwrite(**perm_values)
-        channel = await guild.create_text_channel(
-            name=self.snooze_data["name"],
-            category=category,
-            topic=self.snooze_data["topic"],
-            slowmode_delay=self.snooze_data["slowmode_delay"],
-            overwrites=overwrites,
-            nsfw=self.snooze_data["nsfw"],
-            position=self.snooze_data["position"],
-            reason="Thread unsnoozed/restored",
+        behavior = (self.bot.config.get("snooze_behavior") or "delete").lower()
+
+        # Determine original category; fall back to main_category_id if original missing
+        orig_category = (
+            guild.get_channel(self.snooze_data.get("category_id"))
+            if self.snooze_data.get("category_id")
+            else None
         )
-        self._channel = channel
+        if not isinstance(orig_category, discord.CategoryChannel):
+            main_cat_id = self.bot.config.get("main_category_id")
+            orig_category = guild.get_channel(int(main_cat_id)) if main_cat_id else None
+
+        # Default: assume we'll need to recreate
+        channel: typing.Optional[discord.TextChannel] = None
+
+        # If move-behavior and channel still exists, move it back and restore overwrites
+        if behavior == "move" and isinstance(self.channel, discord.TextChannel):
+            try:
+                await self.channel.edit(
+                    category=orig_category,
+                    position=self.snooze_data.get("position", self.channel.position),
+                    reason="Thread unsnoozed/restored",
+                )
+                # Restore original overwrites captured at snooze time
+                try:
+                    ow_map: dict = {}
+                    for role_id, perm_values in self.snooze_data.get("overwrites", []):
+                        target = guild.get_role(role_id) or guild.get_member(role_id)
+                        if target is None:
+                            continue
+                        ow_map[target] = discord.PermissionOverwrite(**perm_values)
+                    if ow_map:
+                        await self.channel.edit(
+                            overwrites=ow_map, reason="Restore original overwrites"
+                        )
+                except Exception as e:
+                    logger.warning(
+                        "Failed to restore original overwrites on unsnooze: %s", e
+                    )
+
+                channel = self.channel
+            except Exception as e:
+                logger.warning("Failed to move snoozed channel back, recreating: %s", e)
+                channel = None
+
+        # If we couldn't move back (or behavior=delete), recreate the channel
+        if channel is None:
+            try:
+                ow_map: dict = {}
+                for role_id, perm_values in self.snooze_data.get("overwrites", []):
+                    target = guild.get_role(role_id) or guild.get_member(role_id)
+                    if target is None:
+                        continue
+                    ow_map[target] = discord.PermissionOverwrite(**perm_values)
+
+                channel = await guild.create_text_channel(
+                    name=self.snooze_data.get("name") or f"thread-{self.id}",
+                    category=orig_category,
+                    # discord.py expects a dict for overwrites; use empty dict if none
+                    overwrites=ow_map or {},
+                    position=self.snooze_data.get("position"),
+                    topic=self.snooze_data.get("topic"),
+                    slowmode_delay=self.snooze_data.get("slowmode_delay") or 0,
+                    nsfw=bool(self.snooze_data.get("nsfw")),
+                    reason="Thread unsnoozed/restored (recreated)",
+                )
+                self._channel = channel
+            except Exception:
+                logger.error(
+                    "Failed to recreate thread channel during unsnooze.", exc_info=True
+                )
+                return False
+
+        # Helper to safely send to thread channel, recreating once if deleted
+        async def _safe_send_to_channel(
+            *, content=None, embeds=None, allowed_mentions=None
+        ):
+            nonlocal channel
+            try:
+                return await channel.send(
+                    content=content, embeds=embeds, allowed_mentions=allowed_mentions
+                )
+            except discord.NotFound:
+                # Channel was deleted between restore and send; try to recreate once
+                try:
+                    ow_map: dict = {}
+                    for role_id, perm_values in (
+                        self.snooze_data.get("overwrites", []) or []
+                    ):
+                        target = guild.get_role(role_id) or guild.get_member(role_id)
+                        if target is None:
+                            continue
+                        ow_map[target] = discord.PermissionOverwrite(**perm_values)
+                    channel = await guild.create_text_channel(
+                        name=(self.snooze_data.get("name") or f"thread-{self.id}"),
+                        category=orig_category,
+                        # discord.py expects a dict for overwrites; use empty dict if none
+                        overwrites=ow_map or {},
+                        position=self.snooze_data.get("position"),
+                        topic=self.snooze_data.get("topic"),
+                        slowmode_delay=self.snooze_data.get("slowmode_delay") or 0,
+                        nsfw=bool(self.snooze_data.get("nsfw")),
+                        reason="Thread unsnoozed/restored (recreated after NotFound)",
+                    )
+                    self._channel = channel
+                    return await channel.send(
+                        content=content,
+                        embeds=embeds,
+                        allowed_mentions=allowed_mentions,
+                    )
+                except Exception:
+                    logger.error(
+                        "Failed to recreate channel during unsnooze send.",
+                        exc_info=True,
+                    )
+                    return None
+
+        # Ensure genesis message exists; always present after unsnooze
+        genesis_already_sent = False
+
+        async def _ensure_genesis(force: bool = False):
+            nonlocal genesis_already_sent
+            try:
+                existing = await self.get_genesis_message()
+            except Exception:
+                existing = None
+            if existing is None or force:
+                # Build log_url and log_count best-effort
+                prefix = (self.bot.config.get("log_url_prefix") or "").strip("/")
+                if prefix == "NONE":
+                    prefix = ""
+                key = self.snooze_data.get("log_key") or self.log_key
+                log_url = (
+                    f"{self.bot.config['log_url'].strip('/')}{'/' + prefix if prefix else ''}/{key}"
+                    if key
+                    else None
+                )
+                log_count = None
+                try:
+                    logs = await self.bot.api.get_user_logs(self.id)
+                    log_count = sum(1 for log in logs if not log.get("open"))
+                except Exception:
+                    log_count = None
+                # Resolve recipient object
+                user = self.recipient
+                if user is None:
+                    try:
+                        user = await self.bot.get_or_fetch_user(self.id)
+                    except Exception:
+                        user = SimpleNamespace(
+                            id=self.id,
+                            mention=f"<@{self.id}>",
+                            created_at=datetime.now(timezone.utc),
+                        )
+                try:
+                    info_embed = self._format_info_embed(
+                        user, log_url, log_count, self.bot.main_color
+                    )
+                    msg = await channel.send(embed=info_embed)
+                    try:
+                        await msg.pin()
+                    except Exception as e:
+                        logger.warning(
+                            "Failed to pin genesis message during unsnooze: %s", e
+                        )
+                    self._genesis_message = msg
+                    genesis_already_sent = True
+                except Exception:
+                    logger.warning(
+                        "Failed to send genesis message during unsnooze.", exc_info=True
+                    )
+
+        # If we recreated the channel, force-send genesis; if moved back, ensure it's present
+        try:
+            if behavior == "move" and isinstance(channel, discord.TextChannel):
+                await _ensure_genesis(force=False)
+            else:
+                await _ensure_genesis(force=True)
+        except Exception:
+            logger.debug("Genesis ensure step encountered an error.")
+
         # Strictly restore the log_key from snooze_data (never create a new one)
         self.log_key = self.snooze_data.get("log_key")
-        # Replay messages
-        for msg in self.snooze_data["messages"]:
-            author = self.bot.get_user(msg["author_id"]) or await self.bot.get_or_fetch_user(msg["author_id"])
-            content = msg["content"]
-            embeds = [discord.Embed.from_dict(e) for e in msg.get("embeds", []) if e]
-            attachments = msg.get("attachments", [])
-            msg_type = msg.get("type")
-            # Only send if there is content, embeds, or attachments
-            if not content and not embeds and not attachments:
-                continue  # Skip empty messages
-            author_is_mod = msg["author_id"] not in [r.id for r in self.recipients]
-            if author_is_mod:
-                username = msg.get("author_name") or (getattr(author, "name", None)) or "Unknown"
-                user_id = msg.get("author_id")
+
+        # Replay messages only if we re-created the channel (delete behavior or move fallback)
+        if behavior != "move" or (
+            behavior == "move" and not self.snooze_data.get("moved", False)
+        ):
+            # Get history limit from config (0 or None = show all)
+            history_limit = self.bot.config.get("unsnooze_history_limit")
+            all_messages = self.snooze_data.get("messages", [])
+
+            # Separate genesis, notes, and regular messages
+            genesis_msg = None
+            notes = []
+            regular_messages = []
+
+            for msg in all_messages:
+                msg_type = msg.get("type")
+                # Check if it's the genesis message (has Roles field)
+                if msg.get("embeds"):
+                    for embed_dict in msg.get("embeds", []):
+                        if embed_dict.get("fields"):
+                            for field in embed_dict.get("fields", []):
+                                if field.get("name") == "Roles":
+                                    genesis_msg = msg
+                                    break
+                            if genesis_msg:
+                                break
+                # Check if it's a note
+                if msg_type == "mod_only":
+                    notes.append(msg)
+                elif genesis_msg != msg:
+                    regular_messages.append(msg)
+
+            # Apply limit if set
+            limited = False
+            if history_limit:
+                try:
+                    history_limit = int(history_limit)
+                    if history_limit > 0 and len(regular_messages) > history_limit:
+                        regular_messages = regular_messages[-history_limit:]
+                        limited = True
+                except (ValueError, TypeError):
+                    pass
+
+            # Replay genesis first (only if we didn't already create it above)
+            if genesis_msg and not genesis_already_sent:
+                msg = genesis_msg
+                try:
+                    author = self.bot.get_user(
+                        msg["author_id"]
+                    ) or await self.bot.get_or_fetch_user(msg["author_id"])
+                except discord.NotFound:
+                    author = None
+                embeds = [
+                    discord.Embed.from_dict(e) for e in msg.get("embeds", []) if e
+                ]
                 if embeds:
-                    embeds[0].set_author(
-                        name=f"{username} ({user_id})",
-                        icon_url=(
-                            author.display_avatar.url
-                            if author and hasattr(author, "display_avatar")
-                            else None
-                        ),
+                    await _safe_send_to_channel(
+                        embeds=embeds, allowed_mentions=discord.AllowedMentions.none()
+                    )
+
+            # Send history limit notification after genesis
+            if limited:
+                prefix = self.bot.config["log_url_prefix"].strip("/")
+                if prefix == "NONE":
+                    prefix = ""
+                log_url = (
+                    f"{self.bot.config['log_url'].strip('/')}{'/' + prefix if prefix else ''}/{self.log_key}"
+                    if self.log_key
+                    else None
+                )
+
+                limit_embed = discord.Embed(
+                    color=0xFFA500,
+                    title="⚠️ History Limited",
+                    description=f"Only showing the last **{history_limit}** messages due to the `unsnooze_history_limit` setting.",
+                )
+                if log_url:
+                    limit_embed.description += (
+                        f"\n\n[View full history in logs]({log_url})"
                     )
-                    await channel.send(embeds=embeds)
+                await _safe_send_to_channel(
+                    embeds=[limit_embed],
+                    allowed_mentions=discord.AllowedMentions.none(),
+                )
+
+            # Build list of remaining messages to show
+            messages_to_show = []
+            messages_to_show.extend(notes)
+            messages_to_show.extend(regular_messages)
+
+            for msg in messages_to_show:
+                try:
+                    author = self.bot.get_user(
+                        msg["author_id"]
+                    ) or await self.bot.get_or_fetch_user(msg["author_id"])
+                except discord.NotFound:
+                    author = None
+
+                content = msg.get("content")
+                embeds = [
+                    discord.Embed.from_dict(e) for e in msg.get("embeds", []) if e
+                ]
+                attachments = msg.get("attachments", [])
+
+                # Only send if there is something to send
+                if not content and not embeds and not attachments:
+                    continue
+
+                author_is_mod = msg["author_id"] not in [r.id for r in self.recipients]
+                if author_is_mod:
+                    # Prefer stored author_name/avatar
+                    username = (
+                        msg.get("author_name")
+                        or (getattr(author, "name", None) if author else None)
+                        or "Unknown"
+                    )
+                    user_id = msg.get("author_id")
+                    if embeds:
+                        # Ensure embeds show author details
+                        embeds[0].set_author(
+                            name=f"{username} ({user_id})",
+                            icon_url=msg.get("author_avatar")
+                            or (
+                                author.display_avatar.url
+                                if author and hasattr(author, "display_avatar")
+                                else None
+                            ),
+                        )
+                        # If there were attachment URLs, include them as a field so mods can access them
+                        if attachments:
+                            try:
+                                embeds[0].add_field(
+                                    name="Attachments",
+                                    value="\n".join(attachments),
+                                    inline=False,
+                                )
+                            except Exception as e:
+                                logger.info(
+                                    "Failed to add attachments field while replaying unsnoozed messages: %s",
+                                    e,
+                                )
+                        await _safe_send_to_channel(
+                            embeds=embeds,
+                            allowed_mentions=discord.AllowedMentions.none(),
+                        )
+                    else:
+                        # Plain-text path (no embeds): prefix with username and user id
+                        header = f"**{username} ({user_id})**"
+                        body = content or ""
+                        if attachments and not body:
+                            # no content; include attachment URLs on new lines
+                            body = "\n".join(attachments)
+                        formatted = f"{header}: {body}" if body else header
+                        await _safe_send_to_channel(
+                            content=formatted,
+                            allowed_mentions=discord.AllowedMentions.none(),
+                        )
                 else:
-                    formatted = (
-                        f"**{username} ({user_id})**: {content}" if content else f"**{username} ({user_id})**"
+                    # Recipient message: include attachment URLs if content is empty
+                    # When no embeds, prefix plain text with username and user id
+                    username = (
+                        msg.get("author_name")
+                        or (getattr(author, "name", None) if author else None)
+                        or "Unknown"
                     )
-                    await channel.send(formatted)
-            else:
-                await channel.send(content=content or None, embeds=embeds or None)
+                    user_id = msg.get("author_id")
+                    if embeds:
+                        await _safe_send_to_channel(
+                            content=None,
+                            embeds=embeds or None,
+                            allowed_mentions=discord.AllowedMentions.none(),
+                        )
+                    else:
+                        header = f"**{username} ({user_id})**"
+                        body = content or ""
+                        if attachments and not body:
+                            body = "\n".join(attachments)
+                        formatted = f"{header}: {body}" if body else header
+                        await _safe_send_to_channel(
+                            content=formatted,
+                            allowed_mentions=discord.AllowedMentions.none(),
+                        )
         self.snoozed = False
         # Store snooze_data for notification before clearing
         snooze_data_for_notify = self.snooze_data
@@ -291,12 +756,18 @@ async def restore_from_snooze(self):
         if self.log_key:
             result = await self.bot.api.logs.update_one(
                 {"key": self.log_key},
-                {"$set": {"channel_id": str(channel.id)}, "$unset": {"snoozed": "", "snooze_data": ""}},
+                {
+                    "$set": {"channel_id": str(channel.id)},
+                    "$unset": {"snoozed": "", "snooze_data": ""},
+                },
             )
         else:
             result = await self.bot.api.logs.update_one(
                 {"recipient.id": str(self.id)},
-                {"$set": {"channel_id": str(channel.id)}, "$unset": {"snoozed": "", "snooze_data": ""}},
+                {
+                    "$set": {"channel_id": str(channel.id)},
+                    "$unset": {"snoozed": "", "snooze_data": ""},
+                },
             )
             if result.modified_count == 0:
                 result = await self.bot.api.logs.update_one(
@@ -311,24 +782,52 @@ async def restore_from_snooze(self):
         logging.info(f"[UNSNOOZE] DB update result: {result.modified_count}")
         # Notify in the configured channel
         notify_channel = self.bot.config.get("unsnooze_notify_channel") or "thread"
-        notify_text = self.bot.config.get("unsnooze_text") or "This thread has been unsnoozed and restored."
+        notify_text = (
+            self.bot.config.get("unsnooze_text")
+            or "This thread has been unsnoozed and restored."
+        )
         if notify_channel == "thread":
-            await channel.send(notify_text)
+            await _safe_send_to_channel(
+                content=notify_text, allowed_mentions=discord.AllowedMentions.none()
+            )
         else:
-            ch = self.bot.get_channel(int(notify_channel))
+            # Extract channel ID from mention format <#123> or use raw ID
+            channel_id = str(notify_channel).strip("<#>")
+            ch = self.bot.get_channel(int(channel_id))
             if ch:
-                await ch.send(f"Thread for user <@{self.id}> has been unsnoozed and restored.")
+                await ch.send(
+                    f"⏰ Thread for user <@{self.id}> has been unsnoozed and restored in {channel.mention}",
+                    allowed_mentions=discord.AllowedMentions.none(),
+                )
         # Show who ran the snooze command and the command used
         # Use snooze_data_for_notify to avoid accessing self.snooze_data after it is set to None
-        snoozed_by = snooze_data_for_notify.get("snoozed_by") if snooze_data_for_notify else None
-        snooze_command = snooze_data_for_notify.get("snooze_command") if snooze_data_for_notify else None
+        snoozed_by = (
+            snooze_data_for_notify.get("snoozed_by") if snooze_data_for_notify else None
+        )
+        snooze_command = (
+            snooze_data_for_notify.get("snooze_command")
+            if snooze_data_for_notify
+            else None
+        )
         if snoozed_by or snooze_command:
             info = f"Snoozed by: {snoozed_by or 'Unknown'} | Command: {snooze_command or '?snooze'}"
-            await channel.send(info)
+            await channel.send(info, allowed_mentions=discord.AllowedMentions.none())
+
+        # Ensure channel is set before processing commands
+        self._channel = channel
+
+        # Mark unsnooze as complete
+        self._unsnoozing = False
+
+        # Process queued commands
+        await self._process_command_queue()
+
         return True
 
     @classmethod
-    async def from_channel(cls, manager: "ThreadManager", channel: discord.TextChannel) -> "Thread":
+    async def from_channel(
+        cls, manager: "ThreadManager", channel: discord.TextChannel
+    ) -> "Thread":
         # there is a chance it grabs from another recipient's main thread
         _, recipient_id, other_ids = parse_channel_topic(channel.topic)
 
@@ -353,7 +852,11 @@ async def get_genesis_message(self) -> discord.Message:
         if self._genesis_message is None:
             async for m in self.channel.history(limit=5, oldest_first=True):
                 if m.author == self.bot.user:
-                    if m.embeds and m.embeds[0].fields and m.embeds[0].fields[0].name == "Roles":
+                    if (
+                        m.embeds
+                        and m.embeds[0].fields
+                        and m.embeds[0].fields[0].name == "Roles"
+                    ):
                         self._genesis_message = m
 
         return self._genesis_message
@@ -364,29 +867,40 @@ async def setup(self, *, creator=None, category=None, initial_message=None):
         recipient = self.recipient
 
         # in case it creates a channel outside of category
-        overwrites = {self.bot.modmail_guild.default_role: discord.PermissionOverwrite(read_messages=False)}
+        overwrites = {
+            self.bot.modmail_guild.default_role: discord.PermissionOverwrite(
+                read_messages=False
+            )
+        }
 
         category = category or self.bot.main_category
 
         if category is not None:
             overwrites = {}
 
-        try:
-            channel = await create_thread_channel(self.bot, recipient, category, overwrites)
-        except discord.HTTPException as e:  # Failed to create due to missing perms.
-            logger.critical("An error occurred while creating a thread.", exc_info=True)
-            self.manager.cache.pop(self.id)
-
-            embed = discord.Embed(color=self.bot.error_color)
-            embed.title = "Error while trying to create a thread."
-            embed.description = str(e)
-            embed.add_field(name="Recipient", value=recipient.mention)
+        # If thread menu is enabled and this setup call is marked as deferred genesis (initial_message carries flag),
+        # then we may have already created the channel earlier. Only create if channel missing.
+        if self._channel is None:
+            try:
+                channel = await create_thread_channel(
+                    self.bot, recipient, category, overwrites
+                )
+            except discord.HTTPException as e:  # Failed to create due to missing perms.
+                logger.critical(
+                    "An error occurred while creating a thread.", exc_info=True
+                )
+                self.manager.cache.pop(self.id)
 
-            if self.bot.log_channel is not None:
-                await self.bot.log_channel.send(embed=embed)
-            return
+                embed = discord.Embed(color=self.bot.error_color)
+                embed.title = "Error while trying to create a thread."
+                embed.description = str(e)
+                embed.add_field(name="Recipient", value=recipient.mention)
 
-        self._channel = channel
+                if self.bot.log_channel is not None:
+                    await self.bot.log_channel.send(embed=embed)
+                return
+            else:
+                self._channel = channel
 
         try:
             log_url, log_data = await asyncio.gather(
@@ -396,7 +910,9 @@ async def setup(self, *, creator=None, category=None, initial_message=None):
 
             log_count = sum(1 for log in log_data if not log["open"])
         except Exception:
-            logger.error("An error occurred while posting logs to the database.", exc_info=True)
+            logger.error(
+                "An error occurred while posting logs to the database.", exc_info=True
+            )
             log_url = log_count = None
             # ensure core functionality still works
 
@@ -408,16 +924,55 @@ async def setup(self, *, creator=None, category=None, initial_message=None):
             mention = self.bot.config["mention"]
 
         async def send_genesis_message():
-            info_embed = self._format_info_embed(recipient, log_url, log_count, self.bot.main_color)
+            info_embed = self._format_info_embed(
+                recipient, log_url, log_count, self.bot.main_color
+            )
             try:
                 msg = await channel.send(mention, embed=info_embed)
                 self.bot.loop.create_task(msg.pin())
                 self._genesis_message = msg
+                # Option selection logging (if a thread-creation menu option was chosen prior to creation)
+                if getattr(
+                    self, "_selected_thread_creation_menu_option", None
+                ) and self.bot.config.get("thread_creation_menu_selection_log"):
+                    opt = self._selected_thread_creation_menu_option
+                    try:
+                        log_txt = f"Selected menu option: {opt.get('label')} ({opt.get('type')})"
+                        if opt.get("type") == "command":
+                            log_txt += f" -> {opt.get('callback')}"
+                        await channel.send(
+                            embed=discord.Embed(
+                                description=log_txt, color=self.bot.mod_color
+                            )
+                        )
+                    except Exception:
+                        logger.warning(
+                            "Failed logging thread-creation menu selection",
+                            exc_info=True,
+                        )
             except Exception:
                 logger.error("Failed unexpectedly:", exc_info=True)
 
         async def send_recipient_genesis_message():
             # Once thread is ready, tell the recipient (don't send if using contact on others)
+            # Allow disabling the DM receipt embed via config
+            if not self.bot.config.get("thread_creation_send_dm_embed"):
+                # If self-closable is enabled, add the close reaction to the user's
+                # original message instead so functionality is preserved without an embed.
+                try:
+                    recipient_thread_close = self.bot.config.get(
+                        "recipient_thread_close"
+                    )
+                    if recipient_thread_close and initial_message is not None:
+                        close_emoji = self.bot.config["close_emoji"]
+                        close_emoji = await self.bot.convert_emoji(close_emoji)
+                        await self.bot.add_reaction(initial_message, close_emoji)
+                except Exception as e:
+                    logger.info(
+                        "Failed to add self-close reaction to initial message: %s", e
+                    )
+                return
+
             thread_creation_response = self.bot.config["thread_creation_response"]
 
             embed = discord.Embed(
@@ -434,7 +989,10 @@ async def send_recipient_genesis_message():
                 footer = self.bot.config["thread_creation_footer"]
 
             embed.set_footer(
-                text=footer, icon_url=self.bot.get_guild_icon(guild=self.bot.modmail_guild, size=128)
+                text=footer,
+                icon_url=self.bot.get_guild_icon(
+                    guild=self.bot.modmail_guild, size=128
+                ),
             )
             embed.title = self.bot.config["thread_creation_title"]
 
@@ -475,8 +1033,12 @@ class Author:
                     "content": note["message"],
                     "author": Author(),
                 }
-                message = discord.Message(state=State(), channel=self.channel, data=data)
-                ids[note["_id"]] = str((await self.note(message, persistent=True, thread_creation=True)).id)
+                message = discord.Message(
+                    state=State(), channel=self.channel, data=data
+                )
+                ids[note["_id"]] = str(
+                    (await self.note(message, persistent=True, thread_creation=True)).id
+                )
 
             await self.bot.api.update_note_ids(ids)
 
@@ -541,7 +1103,9 @@ def _format_info_embed(self, user, log_url, log_count, color):
             footer = f"User ID: {user.id}"
 
         if member is not None:
-            embed.set_author(name=str(user), icon_url=member.display_avatar.url, url=log_url)
+            embed.set_author(
+                name=str(user), icon_url=member.display_avatar.url, url=log_url
+            )
 
             if self.bot.config["thread_show_join_age"]:
                 joined = discord.utils.format_dt(member.joined_at, "R")
@@ -553,7 +1117,9 @@ def _format_info_embed(self, user, log_url, log_count, color):
                 embed.add_field(name="Roles", value=role_names, inline=True)
             embed.set_footer(text=footer)
         else:
-            embed.set_author(name=str(user), icon_url=user.display_avatar.url, url=log_url)
+            embed.set_author(
+                name=str(user), icon_url=user.display_avatar.url, url=log_url
+            )
             embed.set_footer(text=f"{footer} • (not in main server)")
 
         embed.description += ", ".join(user_info)
@@ -567,13 +1133,17 @@ def _format_info_embed(self, user, log_url, log_count, color):
 
         mutual_guilds = [g for g in self.bot.guilds if user in g.members]
         if member is None or len(mutual_guilds) > 1:
-            embed.add_field(name="Mutual Server(s)", value=", ".join(g.name for g in mutual_guilds))
+            embed.add_field(
+                name="Mutual Server(s)", value=", ".join(g.name for g in mutual_guilds)
+            )
 
         return embed
 
     async def _close_after(self, after, closer, silent, delete_channel, message):
         await asyncio.sleep(after)
-        return self.bot.loop.create_task(self._close(closer, silent, delete_channel, message, True))
+        return self.bot.loop.create_task(
+            self._close(closer, silent, delete_channel, message, True)
+        )
 
     async def close(
         self,
@@ -606,7 +1176,9 @@ async def close(
             self.bot.config["closures"][str(self.id)] = items
             await self.bot.config.update()
 
-            task = asyncio.create_task(self._close_after(after, closer, silent, delete_channel, message))
+            task = asyncio.create_task(
+                self._close_after(after, closer, silent, delete_channel, message)
+            )
 
             if auto_close:
                 self.auto_close_task = task
@@ -615,7 +1187,16 @@ async def close(
         else:
             await self._close(closer, silent, delete_channel, message)
 
-    async def _close(self, closer, silent=False, delete_channel=True, message=None, scheduled=False):
+    async def _close(
+        self, closer, silent=False, delete_channel=True, message=None, scheduled=False
+    ):
+        # Proactively disable any DM thread-creation menu so users can't keep interacting
+        # with the menu after the thread is closed.
+        try:
+            await self._disable_dm_creation_menu()
+        except Exception:
+            # Non-fatal; continue closing even if we can't edit the DM menu
+            pass
         if self.channel:
             self.manager.closing.add(self.channel.id)
         try:
@@ -657,9 +1238,7 @@ async def _close(self, closer, silent=False, delete_channel=True, message=None,
             prefix = self.bot.config["log_url_prefix"].strip("/")
             if prefix == "NONE":
                 prefix = ""
-            log_url = (
-                f"{self.bot.config['log_url'].strip('/')}{'/' + prefix if prefix else ''}/{log_data['key']}"
-            )
+            log_url = f"{self.bot.config['log_url'].strip('/')}{'/' + prefix if prefix else ''}/{log_data['key']}"
 
             if log_data["title"]:
                 sneak_peak = log_data["title"]
@@ -696,17 +1275,23 @@ async def _close(self, closer, silent=False, delete_channel=True, message=None,
 
         event = "Thread Closed as Scheduled" if scheduled else "Thread Closed"
         # embed.set_author(name=f"Event: {event}", url=log_url)
-        embed.set_footer(text=f"{event} by {_closer}", icon_url=closer.display_avatar.url)
+        embed.set_footer(
+            text=f"{event} by {_closer}", icon_url=closer.display_avatar.url
+        )
         embed.timestamp = discord.utils.utcnow()
 
         tasks = [self.bot.config.update()]
 
         if self.bot.log_channel is not None and self.channel is not None:
-            if self.bot.config["show_log_url_button"]:
+            # Only create a URL button if we actually have a valid log_url
+            view = None
+            if self.bot.config.get("show_log_url_button") and log_url:
                 view = discord.ui.View()
-                view.add_item(discord.ui.Button(label="Log link", url=log_url, style=discord.ButtonStyle.url))
-            else:
-                view = None
+                view.add_item(
+                    discord.ui.Button(
+                        label="Log link", url=log_url, style=discord.ButtonStyle.url
+                    )
+                )
             tasks.append(self.bot.log_channel.send(embed=embed, view=view))
 
         # Thread closed message
@@ -725,12 +1310,18 @@ async def _close(self, closer, silent=False, delete_channel=True, message=None,
                 message = self.bot.config["thread_close_response"]
 
         message = self.bot.formatter.format(
-            message, closer=closer, loglink=log_url, logkey=log_data["key"] if log_data else None
+            message,
+            closer=closer,
+            loglink=log_url,
+            logkey=log_data["key"] if log_data else None,
         )
 
         embed.description = message
         footer = self.bot.config["thread_close_footer"]
-        embed.set_footer(text=footer, icon_url=self.bot.get_guild_icon(guild=self.bot.guild, size=128))
+        embed.set_footer(
+            text=footer,
+            icon_url=self.bot.get_guild_icon(guild=self.bot.guild, size=128),
+        )
 
         if not silent:
             for user in self.recipients:
@@ -753,7 +1344,46 @@ async def _close(self, closer, silent=False, delete_channel=True, message=None,
             if self.channel:
                 self.manager.closing.discard(self.channel.id)
 
-        self.bot.dispatch("thread_close", self, closer, silent, delete_channel, message, scheduled)
+        self.bot.dispatch(
+            "thread_close", self, closer, silent, delete_channel, message, scheduled
+        )
+
+    async def _disable_dm_creation_menu(self) -> None:
+        """Best-effort removal of the interactive DM menu view sent during thread creation."""
+        if not self._dm_menu_msg_id:
+            return
+        # We only ever send the menu to the main recipient
+        user = self.recipient
+        if not isinstance(user, (discord.User, discord.Member)):
+            return
+        # Ensure we have a DM channel
+        dm: typing.Optional[discord.DMChannel] = getattr(user, "dm_channel", None)
+        if dm is None:
+            try:
+                dm = await user.create_dm()
+            except Exception as e:
+                logger.info("Failed creating DM channel for menu disable: %s", e)
+                dm = None
+        if not isinstance(dm, discord.DMChannel):
+            return
+        # If we stored the channel id and it differs, but it's still a DM, continue anyway
+        try:
+            msg = await dm.fetch_message(self._dm_menu_msg_id)
+        except (discord.NotFound, discord.Forbidden):
+            return
+        except Exception:
+            return
+        try:
+            closed_text = "This thread has been closed. Send a new message to start a new thread."  # Grammar-friendly guidance
+            closed_embed = discord.Embed(description=closed_text)
+            await msg.edit(content=None, embed=closed_embed, view=None)
+        except Exception as e:
+            # Fallback: at least remove interaction so menu cannot be used
+            logger.warning("Failed editing DM menu message on close: %s", e)
+            try:
+                await msg.edit(view=None)
+            except Exception as inner_e:
+                logger.debug("Failed removing view from DM menu message: %s", inner_e)
 
     async def cancel_closure(self, auto_close: bool = False, all: bool = False) -> None:
         if self.close_task is not None and (not auto_close or all):
@@ -785,7 +1415,9 @@ async def _restart_close_timer(self):
         human_time = discord.utils.format_dt(reset_time)
 
         if self.bot.config.get("thread_auto_close_silently"):
-            return await self.close(closer=self.bot.user, silent=True, after=int(seconds), auto_close=True)
+            return await self.close(
+                closer=self.bot.user, silent=True, after=int(seconds), auto_close=True
+            )
 
         # Grab message
         close_message = self.bot.formatter.format(
@@ -801,7 +1433,12 @@ async def _restart_close_timer(self):
                 time_marker_regex,
             )
 
-        await self.close(closer=self.bot.user, after=int(seconds), message=close_message, auto_close=True)
+        await self.close(
+            closer=self.bot.user,
+            after=int(seconds),
+            message=close_message,
+            auto_close=True,
+        )
 
     async def find_linked_messages(
         self,
@@ -811,31 +1448,81 @@ async def find_linked_messages(
         note: bool = True,
     ) -> typing.Tuple[discord.Message, typing.List[typing.Optional[discord.Message]]]:
         if message1 is not None:
-            if not message1.embeds or not message1.embeds[0].author.url or message1.author != self.bot.user:
-                raise ValueError("Malformed thread message.")
+            if note:
+                # For notes, don't require author.url; rely on footer/author.name markers
+                if not message1.embeds or message1.author != self.bot.user:
+                    logger.warning(
+                        f"Malformed note for deletion: embeds={bool(message1.embeds)}, author={message1.author}"
+                    )
+                    raise ValueError("Malformed note message.")
+            else:
+                if (
+                    not message1.embeds
+                    or not message1.embeds[0].author.url
+                    or message1.author != self.bot.user
+                ):
+                    logger.debug(
+                        f"Malformed thread message for deletion: embeds={bool(message1.embeds)}, author_url={getattr(message1.embeds[0], 'author', None) and message1.embeds[0].author.url}, author={message1.author}"
+                    )
+                    # Keep original error string to avoid extra failure embeds in on_message_delete
+                    raise ValueError("Malformed thread message.")
 
         elif message_id is not None:
             try:
                 message1 = await self.channel.fetch_message(message_id)
             except discord.NotFound:
+                logger.warning(f"Message ID {message_id} not found in channel history.")
                 raise ValueError("Thread message not found.")
 
+            if note:
+                # Try to treat as note/persistent note first
+                if message1.embeds and message1.author == self.bot.user:
+                    footer_text = (
+                        message1.embeds[0].footer and message1.embeds[0].footer.text
+                    ) or ""
+                    author_name = getattr(message1.embeds[0].author, "name", "") or ""
+                    is_note = (
+                        "internal note" in footer_text.lower()
+                        or "persistent internal note" in footer_text.lower()
+                        or author_name.startswith("📝 Note")
+                        or author_name.startswith("📝 Persistent Note")
+                    )
+                    if is_note:
+                        # Notes have no linked DM counterpart; keep None sentinel
+                        return message1, None
+                # else: fall through to relay checks below
+
+            # Non-note path (regular relayed messages): require author.url and colors
             if not (
                 message1.embeds
                 and message1.embeds[0].author.url
                 and message1.embeds[0].color
                 and message1.author == self.bot.user
             ):
+                logger.warning(
+                    f"Message {message_id} is not a valid modmail relay message. embeds={bool(message1.embeds)}, author_url={getattr(message1.embeds[0], 'author', None) and message1.embeds[0].author.url}, color={getattr(message1.embeds[0], 'color', None)}, author={message1.author}"
+                )
                 raise ValueError("Thread message not found.")
 
-            if message1.embeds[0].footer and "Internal Message" in message1.embeds[0].footer.text:
+            if (
+                message1.embeds[0].footer
+                and "Internal Message" in message1.embeds[0].footer.text
+            ):
                 if not note:
-                    raise ValueError("Thread message not found.")
+                    logger.warning(
+                        f"Message {message_id} is an internal message, but note deletion not requested."
+                    )
+                    raise ValueError(
+                        "Thread message is an internal message, not a note."
+                    )
+                # Internal bot-only message treated similarly; keep None sentinel
                 return message1, None
 
             if message1.embeds[0].color.value != self.bot.mod_color and not (
-                either_direction and message1.embeds[0].color.value == self.bot.recipient_color
+                either_direction
+                and message1.embeds[0].color.value == self.bot.recipient_color
             ):
+                logger.warning("Message color does not match mod/recipient colors.")
                 raise ValueError("Thread message not found.")
         else:
             async for message1 in self.channel.history():
@@ -845,7 +1532,11 @@ async def find_linked_messages(
                     and message1.embeds[0].color
                     and (
                         message1.embeds[0].color.value == self.bot.mod_color
-                        or (either_direction and message1.embeds[0].color.value == self.bot.recipient_color)
+                        or (
+                            either_direction
+                            and message1.embeds[0].color.value
+                            == self.bot.recipient_color
+                        )
                     )
                     and message1.embeds[0].author.url.split("#")[-1].isdigit()
                     and message1.author == self.bot.user
@@ -880,7 +1571,9 @@ async def find_linked_messages(
 
         raise ValueError("DM message not found.")
 
-    async def edit_message(self, message_id: typing.Optional[int], message: str) -> None:
+    async def edit_message(
+        self, message_id: typing.Optional[int], message: str
+    ) -> None:
         try:
             message1, *message2 = await self.find_linked_messages(message_id)
         except ValueError:
@@ -890,8 +1583,14 @@ async def edit_message(self, message_id: typing.Optional[int], message: str) ->
         embed1 = message1.embeds[0]
         embed1.description = message
 
-        tasks = [self.bot.api.edit_message(message1.id, message), message1.edit(embed=embed1)]
-        if message1.embeds[0].footer and "Persistent Internal Message" in message1.embeds[0].footer.text:
+        tasks = [
+            self.bot.api.edit_message(message1.id, message),
+            message1.edit(embed=embed1),
+        ]
+        if (
+            message1.embeds[0].footer
+            and "Persistent Internal Note" in message1.embeds[0].footer.text
+        ):
             tasks += [self.bot.api.edit_note(message1.id, message)]
         else:
             for m2 in message2:
@@ -906,19 +1605,23 @@ async def delete_message(
         self, message: typing.Union[int, discord.Message] = None, note: bool = True
     ) -> None:
         if isinstance(message, discord.Message):
-            message1, *message2 = await self.find_linked_messages(message1=message, note=note)
+            message1, *message2 = await self.find_linked_messages(
+                message1=message, note=note
+            )
         else:
             message1, *message2 = await self.find_linked_messages(message, note=note)
         tasks = []
-
-        if not isinstance(message, discord.Message):
-            tasks += [message1.delete()]
+        # Always delete the primary thread message
+        tasks += [message1.delete()]
 
         for m2 in message2:
             if m2 is not None:
                 tasks += [m2.delete()]
 
-        if message1.embeds[0].footer and "Persistent Internal Message" in message1.embeds[0].footer.text:
+        if (
+            message1.embeds[0].footer
+            and "Persistent Internal Note" in message1.embeds[0].footer.text
+        ):
             tasks += [self.bot.api.delete_note(message1.id)]
 
         if tasks:
@@ -998,9 +1701,13 @@ async def edit_dm_message(self, message: discord.Message, content: str) -> None:
             embed = msg.embeds[0]
             if isinstance(msg.channel, discord.TextChannel):
                 # just for thread channel, we put the old message in embed field
-                embed.add_field(name="**Edited, former message:**", value=embed.description)
+                embed.add_field(
+                    name="**Edited, former message:**", value=embed.description
+                )
             embed.description = content
-            await asyncio.gather(self.bot.api.edit_message(message.id, content), msg.edit(embed=embed))
+            await asyncio.gather(
+                self.bot.api.edit_message(message.id, content), msg.edit(embed=embed)
+            )
 
     async def note(
         self, message: discord.Message, persistent=False, thread_creation=False
@@ -1018,7 +1725,9 @@ async def note(
 
         # Log as 'note' type for logviewer
         self.bot.loop.create_task(
-            self.bot.api.append_log(message, message_id=msg.id, channel_id=self.channel.id, type_="note")
+            self.bot.api.append_log(
+                message, message_id=msg.id, channel_id=self.channel.id, type_="note"
+            )
         )
 
         return msg
@@ -1027,6 +1736,30 @@ async def reply(
         self, message: discord.Message, anonymous: bool = False, plain: bool = False
     ) -> typing.Tuple[typing.List[discord.Message], discord.Message]:
         """Returns List[user_dm_msg] and thread_channel_msg"""
+        # If this thread was snoozed using move-behavior, unsnooze automatically when a mod replies
+        try:
+            behavior = (self.bot.config.get("snooze_behavior") or "delete").lower()
+        except Exception:
+            behavior = "delete"
+        if self.snoozed and behavior == "move":
+            # Ensure we have snooze_data to restore location
+            if not self.snooze_data:
+                try:
+                    log_entry = await self.bot.api.logs.find_one(
+                        {"recipient.id": str(self.id), "snoozed": True}
+                    )
+                    if log_entry:
+                        self.snooze_data = log_entry.get("snooze_data")
+                except Exception as e:
+                    logger.info(
+                        "Failed to fetch snooze_data before auto-unsnooze on reply: %s",
+                        e,
+                    )
+            try:
+                await self.restore_from_snooze()
+            except Exception as e:
+                logger.warning("Auto-unsnooze on reply failed: %s", e)
+
         if not message.content and not message.attachments and not message.stickers:
             raise MissingRequiredArgument(DummyParam("msg"))
         for guild in self.bot.guilds:
@@ -1034,7 +1767,10 @@ async def reply(
                 if await self.bot.get_or_fetch_member(guild, self.id):
                     break
             except discord.NotFound:
-                pass
+                logger.info(
+                    "Recipient not found in guild %s when checking mutual servers.",
+                    guild.id if hasattr(guild, "id") else guild,
+                )
         else:
             return await message.channel.send(
                 embed=discord.Embed(
@@ -1084,18 +1820,33 @@ async def reply(
             )
         else:
             # Send the same thing in the thread channel.
-            msg = await self.send(
-                message, destination=self.channel, from_mod=True, anonymous=anonymous, plain=plain
-            )
-
-            tasks.append(
-                self.bot.api.append_log(
+            try:
+                msg = await self.send(
                     message,
-                    message_id=msg.id,
-                    channel_id=self.channel.id,
-                    type_="anonymous" if anonymous else "thread_message",
+                    destination=self.channel,
+                    from_mod=True,
+                    anonymous=anonymous,
+                    plain=plain,
+                )
+            except discord.NotFound:
+                logger.warning(
+                    "Thread channel not found while replying; skipping thread-channel copy of the message."
+                )
+                msg = None
+
+            if msg is not None:
+                tasks.append(
+                    self.bot.api.append_log(
+                        message,
+                        message_id=msg.id,
+                        channel_id=self.channel.id,
+                        type_="anonymous" if anonymous else "thread_message",
+                    )
+                )
+            else:
+                logger.warning(
+                    "Thread channel message failed to send; skipping append_log. Channel may be missing."
                 )
-            )
 
             # Cancel closing if a thread message is sent.
             if self.close_task is not None:
@@ -1133,7 +1884,8 @@ async def send(
 
             # Create embed for note with Discord system message style
             embed = discord.Embed(
-                description=content, color=0x5865F2  # Discord blurple color for system messages
+                description=content,
+                color=0x5865F2,  # Discord blurple color for system messages
             )
 
             # Set author with note icon and username
@@ -1143,7 +1895,8 @@ async def send(
                 note_type = "Note"
 
             embed.set_author(
-                name=f"📝 {note_type} ({message.author.name})", icon_url=message.author.display_avatar.url
+                name=f"📝 {note_type} ({message.author.name})",
+                icon_url=message.author.display_avatar.url,
             )
 
             # Add timestamp if enabled
@@ -1159,7 +1912,9 @@ async def send(
             return await destination.send(embed=embed)
 
         if not note and from_mod:
-            self.bot.loop.create_task(self._restart_close_timer())  # Start or restart thread auto close
+            self.bot.loop.create_task(
+                self._restart_close_timer()
+            )  # Start or restart thread auto close
 
         if self.close_task is not None:
             # cancel closing if a thread message is sent.
@@ -1177,18 +1932,20 @@ async def send(
             await self.wait_until_ready()
 
         if not from_mod and not note:
-            self.bot.loop.create_task(self.bot.api.append_log(message, channel_id=self.channel.id))
+            self.bot.loop.create_task(
+                self.bot.api.append_log(message, channel_id=self.channel.id)
+            )
 
         destination = destination or self.channel
 
         if destination is None:
-            logger.error("Attempted to send a message to a thread with no channel (destination is None).")
-            return
-        try:
-            await destination.typing()
-        except discord.NotFound:
-            logger.warning("Channel not found when trying to send message.")
+            logger.error(
+                "Attempted to send a message to a thread with no channel (destination is None)."
+            )
             return
+        # Initial typing was attempted here previously, but returning on NotFound caused callers to
+        # receive None and crash when accessing attributes on the message. We rely on the
+        # snooze-aware typing block below to handle typing and NotFound cases robustly.
 
         author = message.author
         member = self.bot.guild.get_member(author.id)
@@ -1202,7 +1959,12 @@ async def send(
         if hasattr(message, "message_snapshots") and len(message.message_snapshots) > 0:
             snap = message.message_snapshots[0]
             # Only show "No content" if there's truly no content (no text, attachments, embeds, or stickers)
-            if not snap.content and not message.attachments and not message.embeds and not message.stickers:
+            if (
+                not snap.content
+                and not message.attachments
+                and not message.embeds
+                and not message.stickers
+            ):
                 content = "No content"
             else:
                 content = snap.content or ""
@@ -1217,13 +1979,21 @@ async def send(
                     and message.reference.type == discord.MessageReferenceType.forward
                 ):
                     try:
-                        original_msg_channel = self.bot.get_channel(message.reference.channel_id)
-                        original_msg = await original_msg_channel.fetch_message(message.reference.message_id)
+                        original_msg_channel = self.bot.get_channel(
+                            message.reference.channel_id
+                        )
+                        original_msg = await original_msg_channel.fetch_message(
+                            message.reference.message_id
+                        )
                         forwarded_jump_url = original_msg.jump_url
                     except (discord.NotFound, discord.Forbidden, AttributeError):
                         pass
 
-            content = f"📨 **Forwarded message:**\n{content}" if content else "📨 **Forwarded message:**"
+            content = (
+                f"📨 **Forwarded message:**\n{content}"
+                if content
+                else "📨 **Forwarded message:**"
+            )
         else:
             # Only show "No content" if there's truly no content (no text, attachments, embeds, or stickers)
             if (
@@ -1246,19 +2016,29 @@ async def send(
 
         # Add forwarded message context
         if forwarded_jump_url:
-            embed.add_field(name="Context", value=f"- {forwarded_jump_url}", inline=True)
+            embed.add_field(
+                name="Context", value=f"- {forwarded_jump_url}", inline=True
+            )
 
-        system_avatar_url = "https://discordapp.com/assets/f78426a064bc9dd24847519259bc42af.png"
+        system_avatar_url = (
+            "https://discordapp.com/assets/f78426a064bc9dd24847519259bc42af.png"
+        )
 
         if not note:
-            if anonymous and from_mod and not isinstance(destination, discord.TextChannel):
+            if (
+                anonymous
+                and from_mod
+                and not isinstance(destination, discord.TextChannel)
+            ):
                 # Anonymously sending to the user.
                 tag = self.bot.config["mod_tag"]
                 if tag is None:
-                    tag = str(get_top_role(author, self.bot.config["use_hoisted_top_role"]))
+                    tag = str(
+                        get_top_role(author, self.bot.config["use_hoisted_top_role"])
+                    )
                 name = self.bot.config["anon_username"]
                 if name is None:
-                    name = tag
+                    name = "Anonymous"
                 avatar_url = self.bot.config["anon_avatar_url"]
                 if avatar_url is None:
                     avatar_url = self.bot.get_guild_icon(guild=self.bot.guild, size=128)
@@ -1269,8 +2049,17 @@ async def send(
                 )
             else:
                 # Normal message
-                name = str(author)
-                avatar_url = avatar_url
+                # If this message originated from a thread-creation menu command callback
+                # (user selected an option whose type is command), we force the author
+                # display to be the bot to avoid showing the user as a replying moderator.
+                if getattr(message, "_menu_invoked", False):
+                    name = str(self.bot.user)
+                    avatar_url = getattr(
+                        self.bot.user.display_avatar, "url", system_avatar_url
+                    )
+                else:
+                    name = str(author)
+                    avatar_url = avatar_url
                 embed.set_author(
                     name=name,
                     icon_url=avatar_url,
@@ -1332,7 +2121,11 @@ def lottie_to_png(data):
                 discord.StickerFormatType.gif,
             ):
                 images.append(
-                    (f"https://media.discordapp.net/stickers/{i.id}.{i.format.file_extension}", i.name, True)
+                    (
+                        f"https://media.discordapp.net/stickers/{i.id}.{i.format.file_extension}",
+                        i.name,
+                        True,
+                    )
                 )
             elif i.format == discord.StickerFormatType.lottie:
                 # save the json lottie representation
@@ -1372,14 +2165,17 @@ def lottie_to_png(data):
 
         for url, filename, is_sticker in images:
             if (
-                not prioritize_uploads or ((url is None or is_image_url(url)) and filename)
+                not prioritize_uploads
+                or ((url is None or is_image_url(url)) and filename)
             ) and not embedded_image:
                 if url is not None:
                     embed.set_image(url=url)
                 if filename:
                     if is_sticker:
                         if url is None:
-                            description = f"{filename}: Unable to retrieve sticker image"
+                            description = (
+                                f"{filename}: Unable to retrieve sticker image"
+                            )
                         else:
                             description = f"[{filename}]({url})"
                         embed.add_field(name="Sticker", value=description)
@@ -1401,7 +2197,9 @@ def lottie_to_png(data):
                     img_embed.url = url
                 if filename is not None:
                     img_embed.title = filename
-                img_embed.set_footer(text=f"Additional Image Upload ({additional_count})")
+                img_embed.set_footer(
+                    text=f"Additional Image Upload ({additional_count})"
+                )
                 img_embed.timestamp = message.created_at
                 additional_images.append(destination.send(embed=img_embed))
                 additional_count += 1
@@ -1409,7 +2207,9 @@ def lottie_to_png(data):
         file_upload_count = 1
 
         for url, filename, _ in attachments:
-            embed.add_field(name=f"File upload ({file_upload_count})", value=f"[{filename}]({url})")
+            embed.add_field(
+                name=f"File upload ({file_upload_count})", value=f"[{filename}]({url})"
+            )
             file_upload_count += 1
 
         if from_mod:
@@ -1428,23 +2228,51 @@ def lottie_to_png(data):
                     embed.set_footer(text="Anonymous Reply")
                 # Normal messages
                 elif not anonymous:
+                    # Use configured mod_tag if provided; otherwise fallback to
+                    # the author's top role when available, or their display name.
                     mod_tag = self.bot.config["mod_tag"]
                     if mod_tag is None:
-                        mod_tag = str(get_top_role(message.author, self.bot.config["use_hoisted_top_role"]))
+                        if hasattr(message.author, "roles"):
+                            try:
+                                mod_tag = str(
+                                    get_top_role(
+                                        message.author,
+                                        self.bot.config["use_hoisted_top_role"],
+                                    )  # type: ignore[arg-type]
+                                )
+                            except Exception:
+                                # As a safe fallback, prefer a stable display string
+                                mod_tag = getattr(
+                                    message.author, "display_name", str(message.author)
+                                )
+                        else:
+                            mod_tag = getattr(
+                                message.author, "display_name", str(message.author)
+                            )
                     embed.set_footer(text=mod_tag)  # Normal messages
                 else:
                     embed.set_footer(text=self.bot.config["anon_tag"])
         else:
             # Add forwarded message indicator in footer for mods
             footer_text = f"Message ID: {message.id}"
-            if hasattr(message, "message_snapshots") and len(message.message_snapshots) > 0:
+            if (
+                hasattr(message, "message_snapshots")
+                and len(message.message_snapshots) > 0
+            ):
                 footer_text += " • Forwarded"
             embed.set_footer(text=footer_text)
             embed.colour = self.bot.recipient_color
 
         if (from_mod or note) and not thread_creation:
             delete_message = not bool(message.attachments)
-            if delete_message and destination == self.channel:
+            # Only delete the source command message when it's in a guild text
+            # channel; attempting to delete a DM message can raise 50003.
+            if (
+                delete_message
+                and destination == self.channel
+                and hasattr(message, "channel")
+                and isinstance(message.channel, discord.TextChannel)
+            ):
                 try:
                     await message.delete()
                 except Exception as e:
@@ -1455,16 +2283,39 @@ def lottie_to_png(data):
             and self.bot.config["dm_disabled"] == DMDisabled.ALL_THREADS
             and destination != self.channel
         ):
-            logger.info("Sending a message to %s when DM disabled is set.", self.recipient)
+            logger.info(
+                "Sending a message to %s when DM disabled is set.", self.recipient
+            )
 
-        # Best-effort typing: never block message delivery if typing fails
+        # Best-effort typing with snooze-aware retry: if channel was deleted during snooze, restore and retry once
+        restored = False
         try:
             await destination.typing()
         except discord.NotFound:
-            logger.warning("Channel not found.")
-            raise
+            # Unknown Channel: if snoozed or we have snooze data, attempt to restore and retry once
+            if isinstance(destination, discord.TextChannel) and (
+                self.snoozed or self.snooze_data
+            ):
+                logger.info(
+                    "Thread channel missing while typing; attempting restore from snooze."
+                )
+                try:
+                    await self.restore_from_snooze()
+                    destination = self.channel or destination
+                    restored = True
+                    await destination.typing()
+                except Exception as e:
+                    logger.warning("Restore/typing retry failed: %s", e)
+                    raise
+            else:
+                logger.warning("Channel not found.")
+                raise
         except (discord.Forbidden, discord.HTTPException, Exception) as e:
-            logger.warning("Unable to send typing to %s: %s. Continuing without typing.", destination, e)
+            logger.warning(
+                "Unable to send typing to %s: %s. Continuing without typing.",
+                destination,
+                e,
+            )
 
         if not from_mod and not note:
             mentions = await self.get_notifications()
@@ -1473,29 +2324,53 @@ def lottie_to_png(data):
 
         if plain:
             if from_mod and not isinstance(destination, discord.TextChannel):
-                # Plain to user
+                # Plain to user (DM)
                 with warnings.catch_warnings():
-                    # Catch coroutines not awaited warning
                     warnings.simplefilter("ignore")
                     additional_images = []
 
-                if embed.footer.text:
-                    plain_message = f"**{embed.footer.text} "
-                else:
-                    plain_message = "**"
-                plain_message += f"{embed.author.name}:** {embed.description}"
+                prefix = (
+                    f"**{embed.footer.text} "
+                    if embed.footer and embed.footer.text
+                    else "**"
+                )
+                body = embed.description or ""
+                plain_message = f"{prefix}{embed.author.name}:** {body}"
+
                 files = []
-                for i in message.attachments:
-                    files.append(await i.to_file())
+                for att in message.attachments:
+                    try:
+                        files.append(await att.to_file())
+                    except Exception:
+                        logger.warning(
+                            "Failed to attach file in plain DM.", exc_info=True
+                        )
 
-                msg = await destination.send(plain_message, files=files)
+                msg = await destination.send(plain_message, files=files or None)
             else:
                 # Plain to mods
-                embed.set_footer(text="[PLAIN] " + embed.footer.text)
+                footer_text = embed.footer.text if embed.footer else ""
+                embed.set_footer(text=f"[PLAIN] {footer_text}".strip())
                 msg = await destination.send(mentions, embed=embed)
 
         else:
-            msg = await destination.send(mentions, embed=embed)
+            try:
+                msg = await destination.send(mentions, embed=embed)
+            except discord.NotFound:
+                if (
+                    isinstance(destination, discord.TextChannel)
+                    and (self.snoozed or self.snooze_data)
+                    and not restored
+                ):
+                    logger.info(
+                        "Thread channel missing while sending; attempting restore and resend."
+                    )
+                    await self.restore_from_snooze()
+                    destination = self.channel or destination
+                    msg = await destination.send(mentions, embed=embed)
+                else:
+                    logger.warning("Channel not found during send.")
+                    raise
 
         if additional_images:
             self.ready = False
@@ -1506,16 +2381,19 @@ def lottie_to_png(data):
 
     async def get_notifications(self) -> str:
         key = str(self.id)
-
-        mentions = []
-        mentions.extend(self.bot.config["subscriptions"].get(key, []))
-
-        if key in self.bot.config["notification_squad"]:
-            mentions.extend(self.bot.config["notification_squad"][key])
-            self.bot.config["notification_squad"].pop(key)
+        mentions: typing.List[str] = []
+        subs = self.bot.config["subscriptions"].get(key, [])
+        mentions.extend(subs)
+        one_time = self.bot.config["notification_squad"].get(key, [])
+        mentions.extend(one_time)
+
+        if one_time:
+            self.bot.config["notification_squad"].pop(key, None)
             self.bot.loop.create_task(self.bot.config.update())
 
-        return " ".join(set(mentions))
+        if not mentions:
+            return ""
+        return " ".join(list(dict.fromkeys(mentions)))
 
     async def set_title(self, title: str) -> None:
         topic = f"Title: {title}\n"
@@ -1543,13 +2421,17 @@ async def _update_users_genesis(self):
             embed.add_field(name="Other Recipients", value=value, inline=False)
         else:
             if value:
-                embed.set_field_at(index, name="Other Recipients", value=value, inline=False)
+                embed.set_field_at(
+                    index, name="Other Recipients", value=value, inline=False
+                )
             else:
                 embed.remove_field(index)
 
         await genesis_message.edit(embed=embed)
 
-    async def add_users(self, users: typing.List[typing.Union[discord.Member, discord.User]]) -> None:
+    async def add_users(
+        self, users: typing.List[typing.Union[discord.Member, discord.User]]
+    ) -> None:
         topic = ""
         title, _, _ = parse_channel_topic(self.channel.topic)
         if title is not None:
@@ -1567,7 +2449,9 @@ async def add_users(self, users: typing.List[typing.Union[discord.Member, discor
         await self.channel.edit(topic=topic)
         await self._update_users_genesis()
 
-    async def remove_users(self, users: typing.List[typing.Union[discord.Member, discord.User]]) -> None:
+    async def remove_users(
+        self, users: typing.List[typing.Union[discord.Member, discord.User]]
+    ) -> None:
         topic = ""
         title, user_id, _ = parse_channel_topic(self.channel.topic)
         if title is not None:
@@ -1585,6 +2469,61 @@ async def remove_users(self, users: typing.List[typing.Union[discord.Member, dis
         await self.channel.edit(topic=topic)
         await self._update_users_genesis()
 
+    async def queue_command(self, ctx, command) -> bool:
+        """
+        Queue a command to be executed after unsnooze completes.
+        Close commands are automatically moved to the end of the queue.
+        Returns True if command was queued, False if it should execute immediately.
+        """
+        if self._unsnoozing:
+            command_name = command.qualified_name if command else ""
+
+            # If it's a close command, always add to end
+            if command_name == "close":
+                self._command_queue.append((ctx, command))
+            else:
+                # For non-close commands, insert before any close commands
+                close_index = None
+                for i, (_, cmd) in enumerate(self._command_queue):
+                    if cmd and cmd.qualified_name == "close":
+                        close_index = i
+                        break
+
+                if close_index is not None:
+                    self._command_queue.insert(close_index, (ctx, command))
+                else:
+                    self._command_queue.append((ctx, command))
+
+            return True
+        return False
+
+    async def _process_command_queue(self) -> None:
+        """
+        Process all queued commands after unsnooze completes.
+        Close commands are always last, so processing stops naturally after close.
+        """
+        if not self._command_queue:
+            return
+
+        logger.info(
+            f"Processing {len(self._command_queue)} queued commands for thread {self.id}"
+        )
+
+        # Process commands in order
+        while self._command_queue:
+            ctx, command = self._command_queue.pop(0)
+            try:
+                command_name = command.qualified_name if command else ""
+                await self.bot.invoke(ctx)
+
+                # If close command was executed, stop (it's always last anyway)
+                if command_name == "close":
+                    logger.info("Close command executed, queue processing complete")
+                    break
+
+            except Exception as e:
+                logger.error(f"Error processing queued command: {e}", exc_info=True)
+
 
 class ThreadManager:
     """Class that handles storing, finding and creating Modmail threads."""
@@ -1615,13 +2554,18 @@ async def find(
         recipient_id: int = None,
     ) -> typing.Optional[Thread]:
         """Finds a thread from cache or from discord channel topics."""
-        if recipient is None and channel is not None and isinstance(channel, discord.TextChannel):
+        if (
+            recipient is None
+            and channel is not None
+            and isinstance(channel, discord.TextChannel)
+        ):
             if channel.id in self.closing:
                 return None
             thread = await self._find_from_channel(channel)
             if thread is None:
                 user_id, thread = next(
-                    ((k, v) for k, v in self.cache.items() if v.channel == channel), (-1, None)
+                    ((k, v) for k, v in self.cache.items() if v.channel == channel),
+                    (-1, None),
                 )
                 if thread is not None:
                     logger.debug("Found thread with tempered ID.")
@@ -1636,12 +2580,50 @@ async def find(
             try:
                 await thread.wait_until_ready()
             except asyncio.CancelledError:
-                logger.warning("Thread for %s cancelled.", recipient)
+                # Improve logging: include username and user ID when possible
+                try:
+                    if recipient is not None:
+                        label = f"{recipient} ({recipient.id})"
+                    elif recipient_id is not None:
+                        user = await self.bot.get_or_fetch_user(recipient_id)
+                        label = (
+                            f"{user} ({recipient_id})"
+                            if user
+                            else f"User ({recipient_id})"
+                        )
+                    else:
+                        label = "Unknown User"
+                except Exception:
+                    label = (
+                        f"User ({recipient_id})"
+                        if recipient_id is not None
+                        else "Unknown User"
+                    )
+                logger.warning("Thread for %s cancelled.", label)
                 return thread
             else:
                 # If the thread is snoozed (channel is None), return it for restoration
                 if thread.cancelled:
                     thread = None
+                else:
+                    # If the cached thread points to a deleted channel, treat as non-existent
+                    try:
+                        ch = getattr(thread, "channel", None)
+                        if (
+                            ch
+                            and isinstance(ch, discord.TextChannel)
+                            and self.bot.get_channel(getattr(ch, "id", None)) is None
+                        ):
+                            logger.info(
+                                "Cached thread for %s references a deleted channel. Dropping stale cache entry.",
+                                recipient_id,
+                            )
+                            self.cache.pop(thread.id, None)
+                            thread = None
+                    except Exception:
+                        # If any attribute access fails, be safe and drop it.
+                        self.cache.pop(getattr(thread, "id", None), None)
+                        thread = None
         else:
 
             def check(topic):
@@ -1704,7 +2686,9 @@ async def _find_from_channel(self, channel):
         if recipient is None:
             thread = Thread(self, user_id, channel, other_recipients)
         else:
-            self.cache[user_id] = thread = Thread(self, recipient, channel, other_recipients)
+            self.cache[user_id] = thread = Thread(
+                self, recipient, channel, other_recipients
+            )
         thread.ready = True
 
         return thread
@@ -1732,9 +2716,9 @@ async def create(
             if len(message.content.strip()) < min_chars:
                 embed = discord.Embed(
                     title=self.bot.config["thread_min_characters_title"],
-                    description=self.bot.config["thread_min_characters_response"].replace(
-                        "{min_characters}", str(min_chars)
-                    ),
+                    description=self.bot.config[
+                        "thread_min_characters_response"
+                    ].replace("{min_characters}", str(min_chars)),
                     color=self.bot.error_color,
                 )
                 embed.set_footer(
@@ -1753,31 +2737,62 @@ async def create(
             try:
                 await thread.wait_until_ready()
             except asyncio.CancelledError:
-                logger.warning("Thread for %s cancelled, abort creating.", recipient)
+                # Improve logging to include username and ID
+                try:
+                    label = f"{recipient} ({recipient.id})"
+                except Exception:
+                    label = f"User ({getattr(recipient, 'id', 'unknown')})"
+                logger.warning("Thread for %s cancelled, abort creating.", label)
                 return thread
             else:
                 if thread.channel and self.bot.get_channel(thread.channel.id):
-                    logger.warning("Found an existing thread for %s, abort creating.", recipient)
+                    logger.warning(
+                        "Found an existing thread for %s, abort creating.", recipient
+                    )
                     return thread
-                logger.warning("Found an existing thread for %s, closing previous thread.", recipient)
+                logger.warning(
+                    "Found an existing thread for %s, closing previous thread.",
+                    recipient,
+                )
                 self.bot.loop.create_task(
-                    thread.close(closer=self.bot.user, silent=True, delete_channel=False)
+                    thread.close(
+                        closer=self.bot.user, silent=True, delete_channel=False
+                    )
                 )
 
         thread = Thread(self, recipient)
 
         self.cache[recipient.id] = thread
 
-        if (message or not manual_trigger) and self.bot.config["confirm_thread_creation"]:
+        # Determine if the advanced thread-creation menu is enabled; if so and the user
+        # initiated via DM, we defer confirmation until AFTER the user selects an option.
+        adv_menu_enabled = self.bot.config.get("thread_creation_menu_enabled") and bool(
+            self.bot.config.get("thread_creation_menu_options")
+        )
+        user_initiated_dm = (creator is None or creator == recipient) and manual_trigger
+
+        if (
+            (message or not manual_trigger)
+            and self.bot.config["confirm_thread_creation"]
+            and not (adv_menu_enabled and user_initiated_dm)
+        ):
             if not manual_trigger:
                 destination = recipient
             else:
                 destination = message.channel
             view = ConfirmThreadCreationView()
             view.add_item(
-                AcceptButton("accept-thread-creation", self.bot.config["confirm_thread_creation_accept"])
+                AcceptButton(
+                    "accept-thread-creation",
+                    self.bot.config["confirm_thread_creation_accept"],
+                )
+            )
+            view.add_item(
+                DenyButton(
+                    "deny-thread-creation",
+                    self.bot.config["confirm_thread_creation_deny"],
+                )
             )
-            view.add_item(DenyButton("deny-thread-creation", self.bot.config["confirm_thread_creation_deny"]))
             confirm = await destination.send(
                 embed=discord.Embed(
                     title=self.bot.config["confirm_thread_creation_title"],
@@ -1804,7 +2819,8 @@ async def create(
                 self.bot.loop.create_task(
                     destination.send(
                         embed=discord.Embed(
-                            title=self.bot.config["thread_cancelled"], color=self.bot.error_color
+                            title=self.bot.config["thread_cancelled"],
+                            color=self.bot.error_color,
                         )
                     )
                 )
@@ -1812,7 +2828,772 @@ async def create(
                 del self.cache[recipient.id]
                 return thread
 
-        self.bot.loop.create_task(thread.setup(creator=creator, category=category, initial_message=message))
+        # --- THREAD-CREATION MENU (deferred or precreate channel creation) ---
+        adv_enabled = self.bot.config.get("thread_creation_menu_enabled") and bool(
+            self.bot.config.get("thread_creation_menu_options")
+        )
+        user_initiated = (creator is None or creator == recipient) and manual_trigger
+        precreate = (
+            adv_enabled
+            and user_initiated
+            and bool(self.bot.config.get("thread_creation_menu_precreate_channel"))
+        )
+        if adv_enabled and user_initiated and not precreate:
+            # Send menu prompt FIRST, wait for selection, then create channel.
+            # Build dummy message for menu DM
+            try:
+                embed_text = self.bot.config.get("thread_creation_menu_embed_text")
+                placeholder = self.bot.config.get(
+                    "thread_creation_menu_dropdown_placeholder"
+                )
+                timeout = int(self.bot.config.get("thread_creation_menu_timeout") or 20)
+            except Exception:
+                embed_text = "Please select an option."
+                placeholder = "Select an option to contact the staff team."
+                timeout = 20
+
+            options = self.bot.config.get("thread_creation_menu_options") or {}
+            submenus = self.bot.config.get("thread_creation_menu_submenus") or {}
+
+            # Minimal inline view implementation (avoid importing plugin code)
+
+            thread.ready = False  # not ready yet
+
+            class _ThreadCreationMenuSelect(discord.ui.Select):
+                def __init__(self, outer_thread: Thread):
+                    self.outer_thread = outer_thread
+                    opts = [
+                        discord.SelectOption(
+                            label=o["label"],
+                            description=o["description"],
+                            emoji=o["emoji"],
+                        )
+                        for o in options.values()
+                    ]
+                    super().__init__(
+                        placeholder=placeholder,
+                        min_values=1,
+                        max_values=1,
+                        options=opts,
+                    )
+
+                async def callback(self, interaction: discord.Interaction):
+                    await interaction.response.defer(ephemeral=False)
+                    # If the thread was snoozed before the user selected an option,
+                    # restore it first so channel creation/setup & message relay work.
+                    try:
+                        if self.outer_thread.snoozed:
+                            await self.outer_thread.restore_from_snooze()
+                    except Exception:
+                        logger.warning(
+                            "Failed unsnoozing thread prior to menu selection; continuing."
+                        )
+                    chosen_label = self.values[0]
+                    # Resolve option key
+                    key = chosen_label.lower().replace(" ", "_")
+                    selected = options.get(key)
+                    self.outer_thread._selected_thread_creation_menu_option = selected
+                    # Reflect the selection in the original DM by editing the embed/body
+                    try:
+                        msg = getattr(interaction, "message", None)
+                        if msg is None and self.view and hasattr(self.view, "message"):
+                            msg = self.view.message
+                        if msg is not None:
+                            if msg.embeds:
+                                emb = msg.embeds[0]
+                                emb.description = f"You selected: {chosen_label}"
+                                await msg.edit(embed=emb, view=None)
+                            else:
+                                await msg.edit(
+                                    content=f"You selected: {chosen_label}", view=None
+                                )
+                        else:
+                            try:
+                                await interaction.edit_original_response(
+                                    content=f"You selected: {chosen_label}", view=None
+                                )
+                            except Exception as e:
+                                # Fallback: best-effort remove the view at least
+                                logger.info(
+                                    "Primary edit_original_response failed; trying to remove view only: %s",
+                                    e,
+                                )
+                                await interaction.edit_original_response(view=None)
+                    except Exception as e:
+                        # Ensure the menu is removed even if content edit failed
+                        logger.warning("Failed to update selection message: %s", e)
+                        try:
+                            await interaction.edit_original_response(view=None)
+                        except Exception as inner_e:
+                            logger.debug(
+                                "Failed to remove view after selection failure: %s",
+                                inner_e,
+                            )
+                    # Stop the view to end the interaction lifecycle
+                    if self.view:
+                        try:
+                            self.view.stop()
+                        except Exception as e:
+                            logger.debug(
+                                "Failed to stop menu view after selection: %s", e
+                            )
+                    # Now create channel
+                    # Determine category: prefer option-specific category if configured and valid
+                    sel_category = None
+                    try:
+                        cat_id = (
+                            selected.get("category_id")
+                            if isinstance(selected, dict)
+                            else None
+                        )
+                        if cat_id:
+                            guild = self.outer_thread.bot.modmail_guild
+                            if guild:
+                                ch = guild.get_channel(cat_id)
+                                if isinstance(ch, discord.CategoryChannel):
+                                    sel_category = ch
+                    except Exception:
+                        sel_category = None
+                    # Fallback to provided category (from outer scope) or main category
+                    fallback_category = category or self.outer_thread.bot.main_category
+                    use_category = sel_category or fallback_category
+                    # If confirmation is enabled, prompt now (after option selection)
+                    try:
+                        if self.outer_thread.bot.config.get("confirm_thread_creation"):
+                            dest = message.channel if manual_trigger else recipient
+                            view = ConfirmThreadCreationView()
+                            view.add_item(
+                                AcceptButton(
+                                    "accept-thread-creation",
+                                    self.outer_thread.bot.config[
+                                        "confirm_thread_creation_accept"
+                                    ],
+                                )
+                            )
+                            view.add_item(
+                                DenyButton(
+                                    "deny-thread-creation",
+                                    self.outer_thread.bot.config[
+                                        "confirm_thread_creation_deny"
+                                    ],
+                                )
+                            )
+                            confirm = await dest.send(
+                                embed=discord.Embed(
+                                    title=self.outer_thread.bot.config[
+                                        "confirm_thread_creation_title"
+                                    ],
+                                    description=self.outer_thread.bot.config[
+                                        "confirm_thread_response"
+                                    ],
+                                    color=self.outer_thread.bot.main_color,
+                                ),
+                                view=view,
+                            )
+                            await view.wait()
+                            if view.value is None:
+                                # Timed out
+                                self.outer_thread.cancelled = True
+                                try:
+                                    await dest.send(
+                                        embed=discord.Embed(
+                                            title=self.outer_thread.bot.config[
+                                                "thread_cancelled"
+                                            ],
+                                            description="Timed out",
+                                            color=self.outer_thread.bot.error_color,
+                                        )
+                                    )
+                                    await confirm.edit(view=None)
+                                except Exception:
+                                    logger.warning(
+                                        "Failed notifying user of thread creation timeout.",
+                                        exc_info=True,
+                                    )
+                            elif view.value is False:
+                                self.outer_thread.cancelled = True
+                                try:
+                                    await dest.send(
+                                        embed=discord.Embed(
+                                            title=self.outer_thread.bot.config[
+                                                "thread_cancelled"
+                                            ],
+                                            color=self.outer_thread.bot.error_color,
+                                        )
+                                    )
+                                except Exception:
+                                    logger.warning(
+                                        "Failed notifying user of thread creation denial.",
+                                        exc_info=True,
+                                    )
+                            if self.outer_thread.cancelled:
+                                # Clear pending/menu state and cache
+                                try:
+                                    setattr(self.outer_thread, "_pending_menu", False)
+                                    self.outer_thread.manager.cache.pop(
+                                        self.outer_thread.id, None
+                                    )
+                                except Exception:
+                                    logger.debug(
+                                        "Failed clearing pending menu/cache after cancellation.",
+                                        exc_info=True,
+                                    )
+                                return
+                    except Exception:
+                        # If confirm step fails, proceed to create thread to avoid dead-ends
+                        logger.warning(
+                            "Confirm step failed after menu selection; continuing."
+                        )
+
+                    self.outer_thread.bot.loop.create_task(
+                        self.outer_thread.setup(
+                            creator=creator,
+                            category=use_category,
+                            initial_message=message,
+                        )
+                    )
+                    # Wait until channel is ready, then forward the original message like usual
+                    try:
+                        await self.outer_thread.wait_until_ready()
+                        # Edge-case: unsnoozed restore might have re-created the channel but genesis send failed; ensure ready channel exists
+                        if not self.outer_thread.channel:
+                            logger.warning(
+                                "Thread has no channel after unsnooze+selection; abort relay."
+                            )
+                            setattr(self.outer_thread, "_pending_menu", False)
+                            return
+                        # Forward the user's initial DM to the thread channel
+                        try:
+                            await self.outer_thread.send(message)
+                        except Exception:
+                            logger.error(
+                                "Failed to relay initial message after menu selection",
+                                exc_info=True,
+                            )
+                        else:
+                            # React to the user's DM with the 'sent' emoji
+                            try:
+                                (
+                                    sent_emoji,
+                                    _,
+                                ) = await self.outer_thread.bot.retrieve_emoji()
+                                await self.outer_thread.bot.add_reaction(
+                                    message, sent_emoji
+                                )
+                            except Exception as e:
+                                logger.debug(
+                                    "Failed to add sent reaction to user's DM: %s",
+                                    e,
+                                )
+                            # Dispatch thread_reply event for parity
+                            self.outer_thread.bot.dispatch(
+                                "thread_reply",
+                                self.outer_thread,
+                                False,
+                                message,
+                                False,
+                                False,
+                            )
+                        # Clear pending flag
+                        setattr(self.outer_thread, "_pending_menu", False)
+                    except Exception:
+                        logger.warning(
+                            "Unhandled failure after menu selection while waiting for channel readiness.",
+                            exc_info=True,
+                        )
+                    # Invoke command callback AFTER channel ready if type == command
+                    if selected and selected.get("type") == "command":
+                        alias = selected.get("callback")
+                        if alias:
+                            from discord.ext.commands.view import StringView
+                            from core.utils import normalize_alias
+
+                            ctxs = []
+                            for al in normalize_alias(alias):
+                                view_ = StringView(self.outer_thread.bot.prefix + al)
+                                # Create a synthetic message object that makes the bot appear
+                                # as the author for menu-invoked command replies so the user
+                                # selecting the option is not shown as a "mod" sender.
+                                synthetic = DummyMessage(copy.copy(message))
+                                try:
+                                    synthetic.author = (
+                                        self.outer_thread.bot.modmail_guild.me
+                                        or self.outer_thread.bot.user
+                                    )
+                                except Exception:
+                                    synthetic.author = self.outer_thread.bot.user
+                                # Mark this message as menu-invoked for downstream formatting
+                                setattr(synthetic, "_menu_invoked", True)
+                                ctx_ = commands.Context(
+                                    prefix=self.outer_thread.bot.prefix,
+                                    view=view_,
+                                    bot=self.outer_thread.bot,
+                                    message=synthetic,
+                                )
+                                ctx_.thread = self.outer_thread
+                                discord.utils.find(
+                                    view_.skip_string,
+                                    await self.outer_thread.bot.get_prefix(),
+                                )
+                                ctx_.invoked_with = view_.get_word().lower()
+                                ctx_.command = self.outer_thread.bot.all_commands.get(
+                                    ctx_.invoked_with
+                                )
+                                # Mark context so downstream send/reply logic can treat as system/bot
+                                setattr(ctx_, "_menu_invoked", True)
+                                ctxs.append(ctx_)
+                            for ctx_ in ctxs:
+                                if ctx_.command:
+                                    old_checks = copy.copy(ctx_.command.checks)
+                                    ctx_.command.checks = [
+                                        checks.has_permissions(PermissionLevel.INVALID)
+                                    ]
+                                    try:
+                                        await self.outer_thread.bot.invoke(ctx_)
+                                    finally:
+                                        ctx_.command.checks = old_checks
+
+            class _ThreadCreationMenuView(discord.ui.View):
+                def __init__(self, outer_thread: Thread):
+                    super().__init__(timeout=timeout)
+                    self.outer_thread = outer_thread
+                    self.add_item(_ThreadCreationMenuSelect(outer_thread))
+
+                async def on_timeout(self):
+                    # Timeout -> abort thread creation
+                    if self.outer_thread.bot.config.get(
+                        "thread_creation_menu_close_on_timeout"
+                    ):
+                        try:
+                            await menu_msg.edit(content="Menu timed out.", view=None)
+                        except Exception:
+                            logger.info(
+                                "Failed editing menu message on timeout (close_on_timeout enabled).",
+                                exc_info=True,
+                            )
+                        # remove thread from cache
+                        try:
+                            self.outer_thread.manager.cache.pop(
+                                self.outer_thread.id, None
+                            )
+                        except Exception:
+                            logger.debug(
+                                "Failed popping thread from cache on timeout (close_on_timeout).",
+                                exc_info=True,
+                            )
+                        # Clear pending menu flag so a new message can recreate a fresh thread
+                        setattr(self.outer_thread, "_pending_menu", False)
+                        self.outer_thread.cancelled = True
+                    else:
+                        try:
+                            await menu_msg.edit(
+                                content="Menu timed out. Please send a new message to start again.",
+                                view=None,
+                            )
+                        except Exception:
+                            logger.info(
+                                "Failed editing menu message on timeout (keep alive mode).",
+                                exc_info=True,
+                            )
+                        # Allow subsequent messages to trigger a new menu/thread by clearing state
+                        setattr(self.outer_thread, "_pending_menu", False)
+                        try:
+                            self.outer_thread.manager.cache.pop(
+                                self.outer_thread.id, None
+                            )
+                        except Exception:
+                            logger.debug(
+                                "Failed popping thread from cache on timeout (keep alive mode).",
+                                exc_info=True,
+                            )
+                        self.outer_thread.cancelled = True
+                    # Ensure view is stopped to release any internal tasks
+                    try:
+                        self.stop()
+                    except Exception:
+                        logger.debug(
+                            "Failed stopping ThreadCreationMenuView on timeout.",
+                            exc_info=True,
+                        )
+
+            # Send DM prompt
+            try:
+                # Build embed with new customizable settings
+                try:
+                    embed_title = self.bot.config.get(
+                        "thread_creation_menu_embed_title"
+                    )
+                    embed_footer = self.bot.config.get(
+                        "thread_creation_menu_embed_footer"
+                    )
+                    embed_thumb = self.bot.config.get(
+                        "thread_creation_menu_embed_thumbnail_url"
+                    )
+                    embed_image = self.bot.config.get(
+                        "thread_creation_menu_embed_image_url"
+                    )
+                    embed_footer_icon = self.bot.config.get(
+                        "thread_creation_menu_embed_footer_icon_url"
+                    )
+                    embed_color_raw = self.bot.config.get(
+                        "thread_creation_menu_embed_color"
+                    )
+                except Exception:
+                    embed_title = None
+                    embed_footer = None
+                    embed_thumb = None
+                    embed_image = None
+                    embed_footer_icon = None
+                    embed_color_raw = None
+                embed_color = embed_color_raw or self.bot.mod_color
+                embed = discord.Embed(
+                    title=embed_title, description=embed_text, color=embed_color
+                )
+                if embed_footer:
+                    try:
+                        if embed_footer_icon:
+                            embed.set_footer(
+                                text=embed_footer, icon_url=embed_footer_icon
+                            )
+                        else:
+                            embed.set_footer(text=embed_footer)
+                    except Exception as e:
+                        logger.debug("Footer build failed (ignored): %s", e)
+                # Option A: prefer dedicated large image when provided
+                if embed_image:
+                    try:
+                        embed.set_image(url=embed_image)
+                    except Exception as e:
+                        logger.debug("Image set failed (ignored): %s", e)
+                elif embed_thumb:
+                    try:
+                        embed.set_thumbnail(url=embed_thumb)
+                    except Exception as e:
+                        logger.debug("Thumbnail set failed (ignored): %s", e)
+                menu_view = _ThreadCreationMenuView(thread)
+                menu_msg = await recipient.send(embed=embed, view=menu_view)
+                # mark thread as pending menu selection
+                thread._pending_menu = True
+                # Explicitly attach the message to the view for safety in callbacks
+                try:
+                    menu_view.message = menu_msg
+                except Exception as e:
+                    logger.info(
+                        "Failed attaching menu message reference (initial menu send): %s",
+                        e,
+                    )
+                # Store for later disabling on thread close
+                try:
+                    thread._dm_menu_msg_id = menu_msg.id
+                    thread._dm_menu_channel_id = menu_msg.channel.id
+                except Exception as e:
+                    logger.info(
+                        "Failed storing DM menu identifiers (initial menu send): %s",
+                        e,
+                    )
+            except Exception:
+                logger.warning(
+                    "Failed to send thread-creation menu DM, falling back to immediate thread creation.",
+                    exc_info=True,
+                )
+                self.bot.loop.create_task(
+                    thread.setup(
+                        creator=creator, category=category, initial_message=message
+                    )
+                )
+            return thread
+
+        # If menu is enabled but precreate is requested, send the menu DM but do NOT defer creation.
+        # Selection becomes optional; thread channel will already be created below.
+        if adv_enabled and user_initiated and precreate:
+            try:
+                embed_text = self.bot.config.get("thread_creation_menu_embed_text")
+                placeholder = self.bot.config.get(
+                    "thread_creation_menu_dropdown_placeholder"
+                )
+                timeout = int(self.bot.config.get("thread_creation_menu_timeout") or 20)
+            except Exception:
+                embed_text = "Please select an option."
+                placeholder = "Select an option to contact the staff team."
+                timeout = 20
+
+            options = self.bot.config.get("thread_creation_menu_options") or {}
+
+            class _PrecreateMenuSelect(discord.ui.Select):
+                def __init__(self, outer_thread: Thread):
+                    self.outer_thread = outer_thread
+                    opts = [
+                        discord.SelectOption(
+                            label=o["label"],
+                            description=o["description"],
+                            emoji=o["emoji"],
+                        )
+                        for o in options.values()
+                    ]
+                    super().__init__(
+                        placeholder=placeholder,
+                        min_values=1,
+                        max_values=1,
+                        options=opts,
+                    )
+
+                async def callback(self, interaction: discord.Interaction):
+                    await interaction.response.defer(ephemeral=False)
+                    # If thread somehow got snoozed before selection in precreate flow (rare), restore first.
+                    try:
+                        if self.outer_thread.snoozed:
+                            await self.outer_thread.restore_from_snooze()
+                    except Exception:
+                        logger.warning(
+                            "Failed unsnoozing thread prior to precreate menu selection; continuing.",
+                            exc_info=True,
+                        )
+                    chosen_label = self.values[0]
+                    key = chosen_label.lower().replace(" ", "_")
+                    selected = options.get(key)
+                    self.outer_thread._selected_thread_creation_menu_option = selected
+                    # Remove the view
+                    try:
+                        msg = getattr(interaction, "message", None)
+                        if msg is None and self.view and hasattr(self.view, "message"):
+                            msg = self.view.message
+                        if msg is not None:
+                            if msg.embeds:
+                                emb = msg.embeds[0]
+                                emb.description = f"You choose: {chosen_label}"
+                                await msg.edit(embed=emb, view=None)
+                            else:
+                                await msg.edit(
+                                    content=f"You choose: {chosen_label}", view=None
+                                )
+                        else:
+                            try:
+                                await interaction.edit_original_response(
+                                    content=f"You choose: {chosen_label}", view=None
+                                )
+                            except Exception:
+                                await interaction.edit_original_response(view=None)
+                    except Exception:
+                        try:
+                            await interaction.edit_original_response(view=None)
+                        except Exception:
+                            logger.debug(
+                                "Failed secondary edit_original_response path removing view.",
+                                exc_info=True,
+                            )
+                    if self.view:
+                        try:
+                            self.view.stop()
+                        except Exception:
+                            logger.debug(
+                                "Failed removing view after selection (stop).",
+                                exc_info=True,
+                            )
+                    # Log selection to thread channel if configured
+                    try:
+                        await self.outer_thread.wait_until_ready()
+                        if self.outer_thread.bot.config.get(
+                            "thread_creation_menu_selection_log"
+                        ):
+                            opt = selected or {}
+                            log_txt = f"Selected menu option: {opt.get('label')} ({opt.get('type')})"
+                            if opt.get("type") == "command":
+                                log_txt += f" -> {opt.get('callback')}"
+                            await self.outer_thread.channel.send(
+                                embed=discord.Embed(
+                                    description=log_txt,
+                                    color=self.outer_thread.bot.mod_color,
+                                )
+                            )
+                        # If a category_id is set on the option, move the channel accordingly
+                        try:
+                            cat_id = (
+                                selected.get("category_id")
+                                if isinstance(selected, dict)
+                                else None
+                            )
+                            if cat_id:
+                                guild = self.outer_thread.bot.modmail_guild
+                                target = guild and guild.get_channel(int(cat_id))
+                                if isinstance(target, discord.CategoryChannel):
+                                    await self.outer_thread.channel.edit(
+                                        category=target,
+                                        reason="Menu selection: move to category",
+                                    )
+                        except Exception:
+                            logger.debug(
+                                "Failed moving thread channel based on selected category_id.",
+                                exc_info=True,
+                            )
+                    except Exception:
+                        logger.debug(
+                            "Failed logging menu selection or moving category in precreate flow.",
+                            exc_info=True,
+                        )
+                    # If the option type is command, invoke it now within the created thread
+                    if selected and selected.get("type") == "command":
+                        alias = selected.get("callback")
+                        if alias:
+                            from discord.ext.commands.view import StringView
+                            from core.utils import normalize_alias
+
+                            ctxs = []
+                            for al in normalize_alias(alias):
+                                view_ = StringView(self.outer_thread.bot.prefix + al)
+                                synthetic = DummyMessage(copy.copy(message))
+                                try:
+                                    synthetic.author = (
+                                        self.outer_thread.bot.modmail_guild.me
+                                        or self.outer_thread.bot.user
+                                    )
+                                except Exception:
+                                    synthetic.author = self.outer_thread.bot.user
+                                setattr(synthetic, "_menu_invoked", True)
+                                ctx_ = commands.Context(
+                                    prefix=self.outer_thread.bot.prefix,
+                                    view=view_,
+                                    bot=self.outer_thread.bot,
+                                    message=synthetic,
+                                )
+                                ctx_.thread = self.outer_thread
+                                discord.utils.find(
+                                    view_.skip_string,
+                                    await self.outer_thread.bot.get_prefix(),
+                                )
+                                ctx_.invoked_with = view_.get_word().lower()
+                                ctx_.command = self.outer_thread.bot.all_commands.get(
+                                    ctx_.invoked_with
+                                )
+                                setattr(ctx_, "_menu_invoked", True)
+                                ctxs.append(ctx_)
+                            for ctx_ in ctxs:
+                                if ctx_.command:
+                                    old_checks = copy.copy(ctx_.command.checks)
+                                    ctx_.command.checks = [
+                                        checks.has_permissions(PermissionLevel.INVALID)
+                                    ]
+                                    try:
+                                        await self.outer_thread.bot.invoke(ctx_)
+                                    finally:
+                                        ctx_.command.checks = old_checks
+
+            class _PrecreateMenuView(discord.ui.View):
+                def __init__(self, outer_thread: Thread):
+                    super().__init__(timeout=timeout)
+                    self.add_item(_PrecreateMenuSelect(outer_thread))
+
+                async def on_timeout(self):
+                    try:
+                        await menu_msg.edit(content="Menu timed out.", view=None)
+                    except Exception:
+                        logger.info(
+                            "Failed editing precreate menu message on timeout.",
+                            exc_info=True,
+                        )
+                    try:
+                        self.stop()
+                    except Exception:
+                        logger.debug(
+                            "Failed stopping PrecreateMenuView on timeout.",
+                            exc_info=True,
+                        )
+
+            try:
+                # Build embed with new customizable settings (precreate flow)
+                try:
+                    embed_title = self.bot.config.get(
+                        "thread_creation_menu_embed_title"
+                    )
+                    embed_footer = self.bot.config.get(
+                        "thread_creation_menu_embed_footer"
+                    )
+                    embed_thumb = self.bot.config.get(
+                        "thread_creation_menu_embed_thumbnail_url"
+                    )
+                    embed_image = self.bot.config.get(
+                        "thread_creation_menu_embed_image_url"
+                    )
+                    embed_large = bool(
+                        self.bot.config.get("thread_creation_menu_embed_large_image")
+                    )
+                    embed_footer_icon = self.bot.config.get(
+                        "thread_creation_menu_embed_footer_icon_url"
+                    )
+                    embed_color_raw = self.bot.config.get(
+                        "thread_creation_menu_embed_color"
+                    )
+                except Exception:
+                    embed_title = None
+                    embed_footer = None
+                    embed_thumb = None
+                    embed_image = None
+                    embed_large = False
+                    embed_footer_icon = None
+                    embed_color_raw = None
+                embed_color = embed_color_raw or self.bot.mod_color
+                embed = discord.Embed(
+                    title=embed_title, description=embed_text, color=embed_color
+                )
+                if embed_footer:
+                    try:
+                        if embed_footer_icon:
+                            embed.set_footer(
+                                text=embed_footer, icon_url=embed_footer_icon
+                            )
+                        else:
+                            embed.set_footer(text=embed_footer)
+                    except Exception as e:
+                        logger.debug("Footer build failed (ignored precreate): %s", e)
+                if embed_image:
+                    try:
+                        embed.set_image(url=embed_image)
+                    except Exception as e:
+                        logger.debug("Image set failed (ignored precreate): %s", e)
+                elif embed_thumb:
+                    try:
+                        if embed_large:
+                            embed.set_image(url=embed_thumb)
+                        else:
+                            embed.set_thumbnail(url=embed_thumb)
+                    except Exception as e:
+                        logger.debug(
+                            "Thumbnail/image set failed (ignored precreate): %s", e
+                        )
+                menu_view = _PrecreateMenuView(thread)
+                # Send menu DM AFTER channel creation initiation (channel will be created below)
+                menu_msg = await recipient.send(embed=embed, view=menu_view)
+                try:
+                    menu_view.message = menu_msg
+                except Exception:
+                    logger.debug(
+                        "Failed attaching menu message reference (precreate menu).",
+                        exc_info=True,
+                    )
+                # Store for later disabling on thread close
+                try:
+                    thread._dm_menu_msg_id = menu_msg.id
+                    thread._dm_menu_channel_id = menu_msg.channel.id
+                except Exception:
+                    logger.debug(
+                        "Failed storing DM menu identifiers (precreate menu).",
+                        exc_info=True,
+                    )
+            except Exception:
+                logger.debug(
+                    "Failed to send precreate menu DM; proceeding without menu."
+                )
+
+        # Regular immediate creation (force main_category for user-initiated menu flows)
+        forced_category = None
+        if adv_enabled and user_initiated and precreate:
+            # In precreate mode we still create immediately (main category override optional)
+            forced_category = self.bot.main_category
+        chosen_category = forced_category or category
+        self.bot.loop.create_task(
+            thread.setup(
+                creator=creator, category=chosen_category, initial_message=message
+            )
+        )
         return thread
 
     async def find_or_create(self, recipient) -> Thread:
diff --git a/core/time.py b/core/time.py
index b6ce91f419..4d1db1ce6a 100644
--- a/core/time.py
+++ b/core/time.py
@@ -64,7 +64,9 @@ def __init__(self, argument: str, *, now: Optional[datetime.datetime] = None):
         if match is None or not match.group(0):
             match = self.discord_fmt.fullmatch(argument)
             if match is not None:
-                self.dt = datetime.datetime.utcfromtimestamp(int(match.group("ts")), tz=datetime.timezone.utc)
+                self.dt = datetime.datetime.utcfromtimestamp(
+                    int(match.group("ts")), tz=datetime.timezone.utc
+                )
                 return
             else:
                 raise commands.BadArgument("invalid time provided")
@@ -85,11 +87,18 @@ def __init__(self, argument: str, *, now: Optional[datetime.datetime] = None):
         now = now or datetime.datetime.utcnow()
         dt, status = self.calendar.parseDT(argument, sourceTime=now)
         if not status.hasDateOrTime:
-            raise commands.BadArgument('invalid time provided, try e.g. "tomorrow" or "3 days"')
+            raise commands.BadArgument(
+                'invalid time provided, try e.g. "tomorrow" or "3 days"'
+            )
 
         if not status.hasTime:
             # replace it with the current time
-            dt = dt.replace(hour=now.hour, minute=now.minute, second=now.second, microsecond=now.microsecond)
+            dt = dt.replace(
+                hour=now.hour,
+                minute=now.minute,
+                second=now.second,
+                microsecond=now.microsecond,
+            )
 
         self.dt: datetime.datetime = dt
         self._past: bool = dt < now
@@ -158,7 +167,11 @@ def __init__(self, dt: datetime.datetime, now: datetime.datetime = None):
         self.arg = ""
 
     async def ensure_constraints(
-        self, ctx: Context, uft: UserFriendlyTime, now: datetime.datetime, remaining: str
+        self,
+        ctx: Context,
+        uft: UserFriendlyTime,
+        now: datetime.datetime,
+        remaining: str,
     ) -> None:
         # Strip stray connector words like "in", "to", or "at" that may
         # remain when the natural language parser isolates the time token
@@ -217,7 +230,9 @@ def __init__(
         self.converter: commands.Converter = converter  # type: ignore  # It doesn't understand this narrowing
         self.default: Any = default
 
-    async def convert(self, ctx: Context, argument: str, *, now=None) -> FriendlyTimeResult:
+    async def convert(
+        self, ctx: Context, argument: str, *, now=None
+    ) -> FriendlyTimeResult:
         calendar = HumanTime.calendar
         regex = ShortTime.compiled
         if now is None:
@@ -255,7 +270,9 @@ async def convert(self, ctx: Context, argument: str, *, now=None) -> FriendlyTim
             match = ShortTime.discord_fmt.match(argument)
             if match is not None:
                 result = FriendlyTimeResult(
-                    datetime.datetime.utcfromtimestamp(int(match.group("ts")), now, tz=datetime.timezone.utc)
+                    datetime.datetime.utcfromtimestamp(
+                        int(match.group("ts")), now, tz=datetime.timezone.utc
+                    )
                 )
                 remaining = argument[match.end() :].strip()
                 await result.ensure_constraints(ctx, self, now, remaining)
@@ -287,7 +304,9 @@ async def convert(self, ctx: Context, argument: str, *, now=None) -> FriendlyTim
         dt, status, begin, end, dt_string = elements[0]
 
         if not status.hasDateOrTime:
-            raise commands.BadArgument('Invalid time provided, try e.g. "tomorrow" or "3 days".')
+            raise commands.BadArgument(
+                'Invalid time provided, try e.g. "tomorrow" or "3 days".'
+            )
 
         # If the parsed time token is embedded in the text but only followed by
         # trailing punctuation/whitespace, treat it as if it's positioned at the end.
@@ -301,7 +320,12 @@ async def convert(self, ctx: Context, argument: str, *, now=None) -> FriendlyTim
 
         if not status.hasTime:
             # replace it with the current time
-            dt = dt.replace(hour=now.hour, minute=now.minute, second=now.second, microsecond=now.microsecond)
+            dt = dt.replace(
+                hour=now.hour,
+                minute=now.minute,
+                second=now.second,
+                microsecond=now.microsecond,
+            )
 
         # if midnight is provided, just default to next day
         if status.accuracy == pdt.pdtContext.ACU_HALFDAY:
@@ -331,7 +355,9 @@ async def convert(self, ctx: Context, argument: str, *, now=None) -> FriendlyTim
                     raise commands.BadArgument("Expected quote before time input...")
 
                 if not (end < len(argument) and argument[end] == '"'):
-                    raise commands.BadArgument("If the time is quoted, you must unquote it.")
+                    raise commands.BadArgument(
+                        "If the time is quoted, you must unquote it."
+                    )
 
                 remaining = argument[end + 1 :].lstrip(" ,.!")
             else:
diff --git a/core/utils.py b/core/utils.py
index 19ff4cd37b..19a7490cc3 100644
--- a/core/utils.py
+++ b/core/utils.py
@@ -258,7 +258,9 @@ def cleanup_code(content: str) -> str:
 UID_REGEX = re.compile(r"\bUser ID:\s*(\d{17,21})\b", flags=re.IGNORECASE)
 
 
-def parse_channel_topic(text: str) -> typing.Tuple[typing.Optional[str], int, typing.List[int]]:
+def parse_channel_topic(
+    text: str,
+) -> typing.Tuple[typing.Optional[str], int, typing.List[int]]:
     """
     A helper to parse channel topics and respectivefully returns all the required values
     at once.
@@ -359,7 +361,8 @@ def match_other_recipients(text: str) -> typing.List[int]:
 def create_not_found_embed(word, possibilities, name, n=2, cutoff=0.6) -> discord.Embed:
     # Single reference of Color.red()
     embed = discord.Embed(
-        color=discord.Color.red(), description=f"**{name.capitalize()} `{word}` cannot be found.**"
+        color=discord.Color.red(),
+        description=f"**{name.capitalize()} `{word}` cannot be found.**",
     )
     val = get_close_matches(word, possibilities, n=n, cutoff=cutoff)
     if val:
@@ -369,7 +372,7 @@ def create_not_found_embed(word, possibilities, name, n=2, cutoff=0.6) -> discor
 
 def parse_alias(alias, *, split=True):
     def encode_alias(m):
-        return "\x1AU" + base64.b64encode(m.group(1).encode()).decode() + "\x1AU"
+        return "\x1aU" + base64.b64encode(m.group(1).encode()).decode() + "\x1aU"
 
     def decode_alias(m):
         return base64.b64decode(m.group(1).encode()).decode()
@@ -483,7 +486,9 @@ def get_top_role(member: discord.Member, hoisted=True):
             return role
 
 
-async def create_thread_channel(bot, recipient, category, overwrites, *, name=None, errors_raised=None):
+async def create_thread_channel(
+    bot, recipient, category, overwrites, *, name=None, errors_raised=None
+):
     name = name or bot.format_channel_name(recipient)
     errors_raised = errors_raised or []
 
@@ -506,7 +511,9 @@ async def create_thread_channel(bot, recipient, category, overwrites, *, name=No
             fallback = None
             fallback_id = bot.config["fallback_category_id"]
             if fallback_id:
-                fallback = discord.utils.get(category.guild.categories, id=int(fallback_id))
+                fallback = discord.utils.get(
+                    category.guild.categories, id=int(fallback_id)
+                )
                 if fallback and len(fallback.channels) >= 49:
                     fallback = None
 
@@ -577,7 +584,10 @@ def extract_block_timestamp(reason, id_):
             # found a deprecated version
             try:
                 after = (
-                    datetime.fromisoformat(end_time.group(1)).replace(tzinfo=timezone.utc) - now
+                    datetime.fromisoformat(end_time.group(1)).replace(
+                        tzinfo=timezone.utc
+                    )
+                    - now
                 ).total_seconds()
             except ValueError:
                 logger.warning(
@@ -592,7 +602,10 @@ def extract_block_timestamp(reason, id_):
     else:
         try:
             after = (
-                datetime.utcfromtimestamp(int(end_time.group(1))).replace(tzinfo=timezone.utc) - now
+                datetime.utcfromtimestamp(int(end_time.group(1))).replace(
+                    tzinfo=timezone.utc
+                )
+                - now
             ).total_seconds()
         except ValueError:
             logger.warning(
@@ -612,7 +625,9 @@ def return_or_truncate(text, max_length):
 
 class AcceptButton(discord.ui.Button):
     def __init__(self, custom_id: str, emoji: str):
-        super().__init__(style=discord.ButtonStyle.gray, emoji=emoji, custom_id=custom_id)
+        super().__init__(
+            style=discord.ButtonStyle.gray, emoji=emoji, custom_id=custom_id
+        )
 
     async def callback(self, interaction: discord.Interaction):
         self.view.value = True
@@ -622,7 +637,9 @@ async def callback(self, interaction: discord.Interaction):
 
 class DenyButton(discord.ui.Button):
     def __init__(self, custom_id: str, emoji: str):
-        super().__init__(style=discord.ButtonStyle.gray, emoji=emoji, custom_id=custom_id)
+        super().__init__(
+            style=discord.ButtonStyle.gray, emoji=emoji, custom_id=custom_id
+        )
 
     async def callback(self, interaction: discord.Interaction):
         self.view.value = False
@@ -632,7 +649,8 @@ async def callback(self, interaction: discord.Interaction):
 
 class ConfirmThreadCreationView(discord.ui.View):
     def __init__(self):
-        super().__init__(timeout=20)
+        # Match thread_creation_menu_timeout default (30s) for consistency in UX
+        super().__init__(timeout=30)
         self.value = None
 
 
@@ -659,7 +677,9 @@ def extract_forwarded_content(message) -> typing.Optional[str]:
                 forwarded_parts = []
                 for snap in message.message_snapshots:
                     author = getattr(snap, "author", None)
-                    author_name = getattr(author, "name", "Unknown") if author else "Unknown"
+                    author_name = (
+                        getattr(author, "name", "Unknown") if author else "Unknown"
+                    )
                     snap_content = getattr(snap, "content", "")
 
                     if snap_content:
@@ -673,15 +693,22 @@ def extract_forwarded_content(message) -> typing.Optional[str]:
                                 embed_desc = embed.description
                                 if len(embed_desc) > 300:
                                     embed_desc = embed_desc[:297] + "..."
-                                forwarded_parts.append(f"**{author_name}:** {embed_desc}")
+                                forwarded_parts.append(
+                                    f"**{author_name}:** {embed_desc}"
+                                )
                                 break
                     elif getattr(snap, "attachments", None):
                         attachment_info = ", ".join(
-                            [getattr(a, "filename", "Unknown") for a in snap.attachments[:3]]
+                            [
+                                getattr(a, "filename", "Unknown")
+                                for a in snap.attachments[:3]
+                            ]
                         )
                         if len(snap.attachments) > 3:
                             attachment_info += f" (+{len(snap.attachments) - 3} more)"
-                        forwarded_parts.append(f"**{author_name}:** [Attachments: {attachment_info}]")
+                        forwarded_parts.append(
+                            f"**{author_name}:** [Attachments: {attachment_info}]"
+                        )
                     else:
                         forwarded_parts.append(f"**{author_name}:** [No content]")
 
@@ -689,18 +716,25 @@ def extract_forwarded_content(message) -> typing.Optional[str]:
                     return "\n".join(forwarded_parts)
 
         # Handle single-message forward
-        elif getattr(message, "type", None) == getattr(discord.MessageType, "forward", None):
+        elif getattr(message, "type", None) == getattr(
+            discord.MessageType, "forward", None
+        ):
             ref = getattr(message, "reference", None)
             if (
                 ref
                 and hasattr(discord, "MessageReferenceType")
-                and getattr(ref, "type", None) == getattr(discord.MessageReferenceType, "forward", None)
+                and getattr(ref, "type", None)
+                == getattr(discord.MessageReferenceType, "forward", None)
             ):
                 try:
                     ref_msg = getattr(ref, "resolved", None)
                     if ref_msg:
                         ref_author = getattr(ref_msg, "author", None)
-                        ref_author_name = getattr(ref_author, "name", "Unknown") if ref_author else "Unknown"
+                        ref_author_name = (
+                            getattr(ref_author, "name", "Unknown")
+                            if ref_author
+                            else "Unknown"
+                        )
                         ref_content = getattr(ref_msg, "content", "")
 
                         if ref_content:
@@ -716,13 +750,19 @@ def extract_forwarded_content(message) -> typing.Optional[str]:
                                     return f"**{ref_author_name}:** {embed_desc}"
                         elif getattr(ref_msg, "attachments", None):
                             attachment_info = ", ".join(
-                                [getattr(a, "filename", "Unknown") for a in ref_msg.attachments[:3]]
+                                [
+                                    getattr(a, "filename", "Unknown")
+                                    for a in ref_msg.attachments[:3]
+                                ]
                             )
                             if len(ref_msg.attachments) > 3:
-                                attachment_info += f" (+{len(ref_msg.attachments) - 3} more)"
+                                attachment_info += (
+                                    f" (+{len(ref_msg.attachments) - 3} more)"
+                                )
                             return f"**{ref_author_name}:** [Attachments: {attachment_info}]"
-                except Exception:
-                    pass
+                except Exception as e:
+                    # Log and continue; failing to extract a reference preview shouldn't break flow
+                    logger.debug("Failed to extract reference preview: %s", e)
     except Exception:
         # Silently handle any unexpected errors
         pass
diff --git a/requirements.txt b/requirements.txt
index 8530e8e0d5..6168b5c443 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -20,7 +20,8 @@ frozenlist==1.8.0; python_version >= '3.9'
 idna==3.10; python_version >= '3.6'
 isodate==0.6.1
 lottie[pdf]==0.7.0; python_version >= '3'
-motor==3.3.2; python_version >= '3.7'
+pymongo[srv]==4.9.2; python_version >= '3.9'
+motor==3.6.1; python_version >= '3.7'
 multidict==6.6.4; python_version >= '3.9'
 natural==0.2.0
 orjson==3.11.3; python_version >= '3.9'
@@ -30,7 +31,6 @@ pillow==11.3.0; python_version >= '3.9'
 propcache==0.4.0; python_version >= '3.9'
 pycares==4.11.0; python_version >= '3.9'
 pycparser==2.23; python_version >= '3.8'
-pymongo[srv]==4.15.2; python_version >= '3.9'
 python-dateutil==2.8.2; python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2'
 python-dotenv==1.0.0; python_version >= '3.8'
 requests==2.31.0; python_version >= '3.7'