@poolzin/pool-bot 2026.2.21 → 2026.2.23

package/dist/discord/monitor/message-handler.js

@@ -3,7 +3,7 @@ import { createInboundDebouncer, resolveInboundDebounceMs, } from "../../auto-re
 import { danger } from "../../globals.js";
 import { preflightDiscordMessage } from "./message-handler.preflight.js";
 import { processDiscordMessage } from "./message-handler.process.js";
-import { resolveDiscordMessageText } from "./message-utils.js";
+import { resolveDiscordMessageChannelId, resolveDiscordMessageText } from "./message-utils.js";
 export function createDiscordMessageHandler(params) {
     const groupPolicy = params.discordConfig?.groupPolicy ?? "open";
     const ackReactionScope = params.cfg.messages?.ackReactionScope ?? "group-mentions";
@@ -13,28 +13,37 @@ export function createDiscordMessageHandler(params) {
         buildKey: (entry) => {
             const message = entry.data.message;
             const authorId = entry.data.author?.id;
-            if (!message || !authorId)
+            if (!message || !authorId) {
                 return null;
-            const channelId = message.channelId;
-            if (!channelId)
+            }
+            const channelId = resolveDiscordMessageChannelId({
+                message,
+                eventChannelId: entry.data.channel_id,
+            });
+            if (!channelId) {
                 return null;
+            }
             return `discord:${params.accountId}:${channelId}:${authorId}`;
         },
         shouldDebounce: (entry) => {
             const message = entry.data.message;
-            if (!message)
+            if (!message) {
                 return false;
-            if (message.attachments && message.attachments.length > 0)
+            }
+            if (message.attachments && message.attachments.length > 0) {
                 return false;
+            }
             const baseText = resolveDiscordMessageText(message, { includeForwarded: false });
-            if (!baseText.trim())
+            if (!baseText.trim()) {
                 return false;
+            }
             return !hasControlCommand(baseText, params.cfg);
         },
         onFlush: async (entries) => {
             const last = entries.at(-1);
-            if (!last)
+            if (!last) {
                 return;
+            }
             if (entries.length === 1) {
                 const ctx = await preflightDiscordMessage({
                     ...params,
@@ -43,8 +52,9 @@ export function createDiscordMessageHandler(params) {
                     data: last.data,
                     client: last.client,
                 });
-                if (!ctx)
+                if (!ctx) {
                     return;
+                }
                 await processDiscordMessage(ctx);
                 return;
             }
@@ -73,8 +83,9 @@ export function createDiscordMessageHandler(params) {
                 data: syntheticData,
                 client: last.client,
             });
-            if (!ctx)
+            if (!ctx) {
                 return;
+            }
             if (entries.length > 1) {
                 const ids = entries.map((entry) => entry.data.message?.id).filter(Boolean);
                 if (ids.length > 0) {

package/dist/discord/monitor/message-handler.preflight.js

@@ -3,43 +3,78 @@ import { hasControlCommand } from "../../auto-reply/command-detection.js";
 import { shouldHandleTextCommands } from "../../auto-reply/commands-registry.js";
 import { recordPendingHistoryEntryIfEnabled, } from "../../auto-reply/reply/history.js";
 import { buildMentionRegexes, matchesMentionWithExplicit, } from "../../auto-reply/reply/mentions.js";
+import { formatAllowlistMatchMeta } from "../../channels/allowlist-match.js";
+import { resolveControlCommandGate } from "../../channels/command-gating.js";
+import { logInboundDrop } from "../../channels/logging.js";
+import { resolveMentionGatingWithBypass } from "../../channels/mention-gating.js";
+import { loadConfig } from "../../config/config.js";
 import { logVerbose, shouldLogVerbose } from "../../globals.js";
 import { recordChannelActivity } from "../../infra/channel-activity.js";
 import { enqueueSystemEvent } from "../../infra/system-events.js";
+import { logDebug } from "../../logger.js";
 import { getChildLogger } from "../../logging.js";
 import { buildPairingReply } from "../../pairing/pairing-messages.js";
 import { readChannelAllowFromStore, upsertChannelPairingRequest, } from "../../pairing/pairing-store.js";
 import { resolveAgentRoute } from "../../routing/resolve-route.js";
-import { resolveMentionGatingWithBypass } from "../../channels/mention-gating.js";
-import { formatAllowlistMatchMeta } from "../../channels/allowlist-match.js";
+import { fetchPluralKitMessageInfo } from "../pluralkit.js";
 import { sendMessageDiscord } from "../send.js";
-import { resolveControlCommandGate } from "../../channels/command-gating.js";
-import { logInboundDrop } from "../../channels/logging.js";
-import { allowListMatches, isDiscordGroupAllowedByPolicy, normalizeDiscordAllowList, normalizeDiscordSlug, resolveDiscordAllowListMatch, resolveDiscordChannelConfigWithFallback, resolveDiscordGuildEntry, resolveDiscordShouldRequireMention, resolveDiscordUserAllowed, resolveGroupDmAllow, } from "./allow-list.js";
+import { allowListMatches, isDiscordGroupAllowedByPolicy, normalizeDiscordAllowList, normalizeDiscordSlug, resolveDiscordAllowListMatch, resolveDiscordChannelConfigWithFallback, resolveDiscordGuildEntry, resolveDiscordMemberAccessState, resolveDiscordShouldRequireMention, resolveGroupDmAllow, } from "./allow-list.js";
 import { formatDiscordUserTag, resolveDiscordSystemLocation, resolveTimestampMs, } from "./format.js";
-import { resolveDiscordChannelInfo, resolveDiscordMessageText } from "./message-utils.js";
+import { resolveDiscordChannelInfo, resolveDiscordMessageChannelId, resolveDiscordMessageText, } from "./message-utils.js";
+import { resolveDiscordSenderIdentity, resolveDiscordWebhookId } from "./sender-identity.js";
 import { resolveDiscordSystemEvent } from "./system-events.js";
 import { resolveDiscordThreadChannel, resolveDiscordThreadParentInfo } from "./threading.js";
 export async function preflightDiscordMessage(params) {
     const logger = getChildLogger({ module: "discord-auto-reply" });
     const message = params.data.message;
     const author = params.data.author;
-    if (!author)
+    if (!author) {
+        return null;
+    }
+    const messageChannelId = resolveDiscordMessageChannelId({
+        message,
+        eventChannelId: params.data.channel_id,
+    });
+    if (!messageChannelId) {
+        logVerbose(`discord: drop message ${message.id} (missing channel id)`);
         return null;
+    }
     const allowBots = params.discordConfig?.allowBots ?? false;
-    if (author.bot) {
+    if (params.botUserId && author.id === params.botUserId) {
         // Always ignore own messages to prevent self-reply loops
-        if (params.botUserId && author.id === params.botUserId)
-            return null;
-        if (!allowBots) {
+        return null;
+    }
+    const pluralkitConfig = params.discordConfig?.pluralkit;
+    const webhookId = resolveDiscordWebhookId(message);
+    const shouldCheckPluralKit = Boolean(pluralkitConfig?.enabled) && !webhookId;
+    let pluralkitInfo = null;
+    if (shouldCheckPluralKit) {
+        try {
+            pluralkitInfo = await fetchPluralKitMessageInfo({
+                messageId: message.id,
+                config: pluralkitConfig,
+            });
+        }
+        catch (err) {
+            logVerbose(`discord: pluralkit lookup failed for ${message.id}: ${String(err)}`);
+        }
+    }
+    const sender = resolveDiscordSenderIdentity({
+        author,
+        member: params.data.member,
+        pluralkitInfo,
+    });
+    if (author.bot) {
+        if (!allowBots && !sender.isPluralKit) {
             logVerbose("discord: drop bot message (allowBots=false)");
             return null;
         }
     }
     const isGuildMessage = Boolean(params.data.guild_id);
-    const channelInfo = await resolveDiscordChannelInfo(params.client, message.channelId);
+    const channelInfo = await resolveDiscordChannelInfo(params.client, messageChannelId);
     const isDirectMessage = channelInfo?.type === ChannelType.DM;
     const isGroupDm = channelInfo?.type === ChannelType.GroupDM;
+    logDebug(`[discord-preflight] channelId=${messageChannelId} guild_id=${params.data.guild_id} channelType=${channelInfo?.type} isGuild=${isGuildMessage} isDM=${isDirectMessage} isGroupDm=${isGroupDm}`);
     if (isGroupDm && !params.groupDmEnabled) {
         logVerbose("discord: drop group dm (group dms disabled)");
         return null;
@@ -48,7 +83,7 @@ export async function preflightDiscordMessage(params) {
         logVerbose("discord: drop dm (dms disabled)");
         return null;
     }
-    const dmPolicy = params.discordConfig?.dm?.policy ?? "pairing";
+    const dmPolicy = params.discordConfig?.dmPolicy ?? params.discordConfig?.dm?.policy ?? "pairing";
     let commandAuthorized = true;
     if (isDirectMessage) {
         if (dmPolicy === "disabled") {
@@ -58,14 +93,14 @@ export async function preflightDiscordMessage(params) {
         if (dmPolicy !== "open") {
             const storeAllowFrom = await readChannelAllowFromStore("discord").catch(() => []);
             const effectiveAllowFrom = [...(params.allowFrom ?? []), ...storeAllowFrom];
-            const allowList = normalizeDiscordAllowList(effectiveAllowFrom, ["discord:", "user:"]);
+            const allowList = normalizeDiscordAllowList(effectiveAllowFrom, ["discord:", "user:", "pk:"]);
             const allowMatch = allowList
                 ? resolveDiscordAllowListMatch({
                     allowList,
                     candidate: {
-                        id: author.id,
-                        name: author.username,
-                        tag: formatDiscordUserTag(author),
+                        id: sender.id,
+                        name: sender.name,
+                        tag: sender.tag,
                     },
                 })
                 : { allowed: false };
@@ -101,7 +136,7 @@ export async function preflightDiscordMessage(params) {
                     }
                 }
                 else {
-                    logVerbose(`Blocked unauthorized discord sender ${author.id} (dmPolicy=${dmPolicy}, ${allowMatchMeta})`);
+                    logVerbose(`Blocked unauthorized discord sender ${sender.id} (dmPolicy=${dmPolicy}, ${allowMatchMeta})`);
                 }
                 return null;
             }
@@ -120,15 +155,46 @@ export async function preflightDiscordMessage(params) {
         accountId: params.accountId,
         direction: "inbound",
     });
+    // Resolve thread parent early for binding inheritance
+    const channelName = channelInfo?.name ??
+        ((isGuildMessage || isGroupDm) && message.channel && "name" in message.channel
+            ? message.channel.name
+            : undefined);
+    const earlyThreadChannel = resolveDiscordThreadChannel({
+        isGuildMessage,
+        message,
+        channelInfo,
+        messageChannelId,
+    });
+    let earlyThreadParentId;
+    let earlyThreadParentName;
+    let earlyThreadParentType;
+    if (earlyThreadChannel) {
+        const parentInfo = await resolveDiscordThreadParentInfo({
+            client: params.client,
+            threadChannel: earlyThreadChannel,
+            channelInfo,
+        });
+        earlyThreadParentId = parentInfo.id;
+        earlyThreadParentName = parentInfo.name;
+        earlyThreadParentType = parentInfo.type;
+    }
+    // Fresh config for bindings lookup; other routing inputs are payload-derived.
+    const memberRoleIds = Array.isArray(params.data.rawMember?.roles)
+        ? params.data.rawMember.roles.map((roleId) => String(roleId))
+        : [];
     const route = resolveAgentRoute({
-        cfg: params.cfg,
+        cfg: loadConfig(),
         channel: "discord",
         accountId: params.accountId,
         guildId: params.data.guild_id ?? undefined,
+        memberRoleIds,
         peer: {
-            kind: isDirectMessage ? "dm" : isGroupDm ? "group" : "channel",
-            id: isDirectMessage ? author.id : message.channelId,
+            kind: isDirectMessage ? "direct" : isGroupDm ? "group" : "channel",
+            id: isDirectMessage ? author.id : messageChannelId,
         },
+        // Pass parent peer for thread binding inheritance
+        parentPeer: earlyThreadParentId ? { kind: "channel", id: earlyThreadParentId } : undefined,
     });
     const mentionRegexes = buildMentionRegexes(params.cfg, route.agentId);
     const explicitlyMentioned = Boolean(botId && message.mentionedUsers?.some((user) => user.id === botId));
@@ -136,23 +202,6 @@ export async function preflightDiscordMessage(params) {
         (message.mentionedEveryone ||
             (message.mentionedUsers?.length ?? 0) > 0 ||
             (message.mentionedRoles?.length ?? 0) > 0));
-    const wasMentioned = !isDirectMessage &&
-        matchesMentionWithExplicit({
-            text: baseText,
-            mentionRegexes,
-            explicit: {
-                hasAnyMention,
-                isExplicitlyMentioned: explicitlyMentioned,
-                canResolveExplicit: Boolean(botId),
-            },
-        });
-    const implicitMention = Boolean(!isDirectMessage &&
-        botId &&
-        message.referencedMessage?.author?.id &&
-        message.referencedMessage.author.id === botId);
-    if (shouldLogVerbose()) {
-        logVerbose(`discord: inbound id=${message.id} guild=${message.guild?.id ?? "dm"} channel=${message.channelId} mention=${wasMentioned ? "yes" : "no"} type=${isDirectMessage ? "dm" : isGroupDm ? "group-dm" : "guild"} content=${messageText ? "yes" : "no"}`);
-    }
     if (isGuildMessage &&
         (message.type === MessageType.ChatInputCommand ||
             message.type === MessageType.ContextMenuCommand)) {
@@ -165,35 +214,20 @@ export async function preflightDiscordMessage(params) {
             guildEntries: params.guildEntries,
         })
         : null;
+    logDebug(`[discord-preflight] guild_id=${params.data.guild_id} guild_obj=${!!params.data.guild} guild_obj_id=${params.data.guild?.id} guildInfo=${!!guildInfo} guildEntries=${params.guildEntries ? Object.keys(params.guildEntries).join(",") : "none"}`);
     if (isGuildMessage &&
         params.guildEntries &&
         Object.keys(params.guildEntries).length > 0 &&
         !guildInfo) {
+        logDebug(`[discord-preflight] guild blocked: guild_id=${params.data.guild_id} guildEntries keys=${Object.keys(params.guildEntries).join(",")}`);
         logVerbose(`Blocked discord guild ${params.data.guild_id ?? "unknown"} (not in discord.guilds)`);
         return null;
     }
-    const channelName = channelInfo?.name ??
-        ((isGuildMessage || isGroupDm) && message.channel && "name" in message.channel
-            ? message.channel.name
-            : undefined);
-    const threadChannel = resolveDiscordThreadChannel({
-        isGuildMessage,
-        message,
-        channelInfo,
-    });
-    let threadParentId;
-    let threadParentName;
-    let threadParentType;
-    if (threadChannel) {
-        const parentInfo = await resolveDiscordThreadParentInfo({
-            client: params.client,
-            threadChannel,
-            channelInfo,
-        });
-        threadParentId = parentInfo.id;
-        threadParentName = parentInfo.name;
-        threadParentType = parentInfo.type;
-    }
+    // Reuse early thread resolution from above (for binding inheritance)
+    const threadChannel = earlyThreadChannel;
+    const threadParentId = earlyThreadParentId;
+    const threadParentName = earlyThreadParentName;
+    const threadParentType = earlyThreadParentType;
     const threadName = threadChannel?.name;
     const configChannelName = threadParentName ?? channelName;
     const configChannelSlug = configChannelName ? normalizeDiscordSlug(configChannelName) : "";
@@ -207,7 +241,7 @@ export async function preflightDiscordMessage(params) {
     const channelConfig = isGuildMessage
         ? resolveDiscordChannelConfigWithFallback({
             guildInfo,
-            channelId: message.channelId,
+            channelId: messageChannelId,
             channelName,
             channelSlug: threadChannelSlug,
             parentId: threadParentId ?? undefined,
@@ -217,19 +251,27 @@ export async function preflightDiscordMessage(params) {
         })
         : null;
     const channelMatchMeta = formatAllowlistMatchMeta(channelConfig);
+    if (shouldLogVerbose()) {
+        const channelConfigSummary = channelConfig
+            ? `allowed=${channelConfig.allowed} enabled=${channelConfig.enabled ?? "unset"} requireMention=${channelConfig.requireMention ?? "unset"} matchKey=${channelConfig.matchKey ?? "none"} matchSource=${channelConfig.matchSource ?? "none"} users=${channelConfig.users?.length ?? 0} roles=${channelConfig.roles?.length ?? 0} skills=${channelConfig.skills?.length ?? 0}`
+            : "none";
+        logDebug(`[discord-preflight] channelConfig=${channelConfigSummary} channelMatchMeta=${channelMatchMeta} channelId=${messageChannelId}`);
+    }
     if (isGuildMessage && channelConfig?.enabled === false) {
-        logVerbose(`Blocked discord channel ${message.channelId} (channel disabled, ${channelMatchMeta})`);
+        logDebug(`[discord-preflight] drop: channel disabled`);
+        logVerbose(`Blocked discord channel ${messageChannelId} (channel disabled, ${channelMatchMeta})`);
         return null;
     }
     const groupDmAllowed = isGroupDm &&
         resolveGroupDmAllow({
             channels: params.groupDmChannels,
-            channelId: message.channelId,
+            channelId: messageChannelId,
             channelName: displayChannelName,
             channelSlug: displayChannelSlug,
         });
-    if (isGroupDm && !groupDmAllowed)
+    if (isGroupDm && !groupDmAllowed) {
         return null;
+    }
     const channelAllowlistConfigured = Boolean(guildInfo?.channels) && Object.keys(guildInfo?.channels ?? {}).length > 0;
     const channelAllowed = channelConfig?.allowed !== false;
     if (isGuildMessage &&
@@ -246,23 +288,25 @@ export async function preflightDiscordMessage(params) {
             logVerbose(`discord: drop guild message (groupPolicy: allowlist, no channel allowlist, ${channelMatchMeta})`);
         }
         else {
-            logVerbose(`Blocked discord channel ${message.channelId} not in guild channel allowlist (groupPolicy: allowlist, ${channelMatchMeta})`);
+            logVerbose(`Blocked discord channel ${messageChannelId} not in guild channel allowlist (groupPolicy: allowlist, ${channelMatchMeta})`);
         }
         return null;
     }
     if (isGuildMessage && channelConfig?.allowed === false) {
-        logVerbose(`Blocked discord channel ${message.channelId} not in guild channel allowlist (${channelMatchMeta})`);
+        logDebug(`[discord-preflight] drop: channelConfig.allowed===false`);
+        logVerbose(`Blocked discord channel ${messageChannelId} not in guild channel allowlist (${channelMatchMeta})`);
         return null;
     }
     if (isGuildMessage) {
-        logVerbose(`discord: allow channel ${message.channelId} (${channelMatchMeta})`);
+        logDebug(`[discord-preflight] pass: channel allowed`);
+        logVerbose(`discord: allow channel ${messageChannelId} (${channelMatchMeta})`);
     }
     const textForHistory = resolveDiscordMessageText(message, {
         includeForwarded: true,
     });
     const historyEntry = isGuildMessage && params.historyLimit > 0 && textForHistory
         ? {
-            sender: params.data.member?.nickname ?? author.globalName ?? author.username ?? author.id,
+            sender: sender.label,
             body: textForHistory,
             timestamp: resolveTimestampMs(message.timestamp),
             messageId: message.id,
@@ -277,27 +321,80 @@ export async function preflightDiscordMessage(params) {
         channelConfig,
         guildInfo,
     });
+    // Preflight audio transcription for mention detection in guilds
+    // This allows voice notes to be checked for mentions before being dropped
+    let preflightTranscript;
+    const hasAudioAttachment = message.attachments?.some((att) => att.contentType?.startsWith("audio/"));
+    const needsPreflightTranscription = !isDirectMessage &&
+        shouldRequireMention &&
+        hasAudioAttachment &&
+        !baseText &&
+        mentionRegexes.length > 0;
+    if (needsPreflightTranscription) {
+        try {
+            const { transcribeFirstAudio } = await import("../../media-understanding/audio-preflight.js");
+            const audioPaths = message.attachments
+                ?.filter((att) => att.contentType?.startsWith("audio/"))
+                .map((att) => att.url) ?? [];
+            if (audioPaths.length > 0) {
+                const tempCtx = {
+                    MediaUrls: audioPaths,
+                    MediaTypes: message.attachments
+                        ?.filter((att) => att.contentType?.startsWith("audio/"))
+                        .map((att) => att.contentType)
+                        .filter(Boolean),
+                };
+                preflightTranscript = await transcribeFirstAudio({
+                    ctx: tempCtx,
+                    cfg: params.cfg,
+                    agentDir: undefined,
+                });
+            }
+        }
+        catch (err) {
+            logVerbose(`discord: audio preflight transcription failed: ${String(err)}`);
+        }
+    }
+    const wasMentioned = !isDirectMessage &&
+        matchesMentionWithExplicit({
+            text: baseText,
+            mentionRegexes,
+            explicit: {
+                hasAnyMention,
+                isExplicitlyMentioned: explicitlyMentioned,
+                canResolveExplicit: Boolean(botId),
+            },
+            transcript: preflightTranscript,
+        });
+    const implicitMention = Boolean(!isDirectMessage &&
+        botId &&
+        message.referencedMessage?.author?.id &&
+        message.referencedMessage.author.id === botId);
+    if (shouldLogVerbose()) {
+        logVerbose(`discord: inbound id=${message.id} guild=${params.data.guild_id ?? "dm"} channel=${messageChannelId} mention=${wasMentioned ? "yes" : "no"} type=${isDirectMessage ? "dm" : isGroupDm ? "group-dm" : "guild"} content=${messageText ? "yes" : "no"}`);
+    }
     const allowTextCommands = shouldHandleTextCommands({
         cfg: params.cfg,
         surface: "discord",
     });
     const hasControlCommandInMessage = hasControlCommand(baseText, params.cfg);
+    const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
+        channelConfig,
+        guildInfo,
+        memberRoleIds,
+        sender,
+    });
     if (!isDirectMessage) {
-        const ownerAllowList = normalizeDiscordAllowList(params.allowFrom, ["discord:", "user:"]);
+        const ownerAllowList = normalizeDiscordAllowList(params.allowFrom, [
+            "discord:",
+            "user:",
+            "pk:",
+        ]);
         const ownerOk = ownerAllowList
             ? allowListMatches(ownerAllowList, {
-                id: author.id,
-                name: author.username,
-                tag: formatDiscordUserTag(author),
-            })
-            : false;
-        const channelUsers = channelConfig?.users ?? guildInfo?.users;
-        const usersOk = Array.isArray(channelUsers) && channelUsers.length > 0
-            ? resolveDiscordUserAllowed({
-                allowList: channelUsers,
-                userId: author.id,
-                userName: author.username,
-                userTag: formatDiscordUserTag(author),
+                id: sender.id,
+                name: sender.name,
+                tag: sender.tag,
             })
             : false;
         const useAccessGroups = params.cfg.commands?.useAccessGroups !== false;
@@ -305,7 +402,7 @@ export async function preflightDiscordMessage(params) {
             useAccessGroups,
             authorizers: [
                 { configured: ownerAllowList != null, allowed: ownerOk },
-                { configured: Array.isArray(channelUsers) && channelUsers.length > 0, allowed: usersOk },
+                { configured: hasAccessRestrictions, allowed: memberAllowed },
             ],
             modeWhenAccessGroupsOff: "configured",
             allowTextCommands,
@@ -317,7 +414,7 @@ export async function preflightDiscordMessage(params) {
                 log: logVerbose,
                 channel: "discord",
                 reason: "control command (unauthorized)",
-                target: author.id,
+                target: sender.id,
             });
             return null;
         }
@@ -335,55 +432,50 @@ export async function preflightDiscordMessage(params) {
         commandAuthorized,
     });
     const effectiveWasMentioned = mentionGate.effectiveWasMentioned;
+    logDebug(`[discord-preflight] shouldRequireMention=${shouldRequireMention} mentionGate.shouldSkip=${mentionGate.shouldSkip} wasMentioned=${wasMentioned}`);
     if (isGuildMessage && shouldRequireMention) {
         if (botId && mentionGate.shouldSkip) {
+            logDebug(`[discord-preflight] drop: no-mention`);
             logVerbose(`discord: drop guild message (mention required, botId=${botId})`);
             logger.info({
-                channelId: message.channelId,
+                channelId: messageChannelId,
                 reason: "no-mention",
             }, "discord: skipping guild message");
             recordPendingHistoryEntryIfEnabled({
                 historyMap: params.guildHistories,
-                historyKey: message.channelId,
+                historyKey: messageChannelId,
                 limit: params.historyLimit,
                 entry: historyEntry ?? null,
             });
             return null;
         }
     }
-    if (isGuildMessage) {
-        const channelUsers = channelConfig?.users ?? guildInfo?.users;
-        if (Array.isArray(channelUsers) && channelUsers.length > 0) {
-            const userOk = resolveDiscordUserAllowed({
-                allowList: channelUsers,
-                userId: author.id,
-                userName: author.username,
-                userTag: formatDiscordUserTag(author),
-            });
-            if (!userOk) {
-                logVerbose(`Blocked discord guild sender ${author.id} (not in channel users allowlist)`);
-                return null;
-            }
-        }
+    if (isGuildMessage && hasAccessRestrictions && !memberAllowed) {
+        logDebug(`[discord-preflight] drop: member not allowed`);
+        logVerbose(`Blocked discord guild sender ${sender.id} (not in users/roles allowlist)`);
+        return null;
     }
     const systemLocation = resolveDiscordSystemLocation({
         isDirectMessage,
         isGroupDm,
         guild: params.data.guild ?? undefined,
-        channelName: channelName ?? message.channelId,
+        channelName: channelName ?? messageChannelId,
     });
     const systemText = resolveDiscordSystemEvent(message, systemLocation);
     if (systemText) {
+        logDebug(`[discord-preflight] drop: system event`);
         enqueueSystemEvent(systemText, {
             sessionKey: route.sessionKey,
-            contextKey: `discord:system:${message.channelId}:${message.id}`,
+            contextKey: `discord:system:${messageChannelId}:${message.id}`,
         });
         return null;
     }
     if (!messageText) {
+        logDebug(`[discord-preflight] drop: empty content`);
         logVerbose(`discord: drop message ${message.id} (empty content)`);
         return null;
     }
+    logDebug(`[discord-preflight] success: route=${route.agentId} sessionKey=${route.sessionKey}`);
     return {
         cfg: params.cfg,
         discordConfig: params.discordConfig,
@@ -401,7 +493,9 @@ export async function preflightDiscordMessage(params) {
         data: params.data,
         client: params.client,
         message,
+        messageChannelId,
         author,
+        sender,
         channelInfo,
         channelName,
         isGuildMessage,