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..51badd1956 100644
--- a/bot.py
+++ b/bot.py
@@ -84,12 +84,13 @@ def __init__(self):
         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):
@@ -590,7 +591,7 @@ async def on_ready(self):
             )
 
         for log in await self.api.get_open_logs():
-            if self.get_channel(int(log["channel_id"])) is None:
+            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"],
@@ -880,6 +881,36 @@ 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)
@@ -1055,13 +1086,7 @@ 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)}}
-                )
-        # Re-fetch the thread object to ensure channel is valid
-        thread = await self.threads.find(recipient=message.author)
+            # No need to re-fetch the thread - it's already restored and cached properly
 
         if thread is None:
             delta = await self.get_thread_cooldown(message.author)
@@ -1090,6 +1115,9 @@ def __init__(self, original_message, ref_message):
                 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(
@@ -1356,7 +1384,7 @@ 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:
@@ -1368,11 +1396,44 @@ async def process_commands(self, message):
                     )
                     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:
+                            pass
+                        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
+                try:
+                    behavior = (self.config.get("snooze_behavior") or "delete").lower()
+                except Exception:
+                    behavior = "delete"
+                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:
+                            pass
+                    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"):
@@ -1541,6 +1602,19 @@ 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)
 
@@ -1676,7 +1750,12 @@ async def on_message_delete(self, message):
             await thread.delete_message(message, note=False)
             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)
             else:
diff --git a/cogs/modmail.py b/cogs/modmail.py
index a63eea9103..1210f95d74 100644
--- a/cogs/modmail.py
+++ b/cogs/modmail.py
@@ -29,6 +29,58 @@ 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:
+                            pass
+                        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."""
@@ -471,21 +523,24 @@ 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)
@@ -1072,7 +1127,7 @@ async def anonadduser(self, ctx, *users_arg: Union[discord.Member, discord.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)
@@ -1163,7 +1218,7 @@ async def anonremoveuser(self, ctx, *users_arg: Union[discord.Member, discord.Ro
                 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)
@@ -1522,6 +1577,14 @@ 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 asyncio.sleep(3)
+            await ctx.message.delete()
+        except (discord.Forbidden, discord.NotFound):
+            pass
 
     @note.command(name="persistent", aliases=["persist"])
     @checks.has_permissions(PermissionLevel.SUPPORTER)
@@ -1535,6 +1598,14 @@ async def note_persistent(self, ctx, *, msg: str = ""):
             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)
+        # 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 asyncio.sleep(3)
+            await ctx.message.delete()
+        except (discord.Forbidden, discord.NotFound):
+            pass
 
     @commands.command()
     @checks.has_permissions(PermissionLevel.SUPPORTER)
@@ -1568,6 +1639,25 @@ 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
+                await ctx.send(f"ℹ️ You had a snoozed thread. Unsnoozing now...")
+                await existing_thread.restore_from_snooze()
+                self.bot.threads.cache[existing_thread.id] = existing_thread
+                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]")
@@ -1626,9 +1716,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}"
@@ -1642,6 +1737,17 @@ async def contact(
                 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:
+                    await ctx.send(f"ℹ️ {u.mention} had a snoozed thread. Unsnoozing now...")
+                    await thread.restore_from_snooze()
+                    self.bot.threads.cache[thread.id] = thread
+            # 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 = []
@@ -1658,7 +1764,6 @@ async def contact(
                 await ctx.send(embed=embed, delete_after=10)
 
             if not users:
-                # end
                 return
 
         creator = ctx.author if manual_trigger else users[0]
@@ -2268,31 +2373,125 @@ 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.")
             return
-        max_snooze = self.bot.config.get("max_snooze_time")
-        if max_snooze is None:
-            max_snooze = 604800
-        max_snooze = int(max_snooze)
+        from core.time import ShortTime
+
+        default_snooze = self.bot.config.get("snooze_default_duration")
+        if default_snooze is None:
+            default_snooze = 604800
+        else:
+            try:
+                default_snooze = int(default_snooze)
+            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
+            if snooze_for > default_snooze:
+                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:
+                    # 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:
+                        pass
+                    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:
+                    pass
 
-        # 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",
@@ -2420,24 +2619,17 @@ async def snooze_auto_unsnooze_task(self):
             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)
+                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):
+                        pass
+            await asyncio.sleep(10)
 
     async def process_dm_modmail(self, message: discord.Message) -> None:
         # ... existing code ...
diff --git a/cogs/threadmenu.py b/cogs/threadmenu.py
new file mode 100644
index 0000000000..f12e6a0d33
--- /dev/null
+++ b/cogs/threadmenu.py
@@ -0,0 +1,730 @@
+import json
+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 `cancel` at any time to cancel the process.")
+        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?")
+        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."
+            )
+
+        await ctx.send("What is the emoji of the option?")
+        emoji = (await self.bot.wait_for("message", check=check)).content
+
+        if emoji.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+
+        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 send `cancel` at any time to cancel the process.")
+        await ctx.send("What is the new description of the option?")
+        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."
+            )
+
+        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.")
+
+        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"]
+        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 send `cancel` at any time to cancel the process.")
+        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?")
+        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."
+            )
+
+        await ctx.send("What is the emoji of the option?")
+        emoji = (await self.bot.wait_for("message", check=check)).content
+        if emoji.lower() == "cancel":
+            return await ctx.send("Cancelled.")
+
+        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 send `cancel` at any time to cancel the process.")
+        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?")
+        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."
+            )
+
+        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.")
+
+        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="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..96272d3093 100644
--- a/cogs/utility.py
+++ b/cogs/utility.py
@@ -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
@@ -810,6 +811,31 @@ 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:
@@ -873,21 +899,44 @@ 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,
-            )
-            config = self.bot.config.filter_default(self.bot.config)
+            # 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
 
-            for name, value in config.items():
-                if name in self.bot.config.public_keys:
-                    embed.add_field(name=name, value=f"`{value}`", inline=False)
-
-        return await ctx.send(embed=embed)
+            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]
+
+            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)
diff --git a/core/config.py b/core/config.py
index a704443bb1..e40fb06626 100644
--- a/core/config.py
+++ b/core/config.py
@@ -135,11 +135,35 @@ 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_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)
+        "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_footer_icon_url": None,
+        "thread_creation_menu_embed_color": str(discord.Color.green()),
     }
 
     private_keys = {
@@ -196,10 +220,12 @@ 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"}
 
+    duration_seconds = {"snooze_default_duration"}
+
     booleans = {
         "use_user_id_channel_name",
         "use_timestamp_channel_name",
@@ -239,6 +265,14 @@ class ConfigManager:
         "use_hoisted_top_role",
         "enable_presence_intent",
         "registry_plugins_only",
+        # snooze
+        "snooze_store_attachments",
+        # thread creation menu booleans
+        "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",
     }
 
     enums = {
@@ -275,6 +309,7 @@ def populate_cache(self) -> dict:
                     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)
+
         self._cache = data
 
         config_help_json = os.path.join(os.path.dirname(os.path.abspath(__file__)), "config_help.json")
@@ -360,6 +395,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 +431,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)
@@ -440,6 +487,25 @@ 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
diff --git a/core/config_help.json b/core/config_help.json
index 462e4e1c03..298f60e188 100644
--- a/core/config_help.json
+++ b/core/config_help.json
@@ -1266,15 +1266,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 +1286,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 +1297,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 +1308,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 +1321,239 @@
     "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_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/thread.py b/core/thread.py
index d380552694..26a62002bd 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,11 +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.models import DMDisabled, DummyMessage, PermissionLevel, getLogger
+from core import checks
 from core.time import human_timedelta
 from core.utils import (
     is_image_url,
@@ -71,6 +73,9 @@ def __init__(
         self.snoozed = False  # True if thread is snoozed
         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)})'
@@ -133,13 +138,38 @@ 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
@@ -180,18 +210,18 @@ async def snooze(self, moderator=None, command_used=None, snooze_for=None):
                         )
                         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 +243,426 @@ 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:
+                        pass
+                    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 _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"
                     )
-                    await channel.send(embeds=embeds)
+                    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:
+                                pass
+                        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
@@ -313,18 +693,33 @@ async def restore_from_snooze(self):
         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."
         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
         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
@@ -371,22 +766,25 @@ async def setup(self, *, creator=None, category=None, initial_message=None):
         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 self.bot.log_channel is not None:
-                await self.bot.log_channel.send(embed=embed)
-            return
-
-        self._channel = channel
+        # 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)
+
+                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 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(
@@ -413,6 +811,18 @@ async def send_genesis_message():
                 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)
 
@@ -702,11 +1112,11 @@ async def _close(self, closer, silent=False, delete_channel=True, message=None,
         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
             tasks.append(self.bot.log_channel.send(embed=embed, view=view))
 
         # Thread closed message
@@ -811,31 +1221,73 @@ 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 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
             ):
+                logger.warning("Message color does not match mod/recipient colors.")
                 raise ValueError("Thread message not found.")
         else:
             async for message1 in self.channel.history():
@@ -891,7 +1343,7 @@ async def edit_message(self, message_id: typing.Optional[int], message: str) ->
         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:
+        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:
@@ -910,15 +1362,14 @@ async def delete_message(
         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:
@@ -1027,6 +1478,27 @@ 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:
+                    pass
+            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:
@@ -1258,7 +1730,7 @@ async def send(
                     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 +1741,15 @@ 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,
@@ -1428,9 +1907,20 @@ 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"])
@@ -1444,7 +1934,14 @@ def lottie_to_png(data):
 
         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:
@@ -1457,12 +1954,25 @@ def lottie_to_png(data):
         ):
             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)
 
@@ -1473,29 +1983,45 @@ 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 +2032,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"
@@ -1585,6 +2114,59 @@ 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(f"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."""
@@ -1636,7 +2218,18 @@ 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
@@ -1753,7 +2346,12 @@ 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):
@@ -1768,7 +2366,18 @@ async def create(
 
         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:
@@ -1812,7 +2421,459 @@ 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 channel creation) ---
+        adv_enabled = self.bot.config.get("thread_creation_menu_enabled") and bool(
+            self.bot.config.get("thread_creation_menu_options")
+        )
+        # Always treat user-initiated DM threads as precreate: create channel immediately in main_category
+        user_initiated = (creator is None or creator == recipient) and manual_trigger
+        precreate = adv_enabled and user_initiated  # force precreate semantics for user DM origin
+        if adv_enabled and user_initiated and not precreate:  # condition will never be true now
+            # 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)
+                    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
+                    # FIX: use the parent view reference rather than undefined closure variable
+                    if self.view:
+                        self.view.stop()
+                    try:
+                        await interaction.edit_original_response(view=None)
+                    except Exception:
+                        pass
+                    # 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:
+                                    pass
+                            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:
+                                    pass
+                            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:
+                                    pass
+                                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()
+                        # 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:
+                                pass
+                            # 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:
+                        pass
+                    # 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:
+                            pass
+                        # remove thread from cache
+                        try:
+                            self.outer_thread.manager.cache.pop(self.outer_thread.id, None)
+                        except Exception:
+                            pass
+                        # 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:
+                            pass
+                        # 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:
+                            pass
+                        self.outer_thread.cancelled = True
+                    # Ensure view is stopped to release any internal tasks
+                    try:
+                        self.stop()
+                    except Exception:
+                        pass
+
+            # 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_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_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:
+                    embed.set_footer(text=embed_footer, icon_url=embed_footer_icon or discord.Embed.Empty)
+                if embed_thumb:
+                    try:
+                        embed.set_thumbnail(url=embed_thumb)
+                    except Exception:
+                        pass
+                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:
+                    pass
+            except Exception:
+                logger.warning(
+                    "Failed to send thread-creation menu DM, falling back to immediate thread creation."
+                )
+                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)
+                    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
+                    if self.view:
+                        try:
+                            await interaction.edit_original_response(view=None)
+                        except Exception:
+                            pass
+                        try:
+                            self.view.stop()
+                        except Exception:
+                            pass
+                    # 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:
+                            pass
+                    except Exception:
+                        pass
+                    # 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:
+                        pass
+                    try:
+                        self.stop()
+                    except Exception:
+                        pass
+
+            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_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_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:
+                    embed.set_footer(text=embed_footer, icon_url=embed_footer_icon or discord.Embed.Empty)
+                if embed_thumb:
+                    try:
+                        embed.set_thumbnail(url=embed_thumb)
+                    except Exception:
+                        pass
+                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:
+                    pass
+            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:
+            # Always use main_category for initial creation regardless of passed category
+            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/utils.py b/core/utils.py
index 19ff4cd37b..ea035dccea 100644
--- a/core/utils.py
+++ b/core/utils.py
@@ -369,7 +369,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()
@@ -632,7 +632,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
 
 
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'