@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/discord/monitor/provider.js

@@ -1,10 +1,11 @@
 import { inspect } from "node:util";
 import { Client, ReadyListener, } from "@buape/carbon";
+import { GatewayCloseCodes } from "@buape/carbon/gateway";
+import { VoicePlugin } from "@buape/carbon/voice";
 import { Routes } from "discord-api-types/v10";
 import { resolveTextChunkLimit } from "../../auto-reply/chunk.js";
 import { listNativeCommandSpecsForConfig } from "../../auto-reply/commands-registry.js";
 import { listSkillCommandsForAgents } from "../../auto-reply/skill-commands.js";
-import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, mergeAllowlist, resolveAllowlistIdAdditions, patchAllowlistUsersInConfigEntries, summarizeMapping, } from "../../channels/allowlists/resolve-utils.js";
 import { isNativeCommandsExplicitlyDisabled, resolveNativeCommandsEnabled, resolveNativeSkillsEnabled, } from "../../config/commands.js";
 import { loadConfig } from "../../config/config.js";
 import { danger, logVerbose, shouldLogVerbose, warn } from "../../globals.js";
@@ -13,21 +14,22 @@ import { createDiscordRetryRunner } from "../../infra/retry-policy.js";
 import { createSubsystemLogger } from "../../logging/subsystem.js";
 import { createNonExitingRuntime } from "../../runtime.js";
 import { resolveDiscordAccount } from "../accounts.js";
-import { attachDiscordGatewayLogging } from "../gateway-logging.js";
-import { getDiscordGatewayEmitter, waitForDiscordGatewayStop } from "../monitor.gateway.js";
 import { fetchDiscordApplicationId } from "../probe.js";
-import { resolveDiscordChannelAllowlist } from "../resolve-channels.js";
-import { resolveDiscordUserAllowlist } from "../resolve-users.js";
 import { normalizeDiscordToken } from "../token.js";
+import { createDiscordVoiceCommand } from "../voice/command.js";
+import { DiscordVoiceManager, DiscordVoiceReadyListener } from "../voice/manager.js";
 import { createAgentComponentButton, createAgentSelectMenu, createDiscordComponentButton, createDiscordComponentChannelSelect, createDiscordComponentMentionableSelect, createDiscordComponentModal, createDiscordComponentRoleSelect, createDiscordComponentStringSelect, createDiscordComponentUserSelect, } from "./agent-components.js";
+import { resolveDiscordSlashCommandConfig } from "./commands.js";
 import { createExecApprovalButton, DiscordExecApprovalHandler } from "./exec-approvals.js";
 import { createDiscordGatewayPlugin } from "./gateway-plugin.js";
-import { registerGateway, unregisterGateway } from "./gateway-registry.js";
 import { DiscordMessageListener, DiscordPresenceListener, DiscordReactionListener, DiscordReactionRemoveListener, registerDiscordListener, } from "./listeners.js";
 import { createDiscordMessageHandler } from "./message-handler.js";
-import { createDiscordCommandArgFallbackButton, createDiscordNativeCommand, } from "./native-command.js";
+import { createDiscordCommandArgFallbackButton, createDiscordModelPickerFallbackButton, createDiscordModelPickerFallbackSelect, createDiscordNativeCommand, } from "./native-command.js";
 import { resolveDiscordPresenceUpdate } from "./presence.js";
+import { resolveDiscordAllowlistConfig } from "./provider.allowlist.js";
+import { runDiscordGatewayLifecycle } from "./provider.lifecycle.js";
 import { resolveDiscordRestFetch } from "./rest-fetch.js";
+import { createNoopThreadBindingManager, createThreadBindingManager } from "./thread-bindings.js";
 function summarizeAllowList(list) {
     if (!list || list.length === 0) {
         return "any";
@@ -45,6 +47,46 @@ function summarizeGuilds(entries) {
     const suffix = keys.length > sample.length ? ` (+${keys.length - sample.length})` : "";
     return `${sample.join(", ")}${suffix}`;
 }
+const DEFAULT_THREAD_BINDING_TTL_HOURS = 24;
+function normalizeThreadBindingTtlHours(raw) {
+    if (typeof raw !== "number" || !Number.isFinite(raw)) {
+        return undefined;
+    }
+    if (raw < 0) {
+        return undefined;
+    }
+    return raw;
+}
+function resolveThreadBindingSessionTtlMs(params) {
+    const ttlHours = normalizeThreadBindingTtlHours(params.channelTtlHoursRaw) ??
+        normalizeThreadBindingTtlHours(params.sessionTtlHoursRaw) ??
+        DEFAULT_THREAD_BINDING_TTL_HOURS;
+    return Math.floor(ttlHours * 60 * 60 * 1000);
+}
+function normalizeThreadBindingsEnabled(raw) {
+    if (typeof raw !== "boolean") {
+        return undefined;
+    }
+    return raw;
+}
+function resolveThreadBindingsEnabled(params) {
+    return (normalizeThreadBindingsEnabled(params.channelEnabledRaw) ??
+        normalizeThreadBindingsEnabled(params.sessionEnabledRaw) ??
+        true);
+}
+function formatThreadBindingSessionTtlLabel(ttlMs) {
+    if (ttlMs <= 0) {
+        return "off";
+    }
+    if (ttlMs < 60_000) {
+        return "<1m";
+    }
+    const totalMinutes = Math.floor(ttlMs / 60_000);
+    if (totalMinutes % 60 === 0) {
+        return `${Math.floor(totalMinutes / 60)}h`;
+    }
+    return `${totalMinutes}m`;
+}
 function dedupeSkillCommandsForDiscord(skillCommands) {
     const seen = new Set();
     const deduped = [];
@@ -106,6 +148,14 @@ function formatDiscordDeployErrorDetails(err) {
     }
     return details.length > 0 ? ` (${details.join(", ")})` : "";
 }
+const DISCORD_DISALLOWED_INTENTS_CODE = GatewayCloseCodes.DisallowedIntents;
+function isDiscordDisallowedIntentsError(err) {
+    if (!err) {
+        return false;
+    }
+    const message = formatErrorMessage(err);
+    return message.includes(String(DISCORD_DISALLOWED_INTENTS_CODE));
+}
 export async function monitorDiscordProvider(opts = {}) {
     const cfg = opts.config ?? loadConfig();
     const account = resolveDiscordAccount({
@@ -118,6 +168,8 @@ export async function monitorDiscordProvider(opts = {}) {
     }
     const runtime = opts.runtime ?? createNonExitingRuntime();
     const discordCfg = account.config;
+    const discordRootThreadBindings = cfg.channels?.discord?.threadBindings;
+    const discordAccountThreadBindings = cfg.channels?.discord?.accounts?.[account.accountId]?.threadBindings;
     const discordRestFetch = resolveDiscordRestFetch(discordCfg.proxy, runtime);
     const dmConfig = discordCfg.dm;
     let guildEntries = discordCfg.guilds;
@@ -138,6 +190,14 @@ export async function monitorDiscordProvider(opts = {}) {
     const replyToMode = opts.replyToMode ?? discordCfg.replyToMode ?? "off";
     const dmEnabled = dmConfig?.enabled ?? true;
     const dmPolicy = discordCfg.dmPolicy ?? dmConfig?.policy ?? "pairing";
+    const threadBindingSessionTtlMs = resolveThreadBindingSessionTtlMs({
+        channelTtlHoursRaw: discordAccountThreadBindings?.ttlHours ?? discordRootThreadBindings?.ttlHours,
+        sessionTtlHoursRaw: cfg.session?.threadBindings?.ttlHours,
+    });
+    const threadBindingsEnabled = resolveThreadBindingsEnabled({
+        channelEnabledRaw: discordAccountThreadBindings?.enabled ?? discordRootThreadBindings?.enabled,
+        sessionEnabledRaw: cfg.session?.threadBindings?.enabled,
+    });
     const groupDmEnabled = dmConfig?.groupEnabled ?? false;
     const groupDmChannels = dmConfig?.groupChannels;
     const nativeEnabled = resolveNativeCommandsEnabled({
@@ -155,148 +215,21 @@ export async function monitorDiscordProvider(opts = {}) {
         globalSetting: cfg.commands?.native,
     });
     const useAccessGroups = cfg.commands?.useAccessGroups !== false;
+    const slashCommand = resolveDiscordSlashCommandConfig(discordCfg.slashCommand);
     const sessionPrefix = "discord:slash";
-    const ephemeralDefault = true;
-    if (token) {
-        if (guildEntries && Object.keys(guildEntries).length > 0) {
-            try {
-                const entries = [];
-                for (const [guildKey, guildCfg] of Object.entries(guildEntries)) {
-                    if (guildKey === "*") {
-                        continue;
-                    }
-                    const channels = guildCfg?.channels ?? {};
-                    const channelKeys = Object.keys(channels).filter((key) => key !== "*");
-                    if (channelKeys.length === 0) {
-                        const input = /^\d+$/.test(guildKey) ? `guild:${guildKey}` : guildKey;
-                        entries.push({ input, guildKey });
-                        continue;
-                    }
-                    for (const channelKey of channelKeys) {
-                        entries.push({
-                            input: `${guildKey}/${channelKey}`,
-                            guildKey,
-                            channelKey,
-                        });
-                    }
-                }
-                if (entries.length > 0) {
-                    const resolved = await resolveDiscordChannelAllowlist({
-                        token,
-                        entries: entries.map((entry) => entry.input),
-                        fetcher: discordRestFetch,
-                    });
-                    const nextGuilds = { ...guildEntries };
-                    const mapping = [];
-                    const unresolved = [];
-                    for (const entry of resolved) {
-                        const source = entries.find((item) => item.input === entry.input);
-                        if (!source) {
-                            continue;
-                        }
-                        const sourceGuild = guildEntries?.[source.guildKey] ?? {};
-                        if (!entry.resolved || !entry.guildId) {
-                            unresolved.push(entry.input);
-                            continue;
-                        }
-                        mapping.push(entry.channelId
-                            ? `${entry.input}→${entry.guildId}/${entry.channelId}`
-                            : `${entry.input}→${entry.guildId}`);
-                        const existing = nextGuilds[entry.guildId] ?? {};
-                        const mergedChannels = { ...sourceGuild.channels, ...existing.channels };
-                        const mergedGuild = { ...sourceGuild, ...existing, channels: mergedChannels };
-                        nextGuilds[entry.guildId] = mergedGuild;
-                        if (source.channelKey && entry.channelId) {
-                            const sourceChannel = sourceGuild.channels?.[source.channelKey];
-                            if (sourceChannel) {
-                                nextGuilds[entry.guildId] = {
-                                    ...mergedGuild,
-                                    channels: {
-                                        ...mergedChannels,
-                                        [entry.channelId]: {
-                                            ...sourceChannel,
-                                            ...mergedChannels?.[entry.channelId],
-                                        },
-                                    },
-                                };
-                            }
-                        }
-                    }
-                    guildEntries = nextGuilds;
-                    summarizeMapping("discord channels", mapping, unresolved, runtime);
-                }
-            }
-            catch (err) {
-                runtime.log?.(`discord channel resolve failed; using config entries. ${formatErrorMessage(err)}`);
-            }
-        }
-        const allowEntries = allowFrom?.filter((entry) => String(entry).trim() && String(entry).trim() !== "*") ?? [];
-        if (allowEntries.length > 0) {
-            try {
-                const resolvedUsers = await resolveDiscordUserAllowlist({
-                    token,
-                    entries: allowEntries.map((entry) => String(entry)),
-                    fetcher: discordRestFetch,
-                });
-                const { mapping, unresolved, additions } = buildAllowlistResolutionSummary(resolvedUsers);
-                allowFrom = mergeAllowlist({ existing: allowFrom, additions });
-                summarizeMapping("discord users", mapping, unresolved, runtime);
-            }
-            catch (err) {
-                runtime.log?.(`discord user resolve failed; using config entries. ${formatErrorMessage(err)}`);
-            }
-        }
-        if (guildEntries && Object.keys(guildEntries).length > 0) {
-            const userEntries = new Set();
-            for (const guild of Object.values(guildEntries)) {
-                if (!guild || typeof guild !== "object") {
-                    continue;
-                }
-                addAllowlistUserEntriesFromConfigEntry(userEntries, guild);
-                const channels = guild.channels ?? {};
-                for (const channel of Object.values(channels)) {
-                    addAllowlistUserEntriesFromConfigEntry(userEntries, channel);
-                }
-            }
-            if (userEntries.size > 0) {
-                try {
-                    const resolvedUsers = await resolveDiscordUserAllowlist({
-                        token,
-                        entries: Array.from(userEntries),
-                        fetcher: discordRestFetch,
-                    });
-                    const { resolvedMap, mapping, unresolved } = buildAllowlistResolutionSummary(resolvedUsers);
-                    const nextGuilds = { ...guildEntries };
-                    for (const [guildKey, guildConfig] of Object.entries(guildEntries ?? {})) {
-                        if (!guildConfig || typeof guildConfig !== "object") {
-                            continue;
-                        }
-                        const nextGuild = { ...guildConfig };
-                        const users = guildConfig.users;
-                        if (Array.isArray(users) && users.length > 0) {
-                            const additions = resolveAllowlistIdAdditions({ existing: users, resolvedMap });
-                            nextGuild.users = mergeAllowlist({ existing: users, additions });
-                        }
-                        const channels = guildConfig.channels ?? {};
-                        if (channels && typeof channels === "object") {
-                            nextGuild.channels = patchAllowlistUsersInConfigEntries({
-                                entries: channels,
-                                resolvedMap,
-                            });
-                        }
-                        nextGuilds[guildKey] = nextGuild;
-                    }
-                    guildEntries = nextGuilds;
-                    summarizeMapping("discord channel users", mapping, unresolved, runtime);
-                }
-                catch (err) {
-                    runtime.log?.(`discord channel user resolve failed; using config entries. ${formatErrorMessage(err)}`);
-                }
-            }
-        }
-    }
+    const ephemeralDefault = slashCommand.ephemeral;
+    const voiceEnabled = discordCfg.voice?.enabled !== false;
+    const allowlistResolved = await resolveDiscordAllowlistConfig({
+        token,
+        guildEntries,
+        allowFrom,
+        fetcher: discordRestFetch,
+        runtime,
+    });
+    guildEntries = allowlistResolved.guildEntries;
+    allowFrom = allowlistResolved.allowFrom;
     if (shouldLogVerbose()) {
-        logVerbose(`discord: config dm=${dmEnabled ? "on" : "off"} dmPolicy=${dmPolicy} allowFrom=${summarizeAllowList(allowFrom)} groupDm=${groupDmEnabled ? "on" : "off"} groupDmChannels=${summarizeAllowList(groupDmChannels)} groupPolicy=${groupPolicy} guilds=${summarizeGuilds(guildEntries)} historyLimit=${historyLimit} mediaMaxMb=${Math.round(mediaMaxBytes / (1024 * 1024))} native=${nativeEnabled ? "on" : "off"} nativeSkills=${nativeSkillsEnabled ? "on" : "off"} accessGroups=${useAccessGroups ? "on" : "off"}`);
+        logVerbose(`discord: config dm=${dmEnabled ? "on" : "off"} dmPolicy=${dmPolicy} allowFrom=${summarizeAllowList(allowFrom)} groupDm=${groupDmEnabled ? "on" : "off"} groupDmChannels=${summarizeAllowList(groupDmChannels)} groupPolicy=${groupPolicy} guilds=${summarizeGuilds(guildEntries)} historyLimit=${historyLimit} mediaMaxMb=${Math.round(mediaMaxBytes / (1024 * 1024))} native=${nativeEnabled ? "on" : "off"} nativeSkills=${nativeSkillsEnabled ? "on" : "off"} accessGroups=${useAccessGroups ? "on" : "off"} threadBindings=${threadBindingsEnabled ? "on" : "off"} threadSessionTtl=${formatThreadBindingSessionTtlLabel(threadBindingSessionTtlMs)}`);
     }
     const applicationId = await fetchDiscordApplicationId(token, 4000, discordRestFetch);
     if (!applicationId) {
@@ -318,223 +251,217 @@ export async function monitorDiscordProvider(opts = {}) {
     if (nativeEnabled && commandSpecs.length > maxDiscordCommands) {
         runtime.log?.(warn(`discord: ${commandSpecs.length} commands exceeds limit; some commands may fail to deploy.`));
     }
-    const commands = commandSpecs.map((spec) => createDiscordNativeCommand({
-        command: spec,
-        cfg,
-        discordConfig: discordCfg,
-        accountId: account.accountId,
-        sessionPrefix,
-        ephemeralDefault,
-    }));
-    // Initialize exec approvals handler if enabled
-    const execApprovalsConfig = discordCfg.execApprovals ?? {};
-    const execApprovalsHandler = execApprovalsConfig.enabled
-        ? new DiscordExecApprovalHandler({
-            token,
+    const voiceManagerRef = { current: null };
+    const threadBindings = threadBindingsEnabled
+        ? createThreadBindingManager({
             accountId: account.accountId,
-            config: execApprovalsConfig,
-            cfg,
-            runtime,
+            token,
+            sessionTtlMs: threadBindingSessionTtlMs,
         })
-        : null;
-    const agentComponentsConfig = discordCfg.agentComponents ?? {};
-    const agentComponentsEnabled = agentComponentsConfig.enabled ?? true;
-    const components = [
-        createDiscordCommandArgFallbackButton({
+        : createNoopThreadBindingManager(account.accountId);
+    let lifecycleStarted = false;
+    try {
+        const commands = commandSpecs.map((spec) => createDiscordNativeCommand({
+            command: spec,
             cfg,
             discordConfig: discordCfg,
             accountId: account.accountId,
             sessionPrefix,
-        }),
-    ];
-    const modals = [];
-    if (execApprovalsHandler) {
-        components.push(createExecApprovalButton({ handler: execApprovalsHandler }));
-    }
-    if (agentComponentsEnabled) {
-        const componentContext = {
+            ephemeralDefault,
+            threadBindings,
+        }));
+        if (nativeEnabled && voiceEnabled) {
+            commands.push(createDiscordVoiceCommand({
+                cfg,
+                discordConfig: discordCfg,
+                accountId: account.accountId,
+                groupPolicy,
+                useAccessGroups,
+                getManager: () => voiceManagerRef.current,
+                ephemeralDefault,
+            }));
+        }
+        // Initialize exec approvals handler if enabled
+        const execApprovalsConfig = discordCfg.execApprovals ?? {};
+        const execApprovalsHandler = execApprovalsConfig.enabled
+            ? new DiscordExecApprovalHandler({
+                token,
+                accountId: account.accountId,
+                config: execApprovalsConfig,
+                cfg,
+                runtime,
+            })
+            : null;
+        const agentComponentsConfig = discordCfg.agentComponents ?? {};
+        const agentComponentsEnabled = agentComponentsConfig.enabled ?? true;
+        const components = [
+            createDiscordCommandArgFallbackButton({
+                cfg,
+                discordConfig: discordCfg,
+                accountId: account.accountId,
+                sessionPrefix,
+                threadBindings,
+            }),
+            createDiscordModelPickerFallbackButton({
+                cfg,
+                discordConfig: discordCfg,
+                accountId: account.accountId,
+                sessionPrefix,
+                threadBindings,
+            }),
+            createDiscordModelPickerFallbackSelect({
+                cfg,
+                discordConfig: discordCfg,
+                accountId: account.accountId,
+                sessionPrefix,
+                threadBindings,
+            }),
+        ];
+        const modals = [];
+        if (execApprovalsHandler) {
+            components.push(createExecApprovalButton({ handler: execApprovalsHandler }));
+        }
+        if (agentComponentsEnabled) {
+            const componentContext = {
+                cfg,
+                discordConfig: discordCfg,
+                accountId: account.accountId,
+                guildEntries,
+                allowFrom,
+                dmPolicy,
+                runtime,
+                token,
+            };
+            components.push(createAgentComponentButton(componentContext));
+            components.push(createAgentSelectMenu(componentContext));
+            components.push(createDiscordComponentButton(componentContext));
+            components.push(createDiscordComponentStringSelect(componentContext));
+            components.push(createDiscordComponentUserSelect(componentContext));
+            components.push(createDiscordComponentRoleSelect(componentContext));
+            components.push(createDiscordComponentMentionableSelect(componentContext));
+            components.push(createDiscordComponentChannelSelect(componentContext));
+            modals.push(createDiscordComponentModal(componentContext));
+        }
+        class DiscordStatusReadyListener extends ReadyListener {
+            async handle(_data, client) {
+                const gateway = client.getPlugin("gateway");
+                if (!gateway) {
+                    return;
+                }
+                const presence = resolveDiscordPresenceUpdate(discordCfg);
+                if (!presence) {
+                    return;
+                }
+                gateway.updatePresence(presence);
+            }
+        }
+        const clientPlugins = [
+            createDiscordGatewayPlugin({ discordConfig: discordCfg, runtime }),
+        ];
+        if (voiceEnabled) {
+            clientPlugins.push(new VoicePlugin());
+        }
+        const client = new Client({
+            baseUrl: "http://localhost",
+            deploySecret: "a",
+            clientId: applicationId,
+            publicKey: "a",
+            token,
+            autoDeploy: false,
+        }, {
+            commands,
+            listeners: [new DiscordStatusReadyListener()],
+            components,
+            modals,
+        }, clientPlugins);
+        await deployDiscordCommands({ client, runtime, enabled: nativeEnabled });
+        const logger = createSubsystemLogger("discord/monitor");
+        const guildHistories = new Map();
+        let botUserId;
+        let voiceManager = null;
+        if (nativeDisabledExplicit) {
+            await clearDiscordNativeCommands({
+                client,
+                applicationId,
+                runtime,
+            });
+        }
+        try {
+            const botUser = await client.fetchUser("@me");
+            botUserId = botUser?.id;
+        }
+        catch (err) {
+            runtime.error?.(danger(`discord: failed to fetch bot identity: ${String(err)}`));
+        }
+        if (voiceEnabled) {
+            voiceManager = new DiscordVoiceManager({
+                client,
+                cfg,
+                discordConfig: discordCfg,
+                accountId: account.accountId,
+                runtime,
+                botUserId,
+            });
+            voiceManagerRef.current = voiceManager;
+            registerDiscordListener(client.listeners, new DiscordVoiceReadyListener(voiceManager));
+        }
+        const messageHandler = createDiscordMessageHandler({
             cfg,
             discordConfig: discordCfg,
             accountId: account.accountId,
-            guildEntries,
+            token,
+            runtime,
+            botUserId,
+            guildHistories,
+            historyLimit,
+            mediaMaxBytes,
+            textLimit,
+            replyToMode,
+            dmEnabled,
+            groupDmEnabled,
+            groupDmChannels,
             allowFrom,
-            dmPolicy,
+            guildEntries,
+            threadBindings,
+        });
+        registerDiscordListener(client.listeners, new DiscordMessageListener(messageHandler, logger));
+        registerDiscordListener(client.listeners, new DiscordReactionListener({
+            cfg,
+            accountId: account.accountId,
             runtime,
-            token,
-        };
-        components.push(createAgentComponentButton(componentContext));
-        components.push(createAgentSelectMenu(componentContext));
-        components.push(createDiscordComponentButton(componentContext));
-        components.push(createDiscordComponentStringSelect(componentContext));
-        components.push(createDiscordComponentUserSelect(componentContext));
-        components.push(createDiscordComponentRoleSelect(componentContext));
-        components.push(createDiscordComponentMentionableSelect(componentContext));
-        components.push(createDiscordComponentChannelSelect(componentContext));
-        modals.push(createDiscordComponentModal(componentContext));
-    }
-    class DiscordStatusReadyListener extends ReadyListener {
-        async handle(_data, client) {
-            const gateway = client.getPlugin("gateway");
-            if (!gateway) {
-                return;
-            }
-            const presence = resolveDiscordPresenceUpdate(discordCfg);
-            if (!presence) {
-                return;
-            }
-            gateway.updatePresence(presence);
+            botUserId,
+            guildEntries,
+            logger,
+        }));
+        registerDiscordListener(client.listeners, new DiscordReactionRemoveListener({
+            cfg,
+            accountId: account.accountId,
+            runtime,
+            botUserId,
+            guildEntries,
+            logger,
+        }));
+        if (discordCfg.intents?.presence) {
+            registerDiscordListener(client.listeners, new DiscordPresenceListener({ logger, accountId: account.accountId }));
+            runtime.log?.("discord: GuildPresences intent enabled — presence listener registered");
         }
-    }
-    const client = new Client({
-        baseUrl: "http://localhost",
-        deploySecret: "a",
-        clientId: applicationId,
-        publicKey: "a",
-        token,
-        autoDeploy: false,
-    }, {
-        commands,
-        listeners: [new DiscordStatusReadyListener()],
-        components,
-        modals,
-    }, [createDiscordGatewayPlugin({ discordConfig: discordCfg, runtime })]);
-    await deployDiscordCommands({ client, runtime, enabled: nativeEnabled });
-    const logger = createSubsystemLogger("discord/monitor");
-    const guildHistories = new Map();
-    let botUserId;
-    if (nativeDisabledExplicit) {
-        await clearDiscordNativeCommands({
+        runtime.log?.(`logged in to discord${botUserId ? ` as ${botUserId}` : ""}`);
+        lifecycleStarted = true;
+        await runDiscordGatewayLifecycle({
+            accountId: account.accountId,
             client,
-            applicationId,
             runtime,
-        });
-    }
-    try {
-        const botUser = await client.fetchUser("@me");
-        botUserId = botUser?.id;
-    }
-    catch (err) {
-        runtime.error?.(danger(`discord: failed to fetch bot identity: ${String(err)}`));
-    }
-    const messageHandler = createDiscordMessageHandler({
-        cfg,
-        discordConfig: discordCfg,
-        accountId: account.accountId,
-        token,
-        runtime,
-        botUserId,
-        guildHistories,
-        historyLimit,
-        mediaMaxBytes,
-        textLimit,
-        replyToMode,
-        dmEnabled,
-        groupDmEnabled,
-        groupDmChannels,
-        allowFrom,
-        guildEntries,
-    });
-    registerDiscordListener(client.listeners, new DiscordMessageListener(messageHandler, logger));
-    registerDiscordListener(client.listeners, new DiscordReactionListener({
-        cfg,
-        accountId: account.accountId,
-        runtime,
-        botUserId,
-        guildEntries,
-        logger,
-    }));
-    registerDiscordListener(client.listeners, new DiscordReactionRemoveListener({
-        cfg,
-        accountId: account.accountId,
-        runtime,
-        botUserId,
-        guildEntries,
-        logger,
-    }));
-    if (discordCfg.intents?.presence) {
-        registerDiscordListener(client.listeners, new DiscordPresenceListener({ logger, accountId: account.accountId }));
-        runtime.log?.("discord: GuildPresences intent enabled — presence listener registered");
-    }
-    runtime.log?.(`logged in to discord${botUserId ? ` as ${botUserId}` : ""}`);
-    // Start exec approvals handler after client is ready
-    if (execApprovalsHandler) {
-        await execApprovalsHandler.start();
-    }
-    const gateway = client.getPlugin("gateway");
-    if (gateway) {
-        registerGateway(account.accountId, gateway);
-    }
-    const gatewayEmitter = getDiscordGatewayEmitter(gateway);
-    const stopGatewayLogging = attachDiscordGatewayLogging({
-        emitter: gatewayEmitter,
-        runtime,
-    });
-    const abortSignal = opts.abortSignal;
-    const onAbort = () => {
-        if (!gateway) {
-            return;
-        }
-        // Carbon emits an error when maxAttempts is 0; keep a one-shot listener to avoid
-        // an unhandled error after we tear down listeners during abort.
-        gatewayEmitter?.once("error", () => { });
-        gateway.options.reconnect = { maxAttempts: 0 };
-        gateway.disconnect();
-    };
-    if (abortSignal?.aborted) {
-        onAbort();
-    }
-    else {
-        abortSignal?.addEventListener("abort", onAbort, { once: true });
-    }
-    // Timeout to detect zombie connections where HELLO is never received.
-    const HELLO_TIMEOUT_MS = 30000;
-    let helloTimeoutId;
-    const onGatewayDebug = (msg) => {
-        const message = String(msg);
-        if (!message.includes("WebSocket connection opened")) {
-            return;
-        }
-        if (helloTimeoutId) {
-            clearTimeout(helloTimeoutId);
-        }
-        helloTimeoutId = setTimeout(() => {
-            if (!gateway?.isConnected) {
-                runtime.log?.(danger(`connection stalled: no HELLO received within ${HELLO_TIMEOUT_MS}ms, forcing reconnect`));
-                gateway?.disconnect();
-                gateway?.connect(false);
-            }
-            helloTimeoutId = undefined;
-        }, HELLO_TIMEOUT_MS);
-    };
-    gatewayEmitter?.on("debug", onGatewayDebug);
-    try {
-        await waitForDiscordGatewayStop({
-            gateway: gateway
-                ? {
-                    emitter: gatewayEmitter,
-                    disconnect: () => gateway.disconnect(),
-                }
-                : undefined,
-            abortSignal,
-            onGatewayError: (err) => {
-                runtime.error?.(danger(`discord gateway error: ${String(err)}`));
-            },
-            shouldStopOnError: (err) => {
-                const message = String(err);
-                return (message.includes("Max reconnect attempts") || message.includes("Fatal Gateway error"));
-            },
+            abortSignal: opts.abortSignal,
+            isDisallowedIntentsError: isDiscordDisallowedIntentsError,
+            voiceManager,
+            voiceManagerRef,
+            execApprovalsHandler,
+            threadBindings,
         });
     }
     finally {
-        unregisterGateway(account.accountId);
-        stopGatewayLogging();
-        if (helloTimeoutId) {
-            clearTimeout(helloTimeoutId);
-        }
-        gatewayEmitter?.removeListener("debug", onGatewayDebug);
-        abortSignal?.removeEventListener("abort", onAbort);
-        if (execApprovalsHandler) {
-            await execApprovalsHandler.stop();
+        if (!lifecycleStarted) {
+            threadBindings.stop();
         }
     }
 }
@@ -553,4 +480,5 @@ export const __testing = {
     createDiscordGatewayPlugin,
     dedupeSkillCommandsForDiscord,
     resolveDiscordRestFetch,
+    resolveThreadBindingsEnabled,
 };