snooze(move): auto-unsnooze on reply/any mod message; enforce hidden permissions on auto-created Snoozed Threads and sync perms on move; restore original overwrites on unsnooze; add capacity guard and config docs

Author: lorenzo132

CHANGELOG.md

@@ -34,11 +34,17 @@ Configuration Options:
 * `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.
+* `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.
 
+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.
+
 # v4.1.2
 
 ### Fixed

bot.py

@@ -1398,6 +1398,27 @@ async def process_commands(self, message):
 
             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"):

cogs/modmail.py

@@ -2284,9 +2284,11 @@ 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: max_snooze_time, snooze_title, snooze_text
         """
         thread = ctx.thread
         if thread.snoozed:
@@ -2310,6 +2312,85 @@ async def snooze(self, ctx, *, duration: UserFriendlyTime = None):
         else:
             snooze_for = max_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
         now = datetime.now(timezone.utc)
         await self.bot.api.logs.update_one(

cogs/utility.py

@@ -810,6 +810,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:

core/config.py

@@ -140,6 +140,9 @@ class ConfigManager:
         "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'
     }
 
     private_keys = {

core/config_help.json

@@ -1322,5 +1322,28 @@
       "If set to a channel ID, the notification will be sent to that specific channel.",
       "See also: `unsnooze_text`, `max_snooze_time`."
     ]
+  },
+  "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."
+    ]
   }
 }