diff --git a/bot.py b/bot.py
index a7e7b58..5539e65 100644
--- a/bot.py
+++ b/bot.py
@@ -26,7 +26,7 @@ class VisionBot(commands.Bot):
     async def setup_hook(self):
         logger.info("Chargement des cogs...")
         await self.load_extension("commandes.hello")
-        await self.load_extension("tickets.cog")
+        await self.load_extension("commandes.modmail")
 
         self.tree.on_error = self.on_app_command_error
 
diff --git a/commandes/modmail.py b/commandes/modmail.py
new file mode 100644
index 0000000..af801fb
--- /dev/null
+++ b/commandes/modmail.py
@@ -0,0 +1,620 @@
+import contextlib
+import logging
+
+import discord
+from discord import app_commands
+from discord.ext import commands
+
+from utils import modmail_config as cfg
+from utils.modmail_transcript import generate_transcript, save_transcript
+
+
+class CategorySelect(discord.ui.Select):
+    def __init__(self, categories: dict):
+        options = []
+        for key, cat in categories.items():
+            options.append(
+                discord.SelectOption(
+                    label=cat["name"],
+                    value=key,
+                    emoji=cat.get("emoji", ""),
+                    description=cat.get("description", "")[:100],
+                )
+            )
+        super().__init__(
+            placeholder="Selectionne une categorie...",
+            options=options,
+            custom_id="modmail_category_select",
+        )
+
+    async def callback(self, interaction: discord.Interaction):
+        try:
+            category_key = self.values[0]
+            categories = cfg.get_categories()
+            cat = categories.get(category_key)
+            if not cat:
+                await interaction.response.send_message("Cette categorie n'existe plus.", ephemeral=True)
+                return
+
+            data = cfg.get_config()
+            guild = interaction.client.get_guild(data.get("guild_id"))
+            if not guild:
+                await interaction.response.send_message("Erreur: serveur introuvable.", ephemeral=True)
+                return
+
+            user = interaction.user
+            existing = cfg.get_ticket_by_user(user.id)
+            if existing:
+                ch = guild.get_channel(existing["channel_id"])
+                await interaction.response.send_message(
+                    f"Tu as deja un ticket ouvert: {ch.mention if ch else 'inconnu'}",
+                    ephemeral=True,
+                )
+                return
+
+            await interaction.response.send_modal(TicketModal(category_key, cat.get("name", category_key)))
+        except Exception as e:
+            logging.getLogger("vision").error(f"CategorySelect callback error: {e}", exc_info=True)
+            if not interaction.response.is_done():
+                await interaction.response.send_message(f"Erreur interne: `{e}`", ephemeral=True)
+
+
+class TicketModal(discord.ui.Modal, title="Nouveau Ticket"):
+    reason = discord.ui.TextInput(
+        label="Decris ton probleme",
+        style=discord.TextStyle.paragraph,
+        placeholder="Explique brievement ta demande...",
+        required=True,
+        max_length=2000,
+    )
+
+    def __init__(self, category_key: str, category_name: str):
+        super().__init__()
+        self.category_key = category_key
+        self.category_name = category_name
+
+    async def on_submit(self, interaction: discord.Interaction):
+        await interaction.response.defer(ephemeral=True)
+        bot = interaction.client
+        data = cfg.get_config()
+        if self.category_key not in cfg.get_categories():
+            await interaction.followup.send("La categorie n'existe plus. Reessayez.", ephemeral=True)
+            return
+        guild = bot.get_guild(data.get("guild_id"))
+        if not guild:
+            await interaction.followup.send("Erreur serveur.", ephemeral=True)
+            return
+
+        category = guild.get_channel(data["category_id"]) if data.get("category_id") else None
+        staff_role = guild.get_role(data["staff_role_id"]) if data.get("staff_role_id") else None
+
+        overwrites = {
+            guild.default_role: discord.PermissionOverwrite(view_channel=False),
+            guild.me: discord.PermissionOverwrite(
+                view_channel=True,
+                send_messages=True,
+                read_message_history=True,
+                attach_files=True,
+                manage_channels=True,
+            ),
+        }
+        if staff_role:
+            overwrites[staff_role] = discord.PermissionOverwrite(
+                view_channel=True,
+                send_messages=True,
+                read_message_history=True,
+                attach_files=True,
+            )
+
+        ticket_name = f"ticket-{interaction.user.name}"
+        ticket_channel = await guild.create_text_channel(
+            ticket_name,
+            category=category,
+            overwrites=overwrites,
+            topic=f"Ticket de {interaction.user} ({interaction.user.id}) -- {self.category_name}",
+        )
+
+        cfg.register_ticket(guild.id, interaction.user.id, ticket_channel.id, self.category_key)
+
+        await _send_ticket_panel(ticket_channel, interaction.user, self.category_name, self.reason.value)
+
+        cog = interaction.client.get_cog("ModMail")
+        if cog is not None:
+            cog._dm_messages.setdefault(interaction.user.id, []).append(
+                {
+                    "author": interaction.user,
+                    "content": self.reason.value,
+                    "timestamp": discord.utils.utcnow(),
+                    "attachments": [],
+                    "is_staff": False,
+                }
+            )
+
+        with contextlib.suppress(discord.HTTPException):
+            await interaction.followup.send(
+                f"Ticket cree: {ticket_channel.mention}",
+                ephemeral=True,
+            )
+
+        log_ch = guild.get_channel(data.get("log_channel_id")) if data.get("log_channel_id") else None
+        if log_ch:
+            await log_ch.send(
+                f"Ticket cree par {interaction.user.mention} dans {ticket_channel.mention} ({self.category_name})"
+            )
+
+
+async def _send_ticket_panel(channel, user, category_name, initial_message):
+    container = discord.ui.Container(accent_colour=discord.Colour.blurple())
+    container.add_item(
+        discord.ui.TextDisplay(
+            f"## Ticket — {category_name}\n"
+            f"**Utilisateur:** {user.mention} (`{user.id}`)\n"
+            f"**Categorie:** {category_name}"
+        )
+    )
+    container.add_item(discord.ui.Separator())
+    container.add_item(discord.ui.TextDisplay(f"**Message initial:**\n{initial_message}"))
+    container.add_item(discord.ui.Separator())
+
+    container.add_item(discord.ui.ActionRow(CloseTicketButton()))
+
+    view = discord.ui.LayoutView()
+    view.add_item(container)
+
+    await channel.send(view=view)
+
+
+class CloseTicketButton(discord.ui.Button):
+    def __init__(self):
+        super().__init__(
+            label="Fermer le ticket",
+            style=discord.ButtonStyle.danger,
+            custom_id="modmail_close_ticket",
+        )
+
+    async def callback(self, interaction: discord.Interaction):
+        cog = interaction.client.get_cog("ModMail")
+        if cog:
+            await cog._close_ticket(interaction.channel, interaction.user)
+
+
+class OpenTicketButton(discord.ui.Button):
+    def __init__(self):
+        super().__init__(
+            label="Ouvrir le ticket",
+            style=discord.ButtonStyle.primary,
+            custom_id="modmail_quick_open",
+        )
+
+    async def callback(self, interaction: discord.Interaction):
+        categories = cfg.get_categories()
+        if len(categories) == 1:
+            key = list(categories.keys())[0]
+            cat = categories[key]
+            await interaction.response.send_modal(TicketModal(key, cat.get("name", key)))
+        else:
+            await interaction.response.send_message("Erreur: reconfigurer le modmail.", ephemeral=True)
+
+
+class TicketCategorySelect(discord.ui.ChannelSelect):
+    def __init__(self):
+        super().__init__(
+            placeholder="Categorie des tickets",
+            channel_types=[discord.ChannelType.category],
+            custom_id="modmail_cfg_ticket_category",
+        )
+
+    async def callback(self, interaction: discord.Interaction):
+        cfg.set_category(interaction.guild_id, self.values[0].id)
+        await interaction.response.edit_message(view=ModmailConfigView(interaction.guild))
+
+
+class StaffRoleSelect(discord.ui.RoleSelect):
+    def __init__(self):
+        super().__init__(
+            placeholder="Role du staff",
+            custom_id="modmail_cfg_staff_role",
+        )
+
+    async def callback(self, interaction: discord.Interaction):
+        cfg.set_staff_role(interaction.guild_id, self.values[0].id)
+        await interaction.response.edit_message(view=ModmailConfigView(interaction.guild))
+
+
+class LogChannelSelect(discord.ui.ChannelSelect):
+    def __init__(self):
+        super().__init__(
+            placeholder="Canal de logs",
+            channel_types=[discord.ChannelType.text],
+            custom_id="modmail_cfg_log_channel",
+        )
+
+    async def callback(self, interaction: discord.Interaction):
+        cfg.set_log_channel(interaction.guild_id, self.values[0].id)
+        await interaction.response.edit_message(view=ModmailConfigView(interaction.guild))
+
+
+class ToggleButton(discord.ui.Button):
+    def __init__(self, enabled: bool):
+        super().__init__(
+            label="Desactiver" if enabled else "Activer",
+            style=discord.ButtonStyle.danger if enabled else discord.ButtonStyle.success,
+            custom_id="modmail_cfg_toggle",
+        )
+
+    async def callback(self, interaction: discord.Interaction):
+        data = cfg.get_config()
+        cfg.set_enabled(interaction.guild_id, not data.get("enabled", False))
+        await interaction.response.edit_message(view=ModmailConfigView(interaction.guild))
+
+
+class ManageCategoriesButton(discord.ui.Button):
+    def __init__(self):
+        super().__init__(
+            label="Gerer les categories",
+            style=discord.ButtonStyle.primary,
+            custom_id="modmail_cfg_manage_cat",
+        )
+
+    async def callback(self, interaction: discord.Interaction):
+        await interaction.response.edit_message(view=ModmailCategoriesView(interaction.guild))
+
+
+class CategoryRemoveSelect(discord.ui.Select):
+    def __init__(self, categories: dict):
+        options = [
+            discord.SelectOption(
+                label=v["name"],
+                value=k,
+                emoji=v.get("emoji") or None,
+                description=v.get("description", "")[:100] or None,
+            )
+            for k, v in list(categories.items())[:25]
+        ]
+        super().__init__(
+            placeholder="Supprimer une categorie",
+            options=options,
+            custom_id="modmail_cfg_remove_cat",
+        )
+
+    async def callback(self, interaction: discord.Interaction):
+        cfg.remove_category(interaction.guild_id, self.values[0])
+        await interaction.response.edit_message(view=ModmailCategoriesView(interaction.guild))
+
+
+class AddCategoryButton(discord.ui.Button):
+    def __init__(self):
+        super().__init__(
+            label="Ajouter une categorie",
+            style=discord.ButtonStyle.success,
+            custom_id="modmail_cfg_add_cat",
+        )
+
+    async def callback(self, interaction: discord.Interaction):
+        await interaction.response.send_modal(AddCategoryModal())
+
+
+class BackButton(discord.ui.Button):
+    def __init__(self):
+        super().__init__(
+            label="Retour",
+            style=discord.ButtonStyle.secondary,
+            custom_id="modmail_cfg_back",
+        )
+
+    async def callback(self, interaction: discord.Interaction):
+        await interaction.response.edit_message(view=ModmailConfigView(interaction.guild))
+
+
+class AddCategoryModal(discord.ui.Modal, title="Ajouter une categorie"):
+    name = discord.ui.TextInput(label="Nom", max_length=50, required=True)
+    emoji = discord.ui.TextInput(label="Emoji", max_length=50, required=False)
+    description = discord.ui.TextInput(
+        label="Description",
+        max_length=100,
+        required=False,
+        style=discord.TextStyle.paragraph,
+    )
+
+    async def on_submit(self, interaction: discord.Interaction):
+        cfg.add_category(
+            interaction.guild_id,
+            self.name.value,
+            self.emoji.value or "🎫",
+            self.description.value or "",
+        )
+        await interaction.response.edit_message(view=ModmailCategoriesView(interaction.guild))
+
+
+def _fmt_channel(cid) -> str:
+    return f"<#{cid}>" if cid else "`non defini`"
+
+
+def _fmt_role(rid) -> str:
+    return f"<@&{rid}>" if rid else "`non defini`"
+
+
+class ModmailConfigView(discord.ui.LayoutView):
+    def __init__(self, guild: discord.Guild):
+        super().__init__(timeout=None)
+        data = cfg.get_config()
+        categories = cfg.get_categories()
+        enabled = data.get("enabled", False)
+
+        cat_list = (
+            "\n".join(f"- {v.get('emoji', '')} **{v['name']}**" for v in categories.values()) or "*Aucune categorie*"
+        )
+
+        container = discord.ui.Container(
+            accent_colour=discord.Colour.green() if enabled else discord.Colour.red(),
+        )
+        container.add_item(
+            discord.ui.TextDisplay(
+                f"## Configuration Modmail\n"
+                f"**Statut :** {'🟢 Actif' if enabled else '🔴 Inactif'}\n"
+                f"**Categorie des tickets :** {_fmt_channel(data.get('category_id'))}\n"
+                f"**Role staff :** {_fmt_role(data.get('staff_role_id'))}\n"
+                f"**Canal de logs :** {_fmt_channel(data.get('log_channel_id'))}\n"
+                f"### Categories ({len(categories)})\n{cat_list}"
+            )
+        )
+        container.add_item(discord.ui.Separator())
+        container.add_item(discord.ui.ActionRow(TicketCategorySelect()))
+        container.add_item(discord.ui.ActionRow(StaffRoleSelect()))
+        container.add_item(discord.ui.ActionRow(LogChannelSelect()))
+        container.add_item(discord.ui.ActionRow(ToggleButton(enabled), ManageCategoriesButton()))
+        self.add_item(container)
+
+
+class ModmailCategoriesView(discord.ui.LayoutView):
+    def __init__(self, guild: discord.Guild):
+        super().__init__(timeout=None)
+        categories = cfg.get_categories()
+
+        cat_list = (
+            "\n".join(
+                f"- {v.get('emoji', '')} **{v['name']}**" + (f" — {v['description']}" if v.get("description") else "")
+                for v in categories.values()
+            )
+            or "*Aucune categorie*"
+        )
+
+        container = discord.ui.Container(accent_colour=discord.Colour.blurple())
+        container.add_item(
+            discord.ui.TextDisplay(
+                f"## Gestion des categories\n"
+                f"{cat_list}\n\n"
+                "*Selectionne une categorie pour la supprimer, ou ajoute-en une nouvelle.*"
+            )
+        )
+        container.add_item(discord.ui.Separator())
+        if categories:
+            container.add_item(discord.ui.ActionRow(CategoryRemoveSelect(categories)))
+        container.add_item(discord.ui.ActionRow(AddCategoryButton(), BackButton()))
+        self.add_item(container)
+
+
+class ModMail(commands.Cog):
+    """Systeme de modmail / tickets via DM."""
+
+    def __init__(self, bot: commands.Bot):
+        self.bot = bot
+        self._dm_messages: dict[int, list[dict]] = {}
+
+    # --- LISTENERS ---
+
+    @commands.Cog.listener()
+    async def on_message(self, message: discord.Message):
+        if message.author.bot:
+            return
+        if isinstance(message.channel, discord.DMChannel):
+            await self._handle_dm(message)
+            return
+        await self._relay_to_dm(message)
+        await self.bot.process_commands(message)
+
+    async def _handle_dm(self, message: discord.Message):
+        data = cfg.get_config()
+        if not data.get("enabled"):
+            return
+        if not data.get("guild_id"):
+            return
+
+        existing = cfg.get_ticket_by_user(message.author.id)
+        if existing:
+            guild = self.bot.get_guild(existing["guild_id"])
+            if guild:
+                ch = guild.get_channel(existing["channel_id"])
+                if ch:
+                    await self._send_to_ticket(ch, message.author, message)
+                    return
+
+        categories = cfg.get_categories()
+        if not categories:
+            with contextlib.suppress(discord.HTTPException):
+                await message.author.send(
+                    "Le systeme de tickets n'est pas encore configure. "
+                    "Un administrateur doit d'abord configurer les categories."
+                )
+            return
+
+        await self._send_ticket_creation_panel(message)
+
+    async def _send_ticket_creation_panel(self, message: discord.Message):
+        categories = cfg.get_categories()
+        if not categories:
+            await message.author.send("Aucune categorie de ticket configuree.")
+            return
+
+        if len(categories) == 1:
+            key = list(categories.keys())[0]
+            cat = categories[key]
+
+            container = discord.ui.Container(accent_colour=discord.Colour.blurple())
+            container.add_item(
+                discord.ui.TextDisplay(f"## Ouvrir un ticket\nCliquez pour ouvrir un ticket **{cat['name']}**.")
+            )
+            container.add_item(discord.ui.ActionRow(OpenTicketButton()))
+
+            view = discord.ui.LayoutView()
+            view.add_item(container)
+            await message.author.send(view=view)
+            return
+
+        container = discord.ui.Container(accent_colour=discord.Colour.blurple())
+        container.add_item(
+            discord.ui.TextDisplay("## Ouvrir un ticket\nChoisis une categorie pour ouvrir un ticket avec le staff.")
+        )
+        container.add_item(discord.ui.Separator())
+        container.add_item(CategorySelect(categories))
+
+        view = discord.ui.LayoutView()
+        view.add_item(container)
+
+        await message.author.send(view=view)
+
+    async def _relay_to_dm(self, message: discord.Message):
+        ticket = cfg.get_ticket_by_channel(message.channel.id)
+        if not ticket:
+            return
+
+        user_id = ticket["user_id"]
+        user = self.bot.get_user(user_id)
+        if not user:
+            return
+
+        if not self._dm_messages.get(user_id):
+            self._dm_messages[user_id] = []
+
+        self._dm_messages[user_id].append(
+            {
+                "author": message.author,
+                "content": message.content,
+                "timestamp": message.created_at,
+                "attachments": list(message.attachments),
+                "is_staff": True,
+            }
+        )
+
+        with contextlib.suppress(discord.HTTPException):
+            embed = discord.Embed(
+                description=message.content or "*Pieces jointes*",
+                color=discord.Color.green(),
+                timestamp=message.created_at,
+            )
+            embed.set_author(
+                name=str(message.author),
+                icon_url=message.author.display_avatar.url,
+            )
+            embed.set_footer(text=f"Staff — {message.guild.name}" if message.guild else "Staff")
+            await user.send(embed=embed)
+
+        for att in message.attachments:
+            with contextlib.suppress(discord.HTTPException):
+                await user.send(file=await att.to_file())
+
+    async def _send_to_ticket(self, channel, user, message):
+        if not self._dm_messages.get(user.id):
+            self._dm_messages[user.id] = []
+
+        self._dm_messages[user.id].append(
+            {
+                "author": user,
+                "content": message.content,
+                "timestamp": message.created_at,
+                "attachments": list(message.attachments),
+                "is_staff": False,
+            }
+        )
+
+        embed = discord.Embed(
+            description=message.content or "*Pieces jointes*",
+            color=discord.Color.blurple(),
+            timestamp=message.created_at,
+        )
+        embed.set_author(
+            name=str(user),
+            icon_url=user.display_avatar.url,
+        )
+        embed.set_footer(text=f"User ID: {user.id}")
+        await channel.send(embed=embed)
+
+        for att in message.attachments:
+            await channel.send(file=await att.to_file())
+
+    # --- COMMANDES ---
+
+    modmail_group = app_commands.Group(name="modmail", description="Systeme de modmail")
+
+    @modmail_group.command(name="config", description="Panneau de configuration du modmail")
+    @app_commands.checks.has_permissions(manage_guild=True)
+    async def config_cmd(self, interaction: discord.Interaction):
+        cfg.set_guild_id(interaction.guild_id)
+        await interaction.response.send_message(
+            view=ModmailConfigView(interaction.guild),
+            ephemeral=True,
+        )
+
+    # --- CLOSE ---
+
+    @commands.command(name="close")
+    async def close_prefix(self, ctx: commands.Context):
+        await self._close_ticket(ctx.channel, ctx.author)
+
+    @app_commands.command(name="close", description="Fermer le ticket actuel")
+    async def close_slash(self, interaction: discord.Interaction):
+        await self._close_ticket(interaction.channel, interaction.user)
+
+    async def _close_ticket(self, channel, user):
+        ticket = cfg.get_ticket_by_channel(channel.id)
+        if not ticket:
+            await channel.send("Ce n'est pas un ticket.")
+            return
+
+        user_id = ticket["user_id"]
+        category = ticket.get("category", "inconnu")
+        dm_messages = self._dm_messages.get(user_id, [])
+
+        transcript_html = generate_transcript(
+            dm_messages,
+            {
+                "category": category,
+                "user_id": user_id,
+                "channel_id": channel.id,
+            },
+        )
+        transcript_path = save_transcript(transcript_html, channel.id)
+
+        dm_user = self.bot.get_user(user_id)
+        if dm_user:
+            with contextlib.suppress(discord.HTTPException):
+                await dm_user.send(
+                    "Ton ticket a ete ferme. Voici le transcript:",
+                    file=discord.File(transcript_path, filename=f"ticket_{channel.id}.html"),
+                )
+
+        data = cfg.get_config()
+        log_ch = channel.guild.get_channel(data.get("log_channel_id")) if data.get("log_channel_id") else None
+        if log_ch:
+            await log_ch.send(
+                f"Ticket ferme par {user.mention} — {channel.name}",
+                file=discord.File(transcript_path, filename=f"ticket_{channel.id}.html"),
+            )
+
+        cfg.unregister_ticket(user_id)
+        self._dm_messages.pop(user_id, None)
+
+        container = discord.ui.Container(accent_colour=discord.Colour.red())
+        container.add_item(
+            discord.ui.TextDisplay(f"## Ticket ferme\n**Ferme par:** {user.mention}\n**Categorie:** {category}")
+        )
+        view = discord.ui.LayoutView()
+        view.add_item(container)
+        await channel.send(view=view)
+
+        with contextlib.suppress(discord.HTTPException):
+            await channel.delete(reason=f"Ticket ferme par {user}")
+
+
+async def setup(bot: commands.Bot):
+    await bot.add_cog(ModMail(bot))
diff --git a/tests/test_data.py b/tests/test_data.py
deleted file mode 100644
index 382e769..0000000
--- a/tests/test_data.py
+++ /dev/null
@@ -1,244 +0,0 @@
-from __future__ import annotations
-
-from tickets.data import (
-    GuildTicketConfig,
-    TicketCategory,
-    TicketData,
-    TicketMessage,
-    TicketPriority,
-    TicketStatus,
-)
-
-
-class TestTicketStatus:
-    def test_open_value(self):
-        assert TicketStatus.OPEN.value == "open"
-
-    def test_closed_value(self):
-        assert TicketStatus.CLOSED.value == "closed"
-
-    def test_enum_inheritance(self):
-        assert issubclass(TicketStatus, str)
-
-
-class TestTicketPriority:
-    def test_all_values(self):
-        assert TicketPriority.LOW.value == "low"
-        assert TicketPriority.NORMAL.value == "normal"
-        assert TicketPriority.HIGH.value == "high"
-        assert TicketPriority.URGENT.value == "urgent"
-
-
-class TestTicketCategory:
-    def test_create_default(self):
-        cat = TicketCategory(id="test", name="Test")
-        assert cat.id == "test"
-        assert cat.name == "Test"
-        assert cat.emoji == ""
-        assert cat.description == ""
-        assert cat.staff_role_id is None
-        assert cat.discord_category_id is None
-
-    def test_to_dict(self):
-        cat = TicketCategory(
-            id="support",
-            name="Support",
-            emoji="🎫",
-            description="Aide",
-            staff_role_id=123,
-            discord_category_id=456,
-        )
-        d = cat.to_dict()
-        assert d["id"] == "support"
-        assert d["name"] == "Support"
-        assert d["emoji"] == "🎫"
-        assert d["description"] == "Aide"
-        assert d["staff_role_id"] == 123
-        assert d["discord_category_id"] == 456
-
-    def test_from_dict(self):
-        d = {
-            "id": "support",
-            "name": "Support",
-            "emoji": "🎫",
-            "description": "Aide",
-            "staff_role_id": 123,
-            "discord_category_id": 456,
-        }
-        cat = TicketCategory.from_dict(d)
-        assert cat.id == "support"
-        assert cat.name == "Support"
-        assert cat.staff_role_id == 123
-
-    def test_from_dict_ignores_extra_keys(self):
-        d = {"id": "x", "name": "X", "unknown_key": "should be ignored"}
-        cat = TicketCategory.from_dict(d)
-        assert cat.id == "x"
-
-    def test_roundtrip(self):
-        cat = TicketCategory(id="a", name="A", emoji="🔧", description="desc")
-        cat2 = TicketCategory.from_dict(cat.to_dict())
-        assert cat2 == cat
-
-
-class TestTicketMessage:
-    def test_create_minimal(self):
-        msg = TicketMessage(author_id=1, author_name="user", content="hello", timestamp="2026-01-01")
-        assert msg.attachments == []
-        assert msg.is_staff is False
-
-    def test_create_full(self):
-        msg = TicketMessage(
-            author_id=1,
-            author_name="user",
-            content="hello",
-            timestamp="2026-01-01",
-            attachments=["a.png"],
-            is_staff=True,
-        )
-        assert msg.attachments == ["a.png"]
-        assert msg.is_staff is True
-
-
-class TestTicketData:
-    def test_create_minimal(self):
-        t = TicketData(channel_id=1, guild_id=2, user_id=3, category_id="cat")
-        assert t.status == TicketStatus.OPEN
-        assert t.priority == TicketPriority.NORMAL
-        assert t.locked is False
-        assert t.claimed_by is None
-        assert t.messages == []
-        assert t.reason == ""
-
-    def test_to_dict(self):
-        t = TicketData(
-            channel_id=100,
-            guild_id=200,
-            user_id=300,
-            category_id="support",
-            status=TicketStatus.CLOSED,
-            priority=TicketPriority.HIGH,
-            claimed_by=999,
-            locked=True,
-            reason="test",
-        )
-        d = t.to_dict()
-        assert d["channel_id"] == 100
-        assert d["status"] == "closed"
-        assert d["priority"] == "high"
-        assert d["claimed_by"] == 999
-        assert d["locked"] is True
-        assert d["reason"] == "test"
-
-    def test_to_dict_with_messages(self):
-        t = TicketData(channel_id=1, guild_id=2, user_id=3, category_id="c")
-        t.messages.append(TicketMessage(author_id=1, author_name="a", content="hi", timestamp="t"))
-        d = t.to_dict()
-        assert len(d["messages"]) == 1
-        assert d["messages"][0]["content"] == "hi"
-
-    def test_from_dict(self):
-        d = {
-            "channel_id": 1,
-            "guild_id": 2,
-            "user_id": 3,
-            "category_id": "c",
-            "status": "closed",
-            "priority": "high",
-            "claimed_by": 99,
-            "locked": True,
-            "reason": "r",
-            "messages": [{"author_id": 1, "author_name": "a", "content": "hi", "timestamp": "t"}],
-        }
-        t = TicketData.from_dict(d)
-        assert t.status == TicketStatus.CLOSED
-        assert t.priority == TicketPriority.HIGH
-        assert t.claimed_by == 99
-        assert t.locked is True
-        assert len(t.messages) == 1
-
-    def test_from_dict_legacy_keys(self):
-        d = {
-            "channel_id": 1,
-            "guild_id": 2,
-            "user_id": 3,
-            "category_id": "c",
-            "transcript_path": "/old/path.html",
-            "rating": 5,
-            "feedback": "ok",
-        }
-        t = TicketData.from_dict(d)
-        assert not hasattr(t, "transcript_path")
-        assert not hasattr(t, "rating")
-        assert not hasattr(t, "feedback")
-
-    def test_roundtrip(self):
-        t = TicketData(
-            channel_id=10,
-            guild_id=20,
-            user_id=30,
-            category_id="cat",
-            status=TicketStatus.CLOSED,
-            priority=TicketPriority.URGENT,
-            claimed_by=50,
-            locked=True,
-            reason="test reason",
-            created_at="2026-01-01T00:00:00",
-            closed_at="2026-01-02T00:00:00",
-        )
-        t.messages.append(TicketMessage(author_id=1, author_name="u", content="m", timestamp="t"))
-        t2 = TicketData.from_dict(t.to_dict())
-        assert t2.channel_id == t.channel_id
-        assert t2.status == t.status
-        assert t2.priority == t.priority
-        assert t2.claimed_by == t.claimed_by
-        assert t2.locked == t.locked
-        assert len(t2.messages) == 1
-
-
-class TestGuildTicketConfig:
-    def test_create_default(self):
-        c = GuildTicketConfig(guild_id=1)
-        assert c.enabled is False
-        assert c.categories == []
-        assert c.staff_role_id is None
-        assert c.log_channel_id is None
-        assert c.transcript_enabled is True
-
-    def test_to_dict(self):
-        c = GuildTicketConfig(
-            guild_id=1,
-            enabled=True,
-            staff_role_id=100,
-            log_channel_id=200,
-            panel_channel_id=300,
-            panel_message_id=400,
-        )
-        c.categories.append(TicketCategory(id="a", name="A"))
-        d = c.to_dict()
-        assert d["guild_id"] == 1
-        assert d["enabled"] is True
-        assert d["staff_role_id"] == 100
-        assert d["log_channel_id"] == 200
-        assert len(d["categories"]) == 1
-
-    def test_from_dict(self):
-        d = {
-            "guild_id": 1,
-            "enabled": True,
-            "staff_role_id": 100,
-            "log_channel_id": 200,
-            "categories": [{"id": "a", "name": "A"}],
-        }
-        c = GuildTicketConfig.from_dict(d)
-        assert c.enabled is True
-        assert len(c.categories) == 1
-        assert c.categories[0].id == "a"
-
-    def test_roundtrip(self):
-        c = GuildTicketConfig(guild_id=42, enabled=True)
-        c.categories.append(TicketCategory(id="x", name="X", emoji="🔧"))
-        c2 = GuildTicketConfig.from_dict(c.to_dict())
-        assert c2.guild_id == 42
-        assert c2.enabled is True
-        assert c2.categories[0].id == "x"
diff --git a/tests/test_storage.py b/tests/test_storage.py
deleted file mode 100644
index acd3fb5..0000000
--- a/tests/test_storage.py
+++ /dev/null
@@ -1,130 +0,0 @@
-from __future__ import annotations
-
-import json
-
-import pytest
-
-from tickets import storage
-from tickets.data import GuildTicketConfig, TicketCategory, TicketData
-
-
-@pytest.fixture(autouse=True)
-def clean_storage(tmp_path):
-    """Isolate storage in a temp dir and reset caches."""
-    storage.TICKETS_DIR = tmp_path / "tickets"
-    storage._CONFIG_FILE = storage.TICKETS_DIR / "config.json"
-    storage._config_cache.clear()
-    storage._tickets_cache.clear()
-    yield
-    storage._config_cache.clear()
-    storage._tickets_cache.clear()
-
-
-class TestGetConfig:
-    def test_returns_default_when_missing(self):
-        config = storage.get_config(guild_id=123)
-        assert config.guild_id == 123
-        assert config.enabled is False
-        assert config.categories == []
-
-    def test_returns_same_object(self):
-        c1 = storage.get_config(guild_id=1)
-        c2 = storage.get_config(guild_id=1)
-        assert c1 is c2
-
-    def test_different_guilds_different_configs(self):
-        c1 = storage.get_config(guild_id=1)
-        c2 = storage.get_config(guild_id=2)
-        assert c1.guild_id != c2.guild_id
-
-
-class TestSaveConfig:
-    def test_save_creates_file(self, tmp_path):
-        config = storage.get_config(guild_id=1)
-        config.enabled = True
-        storage.save_config(config)
-        assert storage._CONFIG_FILE.exists()
-
-    def test_save_persists(self, tmp_path):
-        config = storage.get_config(guild_id=1)
-        config.enabled = True
-        config.categories.append(TicketCategory(id="a", name="A"))
-        storage.save_config(config)
-
-        storage._config_cache.clear()
-        loaded = storage.get_config(guild_id=1)
-        assert loaded.enabled is True
-        assert len(loaded.categories) == 1
-        assert loaded.categories[0].id == "a"
-
-    def test_save_multiple_guilds(self):
-        c1 = storage.get_config(guild_id=1)
-        c1.enabled = True
-        storage.save_config(c1)
-
-        c2 = storage.get_config(guild_id=2)
-        c2.enabled = False
-        storage.save_config(c2)
-
-        storage._config_cache.clear()
-        assert storage.get_config(guild_id=1).enabled is True
-        assert storage.get_config(guild_id=2).enabled is False
-
-
-class TestSaveAndGetTicket:
-    def test_get_missing_returns_none(self):
-        assert storage.get_ticket(999) is None
-
-    def test_save_and_get(self):
-        ticket = TicketData(channel_id=100, guild_id=1, user_id=2, category_id="cat")
-        storage.save_ticket(ticket)
-        loaded = storage.get_ticket(100)
-        assert loaded is not None
-        assert loaded.channel_id == 100
-        assert loaded.category_id == "cat"
-
-    def test_save_persists_to_disk(self):
-        ticket = TicketData(channel_id=200, guild_id=1, user_id=2, category_id="c")
-        storage.save_ticket(ticket)
-
-        storage._tickets_cache.clear()
-        loaded = storage.get_ticket(200)
-        assert loaded is not None
-        assert loaded.user_id == 2
-
-    def test_save_overwrites(self):
-        t1 = TicketData(channel_id=300, guild_id=1, user_id=2, category_id="old")
-        storage.save_ticket(t1)
-
-        t2 = TicketData(channel_id=300, guild_id=1, user_id=2, category_id="new")
-        storage.save_ticket(t2)
-
-        loaded = storage.get_ticket(300)
-        assert loaded.category_id == "new"
-
-    def test_multiple_tickets(self):
-        t1 = TicketData(channel_id=400, guild_id=1, user_id=2, category_id="a")
-        t2 = TicketData(channel_id=401, guild_id=1, user_id=3, category_id="b")
-        storage.save_ticket(t1)
-        storage.save_ticket(t2)
-        assert storage.get_ticket(400).category_id == "a"
-        assert storage.get_ticket(401).category_id == "b"
-
-
-class TestDeleteTicket:
-    def test_delete_removes_file(self):
-        ticket = TicketData(channel_id=500, guild_id=1, user_id=2, category_id="c")
-        storage.save_ticket(ticket)
-        assert storage.get_ticket(500) is not None
-
-        storage.delete_ticket(500)
-        assert storage.get_ticket(500) is None
-
-    def test_delete_nonexistent(self):
-        storage.delete_ticket(9999)
-
-    def test_delete_clears_cache(self):
-        ticket = TicketData(channel_id=600, guild_id=1, user_id=2, category_id="c")
-        storage.save_ticket(ticket)
-        storage.delete_ticket(600)
-        assert 600 not in storage._tickets_cache
diff --git a/tests/test_transcript.py b/tests/test_transcript.py
deleted file mode 100644
index 4483d02..0000000
--- a/tests/test_transcript.py
+++ /dev/null
@@ -1,133 +0,0 @@
-from __future__ import annotations
-
-from tickets.data import TicketData, TicketMessage
-from tickets.transcript import _format_ts, generate_transcript
-
-
-class TestFormatTs:
-    def test_valid_iso(self):
-        result = _format_ts("2026-01-15T10:30:00+00:00")
-        assert result == "15/01/2026 10:30:00"
-
-    def test_valid_naive_iso(self):
-        result = _format_ts("2026-06-01T12:00:00")
-        assert result == "01/06/2026 12:00:00"
-
-    def test_invalid_string_returns_as_is(self):
-        assert _format_ts("not-a-date") == "not-a-date"
-
-    def test_empty_string(self):
-        assert _format_ts("") == ""
-
-    def test_none_returns_none(self):
-        assert _format_ts(None) is None
-
-
-def _make_ticket(**kwargs) -> TicketData:
-    defaults = dict(channel_id=123, guild_id=456, user_id=789, category_id="support")
-    defaults.update(kwargs)
-    return TicketData(**defaults)
-
-
-class TestGenerateTranscript:
-    def test_returns_html(self):
-        result = generate_transcript(_make_ticket())
-        assert result.startswith("<!DOCTYPE html>")
-        assert "</html>" in result
-
-    def test_contains_channel_id(self):
-        result = generate_transcript(_make_ticket(channel_id=42))
-        assert "Ticket #42" in result
-
-    def test_empty_messages(self):
-        ticket = _make_ticket()
-        result = generate_transcript(ticket)
-        assert "Aucun message" in result
-
-    def test_single_user_message(self):
-        ticket = _make_ticket()
-        ticket.messages.append(
-            TicketMessage(author_id=1, author_name="TestUser", content="Hello!", timestamp="2026-01-01T00:00:00")
-        )
-        result = generate_transcript(ticket)
-        assert "TestUser" in result
-        assert "Hello!" in result
-        assert 'class="badge badge-staff"' not in result
-
-    def test_staff_message_has_badge(self):
-        ticket = _make_ticket()
-        ticket.messages.append(
-            TicketMessage(
-                author_id=2, author_name="StaffUser", content="Reply", timestamp="2026-01-01T00:00:00", is_staff=True
-            )
-        )
-        result = generate_transcript(ticket)
-        assert "badge-staff" in result
-        assert "STAFF" in result
-
-    def test_message_content_escaped(self):
-        ticket = _make_ticket()
-        ticket.messages.append(
-            TicketMessage(author_id=1, author_name="x", content="<script>alert('xss')</script>", timestamp="t")
-        )
-        result = generate_transcript(ticket)
-        assert "<script>" not in result
-        assert "&lt;script&gt;" in result
-
-    def test_image_attachment(self):
-        ticket = _make_ticket()
-        ticket.messages.append(
-            TicketMessage(
-                author_id=1,
-                author_name="u",
-                content="pic",
-                timestamp="t",
-                attachments=["https://example.com/image.png"],
-            )
-        )
-        result = generate_transcript(ticket)
-        assert "<img" in result
-        assert "image.png" in result
-
-    def test_file_attachment(self):
-        ticket = _make_ticket()
-        ticket.messages.append(
-            TicketMessage(
-                author_id=1,
-                author_name="u",
-                content="file",
-                timestamp="t",
-                attachments=["https://example.com/doc.pdf"],
-            )
-        )
-        result = generate_transcript(ticket)
-        assert "<a href=" in result
-        assert "doc.pdf" in result
-
-    def test_closed_ticket_shows_closed_at(self):
-        ticket = _make_ticket(closed_at="2026-01-02T10:00:00+00:00")
-        result = generate_transcript(ticket)
-        assert "Ferme" in result or "Fermé" in result
-
-    def test_open_ticket_no_closed_at(self):
-        ticket = _make_ticket()
-        result = generate_transcript(ticket)
-        assert "Ferme" not in result
-
-    def test_dark_theme_colors(self):
-        result = generate_transcript(_make_ticket())
-        assert "#0b0d11" in result
-
-    def test_multiple_messages(self):
-        ticket = _make_ticket()
-        for i in range(5):
-            ticket.messages.append(
-                TicketMessage(author_id=i, author_name=f"User{i}", content=f"Message {i}", timestamp=f"t{i}")
-            )
-        result = generate_transcript(ticket)
-        for i in range(5):
-            assert f"Message {i}" in result
-
-    def test_footer_text(self):
-        result = generate_transcript(_make_ticket())
-        assert "Vision Studio" in result
diff --git a/tests/test_ui.py b/tests/test_ui.py
deleted file mode 100644
index d12ea1b..0000000
--- a/tests/test_ui.py
+++ /dev/null
@@ -1,304 +0,0 @@
-from __future__ import annotations
-
-from unittest.mock import AsyncMock, MagicMock
-
-import discord
-import pytest
-
-from tickets import storage
-from tickets.cog import ConfigToggleButton
-from tickets.data import GuildTicketConfig, TicketCategory, TicketData, TicketStatus
-from tickets.ui import (
-    AddMemberButton,
-    ClaimButton,
-    CloseButton,
-    LockButton,
-    PanelCreateButton,
-    TransferButton,
-    _is_staff,
-    _now_iso,
-    _send_log,
-)
-
-STAFF_ROLE_ID = 999999
-
-
-@pytest.fixture(autouse=True)
-def clean_storage():
-    storage._config_cache.clear()
-    storage._tickets_cache.clear()
-    config = GuildTicketConfig(guild_id=999)
-    config.staff_role_id = STAFF_ROLE_ID
-    storage._config_cache[999] = config
-    yield
-    storage._config_cache.clear()
-    storage._tickets_cache.clear()
-
-
-def _make_member(is_admin=False, has_staff_role=True):
-    member = MagicMock(spec=discord.Member)
-    member.guild_permissions.administrator = is_admin
-    if has_staff_role:
-        member.roles = [MagicMock(id=STAFF_ROLE_ID)]
-    else:
-        member.roles = []
-    return member
-
-
-def _mock_interaction(guild_id=999, user_id=1, channel_id=123, member=None):
-    if member is None:
-        member = _make_member()
-    interaction = MagicMock(spec=discord.Interaction)
-    interaction.guild_id = guild_id
-    interaction.channel_id = channel_id
-    interaction.channel = MagicMock()
-    interaction.channel.id = channel_id
-    interaction.user = MagicMock()
-    interaction.user.id = user_id
-    interaction.user.mention = f"<@{user_id}>"
-    interaction.response = AsyncMock()
-    interaction.followup = AsyncMock()
-    interaction.guild = MagicMock(spec=discord.Guild)
-    interaction.guild.id = guild_id
-    interaction.guild.get_member.return_value = member
-    interaction.channel.overwrites_for = MagicMock()
-    interaction.channel.set_permissions = AsyncMock()
-    interaction.channel.delete = AsyncMock()
-    interaction.channel.send = AsyncMock()
-    return interaction
-
-
-def _save_ticket(channel_id=123, **kwargs):
-    defaults = dict(channel_id=channel_id, guild_id=999, user_id=1, category_id="cat")
-    defaults.update(kwargs)
-    ticket = TicketData(**defaults)
-    storage.save_ticket(ticket)
-    return ticket
-
-
-class TestIsStaff:
-    def test_admin(self):
-        member = _make_member(is_admin=True)
-        config = storage.get_config(999)
-        assert _is_staff(member, config) is True
-
-    def test_staff_role_match(self):
-        member = _make_member(has_staff_role=True)
-        config = storage.get_config(999)
-        assert _is_staff(member, config) is True
-
-    def test_not_staff(self):
-        member = _make_member(has_staff_role=False)
-        config = storage.get_config(999)
-        assert _is_staff(member, config) is False
-
-    def test_category_staff_role(self):
-        member = _make_member(has_staff_role=False)
-        member.roles = [MagicMock(id=77777)]
-        config = storage.get_config(999)
-        config.categories = [TicketCategory(id="c", name="C", staff_role_id=77777)]
-        assert _is_staff(member, config) is True
-
-
-class TestNowIso:
-    def test_returns_iso_string(self):
-        result = _now_iso()
-        assert "T" in result
-
-
-class TestSendLog:
-    @pytest.mark.asyncio
-    async def test_no_log_channel(self):
-        config = storage.get_config(999)
-        guild = MagicMock()
-        guild.get_channel.return_value = None
-        await _send_log(guild, config, MagicMock())
-        guild.get_channel.assert_not_called()
-
-    @pytest.mark.asyncio
-    async def test_sends_to_log_channel(self):
-        config = storage.get_config(999)
-        config.log_channel_id = 555
-        channel = AsyncMock()
-        guild = MagicMock()
-        guild.get_channel.return_value = channel
-        embed = MagicMock()
-        await _send_log(guild, config, embed)
-        channel.send.assert_called_once_with(embed=embed)
-
-
-class TestPanelCreateButton:
-    @pytest.mark.asyncio
-    async def test_disabled_system(self):
-        config = storage.get_config(999)
-        config.enabled = False
-        interaction = _mock_interaction()
-        await PanelCreateButton().callback(interaction)
-        interaction.response.send_message.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_no_categories(self):
-        config = storage.get_config(999)
-        config.enabled = True
-        config.categories = []
-        interaction = _mock_interaction()
-        await PanelCreateButton().callback(interaction)
-        interaction.response.send_message.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_single_category_opens_modal(self):
-        config = storage.get_config(999)
-        config.enabled = True
-        config.categories = [TicketCategory(id="c1", name="Cat1")]
-        interaction = _mock_interaction()
-        await PanelCreateButton().callback(interaction)
-        interaction.response.send_modal.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_multiple_categories_sends_select(self):
-        config = storage.get_config(999)
-        config.enabled = True
-        config.categories = [
-            TicketCategory(id="c1", name="Cat1"),
-            TicketCategory(id="c2", name="Cat2"),
-        ]
-        interaction = _mock_interaction()
-        await PanelCreateButton().callback(interaction)
-        call_kwargs = interaction.response.send_message.call_args.kwargs
-        assert "view" in call_kwargs
-
-
-class TestClaimButton:
-    @pytest.mark.asyncio
-    async def test_not_a_ticket(self):
-        interaction = _mock_interaction()
-        await ClaimButton().callback(interaction)
-        assert "pas un ticket" in interaction.response.send_message.call_args[0][0]
-
-    @pytest.mark.asyncio
-    async def test_not_staff(self):
-        _save_ticket()
-        member = _make_member(is_admin=False, has_staff_role=False)
-        interaction = _mock_interaction(member=member)
-        await ClaimButton().callback(interaction)
-        assert "staff" in interaction.response.send_message.call_args[0][0].lower()
-
-    @pytest.mark.asyncio
-    async def test_claim_success(self):
-        _save_ticket()
-        interaction = _mock_interaction()
-        await ClaimButton().callback(interaction)
-        assert storage.get_ticket(123).claimed_by == 1
-
-    @pytest.mark.asyncio
-    async def test_unclaim_own(self):
-        _save_ticket(claimed_by=1)
-        interaction = _mock_interaction()
-        await ClaimButton().callback(interaction)
-        assert storage.get_ticket(123).claimed_by is None
-
-    @pytest.mark.asyncio
-    async def test_already_claimed_by_other(self):
-        _save_ticket(claimed_by=42)
-        interaction = _mock_interaction()
-        await ClaimButton().callback(interaction)
-        assert storage.get_ticket(123).claimed_by == 42
-
-
-class TestLockButton:
-    @pytest.mark.asyncio
-    async def test_not_a_ticket(self):
-        interaction = _mock_interaction(channel_id=99999)
-        await LockButton().callback(interaction)
-        assert "pas un ticket" in interaction.response.send_message.call_args[0][0]
-
-    @pytest.mark.asyncio
-    async def test_lock_toggle(self):
-        _save_ticket(locked=False)
-        interaction = _mock_interaction()
-        interaction.channel.overwrites_for.return_value = MagicMock()
-        await LockButton().callback(interaction)
-        assert storage.get_ticket(123).locked is True
-        interaction.channel.set_permissions.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_unlock_toggle(self):
-        _save_ticket(locked=True)
-        interaction = _mock_interaction()
-        interaction.channel.overwrites_for.return_value = MagicMock()
-        await LockButton().callback(interaction)
-        assert storage.get_ticket(123).locked is False
-
-
-class TestCloseButton:
-    @pytest.mark.asyncio
-    async def test_not_a_ticket(self):
-        interaction = _mock_interaction(channel_id=99999)
-        await CloseButton().callback(interaction)
-        assert "pas un ticket" in interaction.response.send_message.call_args[0][0]
-
-    @pytest.mark.asyncio
-    async def test_not_staff(self):
-        _save_ticket()
-        member = _make_member(is_admin=False, has_staff_role=False)
-        interaction = _mock_interaction(member=member)
-        await CloseButton().callback(interaction)
-        assert "staff" in interaction.response.send_message.call_args[0][0].lower()
-
-    @pytest.mark.asyncio
-    async def test_close_success(self):
-        _save_ticket()
-        interaction = _mock_interaction()
-        await CloseButton().callback(interaction)
-        loaded = storage.get_ticket(123)
-        assert loaded.status == TicketStatus.CLOSED
-        assert loaded.closed_by == 1
-
-    @pytest.mark.asyncio
-    async def test_close_without_transcript(self):
-        config = storage.get_config(999)
-        config.transcript_enabled = False
-        _save_ticket()
-        interaction = _mock_interaction()
-        await CloseButton().callback(interaction)
-        assert storage.get_ticket(123).status == TicketStatus.CLOSED
-
-
-class TestTransferButton:
-    @pytest.mark.asyncio
-    async def test_not_a_ticket(self):
-        interaction = _mock_interaction(channel_id=99999)
-        await TransferButton().callback(interaction)
-        assert "pas un ticket" in interaction.response.send_message.call_args[0][0]
-
-    @pytest.mark.asyncio
-    async def test_sends_user_select(self):
-        _save_ticket()
-        interaction = _mock_interaction()
-        await TransferButton().callback(interaction)
-        assert "view" in interaction.response.send_message.call_args.kwargs
-
-
-class TestAddMemberButton:
-    @pytest.mark.asyncio
-    async def test_not_a_ticket(self):
-        interaction = _mock_interaction(channel_id=99999)
-        await AddMemberButton().callback(interaction)
-        assert "pas un ticket" in interaction.response.send_message.call_args[0][0]
-
-    @pytest.mark.asyncio
-    async def test_sends_user_select(self):
-        _save_ticket()
-        interaction = _mock_interaction()
-        await AddMemberButton().callback(interaction)
-        assert "view" in interaction.response.send_message.call_args.kwargs
-
-
-class TestConfigToggleButton:
-    @pytest.mark.asyncio
-    async def test_toggle(self):
-        config = storage.get_config(999)
-        initial = config.enabled
-        interaction = _mock_interaction()
-        await ConfigToggleButton(enabled=initial).callback(interaction)
-        assert config.enabled != initial
diff --git a/tickets/__init__.py b/tickets/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tickets/cog.py b/tickets/cog.py
deleted file mode 100644
index 2c930d9..0000000
--- a/tickets/cog.py
+++ /dev/null
@@ -1,243 +0,0 @@
-from __future__ import annotations
-
-import logging
-
-import discord
-from discord import app_commands
-from discord.ext import commands
-
-from tickets import storage
-from tickets.data import TicketCategory
-from tickets.ui import (
-    AddMemberButton,
-    ClaimButton,
-    CloseButton,
-    LockButton,
-    PanelCreateButton,
-    TransferButton,
-    _is_staff,
-)
-
-logger = logging.getLogger("vision")
-
-
-class PanelView(discord.ui.LayoutView):
-    def __init__(self):
-        super().__init__(timeout=None)
-        container = discord.ui.Container()
-        container.add_item(
-            discord.ui.TextDisplay(
-                "## Système de tickets\n"
-                "Besoin d'aide ? Créez un ticket et notre équipe vous répondra.\n"
-                "Cliquez sur le bouton ci-dessous pour commencer."
-            )
-        )
-        container.add_item(discord.ui.Separator())
-        container.add_item(discord.ui.ActionRow(PanelCreateButton()))
-        self.add_item(container)
-
-
-class ConfigView(discord.ui.LayoutView):
-    def __init__(self):
-        super().__init__(timeout=None)
-        container = discord.ui.Container()
-        container.add_item(discord.ui.TextDisplay("## Configuration Tickets\nModifications enregistrées."))
-        self.add_item(container)
-
-
-class AddCategoryModal(discord.ui.Modal, title="Ajouter une catégorie"):
-    name = discord.ui.TextInput(label="Nom", max_length=50, required=True)
-    emoji = discord.ui.TextInput(label="Emoji", max_length=10, required=False)
-    description = discord.ui.TextInput(
-        label="Description",
-        max_length=100,
-        required=False,
-        style=discord.TextStyle.paragraph,
-    )
-
-    async def on_submit(self, interaction: discord.Interaction):
-        config = storage.get_config(interaction.guild_id)
-        cat_id = self.name.value.lower().replace(" ", "-")[:20]
-        cat = TicketCategory(
-            id=cat_id,
-            name=self.name.value,
-            emoji=self.emoji.value or "",
-            description=self.description.value or "",
-        )
-        config.categories.append(cat)
-        storage.save_config(config)
-        await interaction.response.send_message(f"Catégorie **{cat.name}** ajoutée.", ephemeral=True)
-
-
-class ConfigToggleButton(discord.ui.Button):
-    def __init__(self, enabled: bool):
-        super().__init__(
-            label="Désactiver" if enabled else "Activer",
-            style=discord.ButtonStyle.danger if enabled else discord.ButtonStyle.success,
-            custom_id="ticket_cfg_toggle",
-        )
-
-    async def callback(self, interaction: discord.Interaction):
-        config = storage.get_config(interaction.guild_id)
-        config.enabled = not config.enabled
-        storage.save_config(config)
-        await interaction.response.edit_message(view=ConfigView())
-
-
-class ConfigAddCatButton(discord.ui.Button):
-    def __init__(self):
-        super().__init__(label="Ajouter catégorie", style=discord.ButtonStyle.primary, custom_id="ticket_cfg_addcat")
-
-    async def callback(self, interaction: discord.Interaction):
-        await interaction.response.send_modal(AddCategoryModal())
-
-
-class ConfigSetStaffButton(discord.ui.Button):
-    def __init__(self):
-        super().__init__(label="Role staff", style=discord.ButtonStyle.secondary, custom_id="ticket_cfg_staff")
-
-    async def callback(self, interaction: discord.Interaction):
-        view = discord.ui.View(timeout=300)
-        sel = discord.ui.RoleSelect(
-            placeholder="Role staff...", custom_id="ticket_staff_role_select", min_values=1, max_values=1
-        )
-
-        async def _cb(interaction: discord.Interaction):
-            config = storage.get_config(interaction.guild_id)
-            config.staff_role_id = sel.values[0].id
-            storage.save_config(config)
-            await interaction.response.edit_message(content=f"Role staff : {sel.values[0].mention}", view=None)
-
-        sel.callback = _cb
-        view.add_item(sel)
-        await interaction.response.send_message("Sélectionnez le rôle staff :", view=view, ephemeral=True)
-
-
-class ConfigSetLogButton(discord.ui.Button):
-    def __init__(self):
-        super().__init__(label="Canal logs", style=discord.ButtonStyle.secondary, custom_id="ticket_cfg_log")
-
-    async def callback(self, interaction: discord.Interaction):
-        view = discord.ui.View(timeout=300)
-        sel = discord.ui.ChannelSelect(
-            placeholder="Canal de logs...",
-            custom_id="ticket_log_channel_select",
-            channel_types=[discord.ChannelType.text],
-            min_values=1,
-            max_values=1,
-        )
-
-        async def _cb(interaction: discord.Interaction):
-            config = storage.get_config(interaction.guild_id)
-            config.log_channel_id = sel.values[0].id
-            storage.save_config(config)
-            await interaction.response.edit_message(content=f"Canal de logs : {sel.values[0].mention}", view=None)
-
-        sel.callback = _cb
-        view.add_item(sel)
-        await interaction.response.send_message("Sélectionnez le canal de logs :", view=view, ephemeral=True)
-
-
-class TicketManagementView(discord.ui.LayoutView):
-    def __init__(self):
-        super().__init__(timeout=None)
-        container = discord.ui.Container()
-        container.add_item(discord.ui.TextDisplay("### Gestion"))
-        container.add_item(discord.ui.ActionRow(ClaimButton(), TransferButton(), LockButton()))
-        container.add_item(discord.ui.Separator())
-        container.add_item(discord.ui.ActionRow(AddMemberButton(), CloseButton()))
-        self.add_item(container)
-
-
-class TicketSystem(commands.Cog):
-    ticket = app_commands.Group(name="ticket", description="Systeme de tickets")
-
-    def __init__(self, bot: commands.Bot):
-        self.bot = bot
-        self.bot.add_view(PanelView())
-        self.bot.add_view(TicketManagementView())
-
-    @commands.Cog.listener()
-    async def on_ready(self):
-        logger.info("TicketSystem cog charge")
-
-    @commands.Cog.listener()
-    async def on_message(self, message: discord.Message):
-        if message.author.bot:
-            return
-        if not message.guild:
-            return
-
-        ticket = storage.get_ticket(message.channel.id)
-        if not ticket:
-            return
-
-        config = storage.get_config(message.guild.id)
-        member = message.guild.get_member(message.author.id)
-        if not member:
-            return
-
-        is_staff = _is_staff(member, config)
-
-        from tickets.data import TicketMessage
-
-        msg = TicketMessage(
-            author_id=message.author.id,
-            author_name=str(message.author),
-            content=message.content,
-            timestamp=message.created_at.isoformat(),
-            attachments=[a.url for a in message.attachments],
-            is_staff=is_staff,
-        )
-        ticket.messages.append(msg)
-        storage.save_ticket(ticket)
-
-    @ticket.command(name="setup", description="Envoyer le panneau de tickets")
-    @app_commands.describe(channel="Canal pour le panneau")
-    @app_commands.checks.has_permissions(manage_guild=True)
-    async def ticket_setup(self, interaction: discord.Interaction, channel: discord.TextChannel):
-        config = storage.get_config(interaction.guild_id)
-        config.enabled = True
-        config.panel_channel_id = channel.id
-        storage.save_config(config)
-        view = PanelView()
-        msg = await channel.send(view=view)
-        config.panel_message_id = msg.id
-        storage.save_config(config)
-        container = discord.ui.Container()
-        container.add_item(discord.ui.TextDisplay(f"## Panneau envoyé\nCanal : {channel.mention}\nStatut : Actif"))
-        resp_view = discord.ui.LayoutView()
-        resp_view.add_item(container)
-        await interaction.response.send_message(view=resp_view, ephemeral=True)
-
-    @ticket.command(name="config", description="Configuration du système de tickets")
-    @app_commands.checks.has_permissions(manage_guild=True)
-    async def ticket_config(self, interaction: discord.Interaction):
-        config = storage.get_config(interaction.guild_id)
-        cats = "\n".join(f"- {c.emoji} **{c.name}**" for c in config.categories) or "*Aucune*"
-        staff_line = f"**Rôle staff :** <@&{config.staff_role_id}>\n" if config.staff_role_id else ""
-        log_line = f"**Canal de logs :** <#{config.log_channel_id}>\n" if config.log_channel_id else ""
-        container = discord.ui.Container()
-        container.add_item(
-            discord.ui.TextDisplay(
-                f"## Configuration Tickets\n"
-                f"**Statut :** {'Actif' if config.enabled else 'Inactif'}\n"
-                f"{staff_line}{log_line}### Categories\n{cats}"
-            )
-        )
-        container.add_item(discord.ui.Separator())
-        container.add_item(
-            discord.ui.ActionRow(
-                ConfigToggleButton(config.enabled),
-                ConfigAddCatButton(),
-                ConfigSetStaffButton(),
-                ConfigSetLogButton(),
-            )
-        )
-        view = discord.ui.LayoutView()
-        view.add_item(container)
-        await interaction.response.send_message(view=view, ephemeral=True)
-
-
-async def setup(bot: commands.Bot):
-    await bot.add_cog(TicketSystem(bot))
diff --git a/tickets/data.py b/tickets/data.py
deleted file mode 100644
index 03b0d4e..0000000
--- a/tickets/data.py
+++ /dev/null
@@ -1,133 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from enum import Enum
-
-
-class TicketStatus(str, Enum):
-    OPEN = "open"
-    CLOSED = "closed"
-
-
-class TicketPriority(str, Enum):
-    LOW = "low"
-    NORMAL = "normal"
-    HIGH = "high"
-    URGENT = "urgent"
-
-
-@dataclass
-class TicketCategory:
-    id: str
-    name: str
-    emoji: str = ""
-    description: str = ""
-    staff_role_id: int | None = None
-    discord_category_id: int | None = None
-
-    def to_dict(self) -> dict:
-        return {
-            "id": self.id,
-            "name": self.name,
-            "emoji": self.emoji,
-            "description": self.description,
-            "staff_role_id": self.staff_role_id,
-            "discord_category_id": self.discord_category_id,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> TicketCategory:
-        return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
-
-
-@dataclass
-class TicketMessage:
-    author_id: int
-    author_name: str
-    content: str
-    timestamp: str
-    attachments: list[str] = field(default_factory=list)
-    is_staff: bool = False
-
-
-@dataclass
-class TicketData:
-    channel_id: int
-    guild_id: int
-    user_id: int
-    category_id: str
-    status: TicketStatus = TicketStatus.OPEN
-    created_at: str = ""
-    closed_at: str | None = None
-    closed_by: int | None = None
-    claimed_by: int | None = None
-    locked: bool = False
-    priority: TicketPriority = TicketPriority.NORMAL
-    messages: list[TicketMessage] = field(default_factory=list)
-    reason: str = ""
-
-    def to_dict(self) -> dict:
-        return {
-            "channel_id": self.channel_id,
-            "guild_id": self.guild_id,
-            "user_id": self.user_id,
-            "category_id": self.category_id,
-            "status": self.status.value,
-            "created_at": self.created_at,
-            "closed_at": self.closed_at,
-            "closed_by": self.closed_by,
-            "claimed_by": self.claimed_by,
-            "locked": self.locked,
-            "priority": self.priority.value,
-            "messages": [
-                {
-                    "author_id": m.author_id,
-                    "author_name": m.author_name,
-                    "content": m.content,
-                    "timestamp": m.timestamp,
-                    "attachments": m.attachments,
-                    "is_staff": m.is_staff,
-                }
-                for m in self.messages
-            ],
-            "reason": self.reason,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> TicketData:
-        messages = [TicketMessage(**m) for m in data.pop("messages", [])]
-        data["status"] = TicketStatus(data.get("status", "open"))
-        data["priority"] = TicketPriority(data.get("priority", "normal"))
-        data.pop("transcript_path", None)
-        data.pop("rating", None)
-        data.pop("feedback", None)
-        return cls(messages=messages, **{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
-
-
-@dataclass
-class GuildTicketConfig:
-    guild_id: int
-    enabled: bool = False
-    categories: list[TicketCategory] = field(default_factory=list)
-    staff_role_id: int | None = None
-    log_channel_id: int | None = None
-    panel_channel_id: int | None = None
-    panel_message_id: int | None = None
-    transcript_enabled: bool = True
-
-    def to_dict(self) -> dict:
-        return {
-            "guild_id": self.guild_id,
-            "enabled": self.enabled,
-            "categories": [c.to_dict() for c in self.categories],
-            "staff_role_id": self.staff_role_id,
-            "log_channel_id": self.log_channel_id,
-            "panel_channel_id": self.panel_channel_id,
-            "panel_message_id": self.panel_message_id,
-            "transcript_enabled": self.transcript_enabled,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> GuildTicketConfig:
-        categories = [TicketCategory.from_dict(c) for c in data.pop("categories", [])]
-        return cls(categories=categories, **{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
diff --git a/tickets/storage.py b/tickets/storage.py
deleted file mode 100644
index 3cf4f70..0000000
--- a/tickets/storage.py
+++ /dev/null
@@ -1,86 +0,0 @@
-from __future__ import annotations
-
-import json
-import logging
-import threading
-
-from config import DATA_DIR
-from tickets.data import GuildTicketConfig, TicketData
-
-logger = logging.getLogger("vision")
-
-TICKETS_DIR = DATA_DIR / "tickets"
-_CONFIG_FILE = TICKETS_DIR / "config.json"
-
-_lock = threading.Lock()
-_config_cache: dict[int, GuildTicketConfig] = {}
-_tickets_cache: dict[int, TicketData] = {}
-
-
-def _ensure_dirs():
-    TICKETS_DIR.mkdir(parents=True, exist_ok=True)
-
-
-def _load_all_configs() -> dict[int, GuildTicketConfig]:
-    global _config_cache
-    _ensure_dirs()
-    if _config_cache:
-        return _config_cache
-    if _CONFIG_FILE.exists():
-        with open(_CONFIG_FILE, "r", encoding="utf-8") as f:
-            raw = json.load(f)
-        _config_cache = {int(k): GuildTicketConfig.from_dict(v) for k, v in raw.items()}
-    else:
-        _config_cache = {}
-    return _config_cache
-
-
-def _save_all_configs():
-    _ensure_dirs()
-    data = {str(k): v.to_dict() for k, v in _config_cache.items()}
-    with open(_CONFIG_FILE, "w", encoding="utf-8") as f:
-        json.dump(data, f, indent=2, ensure_ascii=False)
-
-
-def get_config(guild_id: int) -> GuildTicketConfig:
-    with _lock:
-        configs = _load_all_configs()
-        if guild_id not in configs:
-            configs[guild_id] = GuildTicketConfig(guild_id=guild_id)
-        return configs[guild_id]
-
-
-def save_config(config: GuildTicketConfig):
-    with _lock:
-        _config_cache[config.guild_id] = config
-        _save_all_configs()
-
-
-def get_ticket(channel_id: int) -> TicketData | None:
-    with _lock:
-        if channel_id in _tickets_cache:
-            return _tickets_cache[channel_id]
-        ticket_file = TICKETS_DIR / f"{channel_id}.json"
-        if ticket_file.exists():
-            with open(ticket_file, "r", encoding="utf-8") as f:
-                ticket = TicketData.from_dict(json.load(f))
-            _tickets_cache[channel_id] = ticket
-            return ticket
-    return None
-
-
-def save_ticket(ticket: TicketData):
-    with _lock:
-        _tickets_cache[ticket.channel_id] = ticket
-        _ensure_dirs()
-        ticket_file = TICKETS_DIR / f"{ticket.channel_id}.json"
-        with open(ticket_file, "w", encoding="utf-8") as f:
-            json.dump(ticket.to_dict(), f, indent=2, ensure_ascii=False)
-
-
-def delete_ticket(channel_id: int):
-    with _lock:
-        _tickets_cache.pop(channel_id, None)
-        ticket_file = TICKETS_DIR / f"{channel_id}.json"
-        if ticket_file.exists():
-            ticket_file.unlink()
diff --git a/tickets/transcript.py b/tickets/transcript.py
deleted file mode 100644
index c859fb9..0000000
--- a/tickets/transcript.py
+++ /dev/null
@@ -1,174 +0,0 @@
-from __future__ import annotations
-
-import html
-from datetime import datetime, timezone
-
-from tickets.data import TicketData
-
-
-def _format_ts(dt_str: str) -> str:
-    try:
-        dt = datetime.fromisoformat(dt_str)
-        return dt.strftime("%d/%m/%Y %H:%M:%S")
-    except (ValueError, TypeError):
-        return dt_str
-
-
-def generate_transcript(ticket: TicketData, guild_name: str = "") -> str:
-    now = datetime.now(timezone.utc).strftime("%d/%m/%Y %H:%M:%S")
-
-    messages_html = ""
-    for msg in ticket.messages:
-        content = html.escape(msg.content) if msg.content else ""
-        ts = _format_ts(msg.timestamp)
-        badge = '<span class="badge badge-staff">STAFF</span>' if msg.is_staff else ""
-
-        att_html = ""
-        for att in msg.attachments:
-            if any(att.lower().endswith(ext) for ext in (".png", ".jpg", ".jpeg", ".gif", ".webp")):
-                att_html += f'<div class="attachment"><img src="{html.escape(att)}" /></div>'
-            else:
-                att_html += f'<div class="attachment"><a href="{html.escape(att)}">{html.escape(att.rsplit("/", 1)[-1])}</a></div>'
-
-        messages_html += f"""
-        <div class="message {"staff" if msg.is_staff else "user"}">
-            <div class="msg-header">
-                <span class="author">{html.escape(msg.author_name)}</span>
-                {badge}
-                <span class="timestamp">{ts}</span>
-            </div>
-            <div class="msg-content">{content}</div>
-            {att_html}
-        </div>
-        """
-
-    if not messages_html:
-        messages_html = '<div class="empty">Aucun message.</div>'
-
-    return f"""<!DOCTYPE html>
-<html lang="fr">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>Transcript — Ticket #{ticket.channel_id}</title>
-<style>
-  * {{ margin: 0; padding: 0; box-sizing: border-box; }}
-  body {{
-    font-family: 'Segoe UI', system-ui, -apple-system, sans-serif;
-    background: #0b0d11;
-    color: #dcddde;
-    padding: 20px;
-  }}
-  .header {{
-    background: #1a1d23;
-    border: 1px solid #2f3136;
-    border-radius: 12px;
-    padding: 24px;
-    margin-bottom: 24px;
-    text-align: center;
-  }}
-  .header h1 {{
-    font-size: 22px;
-    color: #fff;
-    margin-bottom: 8px;
-  }}
-  .header .meta {{
-    font-size: 13px;
-    color: #72767d;
-  }}
-  .header .meta span {{
-    background: #2f3136;
-    padding: 2px 10px;
-    border-radius: 20px;
-    margin: 0 4px;
-  }}
-  .messages {{
-    max-width: 800px;
-    margin: 0 auto;
-  }}
-  .message {{
-    padding: 12px 16px;
-    margin-bottom: 4px;
-    border-radius: 8px;
-  }}
-  .message:hover {{
-    background: rgba(255,255,255,0.02);
-  }}
-  .message.staff {{
-    border-left: 3px solid #57f287;
-  }}
-  .message.user {{
-    border-left: 3px solid #5865f2;
-  }}
-  .msg-header {{
-    display: flex;
-    align-items: center;
-    gap: 8px;
-    margin-bottom: 4px;
-  }}
-  .author {{
-    font-weight: 600;
-    font-size: 14px;
-    color: #fff;
-  }}
-  .badge {{
-    font-size: 10px;
-    font-weight: 700;
-    padding: 2px 6px;
-    border-radius: 4px;
-    text-transform: uppercase;
-  }}
-  .badge-staff {{ background: #57f287; color: #000; }}
-  .timestamp {{
-    font-size: 11px;
-    color: #4f545c;
-    margin-left: auto;
-  }}
-  .msg-content {{
-    font-size: 14px;
-    line-height: 1.5;
-    color: #dcddde;
-    white-space: pre-wrap;
-    word-break: break-word;
-    margin-left: 0;
-  }}
-  .attachment {{
-    margin-top: 6px;
-  }}
-  .attachment img {{
-    max-width: 400px;
-    max-height: 300px;
-    border-radius: 8px;
-    border: 1px solid #2f3136;
-  }}
-  .attachment a {{ color: #00aff4; text-decoration: none; }}
-  .empty {{
-    text-align: center;
-    color: #72767d;
-    padding: 40px;
-  }}
-  .footer {{
-    text-align: center;
-    color: #4f545c;
-    font-size: 11px;
-    margin-top: 32px;
-    padding: 16px;
-    border-top: 1px solid #2f3136;
-  }}
-</style>
-</head>
-<body>
-  <div class="header">
-    <h1>Ticket #{ticket.channel_id}</h1>
-    <div class="meta">
-      <span>Categorie: {html.escape(ticket.category_id)}</span>
-      <span>User: {ticket.user_id}</span>
-      <span>Cree: {_format_ts(ticket.created_at)}</span>
-      {f"<span>Ferme: {_format_ts(ticket.closed_at)}</span>" if ticket.closed_at else ""}
-      <span>Genere: {now}</span>
-    </div>
-  </div>
-  <div class="messages">{messages_html}</div>
-  <div class="footer">Vision Studio — Transcript</div>
-</body>
-</html>"""
diff --git a/tickets/ui.py b/tickets/ui.py
deleted file mode 100644
index 641a926..0000000
--- a/tickets/ui.py
+++ /dev/null
@@ -1,619 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import logging
-import os
-from datetime import datetime, timezone
-
-import discord
-
-from tickets import storage
-from tickets.data import TicketCategory, TicketData, TicketStatus
-from tickets.transcript import generate_transcript
-
-logger = logging.getLogger("vision")
-
-
-def _now_iso() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def _is_staff(member: discord.Member, config) -> bool:
-    if member.guild_permissions.administrator:
-        return True
-    if config.staff_role_id and config.staff_role_id in [r.id for r in member.roles]:
-        return True
-    return any(cat.staff_role_id and cat.staff_role_id in [r.id for r in member.roles] for cat in config.categories)
-
-
-async def _send_log(guild: discord.Guild, config, embed: discord.Embed):
-    if config.log_channel_id:
-        ch = guild.get_channel(config.log_channel_id)
-        if ch:
-            with contextlib.suppress(discord.HTTPException):
-                await ch.send(embed=embed)
-
-
-class PanelCreateButton(discord.ui.Button):
-    def __init__(self):
-        super().__init__(
-            label="Créer un ticket",
-            style=discord.ButtonStyle.primary,
-            custom_id="ticket_panel_create",
-        )
-
-    async def callback(self, interaction: discord.Interaction):
-        config = storage.get_config(interaction.guild_id)
-        if not config.enabled:
-            await interaction.response.send_message("Le système de tickets est désactivé.", ephemeral=True)
-            return
-
-        categories = config.categories
-        if not categories:
-            await interaction.response.send_message("Aucune catégorie configurée.", ephemeral=True)
-            return
-
-        if len(categories) == 1:
-            cat = categories[0]
-            await interaction.response.send_modal(TicketModal(cat.id, cat.name))
-            return
-
-        await interaction.response.send_message(
-            "Choisissez une catégorie :",
-            view=CategorySelectView(categories),
-            ephemeral=True,
-        )
-
-
-class CategorySelect(discord.ui.Select):
-    def __init__(self, categories: list[TicketCategory]):
-        options = [
-            discord.SelectOption(
-                label=c.name,
-                value=c.id,
-                emoji=c.emoji or None,
-                description=c.description[:100] if c.description else None,
-            )
-            for c in categories[:25]
-        ]
-        super().__init__(
-            placeholder="Sélectionnez une catégorie...",
-            options=options,
-            custom_id="ticket_category_select",
-        )
-
-    async def callback(self, interaction: discord.Interaction):
-        cat_id = self.values[0]
-        config = storage.get_config(interaction.guild_id)
-        cat = next((c for c in config.categories if c.id == cat_id), None)
-        if not cat:
-            await interaction.response.send_message("Catégorie introuvable.", ephemeral=True)
-            return
-        await interaction.response.send_modal(TicketModal(cat.id, cat.name))
-
-
-class CategorySelectView(discord.ui.View):
-    def __init__(self, categories: list[TicketCategory]):
-        super().__init__(timeout=300)
-        self.add_item(CategorySelect(categories))
-
-
-class TicketModal(discord.ui.Modal, title="Nouveau Ticket"):
-    reason = discord.ui.TextInput(
-        label="Décris ton problème",
-        style=discord.TextStyle.paragraph,
-        placeholder="Explique brièvement ta demande...",
-        required=True,
-        max_length=2000,
-    )
-
-    def __init__(self, category_id: str, category_name: str):
-        super().__init__()
-        self.category_id = category_id
-        self.category_name = category_name
-
-    async def on_submit(self, interaction: discord.Interaction):
-        await interaction.response.defer(ephemeral=True)
-        config = storage.get_config(interaction.guild_id)
-        guild = interaction.guild
-
-        cat = next((c for c in config.categories if c.id == self.category_id), None)
-        if not cat:
-            await interaction.followup.send("Catégorie introuvable.", ephemeral=True)
-            return
-
-        overwrites = {
-            guild.default_role: discord.PermissionOverwrite(view_channel=False),
-            guild.me: discord.PermissionOverwrite(
-                view_channel=True,
-                send_messages=True,
-                read_message_history=True,
-                attach_files=True,
-                manage_channels=True,
-            ),
-            interaction.user: discord.PermissionOverwrite(
-                view_channel=True,
-                send_messages=True,
-                read_message_history=True,
-            ),
-        }
-        if config.staff_role_id:
-            staff_role = guild.get_role(config.staff_role_id)
-            if staff_role:
-                overwrites[staff_role] = discord.PermissionOverwrite(
-                    view_channel=True,
-                    send_messages=True,
-                    read_message_history=True,
-                    attach_files=True,
-                )
-        if cat.staff_role_id:
-            cat_role = guild.get_role(cat.staff_role_id)
-            if cat_role:
-                overwrites[cat_role] = discord.PermissionOverwrite(
-                    view_channel=True,
-                    send_messages=True,
-                    read_message_history=True,
-                    attach_files=True,
-                )
-
-        discord_cat = guild.get_channel(cat.discord_category_id) if cat.discord_category_id else None
-        safe_name = interaction.user.name.lower().replace(" ", "-")[:20]
-        channel = await guild.create_text_channel(
-            f"ticket-{safe_name}",
-            category=discord_cat,
-            overwrites=overwrites,
-            topic=f"Ticket de {interaction.user} | {cat.name}",
-        )
-
-        ticket = TicketData(
-            channel_id=channel.id,
-            guild_id=guild.id,
-            user_id=interaction.user.id,
-            category_id=cat.id,
-            created_at=_now_iso(),
-            reason=self.reason.value,
-        )
-        storage.save_ticket(ticket)
-
-        mention = interaction.user.mention
-        if config.staff_role_id:
-            mention += f" <@&{config.staff_role_id}>"
-        if cat.staff_role_id:
-            mention += f" <@&{cat.staff_role_id}>"
-
-        container = discord.ui.Container()
-        container.add_item(discord.ui.TextDisplay(mention))
-        container.add_item(discord.ui.Separator())
-        container.add_item(
-            discord.ui.TextDisplay(
-                f"## Ticket — {cat.name}\n"
-                f"**Utilisateur :** {interaction.user.mention}\n"
-                f"**Catégorie :** {cat.emoji} {cat.name}\n"
-                f"**Raison :**\n{self.reason.value}"
-            )
-        )
-        container.add_item(discord.ui.Separator())
-        container.add_item(discord.ui.TextDisplay("### Gestion"))
-        container.add_item(
-            discord.ui.ActionRow(
-                ClaimButton(),
-                TransferButton(),
-                LockButton(),
-            )
-        )
-        container.add_item(discord.ui.Separator())
-        container.add_item(
-            discord.ui.ActionRow(
-                AddMemberButton(),
-                CloseButton(),
-            )
-        )
-        view = discord.ui.LayoutView()
-        view.add_item(container)
-
-        await channel.send(view=view)
-
-        await interaction.followup.send(f"Ticket créé : {channel.mention}", ephemeral=True)
-
-        embed = discord.Embed(
-            title="Ticket créé",
-            description=f"**Catégorie :** {cat.name}\n**Utilisateur :** {interaction.user.mention}\n**Canal :** {channel.mention}",
-            color=discord.Color.green(),
-            timestamp=datetime.now(timezone.utc),
-        )
-        await _send_log(guild, config, embed)
-
-
-class ClaimButton(discord.ui.Button):
-    def __init__(self):
-        super().__init__(
-            label="Réclamer",
-            style=discord.ButtonStyle.success,
-            custom_id="ticket_claim",
-        )
-
-    async def callback(self, interaction: discord.Interaction):
-        config = storage.get_config(interaction.guild_id)
-        ticket = storage.get_ticket(interaction.channel.id)
-        if not ticket:
-            await interaction.response.send_message("Ce n'est pas un ticket.", ephemeral=True)
-            return
-
-        member = interaction.guild.get_member(interaction.user.id)
-        if not member or not _is_staff(member, config):
-            await interaction.response.send_message("Seul le staff peut réclamer un ticket.", ephemeral=True)
-            return
-
-        if ticket.claimed_by:
-            if ticket.claimed_by == interaction.user.id:
-                ticket.claimed_by = None
-                storage.save_ticket(ticket)
-                await interaction.response.send_message(
-                    f"{interaction.user.mention} a retiré son réclamation.", ephemeral=True
-                )
-            else:
-                await interaction.response.send_message(
-                    f"Ce ticket est déjà réclamé par <@{ticket.claimed_by}>.", ephemeral=True
-                )
-            return
-
-        ticket.claimed_by = interaction.user.id
-        storage.save_ticket(ticket)
-
-        embed = discord.Embed(
-            title="Ticket claim",
-            description=f"Réclamé par {interaction.user.mention}",
-            color=discord.Color.green(),
-            timestamp=datetime.now(timezone.utc),
-        )
-        await _send_log(interaction.guild, config, embed)
-
-        container = discord.ui.Container()
-        container.add_item(discord.ui.TextDisplay(f"## Ticket réclamé\nRéclamé par {interaction.user.mention}"))
-        view = discord.ui.LayoutView()
-        view.add_item(container)
-        await interaction.response.send_message(view=view)
-
-
-class AddMemberButton(discord.ui.Button):
-    def __init__(self):
-        super().__init__(
-            label="Ajouter un membre",
-            style=discord.ButtonStyle.secondary,
-            custom_id="ticket_add_member",
-        )
-
-    async def callback(self, interaction: discord.Interaction):
-        config = storage.get_config(interaction.guild_id)
-        ticket = storage.get_ticket(interaction.channel.id)
-        if not ticket:
-            await interaction.response.send_message("Ce n'est pas un ticket.", ephemeral=True)
-            return
-
-        member = interaction.guild.get_member(interaction.user.id)
-        if not member or not _is_staff(member, config):
-            await interaction.response.send_message("Seul le staff peut ajouter des membres.", ephemeral=True)
-            return
-
-        await interaction.response.send_message(
-            "Sélectionnez le membre à ajouter :",
-            view=AddMemberSelectView(),
-            ephemeral=True,
-        )
-
-
-class AddMemberSelect(discord.ui.UserSelect):
-    def __init__(self):
-        super().__init__(
-            placeholder="Sélectionnez un membre...",
-            custom_id="ticket_add_member_select",
-            min_values=1,
-            max_values=1,
-        )
-
-    async def callback(self, interaction: discord.Interaction):
-        user = self.values[0]
-        await interaction.channel.set_permissions(
-            user,
-            view_channel=True,
-            send_messages=True,
-            read_message_history=True,
-        )
-        await interaction.response.edit_message(
-            content=f"{user.mention} a été ajouté au ticket.",
-            view=None,
-        )
-        embed = discord.Embed(
-            title="Membre ajouté",
-            description=f"{user.mention} a été ajouté par {interaction.user.mention}",
-            color=discord.Color.blue(),
-            timestamp=datetime.now(timezone.utc),
-        )
-        await _send_log(interaction.guild, storage.get_config(interaction.guild_id), embed)
-
-
-class AddMemberSelectView(discord.ui.View):
-    def __init__(self):
-        super().__init__(timeout=300)
-        self.add_item(AddMemberSelect())
-
-
-class TransferButton(discord.ui.Button):
-    def __init__(self):
-        super().__init__(
-            label="Transférer",
-            style=discord.ButtonStyle.secondary,
-            custom_id="ticket_transfer",
-        )
-
-    async def callback(self, interaction: discord.Interaction):
-        config = storage.get_config(interaction.guild_id)
-        ticket = storage.get_ticket(interaction.channel.id)
-        if not ticket:
-            await interaction.response.send_message("Ce n'est pas un ticket.", ephemeral=True)
-            return
-        member = interaction.guild.get_member(interaction.user.id)
-        if not member or not _is_staff(member, config):
-            await interaction.response.send_message("Seul le staff peut transférer.", ephemeral=True)
-            return
-        await interaction.response.send_message(
-            "Sélectionnez le staff :",
-            view=TransferSelectView(),
-            ephemeral=True,
-        )
-
-
-class TransferSelect(discord.ui.UserSelect):
-    def __init__(self):
-        super().__init__(
-            placeholder="Sélectionnez un staff...",
-            custom_id="ticket_transfer_select",
-            min_values=1,
-            max_values=1,
-        )
-
-    async def callback(self, interaction: discord.Interaction):
-        user = self.values[0]
-        ticket = storage.get_ticket(interaction.channel.id)
-        if ticket:
-            ticket.claimed_by = user.id
-            storage.save_ticket(ticket)
-        await interaction.response.edit_message(
-            content=f"Ticket transféré à {user.mention}.",
-            view=None,
-        )
-        embed = discord.Embed(
-            title="Ticket transféré",
-            description=f"Transféré à {user.mention} par {interaction.user.mention}",
-            color=discord.Color.blue(),
-            timestamp=datetime.now(timezone.utc),
-        )
-        await _send_log(interaction.guild, storage.get_config(interaction.guild_id), embed)
-
-
-class TransferSelectView(discord.ui.View):
-    def __init__(self):
-        super().__init__(timeout=300)
-        self.add_item(TransferSelect())
-
-
-class PriorityButton(discord.ui.Button):
-    def __init__(self):
-        super().__init__(
-            label="Priorite",
-            style=discord.ButtonStyle.secondary,
-            custom_id="ticket_priority",
-        )
-
-    async def callback(self, interaction: discord.Interaction):
-        config = storage.get_config(interaction.guild_id)
-        ticket = storage.get_ticket(interaction.channel.id)
-        if not ticket:
-            await interaction.response.send_message("Ce n'est pas un ticket.", ephemeral=True)
-            return
-        member = interaction.guild.get_member(interaction.user.id)
-        if not member or not _is_staff(member, config):
-            await interaction.response.send_message("Seul le staff peut changer la priorité.", ephemeral=True)
-            return
-        await interaction.response.send_message(
-            "Sélectionnez la priorité :",
-            view=PrioritySelectView(),
-            ephemeral=True,
-        )
-
-
-class PrioritySelect(discord.ui.Select):
-    def __init__(self):
-        super().__init__(
-            placeholder="Sélectionnez la priorité...",
-            custom_id="ticket_priority_select",
-            options=[
-                discord.SelectOption(label="Basse", value="low", emoji="🟢"),
-                discord.SelectOption(label="Normale", value="normal", emoji="🔵"),
-                discord.SelectOption(label="Haute", value="high", emoji="🟠"),
-                discord.SelectOption(label="Urgente", value="urgent", emoji="🔴"),
-            ],
-        )
-
-    async def callback(self, interaction: discord.Interaction):
-        from tickets.data import TicketPriority
-
-        ticket = storage.get_ticket(interaction.channel.id)
-        if ticket:
-            ticket.priority = TicketPriority(self.values[0])
-            storage.save_ticket(ticket)
-        await interaction.response.edit_message(
-            content=f"Priorite definie sur **{self.values[0]}**.",
-            view=None,
-        )
-        embed = discord.Embed(
-            title="Priorite changee",
-            description=f"Priorite : **{self.values[0]}** par {interaction.user.mention}",
-            color=discord.Color.blue(),
-            timestamp=datetime.now(timezone.utc),
-        )
-        await _send_log(interaction.guild, storage.get_config(interaction.guild_id), embed)
-
-
-class PrioritySelectView(discord.ui.View):
-    def __init__(self):
-        super().__init__(timeout=300)
-        self.add_item(PrioritySelect())
-
-
-class LockButton(discord.ui.Button):
-    def __init__(self):
-        super().__init__(
-            label="Verrouiller",
-            style=discord.ButtonStyle.secondary,
-            custom_id="ticket_lock",
-        )
-
-    async def callback(self, interaction: discord.Interaction):
-        config = storage.get_config(interaction.guild_id)
-        ticket = storage.get_ticket(interaction.channel.id)
-        if not ticket:
-            await interaction.response.send_message("Ce n'est pas un ticket.", ephemeral=True)
-            return
-        member = interaction.guild.get_member(interaction.user.id)
-        if not member or not _is_staff(member, config):
-            await interaction.response.send_message("Seul le staff peut verrouiller/déverrouiller.", ephemeral=True)
-            return
-
-        ticket.locked = not ticket.locked
-        storage.save_ticket(ticket)
-
-        overwrites = interaction.channel.overwrites_for(interaction.guild.default_role)
-        overwrites.send_messages = not ticket.locked
-        await interaction.channel.set_permissions(interaction.guild.default_role, overwrite=overwrites)
-
-        self.label = "Déverrouiller" if ticket.locked else "Verrouiller"
-
-        await interaction.response.send_message(
-            f"Ticket {'verrouillé' if ticket.locked else 'déverrouillé'} par {interaction.user.mention}."
-        )
-
-        embed = discord.Embed(
-            title=f"Ticket {'verrouillé' if ticket.locked else 'déverrouillé'}",
-            description=f"Par {interaction.user.mention}",
-            color=discord.Color.orange() if ticket.locked else discord.Color.green(),
-            timestamp=datetime.now(timezone.utc),
-        )
-        await _send_log(interaction.guild, config, embed)
-
-
-class StatsButton(discord.ui.Button):
-    def __init__(self):
-        super().__init__(
-            label="Infos",
-            style=discord.ButtonStyle.secondary,
-            custom_id="ticket_stats",
-        )
-
-    async def callback(self, interaction: discord.Interaction):
-        ticket = storage.get_ticket(interaction.channel.id)
-        if not ticket:
-            await interaction.response.send_message("Ce n'est pas un ticket.", ephemeral=True)
-            return
-        config = storage.get_config(interaction.guild_id)
-        cat = next((c for c in config.categories if c.id == ticket.category_id), None)
-
-        user = interaction.guild.get_member(ticket.user_id)
-        claimed = interaction.guild.get_member(ticket.claimed_by) if ticket.claimed_by else None
-        msg_count = len(ticket.messages)
-
-        container = discord.ui.Container()
-        container.add_item(
-            discord.ui.TextDisplay(
-                f"## Infos Ticket\n"
-                f"**Categorie :** {cat.emoji} {cat.name if cat else ticket.category_id}\n"
-                f"**Utilisateur :** {user.mention if user else ticket.user_id}\n"
-                f"**Claim par :** {claimed.mention if claimed else 'Non claim'}\n"
-                f"**Priorite :** {ticket.priority.value}\n"
-                f"**Statut :** {'Lock' if ticket.locked else 'Ouvert'}\n"
-                f"**Messages :** {msg_count}\n"
-                f"**Cree :** <t:{int(os.path.fromisoformat(ticket.created_at).timestamp())}:R>"
-                if ticket.created_at
-                else ""
-            )
-        )
-        view = discord.ui.LayoutView()
-        view.add_item(container)
-        await interaction.response.send_message(view=view, ephemeral=True)
-
-
-class CloseButton(discord.ui.Button):
-    def __init__(self):
-        super().__init__(
-            label="Fermer le ticket",
-            style=discord.ButtonStyle.danger,
-            custom_id="ticket_close",
-        )
-
-    async def callback(self, interaction: discord.Interaction):
-        config = storage.get_config(interaction.guild_id)
-        ticket = storage.get_ticket(interaction.channel.id)
-        if not ticket:
-            await interaction.response.send_message("Ce n'est pas un ticket.", ephemeral=True)
-            return
-
-        member = interaction.guild.get_member(interaction.user.id)
-        if not member or not _is_staff(member, config):
-            await interaction.response.send_message("Seul le staff peut fermer un ticket.", ephemeral=True)
-            return
-
-        await interaction.response.defer(ephemeral=True)
-
-        ticket.status = TicketStatus.CLOSED
-        ticket.closed_at = _now_iso()
-        ticket.closed_by = interaction.user.id
-
-        if config.transcript_enabled:
-            html_content = generate_transcript(ticket, interaction.guild.name)
-            transcript_file = discord.File(
-                fp=__import__("io").BytesIO(html_content.encode()),
-                filename=f"ticket_{ticket.channel_id}.html",
-            )
-            if config.log_channel_id:
-                ch = interaction.guild.get_channel(config.log_channel_id)
-                if ch:
-                    with contextlib.suppress(discord.HTTPException):
-                        await ch.send(
-                            f"Ticket fermé par {interaction.user.mention}",
-                            file=transcript_file,
-                        )
-
-            for msg in ticket.messages:
-                if not msg.is_staff:
-                    user = interaction.guild.get_member(msg.author_id)
-                    if user:
-                        with contextlib.suppress(discord.HTTPException):
-                            await user.send(
-                                "Ton ticket a été fermé.",
-                                file=discord.File(
-                                    fp=__import__("io").BytesIO(html_content.encode()),
-                                    filename=f"ticket_{ticket.channel_id}.html",
-                                ),
-                            )
-                            break
-
-        storage.save_ticket(ticket)
-
-        embed = discord.Embed(
-            title="Ticket fermé",
-            description=f"**Fermé par :** {interaction.user.mention}\n**Catégorie :** {ticket.category_id}",
-            color=discord.Color.red(),
-            timestamp=datetime.now(timezone.utc),
-        )
-        await _send_log(interaction.guild, config, embed)
-
-        container = discord.ui.Container()
-        container.add_item(discord.ui.TextDisplay("## Ticket fermé\nCe ticket sera supprimé dans 5 secondes."))
-        view = discord.ui.LayoutView()
-        view.add_item(container)
-        await interaction.followup.send(view=view)
-
-        await asyncio.sleep(5)
-        with contextlib.suppress(discord.HTTPException):
-            await interaction.channel.delete(reason=f"Ticket fermé par {interaction.user}")
diff --git a/utils/modmail_config.py b/utils/modmail_config.py
new file mode 100644
index 0000000..b840cc4
--- /dev/null
+++ b/utils/modmail_config.py
@@ -0,0 +1,115 @@
+import json
+
+from config import DATA_DIR
+
+CONFIG_PATH = DATA_DIR / "modmail.json"
+
+DEFAULT_CONFIG = {
+    "enabled": False,
+    "category_id": None,
+    "staff_role_id": None,
+    "log_channel_id": None,
+    "categories": {},
+    "open_tickets": {},
+}
+
+
+def _load() -> dict:
+    if CONFIG_PATH.exists():
+        with open(CONFIG_PATH, "r", encoding="utf-8") as f:
+            return json.load(f)
+    return DEFAULT_CONFIG.copy()
+
+
+def _save(data: dict):
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with open(CONFIG_PATH, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
+
+
+def get_config() -> dict:
+    return _load()
+
+
+def set_guild_id(guild_id: int):
+    data = _load()
+    data["guild_id"] = guild_id
+    _save(data)
+
+
+def set_enabled(guild_id: int, enabled: bool):
+    data = _load()
+    data["enabled"] = enabled
+    _save(data)
+
+
+def set_category(guild_id: int, category_id: int):
+    data = _load()
+    data["category_id"] = category_id
+    _save(data)
+
+
+def set_staff_role(guild_id: int, role_id: int):
+    data = _load()
+    data["staff_role_id"] = role_id
+    _save(data)
+
+
+def set_log_channel(guild_id: int, channel_id: int):
+    data = _load()
+    data["log_channel_id"] = channel_id
+    _save(data)
+
+
+def add_category(guild_id: int, name: str, emoji: str, description: str = ""):
+    data = _load()
+    data["categories"][name.lower()] = {
+        "name": name,
+        "emoji": emoji,
+        "description": description,
+    }
+    _save(data)
+
+
+def remove_category(guild_id: int, name: str):
+    data = _load()
+    data["categories"].pop(name.lower(), None)
+    _save(data)
+
+
+def get_categories() -> dict:
+    data = _load()
+    return data.get("categories", {})
+
+
+def register_ticket(guild_id: int, user_id: int, channel_id: int, category: str):
+    data = _load()
+    data["open_tickets"][str(user_id)] = {
+        "channel_id": channel_id,
+        "category": category,
+        "guild_id": guild_id,
+    }
+    _save(data)
+
+
+def unregister_ticket(user_id: int):
+    data = _load()
+    data["open_tickets"].pop(str(user_id), None)
+    _save(data)
+
+
+def get_ticket_by_user(user_id: int) -> dict | None:
+    data = _load()
+    return data["open_tickets"].get(str(user_id))
+
+
+def get_ticket_by_channel(channel_id: int) -> dict | None:
+    data = _load()
+    for uid, ticket in data.get("open_tickets", {}).items():
+        if ticket["channel_id"] == channel_id:
+            return {"user_id": int(uid), **ticket}
+    return None
+
+
+def is_enabled() -> bool:
+    return _load().get("enabled", False)
diff --git a/utils/modmail_transcript.py b/utils/modmail_transcript.py
new file mode 100644
index 0000000..f5d4a98
--- /dev/null
+++ b/utils/modmail_transcript.py
@@ -0,0 +1,215 @@
+import html
+from datetime import datetime, timezone
+
+
+def _format_timestamp(dt: datetime) -> str:
+    return dt.strftime("%d/%m/%Y %H:%M:%S")
+
+
+def _avatar_url(user) -> str:
+    if user.avatar:
+        return user.avatar.url
+    return f"https://cdn.discordapp.com/embed/avatars/{user.discriminator % 5}.png"
+
+
+def generate_transcript(messages: list[dict], ticket_info: dict) -> str:
+    """Génère un transcript HTML stylé.
+
+    messages: [{"author": discord.User, "content": str, "timestamp": datetime, "attachments": list}]
+    ticket_info: {"category": str, "user_id": int, "channel_id": int}
+    """
+    now = datetime.now(timezone.utc)
+    date_str = _format_timestamp(now)
+
+    messages_html = ""
+    for msg in messages:
+        author = msg["author"]
+        content = html.escape(msg["content"]) if msg["content"] else ""
+        timestamp = _format_timestamp(msg["timestamp"])
+        avatar = _avatar_url(author)
+        is_staff = msg.get("is_staff", False)
+
+        staff_badge = '<span class="badge badge-staff">STAFF</span>' if is_staff else ""
+
+        attachments_html = ""
+        for att in msg.get("attachments", []):
+            if att.url.lower().endswith((".png", ".jpg", ".jpeg", ".gif", ".webp")):
+                attachments_html += (
+                    f'<div class="attachment"><img src="{html.escape(att.url)}" alt="attachment" /></div>'
+                )
+            else:
+                attachments_html += (
+                    f'<div class="attachment"><a href="{html.escape(att.url)}">{html.escape(att.filename)}</a></div>'
+                )
+
+        messages_html += f"""
+        <div class="message {"staff" if is_staff else "user"}">
+            <div class="msg-header">
+                <img class="avatar" src="{avatar}" alt="{html.escape(str(author))}" />
+                <span class="author">{html.escape(str(author))}</span>
+                {staff_badge}
+                <span class="timestamp">{timestamp}</span>
+            </div>
+            <div class="msg-content">{content}</div>
+            {attachments_html}
+        </div>
+        """
+
+    if not messages_html:
+        messages_html = '<div class="empty">Aucun message dans ce ticket.</div>'
+
+    return f"""<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Transcript — Ticket #{ticket_info.get("channel_id", 0)}</title>
+<style>
+  * {{ margin: 0; padding: 0; box-sizing: border-box; }}
+  body {{
+    font-family: 'Segoe UI', system-ui, -apple-system, sans-serif;
+    background: #0b0d11;
+    color: #dcddde;
+    padding: 20px;
+  }}
+  .header {{
+    background: linear-gradient(135deg, #5865f2, #7289da);
+    border-radius: 12px;
+    padding: 24px;
+    margin-bottom: 24px;
+    text-align: center;
+  }}
+  .header h1 {{
+    font-size: 24px;
+    color: #fff;
+    margin-bottom: 8px;
+  }}
+  .header .meta {{
+    font-size: 14px;
+    color: #d4d4d4;
+  }}
+  .header .meta span {{
+    background: rgba(255,255,255,0.15);
+    padding: 2px 10px;
+    border-radius: 20px;
+    margin: 0 4px;
+    font-size: 13px;
+  }}
+  .messages {{
+    max-width: 800px;
+    margin: 0 auto;
+  }}
+  .message {{
+    padding: 12px 16px;
+    margin-bottom: 4px;
+    border-radius: 8px;
+    transition: background 0.15s;
+  }}
+  .message:hover {{
+    background: rgba(255,255,255,0.03);
+  }}
+  .message.staff {{
+    border-left: 3px solid #57f287;
+    background: rgba(87, 242, 135, 0.03);
+  }}
+  .message.user {{
+    border-left: 3px solid #5865f2;
+  }}
+  .msg-header {{
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    margin-bottom: 6px;
+  }}
+  .avatar {{
+    width: 32px;
+    height: 32px;
+    border-radius: 50%;
+  }}
+  .author {{
+    font-weight: 600;
+    font-size: 15px;
+    color: #fff;
+  }}
+  .badge {{
+    font-size: 10px;
+    font-weight: 700;
+    padding: 2px 6px;
+    border-radius: 4px;
+    text-transform: uppercase;
+  }}
+  .badge-staff {{
+    background: #57f287;
+    color: #000;
+  }}
+  .timestamp {{
+    font-size: 12px;
+    color: #72767d;
+    margin-left: auto;
+  }}
+  .msg-content {{
+    font-size: 14px;
+    line-height: 1.5;
+    color: #dcddde;
+    white-space: pre-wrap;
+    word-break: break-word;
+    margin-left: 42px;
+  }}
+  .attachment {{
+    margin-left: 42px;
+    margin-top: 6px;
+  }}
+  .attachment img {{
+    max-width: 400px;
+    max-height: 300px;
+    border-radius: 8px;
+    border: 1px solid #2f3136;
+  }}
+  .attachment a {{
+    color: #00aff4;
+    text-decoration: none;
+  }}
+  .empty {{
+    text-align: center;
+    color: #72767d;
+    padding: 40px;
+    font-size: 16px;
+  }}
+  .footer {{
+    text-align: center;
+    color: #4f545c;
+    font-size: 12px;
+    margin-top: 32px;
+    padding: 16px;
+    border-top: 1px solid #2f3136;
+  }}
+</style>
+</head>
+<body>
+  <div class="header">
+    <h1>Transcript — Ticket #{ticket_info.get("channel_id", 0)}</h1>
+    <div class="meta">
+      <span>Catégorie: {html.escape(ticket_info.get("category", "N/A"))}</span>
+      <span>Utilisateur: {ticket_info.get("user_id", "N/A")}</span>
+      <span>Généré le: {date_str}</span>
+    </div>
+  </div>
+  <div class="messages">
+    {messages_html}
+  </div>
+  <div class="footer">
+    Vision Studio — Transcript généré automatiquement
+  </div>
+</body>
+</html>"""
+
+
+def save_transcript(html_content: str, channel_id: int) -> str:
+    from config import DATA_DIR
+
+    transcripts_dir = DATA_DIR / "transcripts"
+    transcripts_dir.mkdir(parents=True, exist_ok=True)
+    path = transcripts_dir / f"ticket_{channel_id}_{int(datetime.now(timezone.utc).timestamp())}.html"
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(html_content)
+    return str(path)
diff --git a/vision.py b/vision.py
index 42fc021..af44c18 100644
--- a/vision.py
+++ b/vision.py
@@ -26,8 +26,7 @@ async def main():
     instance = "DEV" if config.DEV else "PROD"
     logger.info(f"Lancement de Vision Studio [{instance}]...")
 
-    if not config.DEV:
-        await start_health_server(config.HEALTH_PORT)
+    await start_health_server(config.HEALTH_PORT)
 
     bot = VisionBot()
     try: