diff --git a/.gitignore b/.gitignore
index 8449a5d..1824790 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,3 +13,5 @@ k8s-context
 tsconfig.tsbuildinfo
 .react-router
 tailwind.css
+userInfoCache.json
+vite.config.ts*
diff --git a/CLAUDE.md b/CLAUDE.md
index ae7f3d3..1f66970 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -2,6 +2,7 @@
 
 - You should periodically jot down your thoughts in `/notes`, especially if it will help you remember important implementation details later.
 - Your notes must be named consistently with a date prefix in the format YYYY-MM-DD followed by a sequence in the format \_X where x is a monotonically increasing integer.
+- You must commit periodically, running `npm run validate` first.
 - You expect to be able to access VS Code. If you can't, prompt me about it.
 - This project uses sqlite, so you can inspect the database yourself. You can make your own dummy data, but don't do anything destructive, and make sure to describe how to reverse any DB changes.
 - You can curl this website, it's running locally at http://localhost:3000. You are not able to access areas behind authentication without data from me.
diff --git a/app/commands/demo.ts b/app/commands/demo.ts
index 803ec23..0176544 100644
--- a/app/commands/demo.ts
+++ b/app/commands/demo.ts
@@ -8,7 +8,7 @@ export const command = new SlashCommandBuilder()
 
 export const handler = async (interaction: CommandInteraction) => {
   await interaction.reply({
-    ephemeral: true,
+    flags: "Ephemeral",
     content: "ok",
   });
 };
diff --git a/app/commands/escalationControls.ts b/app/commands/escalationControls.ts
new file mode 100644
index 0000000..b67849e
--- /dev/null
+++ b/app/commands/escalationControls.ts
@@ -0,0 +1,262 @@
+import { InteractionType, PermissionsBitField } from "discord.js";
+import type { MessageComponentCommand } from "#~/helpers/discord";
+import { fetchSettings, SETTINGS } from "#~/models/guilds.server";
+import { deleteAllReportedForUser } from "#~/models/reportedMessages.server";
+import { timeout, ban, kick, applyRestriction } from "#~/models/discord.server";
+
+export const EscalationCommands = [
+  {
+    command: {
+      type: InteractionType.MessageComponent,
+      name: "escalate-delete",
+    },
+    handler: async (interaction) => {
+      await interaction.deferReply();
+      const reportedUserId = interaction.customId.split("|")[1];
+      const guildId = interaction.guildId!;
+
+      // Permission check
+      const member = await interaction.guild!.members.fetch(
+        interaction.user.id,
+      );
+      if (!member.permissions.has(PermissionsBitField.Flags.ManageMessages)) {
+        return interaction.editReply({
+          content: "Insufficient permissions",
+        });
+      }
+
+      try {
+        const result = await deleteAllReportedForUser(reportedUserId, guildId);
+        await interaction.editReply(
+          `Messages deleted by ${interaction.user.username} (${result.deleted}/${result.total} successful)`,
+        );
+      } catch (error) {
+        console.error("Error deleting reported messages:", error);
+        await interaction.editReply({
+          content: "Failed to delete messages",
+        });
+      }
+    },
+  },
+
+  {
+    command: { type: InteractionType.MessageComponent, name: "escalate-kick" },
+    handler: async (interaction) => {
+      const reportedUserId = interaction.customId.split("|")[1];
+      const guildId = interaction.guildId!;
+
+      // Get moderator role for permission check
+      const { moderator: modRoleId } = await fetchSettings(guildId, [
+        SETTINGS.moderator,
+      ]);
+
+      const member = interaction.member;
+      if (
+        !member ||
+        (Array.isArray(member.roles)
+          ? !member.roles.includes(modRoleId)
+          : !member.roles.cache.has(modRoleId))
+      ) {
+        return interaction.reply({
+          content: "Insufficient permissions",
+          ephemeral: true,
+        });
+      }
+
+      try {
+        const reportedMember =
+          await interaction.guild!.members.fetch(reportedUserId);
+        await Promise.allSettled([
+          kick(reportedMember),
+          interaction.reply(
+            `<@${reportedUserId}> kicked by ${interaction.user.username}`,
+          ),
+        ]);
+      } catch (error) {
+        console.error("Error kicking user:", error);
+        await interaction.reply({
+          content: "Failed to kick user",
+          ephemeral: true,
+        });
+      }
+    },
+  },
+
+  {
+    command: { type: InteractionType.MessageComponent, name: "escalate-ban" },
+    handler: async (interaction) => {
+      const reportedUserId = interaction.customId.split("|")[1];
+      const guildId = interaction.guildId!;
+
+      // Get moderator role for permission check
+      const { moderator: modRoleId } = await fetchSettings(guildId, [
+        SETTINGS.moderator,
+      ]);
+
+      const member = interaction.member;
+      if (
+        !member ||
+        (Array.isArray(member.roles)
+          ? !member.roles.includes(modRoleId)
+          : !member.roles.cache.has(modRoleId))
+      ) {
+        return interaction.reply({
+          content: "Insufficient permissions",
+          ephemeral: true,
+        });
+      }
+
+      try {
+        const reportedMember =
+          await interaction.guild!.members.fetch(reportedUserId);
+        await Promise.allSettled([
+          ban(reportedMember),
+          interaction.reply(
+            `<@${reportedUserId}> banned by ${interaction.user.username}`,
+          ),
+        ]);
+      } catch (error) {
+        console.error("Error banning user:", error);
+        await interaction.reply({
+          content: "Failed to ban user",
+          ephemeral: true,
+        });
+      }
+    },
+  },
+
+  {
+    command: {
+      type: InteractionType.MessageComponent,
+      name: "escalate-restrict",
+    },
+    handler: async (interaction) => {
+      const reportedUserId = interaction.customId.split("|")[1];
+      const guildId = interaction.guildId!;
+
+      // Get moderator role for permission check
+      const { moderator: modRoleId } = await fetchSettings(guildId, [
+        SETTINGS.moderator,
+      ]);
+
+      const member = interaction.member;
+      if (
+        !member ||
+        (Array.isArray(member.roles)
+          ? !member.roles.includes(modRoleId)
+          : !member.roles.cache.has(modRoleId))
+      ) {
+        return interaction.reply({
+          content: "Insufficient permissions",
+          ephemeral: true,
+        });
+      }
+
+      try {
+        const reportedMember =
+          await interaction.guild!.members.fetch(reportedUserId);
+        await Promise.allSettled([
+          applyRestriction(reportedMember),
+          interaction.reply(
+            `<@${reportedUserId}> restricted by ${interaction.user.username}`,
+          ),
+        ]);
+      } catch (error) {
+        console.error("Error restricting user:", error);
+        await interaction.reply({
+          content: "Failed to restrict user",
+          ephemeral: true,
+        });
+      }
+    },
+  },
+
+  {
+    command: {
+      type: InteractionType.MessageComponent,
+      name: "escalate-timeout",
+    },
+    handler: async (interaction) => {
+      const reportedUserId = interaction.customId.split("|")[1];
+      const guildId = interaction.guildId!;
+
+      // Get moderator role for permission check
+      const { moderator: modRoleId } = await fetchSettings(guildId, [
+        SETTINGS.moderator,
+      ]);
+
+      const member = interaction.member;
+      if (
+        !member ||
+        (Array.isArray(member.roles)
+          ? !member.roles.includes(modRoleId)
+          : !member.roles.cache.has(modRoleId))
+      ) {
+        return interaction.reply({
+          content: "Insufficient permissions",
+          ephemeral: true,
+        });
+      }
+
+      try {
+        const reportedMember =
+          await interaction.guild!.members.fetch(reportedUserId);
+        await Promise.allSettled([
+          timeout(reportedMember),
+          interaction.reply(
+            `<@${reportedUserId}> timed out by ${interaction.user.username}`,
+          ),
+        ]);
+      } catch (error) {
+        console.error("Error timing out user:", error);
+        await interaction.reply({
+          content: "Failed to timeout user",
+          ephemeral: true,
+        });
+      }
+    },
+  },
+
+  {
+    command: {
+      type: InteractionType.MessageComponent,
+      name: "escalate-escalate",
+    },
+    handler: async (interaction) => {
+      const guildId = interaction.guildId!;
+
+      // Get moderator role for mentions
+      const { moderator: modRoleId } = await fetchSettings(guildId, [
+        SETTINGS.moderator,
+      ]);
+
+      try {
+        const member = await interaction.guild!.members.fetch(
+          interaction.user.id,
+        );
+
+        await Promise.all([
+          interaction.channel && "send" in interaction.channel
+            ? interaction.channel.send(
+                `Report escalated by <@${member.id}>, <@&${modRoleId}> please respond.`,
+              )
+            : Promise.resolve(),
+          interaction.reply({
+            content: `Report escalated successfully`,
+            ephemeral: true,
+          }),
+        ]);
+
+        // Note: The full escalate() function with ModResponse voting would need
+        // more complex refactoring to work without Reacord. For now, this provides
+        // basic escalation notification functionality.
+      } catch (error) {
+        console.error("Error escalating report:", error);
+        await interaction.reply({
+          content: "Failed to escalate report",
+          ephemeral: true,
+        });
+      }
+    },
+  },
+] as Array<MessageComponentCommand>;
diff --git a/app/commands/report.ts b/app/commands/report.ts
index 654a44c..e252170 100644
--- a/app/commands/report.ts
+++ b/app/commands/report.ts
@@ -2,7 +2,7 @@ import type { MessageContextMenuCommandInteraction } from "discord.js";
 import { PermissionFlagsBits, ContextMenuCommandBuilder } from "discord.js";
 import { ApplicationCommandType } from "discord-api-types/v10";
 import { reportUser } from "#~/helpers/modLog";
-import { ReportReasons } from "./track/reportCache";
+import { ReportReasons } from "#~/models/reportedMessages.server";
 import { log, trackPerformance } from "#~/helpers/observability";
 import { commandStats } from "#~/helpers/metrics";
 
diff --git a/app/commands/track.tsx b/app/commands/track.tsx
index f838ce1..05813b9 100644
--- a/app/commands/track.tsx
+++ b/app/commands/track.tsx
@@ -5,7 +5,10 @@ import { Button } from "reacord";
 import { reacord } from "#~/discord/client.server";
 
 import { reportUser } from "#~/helpers/modLog";
-import { ReportReasons } from "#~/commands/track/reportCache";
+import {
+  ReportReasons,
+  markMessageAsDeleted,
+} from "#~/models/reportedMessages.server";
 
 const command = new ContextMenuCommandBuilder()
   .setName("Track")
@@ -35,7 +38,9 @@ const handler = async (interaction: MessageContextMenuCommandInteraction) => {
           const { latestReport, thread } = await reportPromise;
 
           await Promise.allSettled([
-            message.delete(),
+            message
+              .delete()
+              .then(() => markMessageAsDeleted(message.id, message.guild!.id)),
             latestReport?.reply({
               allowedMentions: { users: [] },
               content: `deleted by ${user.username}`,
diff --git a/app/commands/track/reportCache.ts b/app/commands/track/reportCache.ts
deleted file mode 100644
index c8f1c36..0000000
--- a/app/commands/track/reportCache.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-import { simplifyString } from "#~/helpers/string.js";
-import TTLCache from "@isaacs/ttlcache";
-import type { Message, User } from "discord.js";
-
-export interface Report {
-  reason: ReportReasons;
-  message: Message;
-  extra?: string;
-  staff: User | false;
-}
-
-export const enum ReportReasons {
-  anonReport = "anonReport",
-  track = "track",
-  modResolution = "modResolution",
-  spam = "spam",
-}
-
-const HOUR = 60 * 60 * 1000;
-type UserID = string;
-type GuildID = string;
-const cache = new TTLCache<
-  `${UserID}${GuildID}`,
-  Map<
-    string,
-    {
-      logMessage: Message;
-      logs: Report[];
-    }
-  >
->({
-  ttl: 20 * HOUR,
-  max: 1000,
-});
-
-export const queryCacheMetadata = (message: Message) => {
-  const cacheKey = `${message.guildId}${message.author.id}`;
-
-  const user = cache.get(cacheKey);
-  if (!user) {
-    return {
-      uniqueMessages: 0,
-      uniqueChannels: 0,
-      reportCount: 0,
-      allReports: [],
-    };
-  }
-
-  const uniqueMessages = new Set();
-  const uniqueChannels = new Set();
-  let reportCount = 0;
-  user?.forEach((u) => {
-    reportCount += u.logs.length;
-    u.logs.forEach(({ message }) => {
-      uniqueChannels.add(message.channelId);
-      uniqueMessages.add(message.id);
-    });
-  });
-
-  return {
-    uniqueMessages: uniqueMessages.size,
-    uniqueChannels: uniqueChannels.size,
-    reportCount,
-    allReports: [...user.values()].flatMap(({ logs }) => logs),
-  };
-};
-
-export const queryReportCache = (message: Message) => {
-  const cacheKey = `${message.guildId}${message.author.id}`;
-  const simplifiedContent = simplifyString(message.content);
-
-  const cachedWarnings = cache.get(cacheKey);
-  return cachedWarnings?.get(simplifiedContent);
-};
-
-export const trackReport = (logMessage: Message, newReport: Report) => {
-  const cacheKey = `${newReport.message.guildId}${newReport.message.author.id}`;
-  const simplifiedContent = simplifyString(newReport.message.content);
-
-  let cachedWarnings = cache.get(cacheKey);
-  if (!cachedWarnings) {
-    console.log("[trackReport]", "no cached warnings found for guild+author");
-    cachedWarnings = new Map<string, { logMessage: Message; logs: Report[] }>();
-  }
-
-  let existingReports = cachedWarnings.get(simplifiedContent);
-  if (!existingReports) {
-    console.log("[trackReport]", "tracking a new reported message");
-    // This is busted cuz it would need to create a new log thread
-    existingReports = { logMessage, logs: [] };
-  }
-
-  const newLogs = existingReports.logs.concat([newReport]);
-  cachedWarnings.set(simplifiedContent, {
-    logMessage,
-    logs: newLogs,
-  });
-  cache.set(cacheKey, cachedWarnings);
-};
-
-export const deleteAllReported = async (message: Message) => {
-  const allReports = queryReportCache(message);
-  if (!allReports) return;
-
-  await Promise.allSettled(allReports?.logs.map((l) => l.message.delete()));
-};
diff --git a/app/db.d.ts b/app/db.d.ts
index 261c70d..4b448b3 100644
--- a/app/db.d.ts
+++ b/app/db.d.ts
@@ -42,6 +42,22 @@ export interface MessageStats {
   word_count: number;
 }
 
+export interface ReportedMessages {
+  created_at: Generated<string>;
+  deleted_at: string | null;
+  extra: string | null;
+  guild_id: string;
+  id: string;
+  log_channel_id: string;
+  log_message_id: string;
+  reason: string;
+  reported_channel_id: string;
+  reported_message_id: string;
+  reported_user_id: string;
+  staff_id: string | null;
+  staff_username: string | null;
+}
+
 export interface Sessions {
   data: string | null;
   expires: string | null;
@@ -61,12 +77,21 @@ export interface Users {
   id: string;
 }
 
+export interface UserThreads {
+  created_at: Generated<string>;
+  guild_id: string;
+  thread_id: string;
+  user_id: string;
+}
+
 export interface DB {
   channel_info: ChannelInfo;
   guild_subscriptions: GuildSubscriptions;
   guilds: Guilds;
   message_stats: MessageStats;
+  reported_messages: ReportedMessages;
   sessions: Sessions;
   tickets_config: TicketsConfig;
+  user_threads: UserThreads;
   users: Users;
 }
diff --git a/app/discord/activityTracker.ts b/app/discord/activityTracker.ts
index 6d5ff96..5b0cde5 100644
--- a/app/discord/activityTracker.ts
+++ b/app/discord/activityTracker.ts
@@ -144,6 +144,9 @@ export async function startActivityTracking(client: Client) {
   });
 
   client.on(Events.MessageDelete, async (msg) => {
+    if (msg.system || msg.author?.bot) {
+      return;
+    }
     await trackPerformance(
       "processMessageDelete",
       async () => {
diff --git a/app/discord/automod.ts b/app/discord/automod.ts
index a7aabdb..18cc5c1 100644
--- a/app/discord/automod.ts
+++ b/app/discord/automod.ts
@@ -4,7 +4,10 @@ import { isStaff } from "#~/helpers/discord";
 import { reportUser } from "#~/helpers/modLog";
 import { client } from "./client.server";
 import { isSpam } from "#~/helpers/isSpam";
-import { ReportReasons } from "#~/commands/track/reportCache.js";
+import {
+  ReportReasons,
+  markMessageAsDeleted,
+} from "#~/models/reportedMessages.server";
 
 const AUTO_SPAM_THRESHOLD = 3;
 
@@ -27,7 +30,9 @@ export default async (bot: Client) => {
           message: message,
           staff: client.user || false,
         }),
-        message.delete(),
+        message
+          .delete()
+          .then(() => markMessageAsDeleted(message.id, message.guild!.id)),
       ]);
 
       if (warnings >= AUTO_SPAM_THRESHOLD) {
diff --git a/app/helpers/escalate.tsx b/app/helpers/escalate.tsx
index 1aee30d..522c7a3 100644
--- a/app/helpers/escalate.tsx
+++ b/app/helpers/escalate.tsx
@@ -1,7 +1,11 @@
-import { ChannelType, PermissionsBitField } from "discord.js";
+import {
+  ChannelType,
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+} from "discord.js";
 import type { Message, TextChannel, ThreadChannel, User } from "discord.js";
 
-import { reacord } from "#~/discord/client.server";
 import { quoteAndEscape } from "#~/helpers/discord";
 import { reportUser } from "#~/helpers/modLog";
 import { resolutions } from "#~/helpers/modResponse";
@@ -9,101 +13,62 @@ import { resolutions } from "#~/helpers/modResponse";
 import { fetchSettings, SETTINGS } from "#~/models/guilds.server";
 import { applyRestriction, ban, kick, timeout } from "#~/models/discord.server";
 import { ModResponse } from "#~/commands/reacord/ModResponse";
-import {
-  Button,
-  type ComponentEventReplyOptions,
-  type ReacordInstance,
-} from "reacord";
-import {
-  deleteAllReported,
-  ReportReasons,
-} from "#~/commands/track/reportCache.js";
+import { type ComponentEventReplyOptions, type ReacordInstance } from "reacord";
+import { ReportReasons } from "#~/models/reportedMessages.server";
 
 export async function escalationControls(
   reportedMessage: Message,
   thread: ThreadChannel,
-  modRoleId: string,
+  _modRoleId: string,
 ) {
-  reacord.createChannelMessage(thread.id).render(
-    <>
-      Moderator controls
-      <Button
-        label="Delete all reported messages"
-        style="danger"
-        onClick={async (e) => {
-          const { guild } = reportedMessage;
-          const actor = await guild?.members.fetch(e.user.id);
-          if (
-            !actor?.permissions.has(PermissionsBitField.Flags.ManageMessages)
-          ) {
-            return;
-          }
-          await Promise.allSettled([
-            // ...reportedMessages.map((m) => m.delete()),
-            deleteAllReported(reportedMessage),
-            e.reply(`deleted by ${e.user.username}`),
-          ]);
-        }}
-      />
-      <Button
-        onClick={async (e) => {
-          if (!e.guild?.member.roles?.includes(modRoleId)) {
-            return;
-          }
-          console.log(
-            "escalationControls",
-            `${reportedMessage.author.username} kicked by ${e.user.username}`,
-          );
-          await Promise.allSettled([
-            reportedMessage.member?.kick(),
-            e.reply(
-              `<@${reportedMessage.author.id}> (${reportedMessage.author.username}) kicked by ${e.user.username}`,
-            ),
-          ]);
-        }}
-        style="secondary"
-        label="Kick"
-      />
-      <Button
-        onClick={async (e) => {
-          if (!e.guild?.member.roles?.includes(modRoleId)) {
-            return;
-          }
-          console.log(
-            "escalationControls",
-            `${reportedMessage.author.username} banned by ${e.user.username}`,
-          );
-          await Promise.allSettled([
-            reportedMessage.guild?.bans.create(reportedMessage.author),
-            e.reply(
-              `<@${reportedMessage.author.id}> (${reportedMessage.author.username}) banned by ${e.user.username}`,
-            ),
-          ]);
-        }}
-        style="secondary"
-        label="Ban"
-      />
-    </>,
-  );
-  reacord.createChannelMessage(thread.id).render(
-    <>
-      Anyone can escalate, which will notify moderators and call for a vote on
-      how to respond.
-      <Button
-        onClick={async (e) => {
-          const member = await thread.guild.members.fetch(e.user.id);
-          await Promise.all([
-            thread.send(
-              `Report escalated by <@${member.id}>, <@&${modRoleId}> please respond.`,
-            ),
-            escalate(e.reply, member.user, reportedMessage, thread, modRoleId),
-          ]);
-        }}
-        style="primary"
-        label="Escalate"
-      />
-    </>,
-  );
+  const reportedUserId = reportedMessage.author.id;
+
+  await thread.send({
+    content: "Moderator controls",
+    components: [
+      new ActionRowBuilder<ButtonBuilder>().addComponents(
+        new ButtonBuilder()
+          .setCustomId(`escalate-delete|${reportedUserId}`)
+          .setLabel("Delete all reported messages")
+          .setStyle(ButtonStyle.Danger),
+
+        new ButtonBuilder()
+          .setCustomId(`escalate-kick|${reportedUserId}`)
+          .setLabel("Kick")
+          .setStyle(ButtonStyle.Secondary),
+
+        new ButtonBuilder()
+          .setCustomId(`escalate-ban|${reportedUserId}`)
+          .setLabel("Ban")
+          .setStyle(ButtonStyle.Secondary),
+      ),
+
+      new ActionRowBuilder<ButtonBuilder>().addComponents(
+        new ButtonBuilder()
+          .setCustomId(`escalate-restrict|${reportedUserId}`)
+          .setLabel("Restrict")
+          .setStyle(ButtonStyle.Secondary),
+
+        new ButtonBuilder()
+          .setCustomId(`escalate-timeout|${reportedUserId}`)
+          .setLabel("Timeout")
+          .setStyle(ButtonStyle.Secondary),
+      ),
+    ],
+  });
+
+  await thread.send({
+    content:
+      "Anyone can escalate, which will notify moderators and call for a vote on how to respond.",
+    components: [
+      new ActionRowBuilder<ButtonBuilder>().addComponents(
+        new ButtonBuilder()
+          .setCustomId(`escalate-escalate|${reportedUserId}`)
+          .setLabel("Escalate")
+          .setStyle(ButtonStyle.Primary),
+      ),
+    ],
+  });
 }
 
 export async function escalate(
diff --git a/app/helpers/modLog.ts b/app/helpers/modLog.ts
index 7d656fe..0eb9b0a 100644
--- a/app/helpers/modLog.ts
+++ b/app/helpers/modLog.ts
@@ -4,17 +4,21 @@ import type {
   User,
   APIEmbed,
   AnyThreadChannel,
+  TextChannel,
 } from "discord.js";
 import { MessageType, ChannelType } from "discord.js";
-import { format, formatDistanceToNowStrict, differenceInHours } from "date-fns";
+import { formatDistanceToNowStrict } from "date-fns";
 
 import {
-  queryReportCache,
-  queryCacheMetadata,
-  trackReport,
+  deleteReport,
   ReportReasons,
   type Report,
-} from "#~/commands/track/reportCache.js";
+} from "#~/models/reportedMessages.server";
+import {
+  recordReport,
+  getReportsForMessage,
+  getUserReportStats,
+} from "#~/models/reportedMessages.server";
 
 import { fetchSettings, SETTINGS } from "#~/models/guilds.server";
 import {
@@ -26,6 +30,13 @@ import {
 } from "#~/helpers/discord";
 import { truncateMessage } from "#~/helpers/string";
 import { escalationControls } from "#~/helpers/escalate";
+import {
+  getUserThread,
+  createUserThread,
+  updateUserThread,
+} from "#~/models/userThreads.server";
+import { retry } from "./misc";
+import { log } from "./observability";
 
 const ReadableReasons: Record<ReportReasons, string> = {
   [ReportReasons.anonReport]: "Reported anonymously",
@@ -40,12 +51,60 @@ interface Reported {
   latestReport?: Message;
 }
 
-const makeLogThread = (message: Message, user: User) => {
-  return message.startThread({
-    name: `${user.username} – ${format(message.createdAt, "P")}`,
+const makeUserThread = (channel: TextChannel, user: User) => {
+  return channel.threads.create({
+    name: `${user.username} logs`,
   });
 };
 
+const getOrCreateUserThread = async (message: Message, user: User) => {
+  const { guild } = message;
+  if (!guild) throw new Error("Message has no guild");
+
+  // Check if we already have a thread for this user
+  const existingThread = await getUserThread(user.id, guild.id);
+
+  if (existingThread) {
+    try {
+      // Verify the thread still exists and is accessible
+      const thread = await guild.channels.fetch(existingThread.thread_id);
+      if (thread?.isThread()) {
+        return thread;
+      }
+    } catch (error) {
+      log(
+        "warn",
+        "getOrCreateUserThread",
+        "Existing thread not accessible, will create new one",
+        { error },
+      );
+    }
+  }
+
+  // Create new thread and store in database
+  const { modLog: modLogId, moderator } = await fetchSettings(guild.id, [
+    SETTINGS.modLog,
+    SETTINGS.moderator,
+  ]);
+  const modLog = await guild.channels.fetch(modLogId);
+  if (!modLog || modLog.type !== ChannelType.GuildText) {
+    throw new Error("Invalid mod log channel");
+  }
+
+  // Create freestanding private thread
+  const thread = await makeUserThread(modLog, user);
+  await escalationControls(message, thread, moderator);
+
+  // Store or update the thread reference
+  if (existingThread) {
+    await updateUserThread(user.id, guild.id, thread.id);
+  } else {
+    await createUserThread(user.id, guild.id, thread.id);
+  }
+
+  return thread;
+};
+
 // const warningMessages = new ();
 export const reportUser = async ({
   reason,
@@ -55,114 +114,134 @@ export const reportUser = async ({
 }: Omit<Report, "date">): Promise<
   Reported & { allReportedMessages: Report[] }
 > => {
-  const { guild } = message;
-  if (!guild) throw new Error("Tried to report a message without a guild");
-  const cached = queryReportCache(message);
-  const newReport: Report = { message, reason, staff };
+  return await retry(3, async () => {
+    const { guild } = message;
+    if (!guild) throw new Error("Tried to report a message without a guild");
 
-  console.log(
-    "[reportUser]",
-    `${message.author.username}, ${reason}. ${cached ? "cached" : "not cached"}.`,
-  );
+    // Check if this exact message has already been reported
+    const existingReports = await getReportsForMessage(message.id, guild.id);
 
-  const { modLog: modLogId, moderator: modRoleId } = await fetchSettings(
-    guild.id,
-    [SETTINGS.modLog, SETTINGS.moderator],
-  );
+    const { modLog } = await fetchSettings(guild.id, [SETTINGS.modLog]);
+    const alreadyReported = existingReports.find(
+      (r) => r.reported_message_id === message.id,
+    );
 
-  if (cached) {
-    // If we already logged for ~ this message, post to the existing thread
-    const { logMessage: cachedMessage, logs } = cached;
+    log(
+      "info",
+      "reportUser",
+      `${message.author.username}, ${reason}. ${alreadyReported ? "already reported" : "new report"}.`,
+    );
 
-    let thread = cachedMessage.thread;
-    if (!thread || !cachedMessage.hasThread) {
-      thread = await makeLogThread(cachedMessage, message.author);
-      await escalationControls(message, thread, modRoleId);
-    }
+    // Get or create persistent user thread first
+    const thread = await getOrCreateUserThread(message, message.author);
+
+    if (alreadyReported && reason !== ReportReasons.modResolution) {
+      // Message already reported with this reason, just add to thread
+      let priorLogMessage: Message<true>, latestReport: Message<true>;
+      try {
+        priorLogMessage = await thread.messages.fetch(
+          alreadyReported.log_message_id,
+        );
+        latestReport = await priorLogMessage.reply(
+          makeReportMessage({ message, reason, staff }),
+        );
+      } catch (e) {
+        // If the error is because the message doesn't exist, post to the thread
+        log("warn", "reportUser", "message not found, posting to thread", {
+          error: e,
+        });
+        if (e instanceof Error && e.message.includes("Unknown Message")) {
+          latestReport = await thread.send(
+            await constructLog({
+              extra,
+              logs: [{ message, reason, staff }],
+              staff,
+            }),
+          );
+          await deleteReport(alreadyReported.id);
+          await recordReport({
+            reportedMessageId: message.id,
+            reportedChannelId: message.channel.id,
+            reportedUserId: message.author.id,
+            guildId: guild.id,
+            logMessageId: latestReport.id,
+            logChannelId: thread.id,
+            reason,
+          });
+        } else {
+          throw e;
+        }
+      }
+      log("info", "reportUser", "exact message already logged");
 
-    if (cached.logs.some((l) => l.message.id === message.id)) {
-      // If we've already logged exactly this message, don't log it again as a
-      // separate report.
-      const latestReport = // Don't reply in thread if this is a resolved vote
-        reason === ReportReasons.modResolution
-          ? undefined
-          : await thread.send(makeReportMessage(newReport));
-      console.log("[reportUser]", "exact message already logged");
+      const userStats = await getUserReportStats(message.author.id, guild.id);
       return {
-        warnings: logs.length,
-        message: cachedMessage,
+        warnings: userStats.reportCount,
+        message: thread.lastMessage!,
         latestReport,
         thread,
-        allReportedMessages: logs,
+        allReportedMessages: [], // Could fetch if needed
       };
     }
 
-    console.log("[reportUser]", "new message reported");
-    trackReport(cachedMessage, newReport);
-    const { uniqueChannels, uniqueMessages, reportCount } =
-      queryCacheMetadata(message);
-
-    const [latestReport] = await Promise.all([
-      // Don't reply in thread if this is a resolved vote
-      reason === ReportReasons.modResolution
-        ? Promise.resolve(undefined)
-        : thread.send(makeReportMessage(newReport)),
-      cachedMessage.edit(
-        cachedMessage.content
-          .replace(
-            /for \d different messages/,
-            `for ${uniqueMessages} different messages`,
-          )
-          .replace(/in \d channels/, `in ${uniqueChannels} channels`)
-          .replace(/warned \d times/, `warned ${reportCount} times`) || "",
-      ),
-    ]);
-    return {
-      warnings: reportCount,
-      message: cachedMessage,
-      latestReport,
-      thread,
-      allReportedMessages: cached.logs,
-    };
-  }
+    log("info", "reportUser", "new message reported");
 
-  // If this is new, send a new message
-  const modLog = await guild.channels.fetch(modLogId);
-  if (!modLog) {
-    throw new Error("Channel configured for use as mod log not found");
-  }
-  if (modLog.type !== ChannelType.GuildText) {
-    throw new Error(
-      "Invalid channel configured for use as mod log, must be guild text",
+    // Get user stats for constructing the log
+    const previousWarnings = await getUserReportStats(
+      message.author.id,
+      guild.id,
     );
-  }
-  const newLogs: Report[] = [{ message, reason, staff }];
 
-  console.log("[reportUser]", "new message reported");
+    // Send detailed report info to the user thread
+    const logBody = await constructLog({
+      extra,
+      logs: [{ message, reason, staff }],
+      staff,
+    });
 
-  const logBody = await constructLog({
-    extra,
-    logs: newLogs,
-    previousWarnings: queryCacheMetadata(message),
-    staff,
-  });
-  const warningMessage = await modLog.send(logBody);
-  trackReport(warningMessage, newReport);
+    // Send the detailed log message to thread
+    const logMessage = await thread.send(logBody);
+    logMessage.forward(modLog);
 
-  const thread = await makeLogThread(warningMessage, message.author);
-  await escalationControls(message, thread, modRoleId);
+    // Try to record the report in database
+    const recordResult = await recordReport({
+      reportedMessageId: message.id,
+      reportedChannelId: message.channel.id,
+      reportedUserId: message.author.id,
+      guildId: guild.id,
+      logMessageId: logMessage.id,
+      logChannelId: thread.id,
+      reason,
+      staffId: staff ? staff.id : undefined,
+      staffUsername: staff ? staff.username : undefined,
+      extra,
+    });
 
-  const firstReportMessage = makeReportMessage(newReport);
+    // If the record was not inserted due to unique constraint (duplicate),
+    // this means another process already reported the same message while we were preparing the log.
+    // In this case, we'll keep the detailed log we already sent (since it's already there)
+    // but add a short duplicate message and return updated stats
+    if (!recordResult.wasInserted) {
+      log(
+        "warn",
+        "reportUser",
+        "duplicate detected at database level after sending detailed log",
+      );
+      throw new Error("Race condition detected in reportUser, retrying…");
+    }
 
-  const latestReport = await thread.send(firstReportMessage);
+    // For new reports, the detailed log already includes the reason info,
+    // so we don't need a separate short message
+    const latestReport = undefined;
 
-  return {
-    warnings: 1,
-    message: warningMessage,
-    latestReport,
-    thread,
-    allReportedMessages: newLogs,
-  };
+    return {
+      warnings: previousWarnings.reportCount + 1,
+      message: logMessage,
+      latestReport,
+      thread,
+      allReportedMessages: [], // Could fetch from database if needed
+    };
+  });
 };
 
 const makeReportMessage = ({ message, reason, staff }: Report) => {
@@ -171,20 +250,16 @@ const makeReportMessage = ({ message, reason, staff }: Report) => {
   );
 
   return {
-    content: `- ${constructDiscordLink(message)} ${
-      staff ? ` ${staff.username} ` : ""
-    }${ReadableReasons[reason]}`,
+    content: `${staff ? ` ${staff.username} ` : ""}${ReadableReasons[reason]}`,
     embeds: embeds.length === 0 ? undefined : embeds,
   };
 };
 
 const constructLog = async ({
   logs,
-  previousWarnings,
   extra: origExtra = "",
 }: Pick<Report, "extra" | "staff"> & {
   logs: Report[];
-  previousWarnings: NonNullable<ReturnType<typeof queryCacheMetadata>>;
 }): Promise<MessageCreateOptions> => {
   const lastReport = logs.at(-1);
   if (!lastReport || !lastReport.message.guild) {
@@ -210,31 +285,26 @@ const constructLog = async ({
 
   const preface = `<@${lastReport.message.author.id}> (${
     lastReport.message.author.username
-  }) warned ${previousWarnings.reportCount + 1} times recently for ${previousWarnings.uniqueMessages + 1} different messages, posted in ${
-    previousWarnings.uniqueChannels + 1
-  } channels ${formatDistanceToNowStrict(lastReport.message.createdAt)} before this log (<t:${Math.floor(lastReport.message.createdTimestamp / 1000)}:R>)`;
+  }) posted ${formatDistanceToNowStrict(lastReport.message.createdAt)} before this log (<t:${Math.floor(lastReport.message.createdTimestamp / 1000)}:R>)`;
   const extra = origExtra ? `${origExtra}\n` : "";
 
   // If it has the data for a poll, use a specialized formatting function
   const reportedMessage = message.poll
     ? quoteAndEscapePoll(message.poll)
     : quoteAndEscape(message.content).trim();
-  const warnings = previousWarnings.allReports.map(
-    ({ message: logMessage }) => {
-      return `[${format(logMessage.createdAt, differenceInHours(logMessage.createdAt, new Date()) > 24 ? "PP kk:mmX" : "kk:mmX")}](${constructDiscordLink(
-        logMessage,
-      )}) (<t:${Math.floor(logMessage.createdAt.getTime() / 1000)}:R>)`;
-    },
-  );
 
-  const embeds = [describeAttachments(message.attachments)].filter(
-    (e): e is APIEmbed => Boolean(e),
-  );
+  const { content: report, embeds: reactions = [] } =
+    makeReportMessage(lastReport);
 
+  const embeds = [
+    describeAttachments(message.attachments),
+    ...reactions,
+  ].filter((e): e is APIEmbed => Boolean(e));
   return {
     content: truncateMessage(`${preface}
 ${extra}${reportedMessage}
-${warnings.join("\n")}`).trim(),
+${report}
+- ${constructDiscordLink(message)}`).trim(),
     embeds: embeds.length === 0 ? undefined : embeds,
     allowedMentions: { roles: [moderator] },
   };
diff --git a/app/models/reportedMessages.server.ts b/app/models/reportedMessages.server.ts
new file mode 100644
index 0000000..84de843
--- /dev/null
+++ b/app/models/reportedMessages.server.ts
@@ -0,0 +1,330 @@
+import type { Message, User } from "discord.js";
+
+import type { DB } from "#~/db.server";
+import db from "#~/db.server";
+import { log, trackPerformance } from "#~/helpers/observability";
+import { client } from "#~/discord/client.server";
+
+export type ReportedMessage = DB["reported_messages"];
+
+export interface Report {
+  reason: ReportReasons;
+  message: Message;
+  extra?: string;
+  staff: User | false;
+}
+
+export const enum ReportReasons {
+  anonReport = "anonReport",
+  track = "track",
+  modResolution = "modResolution",
+  spam = "spam",
+}
+
+export async function recordReport(data: {
+  reportedMessageId: string;
+  reportedChannelId: string;
+  reportedUserId: string;
+  guildId: string;
+  logMessageId: string;
+  logChannelId: string;
+  reason: ReportReasons;
+  staffId?: string;
+  staffUsername?: string;
+  extra?: string;
+}): Promise<{ wasInserted: boolean }> {
+  return trackPerformance(
+    "recordReport",
+    async () => {
+      log("info", "ReportedMessage", "Recording report", {
+        reportedUserId: data.reportedUserId,
+        guildId: data.guildId,
+        reason: data.reason,
+      });
+
+      try {
+        await db
+          .insertInto("reported_messages")
+          .values({
+            id: crypto.randomUUID(),
+            reported_message_id: data.reportedMessageId,
+            reported_channel_id: data.reportedChannelId,
+            reported_user_id: data.reportedUserId,
+            guild_id: data.guildId,
+            log_message_id: data.logMessageId,
+            log_channel_id: data.logChannelId,
+            reason: data.reason,
+            staff_id: data.staffId,
+            staff_username: data.staffUsername,
+            extra: data.extra,
+          })
+          .execute();
+
+        log("info", "ReportedMessage", "Report recorded", {
+          reportedUserId: data.reportedUserId,
+          guildId: data.guildId,
+        });
+
+        return { wasInserted: true };
+      } catch (error) {
+        // Check if this is a unique constraint violation
+        if (
+          error instanceof Error &&
+          error.message.includes("UNIQUE constraint failed")
+        ) {
+          log(
+            "debug",
+            "ReportedMessage",
+            "Report already exists (unique constraint)",
+            {
+              reportedUserId: data.reportedUserId,
+              guildId: data.guildId,
+              reason: data.reason,
+            },
+          );
+          return { wasInserted: false };
+        }
+
+        // Re-throw other errors
+        throw error;
+      }
+    },
+    { reportedUserId: data.reportedUserId, guildId: data.guildId },
+  );
+}
+
+export async function getReportsForUser(userId: string, guildId: string) {
+  return trackPerformance(
+    "getReportsForUser",
+    async () => {
+      const reports = await db
+        .selectFrom("reported_messages")
+        .selectAll()
+        .where("reported_user_id", "=", userId)
+        .where("guild_id", "=", guildId)
+        .execute();
+
+      return reports;
+    },
+    { userId, guildId },
+  );
+}
+
+export async function getReportsForMessage(
+  messageId: string,
+  guildId: string,
+  includeDeleted: boolean = false,
+) {
+  return trackPerformance(
+    "getReportsForMessage",
+    async () => {
+      let query = db
+        .selectFrom("reported_messages")
+        .selectAll()
+        .where("reported_message_id", "=", messageId)
+        .where("guild_id", "=", guildId);
+
+      if (!includeDeleted) {
+        query = query.where("deleted_at", "is", null);
+      }
+
+      const reports = await query.orderBy("created_at", "desc").execute();
+
+      log("debug", "ReportedMessage", `Found ${reports.length} reports`, {
+        messageId,
+        guildId,
+        includeDeleted,
+      });
+      return reports;
+    },
+    { messageId, guildId },
+  );
+}
+
+export async function getUserReportStats(userId: string, guildId: string) {
+  return trackPerformance(
+    "getUserReportStats",
+    async () => {
+      const [totalReports, uniqueMessages, uniqueChannels] = await Promise.all([
+        db
+          .selectFrom("reported_messages")
+          .select(db.fn.count("id").as("count"))
+          .where("reported_user_id", "=", userId)
+          .where("guild_id", "=", guildId)
+          .where("deleted_at", "is", null) // Only count non-deleted messages
+          .executeTakeFirstOrThrow(),
+
+        db
+          .selectFrom("reported_messages")
+          .select(({ fn }) =>
+            fn.count("reported_message_id").distinct().as("count"),
+          )
+          .where("reported_user_id", "=", userId)
+          .where("guild_id", "=", guildId)
+          .where("deleted_at", "is", null) // Only count non-deleted messages
+          .executeTakeFirstOrThrow(),
+
+        db
+          .selectFrom("reported_messages")
+          .select(({ fn }) =>
+            fn.count("reported_channel_id").distinct().as("count"),
+          )
+          .where("reported_user_id", "=", userId)
+          .where("guild_id", "=", guildId)
+          .where("deleted_at", "is", null) // Only count non-deleted messages
+          .executeTakeFirstOrThrow(),
+      ]);
+
+      const stats = {
+        reportCount: Number(totalReports.count),
+        uniqueMessages: Number(uniqueMessages.count),
+        uniqueChannels: Number(uniqueChannels.count),
+        allReports: [], // Legacy compatibility - could fetch if needed
+      };
+
+      return stats;
+    },
+    { userId, guildId },
+  );
+}
+
+/**
+ * Gets unique message IDs for a user that haven't been deleted yet
+ */
+async function getUniqueNonDeletedMessages(userId: string, guildId: string) {
+  return db
+    .selectFrom("reported_messages")
+    .select(["reported_message_id", "reported_channel_id"])
+    .distinct()
+    .where("reported_user_id", "=", userId)
+    .where("guild_id", "=", guildId)
+    .where("deleted_at", "is", null)
+    .execute();
+}
+
+/**
+ * Deletes a single Discord message and marks it as deleted in database
+ */
+async function deleteSingleMessage(
+  messageId: string,
+  channelId: string,
+  guildId: string,
+) {
+  try {
+    const channel = await client.channels.fetch(channelId);
+    if (!channel || !("messages" in channel)) {
+      throw new Error("Channel not found or not a text channel");
+    }
+
+    const message = await channel.messages.fetch(messageId);
+    await message.delete();
+    await markMessageAsDeleted(messageId, guildId);
+
+    log("debug", "ReportedMessage", "Deleted message", { messageId });
+    return { success: true, messageId };
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Unknown Message")) {
+      await markMessageAsDeleted(messageId, guildId);
+      return { success: true, messageId };
+    }
+
+    log("warn", "ReportedMessage", "Failed to delete message", {
+      messageId,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return { success: false, messageId, error };
+  }
+}
+
+export async function deleteAllReportedForUser(
+  userId: string,
+  guildId: string,
+) {
+  return trackPerformance(
+    "deleteAllReportedForUser",
+    async () => {
+      // Get unique messages that haven't been deleted yet (using SQL DISTINCT)
+      const uniqueMessages = await getUniqueNonDeletedMessages(userId, guildId);
+
+      if (uniqueMessages.length === 0) {
+        log("info", "ReportedMessage", "No messages to delete", {
+          userId,
+          guildId,
+        });
+        return { total: 0, deleted: 0 };
+      }
+
+      // Delete messages sequentially to avoid rate limits and race conditions
+      let deleted = 0;
+      const errors: Array<{ messageId: string; error: unknown }> = [];
+
+      for (const {
+        reported_message_id,
+        reported_channel_id,
+      } of uniqueMessages) {
+        const result = await deleteSingleMessage(
+          reported_message_id,
+          reported_channel_id,
+          guildId,
+        );
+
+        if (result.success) {
+          deleted++;
+        } else {
+          errors.push({ messageId: reported_message_id, error: result.error });
+        }
+      }
+
+      log("info", "ReportedMessage", "Deletion complete", {
+        userId,
+        guildId,
+        total: uniqueMessages.length,
+        deleted,
+        failed: errors.length,
+      });
+
+      return { total: uniqueMessages.length, deleted };
+    },
+    { userId, guildId },
+  );
+}
+
+/**
+ * Deletes a report from the database. Should only be used if the corresponding log message accompanying the report has been deleted.
+ *
+ * @param reportId - The ID of the report to delete.
+ * @returns A promise that resolves when the report is deleted.
+ */
+export async function deleteReport(reportId: string) {
+  return trackPerformance(
+    "deleteReport",
+    async () => {
+      await db
+        .deleteFrom("reported_messages")
+        .where("id", "=", reportId)
+        .execute();
+    },
+    { reportId },
+  );
+}
+
+/**
+ * Marks a specific reported message as deleted
+ */
+export async function markMessageAsDeleted(messageId: string, guildId: string) {
+  return trackPerformance(
+    "markMessageAsDeleted",
+    async () => {
+      const result = await db
+        .updateTable("reported_messages")
+        .set("deleted_at", new Date().toISOString())
+        .where("reported_message_id", "=", messageId)
+        .where("guild_id", "=", guildId)
+        .where("deleted_at", "is", null) // Only update if not already marked as deleted
+        .execute();
+
+      return { updatedCount: result.length };
+    },
+    { messageId, guildId },
+  );
+}
diff --git a/app/models/userThreads.server.ts b/app/models/userThreads.server.ts
new file mode 100644
index 0000000..5782470
--- /dev/null
+++ b/app/models/userThreads.server.ts
@@ -0,0 +1,66 @@
+import type { DB } from "#~/db.server";
+import db from "#~/db.server";
+import { log, trackPerformance } from "#~/helpers/observability";
+
+export type UserThread = DB["user_threads"];
+
+export async function getUserThread(userId: string, guildId: string) {
+  return trackPerformance(
+    "getUserThread",
+    async () => {
+      const thread = await db
+        .selectFrom("user_threads")
+        .selectAll()
+        .where("user_id", "=", userId)
+        .where("guild_id", "=", guildId)
+        .executeTakeFirst();
+
+      log(
+        "debug",
+        "UserThread",
+        thread ? "Found user thread" : "No user thread found",
+        { userId, guildId, threadId: thread?.thread_id },
+      );
+      return thread;
+    },
+    { userId, guildId },
+  );
+}
+
+export async function createUserThread(
+  userId: string,
+  guildId: string,
+  threadId: string,
+): Promise<void> {
+  await trackPerformance(
+    "createUserThread",
+    () =>
+      db
+        .insertInto("user_threads")
+        .values({
+          user_id: userId,
+          guild_id: guildId,
+          thread_id: threadId,
+        })
+        .execute(),
+    { userId, guildId, threadId },
+  );
+}
+
+export async function updateUserThread(
+  userId: string,
+  guildId: string,
+  threadId: string,
+): Promise<void> {
+  await trackPerformance(
+    "updateUserThread",
+    () =>
+      db
+        .updateTable("user_threads")
+        .set({ thread_id: threadId })
+        .where("user_id", "=", userId)
+        .where("guild_id", "=", guildId)
+        .execute(),
+    { userId, guildId, threadId },
+  );
+}
diff --git a/app/server.ts b/app/server.ts
index 55332c1..c84807f 100644
--- a/app/server.ts
+++ b/app/server.ts
@@ -15,6 +15,7 @@ import { Command as setup } from "#~/commands/setup";
 import { Command as report } from "#~/commands/report";
 import { Command as track } from "#~/commands/track";
 import { Command as setupTicket } from "#~/commands/setupTickets";
+import { EscalationCommands } from "#~/commands/escalationControls";
 
 export const app = express();
 
@@ -63,3 +64,4 @@ registerCommand(report);
 registerCommand(forceBan);
 registerCommand(track);
 registerCommand(setupTicket);
+registerCommand(EscalationCommands);
diff --git a/eslint.config.js b/eslint.config.js
index 9de0334..6a1bded 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -23,6 +23,7 @@ export default [
       "node_modules",
       "public",
       ".react-router",
+      "vite.config.ts.timestamp*",
     ],
   },
   {
diff --git a/migrations/20250725192908_user_threads.ts b/migrations/20250725192908_user_threads.ts
new file mode 100644
index 0000000..abbaf5f
--- /dev/null
+++ b/migrations/20250725192908_user_threads.ts
@@ -0,0 +1,24 @@
+import type { Kysely } from "kysely";
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable("user_threads")
+    .addColumn("user_id", "text", (c) => c.notNull())
+    .addColumn("guild_id", "text", (c) => c.notNull())
+    .addColumn("thread_id", "text", (c) => c.notNull())
+    .addColumn("created_at", "datetime", (c) =>
+      c.defaultTo("CURRENT_TIMESTAMP").notNull(),
+    )
+    .execute();
+
+  await db.schema
+    .createIndex("user_threads_pk")
+    .on("user_threads")
+    .columns(["user_id", "guild_id"])
+    .unique()
+    .execute();
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await db.schema.dropTable("user_threads").execute();
+}
diff --git a/migrations/20250726155346_reported_messages.ts b/migrations/20250726155346_reported_messages.ts
new file mode 100644
index 0000000..06ee088
--- /dev/null
+++ b/migrations/20250726155346_reported_messages.ts
@@ -0,0 +1,37 @@
+import type { Kysely } from "kysely";
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable("reported_messages")
+    .addColumn("id", "uuid", (c) => c.primaryKey().notNull())
+    .addColumn("reported_message_id", "text", (c) => c.notNull())
+    .addColumn("reported_channel_id", "text", (c) => c.notNull())
+    .addColumn("reported_user_id", "text", (c) => c.notNull())
+    .addColumn("guild_id", "text", (c) => c.notNull())
+    .addColumn("log_message_id", "text", (c) => c.notNull())
+    .addColumn("log_channel_id", "text", (c) => c.notNull())
+    .addColumn("reason", "text", (c) => c.notNull())
+    .addColumn("staff_id", "text")
+    .addColumn("staff_username", "text")
+    .addColumn("extra", "text")
+    .addColumn("created_at", "datetime", (c) =>
+      c.defaultTo("CURRENT_TIMESTAMP").notNull(),
+    )
+    .execute();
+
+  await db.schema
+    .createIndex("idx_reported_user_guild")
+    .on("reported_messages")
+    .columns(["reported_user_id", "guild_id"])
+    .execute();
+
+  await db.schema
+    .createIndex("idx_reported_message")
+    .on("reported_messages")
+    .columns(["reported_message_id"])
+    .execute();
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await db.schema.dropTable("reported_messages").execute();
+}
diff --git a/migrations/20250726201405_add_unique_constraint_reported_messages.ts b/migrations/20250726201405_add_unique_constraint_reported_messages.ts
new file mode 100644
index 0000000..e4a25fe
--- /dev/null
+++ b/migrations/20250726201405_add_unique_constraint_reported_messages.ts
@@ -0,0 +1,16 @@
+import type { Kysely } from "kysely";
+
+export async function up(db: Kysely<any>): Promise<void> {
+  // Add unique constraint to prevent duplicate reports for the same message/reason/guild
+  await db.schema
+    .createIndex("idx_unique_message_reason_guild")
+    .on("reported_messages")
+    .columns(["reported_message_id", "reason", "guild_id"])
+    .unique()
+    .execute();
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  // Remove the unique constraint
+  await db.schema.dropIndex("idx_unique_message_reason_guild").execute();
+}
diff --git a/migrations/20250726215517_add_deleted_at_to_reported_messages.ts b/migrations/20250726215517_add_deleted_at_to_reported_messages.ts
new file mode 100644
index 0000000..9bdaa3e
--- /dev/null
+++ b/migrations/20250726215517_add_deleted_at_to_reported_messages.ts
@@ -0,0 +1,17 @@
+import type { Kysely } from "kysely";
+
+export async function up(db: Kysely<any>): Promise<void> {
+  // Add deleted_at column to track when messages were deleted
+  await db.schema
+    .alterTable("reported_messages")
+    .addColumn("deleted_at", "datetime")
+    .execute();
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  // Remove the deleted_at column
+  await db.schema
+    .alterTable("reported_messages")
+    .dropColumn("deleted_at")
+    .execute();
+}
diff --git a/notes/2025-07-04_1.md b/notes/2025-07-04_1.md
index 0b3d178..f529fa3 100644
--- a/notes/2025-07-04_1.md
+++ b/notes/2025-07-04_1.md
@@ -1,9 +1,11 @@
 # Observability Integration Plan - July 4, 2025
 
 ## Project Overview
+
 Systematic integration of observability practices across all major features of the Discord bot application, following the established pattern from the subscription service.
 
 ## Current State
+
 - ✅ Observability helpers in `app/helpers/observability.ts`
 - ✅ Business analytics in `app/helpers/metrics.ts` (Amplitude)
 - ✅ Subscription service fully instrumented as reference
@@ -11,6 +13,7 @@ Systematic integration of observability practices across all major features of t
 - ✅ Sentry integration for error tracking
 
 ## Three-Layer Architecture
+
 1. **Operational Observability** - System health, performance, debugging
 2. **Business Analytics** - User behavior, product insights via Amplitude
 3. **Infrastructure Monitoring** - Error tracking, stability via Sentry
@@ -18,30 +21,39 @@ Systematic integration of observability practices across all major features of t
 ## Implementation Phases
 
 ### Phase 1: Critical Business Logic (High Priority)
+
 - Discord Bot Gateway & Event Handling
-- Message Activity Tracking System  
+- Message Activity Tracking System
 - Discord Commands System
 
 ### Phase 2: User Experience (Medium Priority)
+
 - User Management & Authentication
 - Analytics & Dashboard
 - Guild/Server Management
 
 ### Phase 3: Advanced Features (Lower Priority)
+
 - Moderation & Automoderation
 - Database Operations
 
 ## Key Patterns to Follow
+
 ```typescript
 // Dual-track approach: operational + business analytics
-await trackPerformance("operationName", async () => {
-  log("info", "ServiceName", "Operation description", context);
-  // ... business logic
-  // Business analytics tracking
-}, { contextData });
+await trackPerformance(
+  "operationName",
+  async () => {
+    log("info", "ServiceName", "Operation description", context);
+    // ... business logic
+    // Business analytics tracking
+  },
+  { contextData },
+);
 ```
 
 ## Success Metrics
+
 - Comprehensive logging across all major features
 - Performance tracking on critical paths
 - Business analytics for user behavior
@@ -51,18 +63,21 @@ await trackPerformance("operationName", async () => {
 ## Implementation Progress
 
 ### ✅ Phase 1 Completed: Critical Business Logic
+
 - **Discord Bot Gateway & Event Handling**: Added comprehensive logging for bot lifecycle, connection events, error handling, and business analytics
 - **Message Activity Tracking System**: Enhanced all message processing operations with performance tracking and detailed logging
 - **Discord Commands System**: Added observability to setup, report, and force-ban commands with success/failure tracking
 
-### 🚧 Phase 2 In Progress: User Experience 
+### 🚧 Phase 2 In Progress: User Experience
+
 - **User Management & Authentication**: Enhanced user model operations with performance tracking and structured logging
 - **Analytics & Dashboard**: Pending
 - **Guild/Server Management**: Pending
 
 ### 📝 Key Patterns Established
+
 - Dual-track observability: operational + business analytics
 - Performance tracking with `trackPerformance()` wrapper
 - Structured logging with consistent context
 - Business analytics events via Amplitude
-- Error tracking with full context
\ No newline at end of file
+- Error tracking with full context
diff --git a/notes/2025-07-04_1_authorization-architecture-analysis.md b/notes/2025-07-04_1_authorization-architecture-analysis.md
index da815ea..b5946ab 100644
--- a/notes/2025-07-04_1_authorization-architecture-analysis.md
+++ b/notes/2025-07-04_1_authorization-architecture-analysis.md
@@ -3,27 +3,30 @@
 ## Current Authentication System
 
 ### Session Management
+
 - **Dual Session Architecture**: Uses both cookie-based and database-based sessions
   - Cookie session: Stores minimal data directly in encrypted cookie
   - Database session: Stores sensitive data (Discord tokens) in database with session ID
-- **Session Models**: 
+- **Session Models**:
   - `CookieSession`: Lightweight, stores basic info
   - `DbSession`: Secure storage for Discord tokens and OAuth state
 - **Security**: Discord tokens never stored in cookies, only in database
 
 ### OAuth Flow
+
 - **Discord OAuth Integration**: Complete OAuth2 flow with multiple modes
   - User flow: Standard user authentication
   - Bot flow: Bot installation with permissions
   - Signup flow: New user registration
 - **State Management**: Uses UUID-based state parameter for CSRF protection
-- **Scopes**: 
+- **Scopes**:
   - User: `identify email guilds guilds.members.read`
   - Bot: `identify email guilds guilds.members.read bot applications.commands`
 
 ### Current Authorization Patterns
 
 #### User Authentication
+
 - **User Model**: Basic user entity with Discord external ID
 - **Session Functions**:
   - `getUser()`: Get current user from session
@@ -31,17 +34,19 @@
   - `requireUserId()`: Get user ID with authentication check
 
 #### Guild-Based Authorization
+
 - **Guild Permissions**: Discord permission-based authorization
 - **Permission Mapping**:
   - `MOD`: ModerateMembers permission
-  - `ADMIN`: Administrator permission  
+  - `ADMIN`: Administrator permission
   - `MANAGER`: ManageChannels, ManageGuild, or ManageRoles permissions
   - `MANAGE_CHANNELS`: ManageChannels permission
   - `MANAGE_GUILD`: ManageGuild permission
   - `MANAGE_ROLES`: ManageRoles permission
 
 #### Guild Access Control
-- **Guild Filtering**: 
+
+- **Guild Filtering**:
   - Users can only access guilds where they have `MANAGER` level permissions
   - Bot must be installed in guild for management access
 - **Authorization Array**: Each guild has `authz` array with user's permissions
@@ -50,6 +55,7 @@
 ### Database Schema
 
 #### Users Table
+
 ```sql
 - id: UUID (primary key)
 - email: text
@@ -58,6 +64,7 @@
 ```
 
 #### Sessions Table
+
 ```sql
 - id: UUID (primary key)
 - data: JSON (session data)
@@ -65,12 +72,14 @@
 ```
 
 #### Guilds Table
+
 ```sql
 - id: string (Discord guild ID)
 - settings: JSON (guild configuration)
 ```
 
 #### Guild Subscriptions Table
+
 ```sql
 - guild_id: string (primary key)
 - stripe_customer_id: text
@@ -85,16 +94,19 @@
 ### Current Access Control Mechanisms
 
 #### Route-Level Protection
+
 - **Auth Layout**: `__auth.tsx` enforces authentication for protected routes
 - **User Requirement**: Routes under auth layout require valid user session
 - **Guild Context**: Guild-specific routes include guild ID in URL parameters
 
 #### Permission Checking
+
 - **Discord Permissions**: Leverages Discord's native permission system
 - **Guild Membership**: Validates user membership and permissions in target guild
 - **Bot Presence**: Requires bot installation for management features
 
 #### Subscription-Based Access
+
 - **Product Tiers**: Free vs. Paid tiers
 - **Feature Gating**: `SubscriptionService.hasFeature()` (currently returns false)
 - **Subscription Status**: Active/inactive subscription management
@@ -102,26 +114,31 @@
 ### Current Gaps and Limitations
 
 #### Missing Role-Based Access Control
+
 - No internal role system beyond Discord permissions
 - No fine-grained feature permissions
 - No user role management interface
 
 #### Limited Authorization Middleware
+
 - No declarative permission decorators
 - No middleware for route-level permission checks
 - Manual permission validation in loaders
 
 #### No Audit Trail
+
 - No logging of permission changes
 - No access attempt tracking
 - Limited observability for authorization decisions
 
 #### Feature Flag System
+
 - Subscription service exists but feature checking is stubbed
 - No granular feature control
 - No A/B testing or gradual rollouts
 
 #### Guild-Level Permissions
+
 - Guild settings stored as JSON blob
 - No structured permission model for guild features
 - No delegation of permissions to non-admin users
@@ -134,15 +151,17 @@
 4. **Feature Access**: Check subscription tier → Validate feature access (stubbed)
 
 ### Strengths
+
 - Secure Discord integration with proper token handling
 - Caching layer for performance
 - Subscription management foundation
 - Clean separation of cookie vs. database sessions
 
 ### Areas for Extension
+
 - Role-based access control system
 - Permission middleware and decorators
 - Feature flag implementation
 - Audit logging
 - Guild-level permission delegation
-- Fine-grained resource access control
\ No newline at end of file
+- Fine-grained resource access control
diff --git a/notes/2025-07-04_2_major-features-observability-analysis.md b/notes/2025-07-04_2_major-features-observability-analysis.md
index 6892eae..3197bed 100644
--- a/notes/2025-07-04_2_major-features-observability-analysis.md
+++ b/notes/2025-07-04_2_major-features-observability-analysis.md
@@ -1,35 +1,43 @@
 # Major Features Analysis for Observability Integration
 
 ## Overview
+
 This document identifies the major functional areas of the Discord bot application that would benefit from observability integration, providing detailed analysis of each feature with file locations and integration opportunities.
 
 ## Core Application Architecture
 
 ### 1. **Discord Bot Gateway & Event Handling**
+
 **Primary Files:**
+
 - `/app/discord/gateway.ts` - Main Discord bot initialization
 - `/app/discord/client.server.ts` - Discord client setup
 - `/app/server.ts` - Express server with Discord webhooks
 
 **Key Features:**
+
 - Discord bot lifecycle management
 - Event handling for messages, reactions, threads
 - WebSocket connection management
 - Webhook signature verification
 
 **Observability Opportunities:**
+
 - Bot uptime and connection health
 - Event processing rates and latency
 - WebSocket connection stability
 - Webhook validation success/failure rates
 
 ### 2. **Message Activity Tracking System**
+
 **Primary Files:**
+
 - `/app/discord/activityTracker.ts` - Real-time message processing
 - `/app/models/activity.server.ts` - Analytics queries and reports
 - `/app/helpers/messageParsing.ts` - Message content analysis
 
 **Key Features:**
+
 - Real-time message statistics collection
 - Code block detection and analysis
 - Link extraction and tracking
@@ -38,6 +46,7 @@ This document identifies the major functional areas of the Discord bot applicati
 - User participation metrics
 
 **Observability Opportunities:**
+
 - Message processing throughput
 - Channel activity patterns
 - User engagement trends
@@ -45,63 +54,77 @@ This document identifies the major functional areas of the Discord bot applicati
 - Message parsing performance
 
 ### 3. **User Management & Authentication**
+
 **Primary Files:**
+
 - `/app/models/user.server.ts` - User CRUD operations
 - `/app/models/session.server.ts` - Session management
 - `/app/routes/discord-oauth.tsx` - OAuth flow
 - `/app/routes/auth.tsx` - Authentication routes
 
 **Key Features:**
+
 - Discord OAuth integration
 - User registration and login
 - Session management
 - User profile management
 
 **Observability Opportunities:**
+
 - Login success/failure rates
 - Session duration patterns
 - OAuth conversion rates
 - User retention metrics
 
 ### 4. **Guild/Server Management**
+
 **Primary Files:**
+
 - `/app/models/guilds.server.ts` - Guild configuration
 - `/app/discord/onboardGuild.ts` - Guild onboarding
 - `/app/commands/setup.ts` - Initial guild setup
 
 **Key Features:**
+
 - Guild registration and configuration
 - Settings management (JSON-based)
 - Moderator role assignment
 - Channel configuration
 
 **Observability Opportunities:**
+
 - Guild onboarding completion rates
 - Configuration change frequency
 - Active guild counts
 - Setup command success rates
 
 ### 5. **Subscription & Payment System**
+
 **Primary Files:**
+
 - `/app/models/subscriptions.server.ts` - Subscription management (already has observability!)
 - `/app/models/stripe.server.ts` - Payment processing (stub)
 - `/app/routes/upgrade.tsx` - Upgrade interface
 - `/app/routes/payment.success.tsx` - Payment confirmation
 
 **Key Features:**
+
 - Free/paid tier management
 - Subscription lifecycle tracking
 - Payment processing integration
 - Feature access control
 
 **Observability Opportunities:**
+
 - Subscription conversion rates
 - Payment success/failure rates
 - Churn analysis
 - Feature usage by tier
 
 ### 6. **Discord Commands System**
+
 **Primary Files:**
+
 - `/app/commands/setup.ts` - Guild configuration
 - `/app/commands/report.ts` - Message reporting
 - `/app/commands/track.tsx` - Activity tracking
@@ -109,25 +132,30 @@ This document identifies the major functional areas of the Discord bot applicati
 - `/app/commands/setupTickets.ts` - Support tickets
 
 **Key Features:**
+
 - Slash command handling
 - Context menu commands
 - Permission-based access
 - Command registration and deployment
 
 **Observability Opportunities:**
+
 - Command usage frequencies
 - Command execution success rates
 - User interaction patterns
 - Permission validation metrics
 
 ### 7. **Moderation & Automoderation**
+
 **Primary Files:**
+
 - `/app/discord/automod.ts` - Automated moderation
 - `/app/helpers/modLog.ts` - Moderation logging
 - `/app/helpers/isSpam.ts` - Spam detection
 - `/app/helpers/escalate.tsx` - Escalation handling
 
 **Key Features:**
+
 - Automated spam detection
 - User reporting system
 - Moderation action logging
@@ -135,18 +163,22 @@ This document identifies the major functional areas of the Discord bot applicati
 - Staff role verification
 
 **Observability Opportunities:**
+
 - Spam detection accuracy
 - Moderation action frequencies
 - False positive rates
 - Response time metrics
 
 ### 8. **Analytics & Dashboard**
+
 **Primary Files:**
+
 - `/app/routes/__auth/dashboard.tsx` - Main analytics dashboard
 - `/app/routes/__auth/sh-user.tsx` - User-specific analytics
 - `/app/models/activity.server.ts` - Complex query builders
 
 **Key Features:**
+
 - Top participant analysis
 - Message statistics breakdowns
 - User engagement scoring
@@ -154,42 +186,51 @@ This document identifies the major functional areas of the Discord bot applicati
 - CSV export functionality
 
 **Observability Opportunities:**
+
 - Dashboard load times
 - Query performance metrics
 - Export usage patterns
 - User engagement with analytics
 
 ### 9. **Database Operations**
+
 **Primary Files:**
+
 - `/app/db.server.ts` - Database connection
 - `/app/db.d.ts` - Database schema types
 - `/migrations/` - Database migrations
 
 **Key Features:**
+
 - SQLite database with Kysely ORM
 - Complex analytical queries
 - Message statistics storage
 - User and guild data management
 
 **Observability Opportunities:**
+
 - Database query performance
 - Connection pool health
 - Migration success rates
 - Storage usage patterns
 
 ### 10. **API Routes & Web Interface**
+
 **Primary Files:**
+
 - `/app/routes/` - Various route handlers
 - `/app/routes/__auth.tsx` - Authentication layout
 - `/app/routes/healthcheck.tsx` - Health monitoring
 
 **Key Features:**
+
 - Protected route handling
 - Health check endpoints
 - Form submission processing
 - Redirect management
 
 **Observability Opportunities:**
+
 - Route response times
 - Error rates by endpoint
 - Form submission success rates
@@ -198,12 +239,14 @@ This document identifies the major functional areas of the Discord bot applicati
 ## Existing Observability Infrastructure
 
 ### Current Implementation
+
 - **Structured Logging**: `/app/helpers/observability.ts` provides logging utilities
 - **Performance Tracking**: `trackPerformance()` function for timing operations
 - **Sentry Integration**: `/app/helpers/sentry.server.ts` for error tracking
 - **Pino HTTP**: Express middleware for request logging
 
 ### Already Instrumented
+
 - **Subscription Service**: Fully instrumented with logging and performance tracking
 - **Error Handling**: Sentry integration for exception tracking
 - **Basic Request Logging**: HTTP request/response logging via pino
@@ -211,18 +254,21 @@ This document identifies the major functional areas of the Discord bot applicati
 ## Recommended Observability Priorities
 
 ### High Priority (Core Business Logic)
+
 1. **Message Processing Pipeline** - Activity tracking throughput and reliability
 2. **Discord Bot Health** - Connection stability and event processing
 3. **User Authentication Flow** - OAuth success rates and session management
 4. **Command Execution** - Usage patterns and error rates
 
 ### Medium Priority (Feature Usage)
+
 1. **Analytics Dashboard** - Query performance and user engagement
 2. **Moderation System** - Effectiveness and accuracy metrics
 3. **Guild Management** - Configuration and onboarding success
 4. **Payment Processing** - Transaction success and conversion rates
 
 ### Low Priority (Operational)
+
 1. **Database Performance** - Query optimization and connection health
 2. **API Response Times** - General web interface performance
 3. **Export Features** - CSV generation and download patterns
@@ -230,10 +276,11 @@ This document identifies the major functional areas of the Discord bot applicati
 ## Integration Approach
 
 Each major feature area can be enhanced with:
+
 - **Structured logging** using the existing `log()` function
 - **Performance tracking** using the existing `trackPerformance()` wrapper
 - **Custom metrics** for business-specific KPIs
 - **Error tracking** via Sentry integration
 - **Health checks** for system components
 
-The application already has a solid foundation with the observability helpers and Sentry integration, making it straightforward to add comprehensive monitoring to each feature area.
\ No newline at end of file
+The application already has a solid foundation with the observability helpers and Sentry integration, making it straightforward to add comprehensive monitoring to each feature area.
diff --git a/notes/2025-07-04_3_observability-implementation-summary.md b/notes/2025-07-04_3_observability-implementation-summary.md
index dfbe6af..23ea021 100644
--- a/notes/2025-07-04_3_observability-implementation-summary.md
+++ b/notes/2025-07-04_3_observability-implementation-summary.md
@@ -1,13 +1,15 @@
 # Observability Integration Implementation Summary - July 4, 2025
 
 ## Overview
+
 Successfully completed comprehensive observability integration across all major Discord bot application features, implementing a three-layer observability architecture following industry best practices.
 
 ## Architecture Implemented
 
 ### Three-Layer Observability Stack
+
 1. **Operational Observability** - System health, performance, debugging via structured logging
-2. **Business Analytics** - User behavior, product insights via Amplitude integration  
+2. **Business Analytics** - User behavior, product insights via Amplitude integration
 3. **Infrastructure Monitoring** - Error tracking, stability via Sentry integration
 
 ## Features Enhanced
@@ -15,18 +17,21 @@ Successfully completed comprehensive observability integration across all major
 ### ✅ Phase 1: Critical Business Logic (Complete)
 
 #### 1. Discord Bot Gateway & Event Handling
+
 - **Files Enhanced**: `app/discord/gateway.ts`, `app/discord/client.server.ts`
 - **Added**: Comprehensive logging for bot lifecycle, connection events, startup performance tracking
 - **Business Analytics**: Bot startup events, reconnection tracking, error events
 - **Key Metrics**: Bot uptime, connection stability, guild/user counts
 
 #### 2. Message Activity Tracking System
+
 - **Files Enhanced**: `app/discord/activityTracker.ts`
 - **Added**: Performance tracking for all message processing operations, detailed logging for channel caching, reaction tracking
 - **Business Analytics**: Message tracking events already existed, enhanced with additional context
 - **Key Metrics**: Message processing throughput, channel activity, user engagement
 
 #### 3. Discord Commands System
+
 - **Files Enhanced**: `app/commands/setup.ts`, `app/commands/report.ts`, `app/commands/force-ban.ts`
 - **Added**: Command execution tracking, success/failure logging, business analytics for command usage
 - **Business Analytics**: Command execution events, setup completion tracking, report submission events
@@ -35,16 +40,19 @@ Successfully completed comprehensive observability integration across all major
 ### ✅ Phase 2: User Experience (Complete)
 
 #### 4. User Management & Authentication
+
 - **Files Enhanced**: `app/models/user.server.ts`
 - **Added**: Performance tracking for all user database operations, structured logging for user lifecycle
 - **Key Metrics**: User lookup performance, authentication success rates, user creation events
 
 #### 5. Analytics & Dashboard
+
 - **Files Enhanced**: `app/routes/__auth/dashboard.tsx`
 - **Added**: Dashboard access logging, performance tracking for complex queries
 - **Key Metrics**: Dashboard load times, query performance, user engagement with analytics
 
 #### 6. Guild/Server Management
+
 - **Files Enhanced**: `app/models/guilds.server.ts`
 - **Added**: Guild registration tracking, settings management logging, error handling
 - **Key Metrics**: Guild onboarding success rates, configuration changes
@@ -52,6 +60,7 @@ Successfully completed comprehensive observability integration across all major
 ### ✅ Business Analytics Infrastructure
 
 #### Enhanced Metrics System
+
 - **File Enhanced**: `app/helpers/metrics.ts`
 - **Added**: Command tracking events, bot lifecycle events, comprehensive Discord event tracking
 - **Events Added**:
@@ -64,15 +73,21 @@ Successfully completed comprehensive observability integration across all major
 ## Technical Implementation Details
 
 ### Performance Tracking Pattern
+
 ```typescript
-await trackPerformance("operationName", async () => {
-  log("info", "ServiceName", "Operation description", context);
-  // ... business logic
-  // Business analytics tracking
-}, { contextData });
+await trackPerformance(
+  "operationName",
+  async () => {
+    log("info", "ServiceName", "Operation description", context);
+    // ... business logic
+    // Business analytics tracking
+  },
+  { contextData },
+);
 ```
 
 ### Structured Logging Pattern
+
 ```typescript
 log("level", "ServiceName", "Message", {
   contextKey: "value",
@@ -81,6 +96,7 @@ log("level", "ServiceName", "Message", {
 ```
 
 ### Business Analytics Pattern
+
 ```typescript
 // Operational tracking
 commandStats.commandExecuted(interaction, "commandName", success);
@@ -91,24 +107,28 @@ commandStats.setupCompleted(interaction, settings);
 ## Observability Capabilities Added
 
 ### 1. System Health Monitoring
+
 - Bot connection status and reconnection events
 - Gateway error tracking and alerting
 - Performance metrics for all critical operations
 - Database operation performance tracking
 
 ### 2. User Behavior Analytics
+
 - Command usage patterns and frequencies
 - Guild setup completion rates
 - User engagement with dashboard features
 - Message activity and participation metrics
 
 ### 3. Operational Debugging
+
 - Comprehensive error logging with stack traces
 - Structured context for all operations
 - Performance bottleneck identification
 - User authentication flow tracking
 
 ### 4. Business Intelligence
+
 - Bot adoption metrics (guild counts, user engagement)
 - Feature usage analytics (command popularity, setup success)
 - User journey tracking (onboarding, feature discovery)
@@ -117,18 +137,21 @@ commandStats.setupCompleted(interaction, settings);
 ## Impact & Benefits
 
 ### For Development Team
+
 - **Faster Debugging**: Structured logs with comprehensive context
 - **Performance Insights**: Timing data for all critical operations
 - **Error Visibility**: Detailed error tracking with Sentry integration
 - **Code Quality**: Consistent observability patterns across codebase
 
 ### For Product Team
+
 - **User Behavior Insights**: Comprehensive analytics via Amplitude
 - **Feature Adoption Tracking**: Command usage and setup completion rates
 - **Performance Monitoring**: Dashboard load times and query performance
 - **Business Metrics**: Guild growth, user engagement, feature popularity
 
 ### For Operations Team
+
 - **System Health**: Real-time bot status and connection monitoring
 - **Alert-Ready**: Structured data ready for monitoring dashboards
 - **Incident Response**: Detailed context for debugging production issues
@@ -137,12 +160,14 @@ commandStats.setupCompleted(interaction, settings);
 ## Files Modified/Created
 
 ### New Files
+
 - `app/helpers/metrics.ts` - Enhanced business analytics
 - `notes/2025-07-04_1.md` - Implementation plan
 - `notes/2025-07-04_2_major-features-observability-analysis.md` - Feature analysis
 - `notes/2025-07-04_3_observability-implementation-summary.md` - This summary
 
 ### Enhanced Files
+
 - `app/discord/gateway.ts` - Bot lifecycle observability
 - `app/discord/client.server.ts` - Client connection tracking
 - `app/discord/activityTracker.ts` - Message processing observability
@@ -156,11 +181,13 @@ commandStats.setupCompleted(interaction, settings);
 ## Next Steps & Recommendations
 
 ### Immediate (Production Ready)
+
 1. **Configure Monitoring Dashboards**: Use structured log data for operational dashboards
 2. **Set Up Alerting**: Configure alerts for error rates, performance thresholds
 3. **Business Analytics Review**: Analyze Amplitude data for product insights
 
 ### Future Enhancements
+
 1. **Distributed Tracing**: Add trace IDs for request correlation across services
 2. **Custom Metrics**: Integration with Prometheus/Grafana for infrastructure metrics
 3. **Advanced Analytics**: Enhanced user journey tracking and cohort analysis
@@ -170,4 +197,4 @@ commandStats.setupCompleted(interaction, settings);
 
 Successfully implemented enterprise-grade observability across the entire Discord bot application. The three-layer architecture provides comprehensive visibility into system health, user behavior, and business metrics. The consistent patterns established make it easy to extend observability to new features and maintain high operational standards.
 
-The implementation follows industry best practices and provides a solid foundation for production operations, enabling proactive monitoring, quick debugging, and data-driven product decisions.
\ No newline at end of file
+The implementation follows industry best practices and provides a solid foundation for production operations, enabling proactive monitoring, quick debugging, and data-driven product decisions.
diff --git a/notes/2025-07-25_1-track-changes.md b/notes/2025-07-25_1-track-changes.md
new file mode 100644
index 0000000..804690f
--- /dev/null
+++ b/notes/2025-07-25_1-track-changes.md
@@ -0,0 +1,11 @@
+Currently we post a new message to the designated "mod log" channel for every new message reported, logging who it was and creating a thread to discuss the message. Historically I've used the search box to track history, e.g. mentions:<userid> in:mod-log, but recently that's been breaking sometimes (perhaps as they optimize/break search indices).
+
+We could instead move to a model where the entire moderation history for a user is captured in a single thread. This actually works really well for a couple of other benefits, like making this history easily discoverable by programmatic means without storing a complete duplicate of the records in our own database. We could store a thread lookup alongside a user record, and use that to retrieve message history for summary.
+
+let's not do this but capturing it
+This change would mean a database record like
+
+user_id | guild_id | thread_id | created_at | expires (?)
+Behavior within the thread would be similar to now, with a thread consisting of member reports and moderator actions. We should add in logs for timeouts as well, and try to capture kicks/bans not initiated through Euno features.
+
+Outside of the thread, we should post a new top-level message linking back to the thread when any new reports come in. Perhaps it would make sense to keep the same "new report" message format, and forward it back to the top level channel.
diff --git a/notes/2025-07-25_1_database-structure-analysis.md b/notes/2025-07-25_1_database-structure-analysis.md
new file mode 100644
index 0000000..7799279
--- /dev/null
+++ b/notes/2025-07-25_1_database-structure-analysis.md
@@ -0,0 +1,154 @@
+# Database Structure Analysis - 2025-07-25
+
+## Overview
+
+This codebase uses **Kysely** as the TypeScript query builder with **SQLite** as the database engine. The project follows a clear pattern for database management with migrations, models, and type definitions.
+
+## Key Files and Structure
+
+### Database Configuration
+
+- **`/app/db.server.ts`** - Main database connection using Kysely with SQLite dialect
+- **`/kysely.config.ts`** - Migration configuration using kysely-ctl
+- **`/app/db.d.ts`** - Auto-generated TypeScript type definitions for all tables
+
+### Models Directory
+
+All database models are in `/app/models/` with `.server.ts` suffix:
+
+- `user.server.ts` - User management functions
+- `guilds.server.ts` - Discord guild management
+- `activity.server.ts` - Message analytics and statistics
+- `session.server.ts` - Session management
+- `stripe.server.ts` - Payment integration
+- `subscriptions.server.ts` - Subscription management
+- `discord.server.ts` - Discord bot specific functions
+
+### Migrations Directory
+
+Located at `/migrations/` with timestamp-prefixed files following pattern `YYYYMMDDHHMMSS_description.ts`
+
+## Database Schema (Current Tables)
+
+Based on `/app/db.d.ts`, current tables are:
+
+1. **users**
+
+   - `id` (uuid, primary key)
+   - `email` (text, nullable)
+   - `externalId` (text, not null) - Discord user ID
+   - `authProvider` (text, defaults to "discord")
+
+2. **sessions**
+
+   - `id` (uuid, primary key)
+   - `data` (json)
+   - `expires` (datetime)
+
+3. **guilds**
+
+   - `id` (text, primary key) - Discord guild ID
+   - `settings` (json) - Guild configuration
+
+4. **message_stats**
+
+   - `author_id` (text)
+   - `channel_id` (text)
+   - `channel_category` (text, nullable)
+   - `guild_id` (text)
+   - `message_id` (text, nullable)
+   - `recipient_id` (text, nullable)
+   - `sent_at` (number) - Unix timestamp
+   - `word_count`, `char_count`, `react_count` (numbers)
+   - `code_stats`, `link_stats` (json)
+
+5. **channel_info**
+
+   - `id` (text, nullable)
+   - `name` (text, nullable)
+   - `category` (text, nullable)
+
+6. **tickets_config**
+
+   - `message_id` (text, primary key)
+   - `channel_id` (text, nullable)
+   - `role_id` (text)
+
+7. **guild_subscriptions**
+   - `guild_id` (text, primary key)
+   - `stripe_customer_id`, `stripe_subscription_id` (text, nullable)
+   - `product_tier` (text, defaults to "free")
+   - `status` (text, defaults to "active")
+   - `current_period_end` (datetime, nullable)
+   - `created_at`, `updated_at` (datetime, auto-generated)
+
+## Patterns to Follow for New Tables
+
+### Migration Pattern
+
+```typescript
+import type { Kysely } from "kysely";
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable("table_name")
+    .addColumn("id", "uuid", (c) => c.primaryKey().notNull())
+    .addColumn("created_at", "datetime", (c) =>
+      c.defaultTo("CURRENT_TIMESTAMP"),
+    )
+    // ... other columns
+    .execute();
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await db.schema.dropTable("table_name").execute();
+}
+```
+
+### Model Pattern
+
+```typescript
+import type { DB } from "#~/db.server";
+import db from "#~/db.server";
+import { log, trackPerformance } from "#~/helpers/observability";
+
+export type TableType = DB["table_name"];
+
+export async function getById(id: string) {
+  return trackPerformance(
+    "getById",
+    async () => {
+      log("debug", "TableName", "Fetching by ID", { id });
+
+      const result = await db
+        .selectFrom("table_name")
+        .selectAll()
+        .where("id", "=", id)
+        .executeTakeFirst();
+
+      log("debug", "TableName", result ? "Found" : "Not found", { id });
+      return result;
+    },
+    { id },
+  );
+}
+```
+
+### Key Patterns
+
+1. **Observability**: All database operations wrapped with `trackPerformance()` and include `log()` calls
+2. **Type Safety**: Export table types from models using `DB["table_name"]`
+3. **Async/Await**: All database operations are async
+4. **Error Handling**: SQLite errors caught and handled appropriately
+5. **Naming**: Snake_case for database columns, camelCase for TypeScript
+6. **Primary Keys**: UUIDs for user-related tables, natural keys (like Discord IDs) for external entities
+
+## For user_threads Table
+
+Based on patterns, a user_threads table should:
+
+- Use `user_id` (uuid) referencing users.id
+- Use `thread_id` (text) as Discord thread ID
+- Include `created_at`, `updated_at` timestamps
+- Follow the established model pattern with observability
+- Have a corresponding migration file with timestamp prefix
diff --git a/notes/2025-07-25_2-modlog-refactor-plan.md b/notes/2025-07-25_2-modlog-refactor-plan.md
new file mode 100644
index 0000000..7663282
--- /dev/null
+++ b/notes/2025-07-25_2-modlog-refactor-plan.md
@@ -0,0 +1,62 @@
+# ModLog Refactor Plan - User-Based Threading
+
+## Current System Analysis
+
+### Issues with Current Implementation
+
+- Creates new threads per message via `makeLogThread()` (modLog.ts:43-47)
+- Uses message-based caching with `queryReportCache()`
+- Thread naming is date-based: `${user.username} – ${format(message.createdAt, "P")}`
+- Search history tracking via Discord search is unreliable
+- Creates channel clutter with many threads per user
+
+### Key Functions to Refactor
+
+- `reportUser()`: Main function handling report logic (modLog.ts:50-166)
+- `makeLogThread()`: Thread creation logic (modLog.ts:43-47)
+- `constructLog()`: Message formatting for initial reports (modLog.ts:181-241)
+- Cache system in `reportCache.js` for user-based lookup
+
+## New System Design
+
+### Database Schema
+
+```sql
+user_threads (
+  user_id TEXT,
+  guild_id TEXT,
+  thread_id TEXT,
+  created_at DATETIME,
+  PRIMARY KEY (user_id, guild_id)
+)
+```
+
+### Threading Strategy
+
+1. **One thread per user per guild** - persistent across all reports
+2. **Thread naming**: `${user.username} Moderation History`
+3. **Top-level notifications**: New message in mod-log channel linking to user thread
+4. **Thread content**: All reports, actions, timeouts, kicks/bans for that user
+
+### Notification Flow
+
+1. New report comes in
+2. Lookup/create persistent user thread
+3. Post report details in user thread
+4. Post notification in main mod-log channel linking to thread
+5. Update any escalation controls in user thread
+
+## Integration Points
+
+- **Report feature**: Uses `reportUser()` directly
+- **Track feature**: Uses `reportUser()` via track commands
+- **Automod**: Calls `reportUser()` for automated reports
+- **Escalate**: Uses threads created by `reportUser()`
+
+## Benefits
+
+- Consolidated user history in single discoverable thread
+- Programmatic access via thread lookup table
+- Reduced channel clutter
+- Better historical context for moderation decisions
+- More reliable than Discord search
diff --git a/notes/2025-07-25_3-modlog-refactor-complete.md b/notes/2025-07-25_3-modlog-refactor-complete.md
new file mode 100644
index 0000000..48d3072
--- /dev/null
+++ b/notes/2025-07-25_3-modlog-refactor-complete.md
@@ -0,0 +1,61 @@
+# ModLog Refactor Implementation Complete - 2025-07-25
+
+## Summary
+
+Successfully refactored the moderation logging system from per-message threads to persistent user-based threads. This consolidates all moderation history for each user into a single thread per guild, improving discoverability and reducing channel clutter.
+
+## Key Changes Implemented
+
+### Database Layer
+
+- **Migration**: `20250725192908_user_threads.ts` - Creates user_threads table with unique composite key (user_id, guild_id)
+- **Model**: `app/models/userThreads.server.ts` - CRUD operations with full observability integration
+- **Schema**: user_id, guild_id, thread_id, created_at with unique constraint
+
+### Core Logic Changes
+
+- **Thread Creation**: `makeUserThread()` creates threads with "Username Moderation History" naming
+- **Thread Management**: `getOrCreateUserThread()` handles lookup/creation with database persistence
+- **Notification System**: Main channel posts link to user thread instead of full content
+- **Report Flow**: Detailed reports posted in user threads, notifications in main channel
+
+### Integration Points Verified
+
+All existing features maintain compatibility through the `reportUser()` API:
+
+- **Report Command**: Anonymous reporting via context menu
+- **Track Command**: Staff message tracking
+- **Automod**: Spam detection and auto-moderation
+- **Escalate System**: All resolution types (restrict, kick, ban, warning, timeout)
+
+## Benefits Achieved
+
+1. **Consolidated History**: All user moderation actions in single persistent thread
+2. **Improved Discoverability**: Database lookup instead of Discord search
+3. **Reduced Clutter**: One thread per user instead of per message
+4. **Better Context**: Historical view of all user interactions
+5. **Programmatic Access**: Thread IDs stored for easy API access
+
+## Technical Quality
+
+- ✅ **Type Safety**: Full TypeScript integration with generated DB types
+- ✅ **Observability**: All operations include performance tracking and logging
+- ✅ **Error Handling**: Graceful fallbacks for missing/inaccessible threads
+- ✅ **Backward Compatibility**: Existing API preserved, internal implementation changed
+- ✅ **Database Integrity**: Unique constraints and proper indexing
+
+## Files Modified
+
+- `app/helpers/modLog.ts` - Core refactoring with new threading logic
+- `app/models/userThreads.server.ts` - New database model
+- `migrations/20250725192908_user_threads.ts` - Database schema
+- `app/db.d.ts` - Updated type definitions
+
+## Next Steps for Production
+
+1. **Testing**: Verify functionality in development environment
+2. **Migration**: Run migration in production (backward compatible)
+3. **Monitoring**: Watch observability logs for thread access patterns
+4. **Cleanup**: Eventually clean up old per-message threads (manual process)
+
+The refactor maintains full API compatibility while delivering significant UX improvements for moderators.
diff --git a/notes/2025-07-25_4-escalation-controls-persistence-analysis.md b/notes/2025-07-25_4-escalation-controls-persistence-analysis.md
new file mode 100644
index 0000000..6ebe54d
--- /dev/null
+++ b/notes/2025-07-25_4-escalation-controls-persistence-analysis.md
@@ -0,0 +1,185 @@
+# Escalation Controls Persistence Analysis - 2025-07-25
+
+## Problem
+
+Current escalation controls use Reacord with in-memory `onClick` handlers that break when the server restarts. Need to implement persistent button handlers like `setupTickets.ts`.
+
+## Current Implementation Analysis
+
+### Reacord Approach (escalate.tsx)
+
+```tsx
+reacord.createChannelMessage(thread.id).render(
+  <Button
+    onClick={async (e) => {
+      /* handler logic */
+    }}
+  />,
+);
+```
+
+- **Problem**: `onClick` handlers are in-memory functions
+- **Impact**: All buttons become non-functional after server restart
+- **Data Access**: Has direct access to `reportedMessage`, `modRoleId` in closure
+
+### setupTickets.ts Approach
+
+```ts
+// Button creation
+customId: "close-ticket"
+
+// Persistent handler
+{ command: { type: InteractionType.MessageComponent, name: "close-ticket" } }
+```
+
+- **Advantage**: Handlers are command definitions that persist across restarts
+- **Data Storage**: Uses database (`tickets_config`) to store context
+- **Context Passing**: Uses `customId` with encoded data or database lookups
+
+## Implementation Approaches
+
+### Approach 1: Direct customId Migration
+
+**Strategy**: Replace Reacord with native Discord.js components using customId patterns
+
+```ts
+// Button creation
+new ButtonBuilder()
+  .setCustomId(`escalate-delete-${reportedMessage.id}`)
+  .setLabel("Delete all reported messages")
+
+// Handler
+{ command: { type: InteractionType.MessageComponent, name: "escalate-delete" } }
+```
+
+**Pros:**
+
+- Minimal database changes
+- Follows exact setupTickets.ts pattern
+
+**Cons:**
+
+- CustomId limited to 100 characters
+- Need to encode/decode context data
+- Complex state reconstruction
+
+### Approach 2: Database-Backed Context Storage
+
+**Strategy**: Create `escalation_contexts` table to store all necessary data
+
+```sql
+escalation_contexts (
+  id UUID PRIMARY KEY,
+  thread_id TEXT,
+  reported_message_id TEXT,
+  reported_user_id TEXT,
+  guild_id TEXT,
+  mod_role_id TEXT,
+  created_at DATETIME,
+  expires_at DATETIME
+)
+```
+
+```ts
+// Button creation
+customId: `escalate-${contextId}`;
+
+// Handler looks up context from database
+const context = await getEscalationContext(contextId);
+```
+
+**Pros:**
+
+- Clean separation of concerns
+- Unlimited context data storage
+- Easy expiration/cleanup
+
+**Cons:**
+
+- New database table and migration needed
+- More complex data flow
+- Need expiration logic
+
+### Approach 3: Hybrid Message-Based Context
+
+**Strategy**: Use reported message ID as primary key, supplement with database as needed
+
+```ts
+// Button creation
+customId: `escalate-delete-${reportedMessage.id}-${guildId}`;
+
+// Handler
+const reportedMessage = await channel.messages.fetch(messageId);
+// Use existing deleteAllReported(reportedMessage)
+```
+
+**Pros:**
+
+- Minimal changes to existing logic
+- Leverages existing `deleteAllReported` function
+- No new database tables
+
+**Cons:**
+
+- Message might be deleted/unavailable
+- CustomId length constraints with guild ID
+- Fragile if message gets deleted
+
+## Specific Challenges
+
+### "Delete all reported messages" Button
+
+**Current Logic:**
+
+```ts
+deleteAllReported(reportedMessage) // Needs Message object
+  -> queryReportCache(message)     // Uses message.guildId + message.author.id
+  -> allReports.logs.map(l => l.message.delete()) // Deletes Discord messages
+```
+
+**Challenge**: Function requires `Message` object but we only have IDs after restart
+
+**Solutions:**
+
+1. **Message Reconstruction**: Fetch message by ID, pass to existing function
+2. **Direct Cache Access**: Bypass message object, directly query cache with IDs
+3. **Database Migration**: Store report references in database instead of cache
+
+### Other Buttons (Kick/Ban/etc)
+
+**Current Logic:**
+
+```ts
+reportedMessage.member?.kick();
+reportedMessage.guild?.bans.create(reportedMessage.author);
+```
+
+**Challenge**: Need `reportedMessage.member` and `reportedMessage.author`
+
+**Solutions:**
+
+1. **User ID Storage**: Store user ID in customId/database, fetch member separately
+2. **Guild Context**: Store guild ID, reconstruct guild.members.fetch(userId)
+
+## Recommended Approach
+
+**Hybrid Approach 3** with database fallback:
+
+1. **Primary**: Use `escalate-{action}-{messageId}-{guildId}` customId pattern
+2. **Fallback**: If message fetch fails, query database for user context
+3. **Gradual Migration**: Start with simple actions (kick/ban), then tackle delete-all
+
+**Implementation Steps:**
+
+1. Create message component handlers for each action
+2. Modify `escalationControls` to use native Discord.js components
+3. Add database table for cases where message context is lost
+4. Implement `deleteAllReported` variant that works with user/guild IDs
+
+**Delete Button Specific Solution:**
+
+- Try message fetch first: `deleteAllReported(fetchedMessage)`
+- If fails, create new function: `deleteAllReportedByUser(userId, guildId)`
+- Query cache directly with `${guildId}${userId}` pattern from reportCache.ts
+
+This maintains existing functionality while providing persistence across server restarts.
diff --git a/notes/2025-07-25_5-persistent-escalation-controls-implementation-plan.md b/notes/2025-07-25_5-persistent-escalation-controls-implementation-plan.md
new file mode 100644
index 0000000..50be5c9
--- /dev/null
+++ b/notes/2025-07-25_5-persistent-escalation-controls-implementation-plan.md
@@ -0,0 +1,349 @@
+# Persistent Escalation Controls Implementation Plan - 2025-07-25
+
+## Overview
+
+Convert Reacord-based escalation controls to persistent Discord.js components using database-backed report caching, following the setupTickets.ts pattern.
+
+## Phase 1: Database Schema for Report Caching
+
+### New Tables
+
+#### `reported_messages`
+
+Replace TTL cache with persistent storage
+
+```sql
+reported_messages (
+  id UUID PRIMARY KEY,
+  user_id TEXT NOT NULL,
+  guild_id TEXT NOT NULL,
+  channel_id TEXT NOT NULL,
+  message_id TEXT NOT NULL,
+  message_content TEXT,
+  message_link TEXT,
+  reported_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  expires_at DATETIME, -- TTL equivalent
+  INDEX idx_user_guild (user_id, guild_id),
+  INDEX idx_expires (expires_at)
+)
+```
+
+#### `report_entries`
+
+Individual reports for each message
+
+```sql
+report_entries (
+  id UUID PRIMARY KEY,
+  reported_message_id UUID REFERENCES reported_messages(id),
+  reason TEXT NOT NULL, -- ReportReasons enum
+  staff_id TEXT, -- User ID who made report (nullable for anonymous)
+  staff_username TEXT,
+  extra TEXT, -- Additional context
+  log_message_id TEXT, -- Discord message ID of the log entry
+  log_channel_id TEXT, -- Thread/channel where log was posted
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+)
+```
+
+#### `escalation_contexts`
+
+Store context for persistent button handlers
+
+```sql
+escalation_contexts (
+  id UUID PRIMARY KEY,
+  thread_id TEXT NOT NULL,
+  reported_message_id UUID REFERENCES reported_messages(id),
+  mod_role_id TEXT NOT NULL,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  expires_at DATETIME DEFAULT (datetime('now', '+7 days')),
+  INDEX idx_thread (thread_id),
+  INDEX idx_expires (expires_at)
+)
+```
+
+## Phase 2: Database Models and Migration
+
+### Migration Strategy
+
+1. **Dual-write period**: Write to both TTL cache AND database
+2. **Background migration**: Convert existing TTL cache entries to database
+3. **Read preference**: Try database first, fallback to TTL cache
+4. **Cleanup period**: Remove TTL cache after validation
+
+### Model Functions
+
+```typescript
+// app/models/reportedMessages.server.ts
+export interface ReportedMessage {
+  id: string;
+  user_id: string;
+  guild_id: string;
+  // ... other fields
+}
+
+export async function getReportedMessagesForUser(
+  userId: string,
+  guildId: string,
+);
+export async function createReportedMessage(data: ReportedMessageData);
+export async function addReportEntry(
+  reportedMessageId: string,
+  report: ReportEntryData,
+);
+export async function deleteReportedMessages(reportedMessageId: string);
+export async function createEscalationContext(data: EscalationContextData);
+export async function getEscalationContext(contextId: string);
+```
+
+## Phase 3: Replace Reacord with Native Discord Components
+
+### Current vs New Pattern
+
+**Current (Reacord):**
+
+```tsx
+reacord.createChannelMessage(thread.id).render(
+  <Button
+    onClick={async (e) => {
+      deleteAllReported(reportedMessage);
+    }}
+  />,
+);
+```
+
+**New (Native Discord.js):**
+
+```typescript
+// In escalationControls function
+const contextId = await createEscalationContext({
+  thread_id: thread.id,
+  reported_message_id: reportedMessage.id,
+  mod_role_id: modRoleId,
+});
+
+await thread.send({
+  content: "Moderator controls",
+  components: [
+    new ActionRowBuilder().addComponents(
+      new ButtonBuilder()
+        .setCustomId(`escalate-delete-${contextId}`)
+        .setLabel("Delete all reported messages")
+        .setStyle(ButtonStyle.Danger),
+      new ButtonBuilder()
+        .setCustomId(`escalate-kick-${contextId}`)
+        .setLabel("Kick")
+        .setStyle(ButtonStyle.Secondary),
+      // ... other buttons
+    ),
+  ],
+});
+```
+
+### Component Handlers
+
+```typescript
+// Add to existing command structure
+export const EscalationCommands = [
+  {
+    command: {
+      type: InteractionType.MessageComponent,
+      name: "escalate-delete",
+    },
+    handler: async (interaction) => {
+      const contextId = interaction.customId.split("-")[2];
+      const context = await getEscalationContext(contextId);
+      // Implement delete logic
+    },
+  },
+  {
+    command: { type: InteractionType.MessageComponent, name: "escalate-kick" },
+    handler: async (interaction) => {
+      // Implement kick logic
+    },
+  },
+  // ... other handlers
+] as Array<MessageComponentCommand>;
+```
+
+## Phase 4: Implement Delete All Messages Logic
+
+### New Implementation Strategy
+
+**Replace TTL cache dependency:**
+
+```typescript
+// Old: deleteAllReported(reportedMessage)
+// New: deleteAllReportedById(reportedMessageId)
+
+export async function deleteAllReportedById(reportedMessageId: string) {
+  const reportEntries = await getReportEntriesForMessage(reportedMessageId);
+
+  await Promise.allSettled([
+    // Delete Discord messages
+    ...reportEntries.map(async (entry) => {
+      try {
+        const channel = await client.channels.fetch(entry.log_channel_id);
+        const message = await channel.messages.fetch(entry.log_message_id);
+        return message.delete();
+      } catch (error) {
+        console.warn(
+          `Failed to delete message ${entry.log_message_id}:`,
+          error,
+        );
+      }
+    }),
+
+    // Mark as deleted in database
+    markReportedMessageDeleted(reportedMessageId),
+  ]);
+}
+```
+
+**Handler implementation:**
+
+```typescript
+async handler(interaction) {
+  const contextId = interaction.customId.split('-')[2];
+  const context = await getEscalationContext(contextId);
+
+  if (!context) {
+    return interaction.reply({ content: "Context expired", ephemeral: true });
+  }
+
+  // Permission check
+  const member = await interaction.guild.members.fetch(interaction.user.id);
+  if (!member.permissions.has(PermissionsBitField.Flags.ManageMessages)) {
+    return interaction.reply({ content: "Insufficient permissions", ephemeral: true });
+  }
+
+  await deleteAllReportedById(context.reported_message_id);
+  await interaction.reply(`Messages deleted by ${interaction.user.username}`);
+}
+```
+
+## Phase 5: Migration from modLog.ts
+
+### Update reportUser function
+
+```typescript
+// Replace TTL cache calls with database calls
+export const reportUser = async ({ reason, message, extra, staff }) => {
+  // ... existing logic ...
+
+  // Replace trackReport(warningMessage, newReport)
+  const reportedMsg = await getOrCreateReportedMessage({
+    user_id: message.author.id,
+    guild_id: message.guild.id,
+    channel_id: message.channel.id,
+    message_id: message.id,
+    message_content: message.content,
+    message_link: constructDiscordLink(message),
+  });
+
+  await addReportEntry(reportedMsg.id, {
+    reason,
+    staff_id: staff?.id,
+    staff_username: staff?.username,
+    extra,
+    log_message_id: logMessage.id,
+    log_channel_id: thread.id,
+  });
+
+  // ... rest of logic ...
+};
+```
+
+### Update escalationControls function
+
+```typescript
+export async function escalationControls(
+  reportedMessage: Message,
+  thread: ThreadChannel,
+  modRoleId: string,
+) {
+  // Get or create reported message record
+  const reportedMsg = await getReportedMessageByDiscordId(
+    reportedMessage.id,
+    reportedMessage.guild.id,
+  );
+
+  if (!reportedMsg) {
+    throw new Error("Reported message not found in database");
+  }
+
+  // Create escalation context
+  const contextId = await createEscalationContext({
+    thread_id: thread.id,
+    reported_message_id: reportedMsg.id,
+    mod_role_id: modRoleId,
+  });
+
+  // Send native Discord components
+  await thread.send({
+    content: "Moderator controls",
+    components: [
+      /* ... native buttons ... */
+    ],
+  });
+}
+```
+
+## Phase 6: Testing and Rollout
+
+### Testing Strategy
+
+1. **Unit tests**: Database models and functions
+2. **Integration tests**: Button handlers and context flow
+3. **Manual testing**: Server restart scenarios
+4. **Gradual rollout**: Test in development first
+
+### Rollback Plan
+
+- Keep TTL cache alongside database during transition
+- Feature flag to switch between old/new systems
+- Database migration can be reversed if needed
+
+### Performance Considerations
+
+- Index on frequently queried columns (user_id, guild_id)
+- Cleanup job for expired records
+- Monitor database size and query performance
+
+## Acceptance Criteria
+
+✅ **Functionality**
+
+- All escalation buttons work after server restart
+- "Delete all reported messages" works with database lookup
+- Permission checks work correctly
+- Error handling for missing context
+
+✅ **Data Integrity**
+
+- No data loss during migration from TTL cache
+- Report history remains accurate
+- Context expiration works correctly
+
+✅ **Performance**
+
+- Button interactions respond within 2 seconds
+- Database queries are optimized
+- No memory leaks from abandoned contexts
+
+✅ **Maintainability**
+
+- Code follows existing patterns (setupTickets.ts)
+- Clear separation between Discord logic and database logic
+- Comprehensive logging and error handling
+
+## Estimated Effort
+
+- **Phase 1-2 (Database)**: 1-2 days
+- **Phase 3-4 (Components)**: 2-3 days
+- **Phase 5 (Migration)**: 1-2 days
+- **Phase 6 (Testing)**: 1 day
+- **Total**: 5-8 days
+
+This plan maintains all existing functionality while providing persistence across server restarts and better long-term maintainability.
diff --git a/notes/2025-07-25_8-final-implementation-plan.md b/notes/2025-07-25_8-final-implementation-plan.md
new file mode 100644
index 0000000..3b1739c
--- /dev/null
+++ b/notes/2025-07-25_8-final-implementation-plan.md
@@ -0,0 +1,433 @@
+# Final Implementation Plan - Persistent Escalation Controls - 2025-07-25
+
+## Updated Schema (Based on User Corrections)
+
+### Single Table: `reported_messages`
+
+```sql
+reported_messages (
+  id UUID PRIMARY KEY,
+  reported_message_id TEXT NOT NULL,        -- Original Discord message ID
+  reported_channel_id TEXT NOT NULL,        -- Where original message lives
+  reported_user_id TEXT NOT NULL,           -- Who sent the original message
+  guild_id TEXT NOT NULL,                   -- Which guild
+
+  log_message_id TEXT NOT NULL,             -- Mod-log entry Discord message ID
+  log_channel_id TEXT NOT NULL,             -- Thread/channel where log lives
+
+  reason TEXT NOT NULL,                     -- ReportReasons enum
+  staff_id TEXT,                            -- Who made the report (nullable for anon)
+  staff_username TEXT,
+  extra TEXT,                               -- Additional context
+
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+
+  INDEX idx_reported_user_guild (reported_user_id, guild_id),
+  INDEX idx_reported_message (reported_message_id)
+)
+```
+
+**Key Changes:**
+
+- ✅ **No expiration** - keep persistent record of everything
+- ✅ **No escalation_contexts table** - use customId with user_id instead
+
+## Button Implementation Strategy
+
+### Custom ID Pattern
+
+```typescript
+// Button creation
+customId: `escalate-delete-${reportedUserId}`;
+customId: `escalate-kick-${reportedUserId}`;
+customId: `escalate-ban-${reportedUserId}`;
+```
+
+### Handler Context Extraction
+
+```typescript
+async handler(interaction) {
+  // Extract from customId
+  const reportedUserId = interaction.customId.split('-')[2];
+
+  // Get from interaction context
+  const guildId = interaction.guildId;
+  const threadId = interaction.channelId;
+
+  // Get from settings
+  const { moderator: modRoleId } = await fetchSettings(guildId, [SETTINGS.moderator]);
+
+  // Now we have all needed context: reportedUserId, guildId, threadId, modRoleId
+}
+```
+
+## Implementation Steps
+
+### Phase 1: Database Setup
+
+1. **Create migration** for `reported_messages` table
+2. **Create model** with database functions
+3. **Generate TypeScript types**
+
+### Phase 2: Replace TTL Cache
+
+1. **Update modLog.ts** to use database instead of TTL cache
+2. **Replace functions**:
+   - `trackReport()` → `recordReport()`
+   - `queryReportCache()` → `getReportsForMessage()`
+   - `queryCacheMetadata()` → `getUserReportStats()`
+   - `deleteAllReported()` → `deleteAllReportedForUser()`
+
+### Phase 3: Native Discord Components
+
+1. **Create component handlers** following setupTickets.ts pattern
+2. **Update escalationControls()** to use ButtonBuilder with customId
+3. **Remove Reacord dependency** from escalation controls
+
+### Phase 4: Test and Deploy
+
+1. **Test button persistence** across server restarts
+2. **Test delete functionality** with database lookup
+3. **Verify statistics** still work correctly
+
+## Detailed Implementation
+
+### 1. Database Migration
+
+```typescript
+// migrations/YYYYMMDDHHMMSS_reported_messages.ts
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable("reported_messages")
+    .addColumn("id", "uuid", (c) => c.primaryKey().notNull())
+    .addColumn("reported_message_id", "text", (c) => c.notNull())
+    .addColumn("reported_channel_id", "text", (c) => c.notNull())
+    .addColumn("reported_user_id", "text", (c) => c.notNull())
+    .addColumn("guild_id", "text", (c) => c.notNull())
+    .addColumn("log_message_id", "text", (c) => c.notNull())
+    .addColumn("log_channel_id", "text", (c) => c.notNull())
+    .addColumn("reason", "text", (c) => c.notNull())
+    .addColumn("staff_id", "text")
+    .addColumn("staff_username", "text")
+    .addColumn("extra", "text")
+    .addColumn("created_at", "datetime", (c) =>
+      c.defaultTo("CURRENT_TIMESTAMP").notNull(),
+    )
+    .execute();
+
+  await db.schema
+    .createIndex("idx_reported_user_guild")
+    .on("reported_messages")
+    .columns(["reported_user_id", "guild_id"])
+    .execute();
+
+  await db.schema
+    .createIndex("idx_reported_message")
+    .on("reported_messages")
+    .columns(["reported_message_id"])
+    .execute();
+}
+```
+
+### 2. Database Model
+
+```typescript
+// app/models/reportedMessages.server.ts
+import type { DB } from "#~/db.server";
+import db from "#~/db.server";
+import { log, trackPerformance } from "#~/helpers/observability";
+import { ReportReasons } from "#~/models/reportedMessages.server";
+
+export type ReportedMessage = DB["reported_messages"];
+
+export async function recordReport(data: {
+  reportedMessageId: string;
+  reportedChannelId: string;
+  reportedUserId: string;
+  guildId: string;
+  logMessageId: string;
+  logChannelId: string;
+  reason: ReportReasons;
+  staffId?: string;
+  staffUsername?: string;
+  extra?: string;
+}): Promise<void> {
+  return trackPerformance(
+    "recordReport",
+    async () => {
+      log("info", "ReportedMessage", "Recording report", {
+        reportedUserId: data.reportedUserId,
+        guildId: data.guildId,
+        reason: data.reason,
+      });
+
+      await db
+        .insertInto("reported_messages")
+        .values({
+          id: crypto.randomUUID(),
+          reported_message_id: data.reportedMessageId,
+          reported_channel_id: data.reportedChannelId,
+          reported_user_id: data.reportedUserId,
+          guild_id: data.guildId,
+          log_message_id: data.logMessageId,
+          log_channel_id: data.logChannelId,
+          reason: data.reason,
+          staff_id: data.staffId,
+          staff_username: data.staffUsername,
+          extra: data.extra,
+        })
+        .execute();
+
+      log("info", "ReportedMessage", "Report recorded", {
+        reportedUserId: data.reportedUserId,
+        guildId: data.guildId,
+      });
+    },
+    { reportedUserId: data.reportedUserId, guildId: data.guildId },
+  );
+}
+
+export async function getReportsForUser(userId: string, guildId: string) {
+  return trackPerformance(
+    "getReportsForUser",
+    async () => {
+      log("debug", "ReportedMessage", "Fetching reports for user", {
+        userId,
+        guildId,
+      });
+
+      const reports = await db
+        .selectFrom("reported_messages")
+        .selectAll()
+        .where("reported_user_id", "=", userId)
+        .where("guild_id", "=", guildId)
+        .execute();
+
+      log("debug", "ReportedMessage", `Found ${reports.length} reports`, {
+        userId,
+        guildId,
+      });
+      return reports;
+    },
+    { userId, guildId },
+  );
+}
+
+export async function getUserReportStats(userId: string, guildId: string) {
+  return trackPerformance(
+    "getUserReportStats",
+    async () => {
+      const [totalReports, uniqueMessages] = await Promise.all([
+        db
+          .selectFrom("reported_messages")
+          .select(db.fn.count("id").as("count"))
+          .where("reported_user_id", "=", userId)
+          .where("guild_id", "=", guildId)
+          .executeTakeFirstOrThrow(),
+
+        db
+          .selectFrom("reported_messages")
+          .select(db.fn.countDistinct("reported_message_id").as("count"))
+          .where("reported_user_id", "=", userId)
+          .where("guild_id", "=", guildId)
+          .executeTakeFirstOrThrow(),
+      ]);
+
+      const stats = {
+        reportCount: Number(totalReports.count),
+        uniqueMessages: Number(uniqueMessages.count),
+        uniqueChannels: 0, // Could implement if needed
+        allReports: [], // Legacy compatibility
+      };
+
+      log("debug", "ReportedMessage", "Calculated stats", {
+        userId,
+        guildId,
+        stats,
+      });
+      return stats;
+    },
+    { userId, guildId },
+  );
+}
+
+export async function deleteAllReportedForUser(
+  userId: string,
+  guildId: string,
+) {
+  return trackPerformance(
+    "deleteAllReportedForUser",
+    async () => {
+      log("info", "ReportedMessage", "Deleting all reported messages", {
+        userId,
+        guildId,
+      });
+
+      const reports = await getReportsForUser(userId, guildId);
+
+      const deleteResults = await Promise.allSettled(
+        reports.map(async (report) => {
+          try {
+            const channel = await client.channels.fetch(
+              report.reported_channel_id,
+            );
+            const message = await channel.messages.fetch(
+              report.reported_message_id,
+            );
+            await message.delete();
+            log("debug", "ReportedMessage", "Deleted message", {
+              messageId: report.reported_message_id,
+            });
+          } catch (error) {
+            log("warn", "ReportedMessage", "Failed to delete message", {
+              messageId: report.reported_message_id,
+              error: error.message,
+            });
+          }
+        }),
+      );
+
+      const deleted = deleteResults.filter(
+        (r) => r.status === "fulfilled",
+      ).length;
+      log("info", "ReportedMessage", "Deletion complete", {
+        userId,
+        guildId,
+        total: reports.length,
+        deleted,
+      });
+    },
+    { userId, guildId },
+  );
+}
+```
+
+### 3. Update escalationControls
+
+```typescript
+// app/helpers/escalate.tsx - NEW native implementation
+export async function escalationControls(
+  reportedMessage: Message,
+  thread: ThreadChannel,
+  modRoleId: string,
+) {
+  const reportedUserId = reportedMessage.author.id;
+
+  await thread.send({
+    content: "Moderator controls",
+    components: [
+      new ActionRowBuilder().addComponents(
+        new ButtonBuilder()
+          .setCustomId(`escalate-delete-${reportedUserId}`)
+          .setLabel("Delete all reported messages")
+          .setStyle(ButtonStyle.Danger),
+
+        new ButtonBuilder()
+          .setCustomId(`escalate-kick-${reportedUserId}`)
+          .setLabel("Kick")
+          .setStyle(ButtonStyle.Secondary),
+
+        new ButtonBuilder()
+          .setCustomId(`escalate-ban-${reportedUserId}`)
+          .setLabel("Ban")
+          .setStyle(ButtonStyle.Secondary),
+      ),
+
+      new ActionRowBuilder().addComponents(
+        new ButtonBuilder()
+          .setCustomId(`escalate-restrict-${reportedUserId}`)
+          .setLabel("Restrict")
+          .setStyle(ButtonStyle.Secondary),
+
+        new ButtonBuilder()
+          .setCustomId(`escalate-timeout-${reportedUserId}`)
+          .setLabel("Timeout")
+          .setStyle(ButtonStyle.Secondary),
+      ),
+    ],
+  });
+}
+```
+
+### 4. Component Handlers
+
+```typescript
+// Add to existing command exports
+export const EscalationCommands = [
+  {
+    command: {
+      type: InteractionType.MessageComponent,
+      name: "escalate-delete",
+    },
+    handler: async (interaction) => {
+      const reportedUserId = interaction.customId.split("-")[2];
+      const guildId = interaction.guildId!;
+
+      // Permission check
+      const member = await interaction.guild!.members.fetch(
+        interaction.user.id,
+      );
+      if (!member.permissions.has(PermissionsBitField.Flags.ManageMessages)) {
+        return interaction.reply({
+          content: "Insufficient permissions",
+          ephemeral: true,
+        });
+      }
+
+      await deleteAllReportedForUser(reportedUserId, guildId);
+      await interaction.reply(
+        `Messages deleted by ${interaction.user.username}`,
+      );
+    },
+  },
+
+  {
+    command: { type: InteractionType.MessageComponent, name: "escalate-kick" },
+    handler: async (interaction) => {
+      const reportedUserId = interaction.customId.split("-")[2];
+      const { moderator: modRoleId } = await fetchSettings(
+        interaction.guildId!,
+        [SETTINGS.moderator],
+      );
+
+      if (!interaction.member?.roles?.includes(modRoleId)) {
+        return interaction.reply({
+          content: "Insufficient permissions",
+          ephemeral: true,
+        });
+      }
+
+      const reportedMember =
+        await interaction.guild!.members.fetch(reportedUserId);
+      await Promise.allSettled([
+        reportedMember.kick(),
+        interaction.reply(
+          `<@${reportedUserId}> kicked by ${interaction.user.username}`,
+        ),
+      ]);
+    },
+  },
+
+  // ... other handlers for ban, restrict, timeout
+] as Array<MessageComponentCommand>;
+```
+
+## Benefits of This Approach
+
+1. ✅ **Simpler**: No complex escalation context table
+2. ✅ **Persistent**: Works across server restarts
+3. ✅ **Efficient**: Only store essential IDs, fetch content on-demand
+4. ✅ **Follows patterns**: Same approach as setupTickets.ts
+5. ✅ **Permanent records**: No artificial expiration of reports
+
+## Ready to Implement?
+
+This plan addresses all the requirements:
+
+- Persistent button handlers ✅
+- Database-backed report tracking ✅
+- Simplified schema ✅
+- No unnecessary context storage ✅
+- Permanent audit trail ✅
+
+Should we proceed with Phase 1 (database setup)?
diff --git a/package-lock.json b/package-lock.json
index b619167..63fa59c 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -20,7 +20,7 @@
         "date-fns": "^4.1.0",
         "discord-api-types": "0.37.97",
         "discord-interactions": "^4.1.0",
-        "discord.js": "^14.16.0",
+        "discord.js": "^14.21.0",
         "dotenv": "^16.0.1",
         "express": "^4.18.1",
         "isbot": "^5",
@@ -725,26 +725,35 @@
       }
     },
     "node_modules/@discordjs/builders": {
-      "version": "1.9.0",
-      "resolved": "https://registry.npmjs.org/@discordjs/builders/-/builders-1.9.0.tgz",
-      "integrity": "sha512-0zx8DePNVvQibh5ly5kCEei5wtPBIUbSoE9n+91Rlladz4tgtFbJ36PZMxxZrTEOQ7AHMZ/b0crT/0fCy6FTKg==",
+      "version": "1.11.2",
+      "resolved": "https://registry.npmjs.org/@discordjs/builders/-/builders-1.11.2.tgz",
+      "integrity": "sha512-F1WTABdd8/R9D1icJzajC4IuLyyS8f3rTOz66JsSI3pKvpCAtsMBweu8cyNYsIyvcrKAVn9EPK+Psoymq+XC0A==",
       "license": "Apache-2.0",
       "dependencies": {
-        "@discordjs/formatters": "^0.5.0",
+        "@discordjs/formatters": "^0.6.1",
         "@discordjs/util": "^1.1.1",
         "@sapphire/shapeshift": "^4.0.0",
-        "discord-api-types": "0.37.97",
+        "discord-api-types": "^0.38.1",
         "fast-deep-equal": "^3.1.3",
         "ts-mixer": "^6.0.4",
         "tslib": "^2.6.3"
       },
       "engines": {
-        "node": ">=18"
+        "node": ">=16.11.0"
       },
       "funding": {
         "url": "https://github.com/discordjs/discord.js?sponsor"
       }
     },
+    "node_modules/@discordjs/builders/node_modules/discord-api-types": {
+      "version": "0.38.17",
+      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.38.17.tgz",
+      "integrity": "sha512-/fCx5jdUoR2hBFcj77Qx7Tmx1Ub8V/QpyS6uorjFvxRLcJJ348QxMFml9QW/eXh3i46eO4Ve8qGVepStpInEPg==",
+      "license": "MIT",
+      "workspaces": [
+        "scripts/actions/documentation"
+      ]
+    },
     "node_modules/@discordjs/collection": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/@discordjs/collection/-/collection-2.1.1.tgz",
@@ -758,24 +767,33 @@
       }
     },
     "node_modules/@discordjs/formatters": {
-      "version": "0.5.0",
-      "resolved": "https://registry.npmjs.org/@discordjs/formatters/-/formatters-0.5.0.tgz",
-      "integrity": "sha512-98b3i+Y19RFq1Xke4NkVY46x8KjJQjldHUuEbCqMvp1F5Iq9HgnGpu91jOi/Ufazhty32eRsKnnzS8n4c+L93g==",
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/@discordjs/formatters/-/formatters-0.6.1.tgz",
+      "integrity": "sha512-5cnX+tASiPCqCWtFcFslxBVUaCetB0thvM/JyavhbXInP1HJIEU+Qv/zMrnuwSsX3yWH2lVXNJZeDK3EiP4HHg==",
       "license": "Apache-2.0",
       "dependencies": {
-        "discord-api-types": "0.37.97"
+        "discord-api-types": "^0.38.1"
       },
       "engines": {
-        "node": ">=18"
+        "node": ">=16.11.0"
       },
       "funding": {
         "url": "https://github.com/discordjs/discord.js?sponsor"
       }
     },
+    "node_modules/@discordjs/formatters/node_modules/discord-api-types": {
+      "version": "0.38.17",
+      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.38.17.tgz",
+      "integrity": "sha512-/fCx5jdUoR2hBFcj77Qx7Tmx1Ub8V/QpyS6uorjFvxRLcJJ348QxMFml9QW/eXh3i46eO4Ve8qGVepStpInEPg==",
+      "license": "MIT",
+      "workspaces": [
+        "scripts/actions/documentation"
+      ]
+    },
     "node_modules/@discordjs/rest": {
-      "version": "2.4.0",
-      "resolved": "https://registry.npmjs.org/@discordjs/rest/-/rest-2.4.0.tgz",
-      "integrity": "sha512-Xb2irDqNcq+O8F0/k/NaDp7+t091p+acb51iA4bCKfIn+WFWd6HrNvcsSbMMxIR9NjcMZS6NReTKygqiQN+ntw==",
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/@discordjs/rest/-/rest-2.5.1.tgz",
+      "integrity": "sha512-Tg9840IneBcbrAjcGaQzHUJWFNq1MMWZjTdjJ0WS/89IffaNKc++iOvffucPxQTF/gviO9+9r8kEPea1X5J2Dw==",
       "license": "Apache-2.0",
       "dependencies": {
         "@discordjs/collection": "^2.1.1",
@@ -783,10 +801,10 @@
         "@sapphire/async-queue": "^1.5.3",
         "@sapphire/snowflake": "^3.5.3",
         "@vladfrangu/async_event_emitter": "^2.4.6",
-        "discord-api-types": "0.37.97",
+        "discord-api-types": "^0.38.1",
         "magic-bytes.js": "^1.10.0",
         "tslib": "^2.6.3",
-        "undici": "6.19.8"
+        "undici": "6.21.3"
       },
       "engines": {
         "node": ">=18"
@@ -795,6 +813,15 @@
         "url": "https://github.com/discordjs/discord.js?sponsor"
       }
     },
+    "node_modules/@discordjs/rest/node_modules/discord-api-types": {
+      "version": "0.38.17",
+      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.38.17.tgz",
+      "integrity": "sha512-/fCx5jdUoR2hBFcj77Qx7Tmx1Ub8V/QpyS6uorjFvxRLcJJ348QxMFml9QW/eXh3i46eO4Ve8qGVepStpInEPg==",
+      "license": "MIT",
+      "workspaces": [
+        "scripts/actions/documentation"
+      ]
+    },
     "node_modules/@discordjs/util": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/@discordjs/util/-/util-1.1.1.tgz",
@@ -808,20 +835,20 @@
       }
     },
     "node_modules/@discordjs/ws": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@discordjs/ws/-/ws-1.1.1.tgz",
-      "integrity": "sha512-PZ+vLpxGCRtmr2RMkqh8Zp+BenUaJqlS6xhgWKEZcgC/vfHLEzpHtKkB0sl3nZWpwtcKk6YWy+pU3okL2I97FA==",
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@discordjs/ws/-/ws-1.2.3.tgz",
+      "integrity": "sha512-wPlQDxEmlDg5IxhJPuxXr3Vy9AjYq5xCvFWGJyD7w7Np8ZGu+Mc+97LCoEc/+AYCo2IDpKioiH0/c/mj5ZR9Uw==",
       "license": "Apache-2.0",
       "dependencies": {
         "@discordjs/collection": "^2.1.0",
-        "@discordjs/rest": "^2.3.0",
+        "@discordjs/rest": "^2.5.1",
         "@discordjs/util": "^1.1.0",
         "@sapphire/async-queue": "^1.5.2",
         "@types/ws": "^8.5.10",
         "@vladfrangu/async_event_emitter": "^2.2.4",
-        "discord-api-types": "0.37.83",
+        "discord-api-types": "^0.38.1",
         "tslib": "^2.6.2",
-        "ws": "^8.16.0"
+        "ws": "^8.17.0"
       },
       "engines": {
         "node": ">=16.11.0"
@@ -831,10 +858,13 @@
       }
     },
     "node_modules/@discordjs/ws/node_modules/discord-api-types": {
-      "version": "0.37.83",
-      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.37.83.tgz",
-      "integrity": "sha512-urGGYeWtWNYMKnYlZnOnDHm8fVRffQs3U0SpE8RHeiuLKb/u92APS8HoQnPTFbnXmY1vVnXjXO4dOxcAn3J+DA==",
-      "license": "MIT"
+      "version": "0.38.17",
+      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.38.17.tgz",
+      "integrity": "sha512-/fCx5jdUoR2hBFcj77Qx7Tmx1Ub8V/QpyS6uorjFvxRLcJJ348QxMFml9QW/eXh3i46eO4Ve8qGVepStpInEPg==",
+      "license": "MIT",
+      "workspaces": [
+        "scripts/actions/documentation"
+      ]
     },
     "node_modules/@esbuild/aix-ppc64": {
       "version": "0.23.1",
@@ -2996,9 +3026,9 @@
       "peer": true
     },
     "node_modules/@types/ws": {
-      "version": "8.5.13",
-      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.5.13.tgz",
-      "integrity": "sha512-osM/gWBTPKgHV8XkTunnegTRIsvF6owmf5w+JtAfOw472dptdm0dlGv4xCt6GwQRcC2XVOvvRE/0bAoQcL2QkA==",
+      "version": "8.18.1",
+      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
+      "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
       "license": "MIT",
       "dependencies": {
         "@types/node": "*"
@@ -4792,23 +4822,24 @@
       }
     },
     "node_modules/discord.js": {
-      "version": "14.16.3",
-      "resolved": "https://registry.npmjs.org/discord.js/-/discord.js-14.16.3.tgz",
-      "integrity": "sha512-EPCWE9OkA9DnFFNrO7Kl1WHHDYFXu3CNVFJg63bfU7hVtjZGyhShwZtSBImINQRWxWP2tgo2XI+QhdXx28r0aA==",
+      "version": "14.21.0",
+      "resolved": "https://registry.npmjs.org/discord.js/-/discord.js-14.21.0.tgz",
+      "integrity": "sha512-U5w41cEmcnSfwKYlLv5RJjB8Joa+QJyRwIJz5i/eg+v2Qvv6EYpCRhN9I2Rlf0900LuqSDg8edakUATrDZQncQ==",
       "license": "Apache-2.0",
       "dependencies": {
-        "@discordjs/builders": "^1.9.0",
+        "@discordjs/builders": "^1.11.2",
         "@discordjs/collection": "1.5.3",
-        "@discordjs/formatters": "^0.5.0",
-        "@discordjs/rest": "^2.4.0",
+        "@discordjs/formatters": "^0.6.1",
+        "@discordjs/rest": "^2.5.1",
         "@discordjs/util": "^1.1.1",
-        "@discordjs/ws": "1.1.1",
+        "@discordjs/ws": "^1.2.3",
         "@sapphire/snowflake": "3.5.3",
-        "discord-api-types": "0.37.100",
+        "discord-api-types": "^0.38.1",
         "fast-deep-equal": "3.1.3",
         "lodash.snakecase": "4.1.1",
+        "magic-bytes.js": "^1.10.0",
         "tslib": "^2.6.3",
-        "undici": "6.19.8"
+        "undici": "6.21.3"
       },
       "engines": {
         "node": ">=18"
@@ -4837,10 +4868,13 @@
       }
     },
     "node_modules/discord.js/node_modules/discord-api-types": {
-      "version": "0.37.100",
-      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.37.100.tgz",
-      "integrity": "sha512-a8zvUI0GYYwDtScfRd/TtaNBDTXwP5DiDVX7K5OmE+DRT57gBqKnwtOC5Ol8z0mRW8KQfETIgiB8U0YZ9NXiCA==",
-      "license": "MIT"
+      "version": "0.38.17",
+      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.38.17.tgz",
+      "integrity": "sha512-/fCx5jdUoR2hBFcj77Qx7Tmx1Ub8V/QpyS6uorjFvxRLcJJ348QxMFml9QW/eXh3i46eO4Ve8qGVepStpInEPg==",
+      "license": "MIT",
+      "workspaces": [
+        "scripts/actions/documentation"
+      ]
     },
     "node_modules/dlv": {
       "version": "1.1.3",
@@ -12108,9 +12142,9 @@
       }
     },
     "node_modules/undici": {
-      "version": "6.19.8",
-      "resolved": "https://registry.npmjs.org/undici/-/undici-6.19.8.tgz",
-      "integrity": "sha512-U8uCCl2x9TK3WANvmBavymRzxbfFYG+tAu+fgx3zxQy3qdagQqBLwJVrdyO1TBfUXvfKveMKJZhpvUYoOjM+4g==",
+      "version": "6.21.3",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-6.21.3.tgz",
+      "integrity": "sha512-gBLkYIlEnSp8pFbT64yFgGE6UIB9tAkhukC23PmMDCe5Nd+cRqKxSjw5y54MK2AZMgZfJWMaNE4nYUHgi1XEOw==",
       "license": "MIT",
       "engines": {
         "node": ">=18.17"
@@ -13175,9 +13209,9 @@
       "license": "ISC"
     },
     "node_modules/ws": {
-      "version": "8.18.0",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.0.tgz",
-      "integrity": "sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw==",
+      "version": "8.18.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"
diff --git a/package.json b/package.json
index d8e9064..8050684 100644
--- a/package.json
+++ b/package.json
@@ -46,7 +46,7 @@
     "date-fns": "^4.1.0",
     "discord-api-types": "0.37.97",
     "discord-interactions": "^4.1.0",
-    "discord.js": "^14.16.0",
+    "discord.js": "^14.21.0",
     "dotenv": "^16.0.1",
     "express": "^4.18.1",
     "isbot": "^5",