Implement listener registry pattern for HMR support

Separates "login once" from "bind listeners" logic to enable proper hot
module reloading. Previously, the gateway flag prevented duplicate logins
but also prevented listener code from being updated on HMR.

Key changes:
- Add listenerRegistry.ts with registerListener/removeAllListeners
- Add HMR state helpers to client.server.ts (isClientReady, clearScheduledTasks)
- Modify schedule.ts to return timer handles for cleanup
- Refactor gateway.ts to split login from listener binding
- Update all listener modules to use registerListener

On HMR, old listeners are removed before rebinding new ones with fresh closures.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: vcarl

app/discord/activityTracker.ts

@@ -5,14 +5,15 @@ import { getMessageStats } from "#~/helpers/discord.js";
 import { threadStats } from "#~/helpers/metrics";
 import { log, trackPerformance } from "#~/helpers/observability";
 
+import { registerListener } from "./listenerRegistry";
 import { getOrFetchChannel } from "./utils";
 
 export async function startActivityTracking(client: Client) {
   log("info", "ActivityTracker", "Starting activity tracking", {
     guildCount: client.guilds.cache.size,
   });
 
-  client.on(Events.MessageCreate, async (msg) => {
+  registerListener(client, Events.MessageCreate, async (msg) => {
     if (msg.author.system) return;
     if (msg.channel.type !== ChannelType.GuildText || msg.author.bot) {
       return;
@@ -69,7 +70,7 @@ export async function startActivityTracking(client: Client) {
     threadStats.messageTracked(msg);
   });
 
-  client.on(Events.MessageUpdate, async (msg) => {
+  registerListener(client, Events.MessageUpdate, async (msg) => {
     await trackPerformance(
       "processMessageUpdate",
       async () => {
@@ -93,7 +94,7 @@ export async function startActivityTracking(client: Client) {
     );
   });
 
-  client.on(Events.MessageDelete, async (msg) => {
+  registerListener(client, Events.MessageDelete, async (msg) => {
     if (msg.system || msg.author?.bot) {
       return;
     }
@@ -113,7 +114,7 @@ export async function startActivityTracking(client: Client) {
     );
   });
 
-  client.on(Events.MessageReactionAdd, async (msg) => {
+  registerListener(client, Events.MessageReactionAdd, async (msg) => {
     await trackPerformance(
       "processReactionAdd",
       async () => {
@@ -131,7 +132,7 @@ export async function startActivityTracking(client: Client) {
     );
   });
 
-  client.on(Events.MessageReactionRemove, async (msg) => {
+  registerListener(client, Events.MessageReactionRemove, async (msg) => {
     await trackPerformance(
       "processReactionRemove",
       async () => {

app/discord/automod.ts

@@ -16,6 +16,7 @@ import {
 } from "#~/models/reportedMessages.server";
 
 import { client } from "./client.server";
+import { registerListener } from "./listenerRegistry";
 
 const AUTO_SPAM_THRESHOLD = 3;
 
@@ -69,21 +70,25 @@ async function handleAutomodAction(execution: AutoModerationActionExecution) {
 
 export default async (bot: Client) => {
   // Handle Discord's built-in automod actions
-  bot.on(Events.AutoModerationActionExecution, async (execution) => {
-    try {
-      log("info", "automod.logging", "handling automod event", { execution });
-      await handleAutomodAction(execution);
-    } catch (e) {
-      log("error", "Automod", "Failed to handle automod action", {
-        error: e,
-        userId: execution.userId,
-        guildId: execution.guild.id,
-      });
-    }
-  });
+  registerListener(
+    bot,
+    Events.AutoModerationActionExecution,
+    async (execution) => {
+      try {
+        log("info", "automod.logging", "handling automod event", { execution });
+        await handleAutomodAction(execution);
+      } catch (e) {
+        log("error", "Automod", "Failed to handle automod action", {
+          error: e,
+          userId: execution.userId,
+          guildId: execution.guild.id,
+        });
+      }
+    },
+  );
 
   // Handle our custom spam detection
-  bot.on(Events.MessageCreate, async (msg) => {
+  registerListener(bot, Events.MessageCreate, async (msg) => {
     if (msg.author.id === bot.user?.id || !msg.guild) return;
 
     const [member, message] = await Promise.all([

app/discord/client.server.ts

@@ -4,6 +4,39 @@ import { ReacordDiscordJs } from "reacord";
 import { discordToken } from "#~/helpers/env.server";
 import { log, trackPerformance } from "#~/helpers/observability";
 
+// HMR state helpers - persisted across module reloads
+declare global {
+  var __discordClientReady: boolean | undefined;
+  var __discordScheduledTasks: ReturnType<typeof setTimeout>[] | undefined;
+}
+
+export function isClientReady(): boolean {
+  return globalThis.__discordClientReady ?? false;
+}
+
+export function setClientReady(): void {
+  globalThis.__discordClientReady = true;
+}
+
+export function registerScheduledTask(
+  timer: ReturnType<typeof setTimeout>,
+): void {
+  globalThis.__discordScheduledTasks ??= [];
+  globalThis.__discordScheduledTasks.push(timer);
+}
+
+export function clearScheduledTasks(): void {
+  const tasks = globalThis.__discordScheduledTasks ?? [];
+  if (tasks.length > 0) {
+    log("info", "Client", `Clearing ${tasks.length} scheduled tasks for HMR`);
+  }
+  for (const timer of tasks) {
+    clearTimeout(timer);
+    clearInterval(timer);
+  }
+  globalThis.__discordScheduledTasks = [];
+}
+
 export const client = new Client({
   intents: [
     GatewayIntentBits.Guilds,

app/discord/deployCommands.server.ts

@@ -10,6 +10,7 @@ import {
 } from "discord.js";
 
 import { ssrDiscordSdk } from "#~/discord/api";
+import { registerListener } from "#~/discord/listenerRegistry";
 import {
   isMessageComponentCommand,
   isMessageContextCommand,
@@ -41,7 +42,7 @@ export const deployCommands = async (client: Client) => {
     ? deployProdCommands(client, localCommands)
     : deployTestCommands(client, localCommands));
 
-  client.on(Events.InteractionCreate, (interaction) => {
+  registerListener(client, Events.InteractionCreate, (interaction) => {
     log("info", "deployCommands", "Handling interaction", {
       type: interaction.type,
       id: interaction.id,

app/discord/escalationResolver.ts

@@ -9,6 +9,7 @@ import {
 } from "discord.js";
 
 import { tallyVotes } from "#~/commands/escalate/voting.js";
+import { registerScheduledTask } from "#~/discord/client.server";
 import {
   humanReadableResolutions,
   resolutions,
@@ -298,7 +299,15 @@ export function startEscalationResolver(client: Client): void {
     {},
   );
 
-  scheduleTask("EscalationResolver", ONE_MINUTE * 15, () => {
+  const handle = scheduleTask("EscalationResolver", ONE_MINUTE * 15, () => {
     void checkPendingEscalations(client);
   });
+
+  // Register timers for HMR cleanup
+  if (handle) {
+    registerScheduledTask(handle.initialTimer);
+    // The interval timer is created inside the setTimeout, so we need to
+    // register it when it's available. Since clearScheduledTasks clears both
+    // timeouts and intervals, the initial timer registration will handle cleanup.
+  }
 }