@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/discord/monitor/allow-list.js

@@ -1,15 +1,17 @@
 import { buildChannelKeyCandidates, resolveChannelEntryMatchWithFallback, resolveChannelMatchConfig, } from "../../channels/channel-config.js";
 import { formatDiscordUserTag } from "./format.js";
 export function normalizeDiscordAllowList(raw, prefixes) {
-    if (!raw || raw.length === 0)
+    if (!raw || raw.length === 0) {
         return null;
+    }
     const ids = new Set();
     const names = new Set();
     const allowAll = raw.some((entry) => String(entry).trim() === "*");
     for (const entry of raw) {
         const text = String(entry).trim();
-        if (!text || text === "*")
+        if (!text || text === "*") {
             continue;
+        }
         const normalized = normalizeDiscordSlug(text);
         const maybeId = text.replace(/^<@!?/, "").replace(/>$/, "");
         if (/^\d+$/.test(maybeId)) {
@@ -19,8 +21,9 @@ export function normalizeDiscordAllowList(raw, prefixes) {
         const prefix = prefixes.find((entry) => text.startsWith(entry));
         if (prefix) {
             const candidate = text.slice(prefix.length);
-            if (candidate)
+            if (candidate) {
                 ids.add(candidate);
+            }
             continue;
         }
         if (normalized) {
@@ -38,15 +41,19 @@ export function normalizeDiscordSlug(value) {
         .replace(/^-+|-+$/g, "");
 }
 export function allowListMatches(list, candidate) {
-    if (list.allowAll)
+    if (list.allowAll) {
         return true;
-    if (candidate.id && list.ids.has(candidate.id))
+    }
+    if (candidate.id && list.ids.has(candidate.id)) {
         return true;
+    }
     const slug = candidate.name ? normalizeDiscordSlug(candidate.name) : "";
-    if (slug && list.names.has(slug))
+    if (slug && list.names.has(slug)) {
         return true;
-    if (candidate.tag && list.names.has(normalizeDiscordSlug(candidate.tag)))
+    }
+    if (candidate.tag && list.names.has(normalizeDiscordSlug(candidate.tag))) {
         return true;
+    }
     return false;
 }
 export function resolveDiscordAllowListMatch(params) {
@@ -69,25 +76,62 @@ export function resolveDiscordAllowListMatch(params) {
 }
 export function resolveDiscordUserAllowed(params) {
     const allowList = normalizeDiscordAllowList(params.allowList, ["discord:", "user:", "pk:"]);
-    if (!allowList)
+    if (!allowList) {
         return true;
+    }
     return allowListMatches(allowList, {
         id: params.userId,
         name: params.userName,
         tag: params.userTag,
     });
 }
-export function resolveDiscordCommandAuthorized(params) {
-    if (!params.isDirectMessage)
+export function resolveDiscordRoleAllowed(params) {
+    // Role allowlists accept role IDs only. Names are ignored.
+    const allowList = normalizeDiscordAllowList(params.allowList, ["role:"]);
+    if (!allowList) {
         return true;
-    const allowList = normalizeDiscordAllowList(params.allowFrom, ["discord:", "user:", "pk:"]);
-    if (!allowList)
+    }
+    if (allowList.allowAll) {
         return true;
-    return allowListMatches(allowList, {
-        id: params.author.id,
-        name: params.author.username,
-        tag: formatDiscordUserTag(params.author),
+    }
+    return params.memberRoleIds.some((roleId) => allowList.ids.has(roleId));
+}
+export function resolveDiscordMemberAllowed(params) {
+    const hasUserRestriction = Array.isArray(params.userAllowList) && params.userAllowList.length > 0;
+    const hasRoleRestriction = Array.isArray(params.roleAllowList) && params.roleAllowList.length > 0;
+    if (!hasUserRestriction && !hasRoleRestriction) {
+        return true;
+    }
+    const userOk = hasUserRestriction
+        ? resolveDiscordUserAllowed({
+            allowList: params.userAllowList,
+            userId: params.userId,
+            userName: params.userName,
+            userTag: params.userTag,
+        })
+        : false;
+    const roleOk = hasRoleRestriction
+        ? resolveDiscordRoleAllowed({
+            allowList: params.roleAllowList,
+            memberRoleIds: params.memberRoleIds,
+        })
+        : false;
+    return userOk || roleOk;
+}
+export function resolveDiscordMemberAccessState(params) {
+    const channelUsers = params.channelConfig?.users ?? params.guildInfo?.users;
+    const channelRoles = params.channelConfig?.roles ?? params.guildInfo?.roles;
+    const hasAccessRestrictions = (Array.isArray(channelUsers) && channelUsers.length > 0) ||
+        (Array.isArray(channelRoles) && channelRoles.length > 0);
+    const memberAllowed = resolveDiscordMemberAllowed({
+        userAllowList: channelUsers,
+        roleAllowList: channelRoles,
+        memberRoleIds: params.memberRoleIds,
+        userId: params.sender.id,
+        userName: params.sender.name,
+        userTag: params.sender.tag,
     });
+    return { channelUsers, channelRoles, hasAccessRestrictions, memberAllowed };
 }
 export function resolveDiscordOwnerAllowFrom(params) {
     const rawAllowList = params.channelConfig?.users ?? params.guildInfo?.users;
@@ -111,21 +155,39 @@ export function resolveDiscordOwnerAllowFrom(params) {
     }
     return [match.matchKey];
 }
+export function resolveDiscordCommandAuthorized(params) {
+    if (!params.isDirectMessage) {
+        return true;
+    }
+    const allowList = normalizeDiscordAllowList(params.allowFrom, ["discord:", "user:", "pk:"]);
+    if (!allowList) {
+        return true;
+    }
+    return allowListMatches(allowList, {
+        id: params.author.id,
+        name: params.author.username,
+        tag: formatDiscordUserTag(params.author),
+    });
+}
 export function resolveDiscordGuildEntry(params) {
     const guild = params.guild;
     const entries = params.guildEntries;
-    if (!guild || !entries)
+    if (!guild || !entries) {
         return null;
+    }
     const byId = entries[guild.id];
-    if (byId)
+    if (byId) {
         return { ...byId, id: guild.id };
+    }
     const slug = normalizeDiscordSlug(guild.name ?? "");
     const bySlug = entries[slug];
-    if (bySlug)
+    if (bySlug) {
         return { ...bySlug, id: guild.id, slug: slug || bySlug.slug };
+    }
     const wildcard = entries["*"];
-    if (wildcard)
+    if (wildcard) {
         return { ...wildcard, id: guild.id, slug: slug || wildcard.slug };
+    }
     return null;
 }
 function buildDiscordChannelKeys(params) {
@@ -142,6 +204,9 @@ function resolveDiscordChannelEntryMatch(channels, params, parentParams) {
         wildcardKey: "*",
     });
 }
+function hasConfiguredDiscordChannels(channels) {
+    return Boolean(channels && Object.keys(channels).length > 0);
+}
 function resolveDiscordChannelConfigEntry(entry) {
     const resolved = {
         allowed: entry.allow !== false,
@@ -149,6 +214,7 @@ function resolveDiscordChannelConfigEntry(entry) {
         skills: entry.skills,
         enabled: entry.enabled,
         users: entry.users,
+        roles: entry.roles,
         systemPrompt: entry.systemPrompt,
         includeThreadStarter: entry.includeThreadStarter,
         autoThread: entry.autoThread,
@@ -158,8 +224,9 @@ function resolveDiscordChannelConfigEntry(entry) {
 export function resolveDiscordChannelConfig(params) {
     const { guildInfo, channelId, channelName, channelSlug } = params;
     const channels = guildInfo?.channels;
-    if (!channels)
+    if (!hasConfiguredDiscordChannels(channels)) {
         return null;
+    }
     const match = resolveDiscordChannelEntryMatch(channels, {
         id: channelId,
         name: channelName,
@@ -171,8 +238,9 @@ export function resolveDiscordChannelConfig(params) {
 export function resolveDiscordChannelConfigWithFallback(params) {
     const { guildInfo, channelId, channelName, channelSlug, parentId, parentName, parentSlug, scope, } = params;
     const channels = guildInfo?.channels;
-    if (!channels)
+    if (!hasConfiguredDiscordChannels(channels)) {
         return null;
+    }
     const resolvedParentSlug = parentSlug ?? (parentName ? normalizeDiscordSlug(parentName) : "");
     const match = resolveDiscordChannelEntryMatch(channels, {
         id: channelId,
@@ -189,39 +257,48 @@ export function resolveDiscordChannelConfigWithFallback(params) {
     return resolveChannelMatchConfig(match, resolveDiscordChannelConfigEntry) ?? { allowed: false };
 }
 export function resolveDiscordShouldRequireMention(params) {
-    if (!params.isGuildMessage)
+    if (!params.isGuildMessage) {
         return false;
+    }
     // Only skip mention requirement in threads created by the bot (when autoThread is enabled).
     const isBotThread = params.isAutoThreadOwnedByBot ?? isDiscordAutoThreadOwnedByBot(params);
-    if (isBotThread)
+    if (isBotThread) {
         return false;
+    }
     return params.channelConfig?.requireMention ?? params.guildInfo?.requireMention ?? true;
 }
 export function isDiscordAutoThreadOwnedByBot(params) {
-    if (!params.isThread)
+    if (!params.isThread) {
         return false;
-    if (!params.channelConfig?.autoThread)
+    }
+    if (!params.channelConfig?.autoThread) {
         return false;
+    }
     const botId = params.botId?.trim();
     const threadOwnerId = params.threadOwnerId?.trim();
     return Boolean(botId && threadOwnerId && botId === threadOwnerId);
 }
 export function isDiscordGroupAllowedByPolicy(params) {
     const { groupPolicy, guildAllowlisted, channelAllowlistConfigured, channelAllowed } = params;
-    if (groupPolicy === "disabled")
+    if (groupPolicy === "disabled") {
         return false;
-    if (groupPolicy === "open")
+    }
+    if (groupPolicy === "open") {
         return true;
-    if (!guildAllowlisted)
+    }
+    if (!guildAllowlisted) {
         return false;
-    if (!channelAllowlistConfigured)
+    }
+    if (!channelAllowlistConfigured) {
         return true;
+    }
     return channelAllowed;
 }
 export function resolveGroupDmAllow(params) {
     const { channels, channelId, channelName, channelSlug } = params;
-    if (!channels || channels.length === 0)
+    if (!channels || channels.length === 0) {
         return true;
+    }
     const allowList = new Set(channels.map((entry) => normalizeDiscordSlug(String(entry))));
     const candidates = [
         normalizeDiscordSlug(channelId),
@@ -232,17 +309,20 @@ export function resolveGroupDmAllow(params) {
 }
 export function shouldEmitDiscordReactionNotification(params) {
     const mode = params.mode ?? "own";
-    if (mode === "off")
+    if (mode === "off") {
         return false;
-    if (mode === "all")
+    }
+    if (mode === "all") {
         return true;
+    }
     if (mode === "own") {
         return Boolean(params.botId && params.messageAuthorId === params.botId);
     }
     if (mode === "allowlist") {
         const list = normalizeDiscordAllowList(params.allowlist, ["discord:", "user:", "pk:"]);
-        if (!list)
+        if (!list) {
             return false;
+        }
         return allowListMatches(list, {
             id: params.userId,
             name: params.userName,

package/dist/discord/monitor/listeners.js

@@ -1,18 +1,19 @@
 import { ChannelType, MessageCreateListener, MessageReactionAddListener, MessageReactionRemoveListener, PresenceUpdateListener, } from "@buape/carbon";
 import { danger } from "../../globals.js";
-import { formatDurationSeconds } from "../../infra/format-duration.js";
+import { formatDurationSeconds } from "../../infra/format-time/format-duration.js";
 import { enqueueSystemEvent } from "../../infra/system-events.js";
-import { setPresence } from "./presence-cache.js";
 import { createSubsystemLogger } from "../../logging/subsystem.js";
 import { resolveAgentRoute } from "../../routing/resolve-route.js";
 import { normalizeDiscordSlug, resolveDiscordChannelConfigWithFallback, resolveDiscordGuildEntry, shouldEmitDiscordReactionNotification, } from "./allow-list.js";
 import { formatDiscordReactionEmoji, formatDiscordUserTag } from "./format.js";
 import { resolveDiscordChannelInfo } from "./message-utils.js";
+import { setPresence } from "./presence-cache.js";
 const DISCORD_SLOW_LISTENER_THRESHOLD_MS = 30_000;
 const discordEventQueueLog = createSubsystemLogger("discord/event-queue");
 function logSlowDiscordListener(params) {
-    if (params.durationMs < DISCORD_SLOW_LISTENER_THRESHOLD_MS)
+    if (params.durationMs < DISCORD_SLOW_LISTENER_THRESHOLD_MS) {
         return;
+    }
     const duration = formatDurationSeconds(params.durationMs, {
         decimals: 1,
         unit: "seconds",
@@ -67,27 +68,14 @@ export class DiscordReactionListener extends MessageReactionAddListener {
         this.params = params;
     }
     async handle(data, client) {
-        const startedAt = Date.now();
-        try {
-            await handleDiscordReactionEvent({
-                data,
-                client,
-                action: "added",
-                cfg: this.params.cfg,
-                accountId: this.params.accountId,
-                botUserId: this.params.botUserId,
-                guildEntries: this.params.guildEntries,
-                logger: this.params.logger,
-            });
-        }
-        finally {
-            logSlowDiscordListener({
-                logger: this.params.logger,
-                listener: this.constructor.name,
-                event: this.type,
-                durationMs: Date.now() - startedAt,
-            });
-        }
+        await runDiscordReactionHandler({
+            data,
+            client,
+            action: "added",
+            handlerParams: this.params,
+            listener: this.constructor.name,
+            event: this.type,
+        });
     }
 }
 export class DiscordReactionRemoveListener extends MessageReactionRemoveListener {
@@ -97,69 +85,200 @@ export class DiscordReactionRemoveListener extends MessageReactionRemoveListener
         this.params = params;
     }
     async handle(data, client) {
-        const startedAt = Date.now();
-        try {
-            await handleDiscordReactionEvent({
-                data,
-                client,
-                action: "removed",
-                cfg: this.params.cfg,
-                accountId: this.params.accountId,
-                botUserId: this.params.botUserId,
-                guildEntries: this.params.guildEntries,
-                logger: this.params.logger,
-            });
-        }
-        finally {
-            logSlowDiscordListener({
-                logger: this.params.logger,
-                listener: this.constructor.name,
-                event: this.type,
-                durationMs: Date.now() - startedAt,
-            });
-        }
+        await runDiscordReactionHandler({
+            data,
+            client,
+            action: "removed",
+            handlerParams: this.params,
+            listener: this.constructor.name,
+            event: this.type,
+        });
+    }
+}
+async function runDiscordReactionHandler(params) {
+    const startedAt = Date.now();
+    try {
+        await handleDiscordReactionEvent({
+            data: params.data,
+            client: params.client,
+            action: params.action,
+            cfg: params.handlerParams.cfg,
+            accountId: params.handlerParams.accountId,
+            botUserId: params.handlerParams.botUserId,
+            guildEntries: params.handlerParams.guildEntries,
+            logger: params.handlerParams.logger,
+        });
+    }
+    finally {
+        logSlowDiscordListener({
+            logger: params.handlerParams.logger,
+            listener: params.listener,
+            event: params.event,
+            durationMs: Date.now() - startedAt,
+        });
     }
 }
 async function handleDiscordReactionEvent(params) {
     try {
         const { data, client, action, botUserId, guildEntries } = params;
-        if (!("user" in data))
+        if (!("user" in data)) {
             return;
+        }
         const user = data.user;
-        if (!user || user.bot)
+        if (!user || user.bot) {
             return;
-        if (!data.guild_id)
+        }
+        // Early exit: skip bot's own reactions before expensive network calls
+        if (botUserId && user.id === botUserId) {
             return;
-        const guildInfo = resolveDiscordGuildEntry({
-            guild: data.guild ?? undefined,
-            guildEntries,
-        });
-        if (guildEntries && Object.keys(guildEntries).length > 0 && !guildInfo) {
+        }
+        const isGuildMessage = Boolean(data.guild_id);
+        const guildInfo = isGuildMessage
+            ? resolveDiscordGuildEntry({
+                guild: data.guild ?? undefined,
+                guildEntries,
+            })
+            : null;
+        if (isGuildMessage && guildEntries && Object.keys(guildEntries).length > 0 && !guildInfo) {
             return;
         }
         const channel = await client.fetchChannel(data.channel_id);
-        if (!channel)
+        if (!channel) {
             return;
+        }
         const channelName = "name" in channel ? (channel.name ?? undefined) : undefined;
         const channelSlug = channelName ? normalizeDiscordSlug(channelName) : "";
         const channelType = "type" in channel ? channel.type : undefined;
+        const isDirectMessage = channelType === ChannelType.DM;
+        const isGroupDm = channelType === ChannelType.GroupDM;
         const isThreadChannel = channelType === ChannelType.PublicThread ||
             channelType === ChannelType.PrivateThread ||
             channelType === ChannelType.AnnouncementThread;
         let parentId = "parentId" in channel ? (channel.parentId ?? undefined) : undefined;
         let parentName;
         let parentSlug = "";
-        if (isThreadChannel) {
+        const memberRoleIds = Array.isArray(data.rawMember?.roles)
+            ? data.rawMember.roles.map((roleId) => String(roleId))
+            : [];
+        let reactionBase = null;
+        const resolveReactionBase = () => {
+            if (reactionBase) {
+                return reactionBase;
+            }
+            const emojiLabel = formatDiscordReactionEmoji(data.emoji);
+            const actorLabel = formatDiscordUserTag(user);
+            const guildSlug = guildInfo?.slug ||
+                (data.guild?.name
+                    ? normalizeDiscordSlug(data.guild.name)
+                    : (data.guild_id ?? (isGroupDm ? "group-dm" : "dm")));
+            const channelLabel = channelSlug
+                ? `#${channelSlug}`
+                : channelName
+                    ? `#${normalizeDiscordSlug(channelName)}`
+                    : `#${data.channel_id}`;
+            const baseText = `Discord reaction ${action}: ${emojiLabel} by ${actorLabel} on ${guildSlug} ${channelLabel} msg ${data.message_id}`;
+            const contextKey = `discord:reaction:${action}:${data.message_id}:${user.id}:${emojiLabel}`;
+            reactionBase = { baseText, contextKey };
+            return reactionBase;
+        };
+        const emitReaction = (text, parentPeerId) => {
+            const { contextKey } = resolveReactionBase();
+            const route = resolveAgentRoute({
+                cfg: params.cfg,
+                channel: "discord",
+                accountId: params.accountId,
+                guildId: data.guild_id ?? undefined,
+                memberRoleIds,
+                peer: {
+                    kind: isDirectMessage ? "direct" : isGroupDm ? "group" : "channel",
+                    id: isDirectMessage ? user.id : data.channel_id,
+                },
+                parentPeer: parentPeerId ? { kind: "channel", id: parentPeerId } : undefined,
+            });
+            enqueueSystemEvent(text, {
+                sessionKey: route.sessionKey,
+                contextKey,
+            });
+        };
+        const shouldNotifyReaction = (options) => shouldEmitDiscordReactionNotification({
+            mode: options.mode,
+            botId: botUserId,
+            messageAuthorId: options.messageAuthorId,
+            userId: user.id,
+            userName: user.username,
+            userTag: formatDiscordUserTag(user),
+            allowlist: guildInfo?.users,
+        });
+        const emitReactionWithAuthor = (message) => {
+            const { baseText } = resolveReactionBase();
+            const authorLabel = message?.author ? formatDiscordUserTag(message.author) : undefined;
+            const text = authorLabel ? `${baseText} from ${authorLabel}` : baseText;
+            emitReaction(text, parentId);
+        };
+        const loadThreadParentInfo = async () => {
             if (!parentId) {
-                const channelInfo = await resolveDiscordChannelInfo(client, data.channel_id);
+                return;
+            }
+            const parentInfo = await resolveDiscordChannelInfo(client, parentId);
+            parentName = parentInfo?.name;
+            parentSlug = parentName ? normalizeDiscordSlug(parentName) : "";
+        };
+        const resolveThreadChannelConfig = () => resolveDiscordChannelConfigWithFallback({
+            guildInfo,
+            channelId: data.channel_id,
+            channelName,
+            channelSlug,
+            parentId,
+            parentName,
+            parentSlug,
+            scope: "thread",
+        });
+        // Parallelize async operations for thread channels
+        if (isThreadChannel) {
+            const reactionMode = guildInfo?.reactionNotifications ?? "own";
+            // Early exit: skip fetching message if notifications are off
+            if (reactionMode === "off") {
+                return;
+            }
+            const channelInfoPromise = parentId
+                ? Promise.resolve({ parentId })
+                : resolveDiscordChannelInfo(client, data.channel_id);
+            // Fast path: for "all" and "allowlist" modes, we don't need to fetch the message
+            if (reactionMode === "all" || reactionMode === "allowlist") {
+                const channelInfo = await channelInfoPromise;
                 parentId = channelInfo?.parentId;
+                await loadThreadParentInfo();
+                const channelConfig = resolveThreadChannelConfig();
+                if (channelConfig?.allowed === false) {
+                    return;
+                }
+                // For allowlist mode, check if user is in allowlist first
+                if (reactionMode === "allowlist") {
+                    if (!shouldNotifyReaction({ mode: reactionMode })) {
+                        return;
+                    }
+                }
+                const { baseText } = resolveReactionBase();
+                emitReaction(baseText, parentId);
+                return;
+            }
+            // For "own" mode, we need to fetch the message to check the author
+            const messagePromise = data.message.fetch().catch(() => null);
+            const [channelInfo, message] = await Promise.all([channelInfoPromise, messagePromise]);
+            parentId = channelInfo?.parentId;
+            await loadThreadParentInfo();
+            const channelConfig = resolveThreadChannelConfig();
+            if (channelConfig?.allowed === false) {
+                return;
             }
-            if (parentId) {
-                const parentInfo = await resolveDiscordChannelInfo(client, parentId);
-                parentName = parentInfo?.name;
-                parentSlug = parentName ? normalizeDiscordSlug(parentName) : "";
+            const messageAuthorId = message?.author?.id ?? undefined;
+            if (!shouldNotifyReaction({ mode: reactionMode, messageAuthorId })) {
+                return;
             }
+            emitReactionWithAuthor(message);
+            return;
         }
+        // Non-thread channel path
         const channelConfig = resolveDiscordChannelConfigWithFallback({
             guildInfo,
             channelId: data.channel_id,
@@ -168,48 +287,35 @@ async function handleDiscordReactionEvent(params) {
             parentId,
             parentName,
             parentSlug,
-            scope: isThreadChannel ? "thread" : "channel",
+            scope: "channel",
         });
-        if (channelConfig?.allowed === false)
-            return;
-        if (botUserId && user.id === botUserId)
+        if (channelConfig?.allowed === false) {
             return;
+        }
         const reactionMode = guildInfo?.reactionNotifications ?? "own";
+        // Early exit: skip fetching message if notifications are off
+        if (reactionMode === "off") {
+            return;
+        }
+        // Fast path: for "all" and "allowlist" modes, we don't need to fetch the message
+        if (reactionMode === "all" || reactionMode === "allowlist") {
+            // For allowlist mode, check if user is in allowlist first
+            if (reactionMode === "allowlist") {
+                if (!shouldNotifyReaction({ mode: reactionMode })) {
+                    return;
+                }
+            }
+            const { baseText } = resolveReactionBase();
+            emitReaction(baseText, parentId);
+            return;
+        }
+        // For "own" mode, we need to fetch the message to check the author
         const message = await data.message.fetch().catch(() => null);
         const messageAuthorId = message?.author?.id ?? undefined;
-        const shouldNotify = shouldEmitDiscordReactionNotification({
-            mode: reactionMode,
-            botId: botUserId,
-            messageAuthorId,
-            userId: user.id,
-            userName: user.username,
-            userTag: formatDiscordUserTag(user),
-            allowlist: guildInfo?.users,
-        });
-        if (!shouldNotify)
+        if (!shouldNotifyReaction({ mode: reactionMode, messageAuthorId })) {
             return;
-        const emojiLabel = formatDiscordReactionEmoji(data.emoji);
-        const actorLabel = formatDiscordUserTag(user);
-        const guildSlug = guildInfo?.slug || (data.guild?.name ? normalizeDiscordSlug(data.guild.name) : data.guild_id);
-        const channelLabel = channelSlug
-            ? `#${channelSlug}`
-            : channelName
-                ? `#${normalizeDiscordSlug(channelName)}`
-                : `#${data.channel_id}`;
-        const authorLabel = message?.author ? formatDiscordUserTag(message.author) : undefined;
-        const baseText = `Discord reaction ${action}: ${emojiLabel} by ${actorLabel} on ${guildSlug} ${channelLabel} msg ${data.message_id}`;
-        const text = authorLabel ? `${baseText} from ${authorLabel}` : baseText;
-        const route = resolveAgentRoute({
-            cfg: params.cfg,
-            channel: "discord",
-            accountId: params.accountId,
-            guildId: data.guild_id ?? undefined,
-            peer: { kind: "channel", id: data.channel_id },
-        });
-        enqueueSystemEvent(text, {
-            sessionKey: route.sessionKey,
-            contextKey: `discord:reaction:${action}:${data.message_id}:${user.id}:${emojiLabel}`,
-        });
+        }
+        emitReactionWithAuthor(message);
     }
     catch (err) {
         params.logger.error(danger(`discord reaction handler failed: ${String(err)}`));
@@ -228,8 +334,9 @@ export class DiscordPresenceListener extends PresenceUpdateListener {
             const userId = "user" in data && data.user && typeof data.user === "object" && "id" in data.user
                 ? String(data.user.id)
                 : undefined;
-            if (!userId)
+            if (!userId) {
                 return;
+            }
             setPresence(this.accountId, userId, data);
         }
         catch (err) {