@gguf/claw 2026.2.1 → 2026.2.3

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

@@ -3,6 +3,10 @@ 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 { logVerbose, shouldLogVerbose } from "../../globals.js";
 import { recordChannelActivity } from "../../infra/channel-activity.js";
 import { enqueueSystemEvent } from "../../infra/system-events.js";
@@ -10,14 +14,12 @@ 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 { formatDiscordUserTag, resolveDiscordSystemLocation, resolveTimestampMs, } from "./format.js";
 import { resolveDiscordChannelInfo, 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) {
@@ -28,12 +30,32 @@ export async function preflightDiscordMessage(params) {
         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;
+        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)}`);
         }
-        if (!allowBots) {
+    }
+    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;
         }
@@ -60,14 +82,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 };
@@ -103,7 +125,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;
             }
@@ -122,6 +144,29 @@ 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,
+    });
+    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;
+    }
     const route = resolveAgentRoute({
         cfg: params.cfg,
         channel: "discord",
@@ -131,6 +176,8 @@ export async function preflightDiscordMessage(params) {
             kind: isDirectMessage ? "dm" : isGroupDm ? "group" : "channel",
             id: isDirectMessage ? author.id : message.channelId,
         },
+        // 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));
@@ -174,28 +221,11 @@ export async function preflightDiscordMessage(params) {
         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) : "";
@@ -265,7 +295,7 @@ export async function preflightDiscordMessage(params) {
     });
     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,
@@ -286,21 +316,25 @@ export async function preflightDiscordMessage(params) {
     });
     const hasControlCommandInMessage = hasControlCommand(baseText, params.cfg);
     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),
+                id: sender.id,
+                name: sender.name,
+                tag: sender.tag,
             })
             : 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),
+                userId: sender.id,
+                userName: sender.name,
+                userTag: sender.tag,
             })
             : false;
         const useAccessGroups = params.cfg.commands?.useAccessGroups !== false;
@@ -320,7 +354,7 @@ export async function preflightDiscordMessage(params) {
                 log: logVerbose,
                 channel: "discord",
                 reason: "control command (unauthorized)",
-                target: author.id,
+                target: sender.id,
             });
             return null;
         }
@@ -359,12 +393,12 @@ export async function preflightDiscordMessage(params) {
         if (Array.isArray(channelUsers) && channelUsers.length > 0) {
             const userOk = resolveDiscordUserAllowed({
                 allowList: channelUsers,
-                userId: author.id,
-                userName: author.username,
-                userTag: formatDiscordUserTag(author),
+                userId: sender.id,
+                userName: sender.name,
+                userTag: sender.tag,
             });
             if (!userOk) {
-                logVerbose(`Blocked discord guild sender ${author.id} (not in channel users allowlist)`);
+                logVerbose(`Blocked discord guild sender ${sender.id} (not in channel users allowlist)`);
                 return null;
             }
         }
@@ -405,6 +439,7 @@ export async function preflightDiscordMessage(params) {
         client: params.client,
         message,
         author,
+        sender,
         channelInfo,
         channelName,
         isGuildMessage,

package/dist/discord/monitor/message-handler.preflight.types.d.ts

@@ -4,6 +4,8 @@ import type { ReplyToMode } from "../../config/config.js";
 import type { resolveAgentRoute } from "../../routing/resolve-route.js";
 import type { DiscordChannelConfigResolved, DiscordGuildEntryResolved } from "./allow-list.js";
 import type { DiscordChannelInfo } from "./message-utils.js";
+import type { DiscordSenderIdentity } from "./sender-identity.js";
+export type { DiscordSenderIdentity } from "./sender-identity.js";
 import type { DiscordThreadChannel } from "./threading.js";
 export type LoadedConfig = ReturnType<typeof import("../../config/config.js").loadConfig>;
 export type RuntimeEnv = import("../../runtime.js").RuntimeEnv;
@@ -26,6 +28,7 @@ export type DiscordMessagePreflightContext = {
     client: Client;
     message: DiscordMessageEvent["message"];
     author: User;
+    sender: DiscordSenderIdentity;
     channelInfo: DiscordChannelInfo | null;
     channelName?: string;
     isGuildMessage: boolean;

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

@@ -1,32 +1,32 @@
 import { ChannelType } from "@buape/carbon";
 import { resolveAckReaction, resolveHumanDelayConfig } from "../../agents/identity.js";
-import { removeAckReactionAfterReply, shouldAckReaction as shouldAckReactionGate, } from "../../channels/ack-reactions.js";
-import { logTypingFailure, logAckFailure } from "../../channels/logging.js";
-import { createReplyPrefixContext } from "../../channels/reply-prefix.js";
-import { createTypingCallbacks } from "../../channels/typing.js";
-import { formatInboundEnvelope, formatThreadStarterEnvelope, resolveEnvelopeFormatOptions, } from "../../auto-reply/envelope.js";
+import { resolveChunkMode } from "../../auto-reply/chunk.js";
 import { dispatchInboundMessage } from "../../auto-reply/dispatch.js";
+import { formatInboundEnvelope, formatThreadStarterEnvelope, resolveEnvelopeFormatOptions, } from "../../auto-reply/envelope.js";
 import { buildPendingHistoryContextFromMap, clearHistoryEntriesIfEnabled, } from "../../auto-reply/reply/history.js";
 import { finalizeInboundContext } from "../../auto-reply/reply/inbound-context.js";
 import { createReplyDispatcherWithTyping } from "../../auto-reply/reply/reply-dispatcher.js";
+import { removeAckReactionAfterReply, shouldAckReaction as shouldAckReactionGate, } from "../../channels/ack-reactions.js";
+import { logTypingFailure, logAckFailure } from "../../channels/logging.js";
+import { createReplyPrefixContext } from "../../channels/reply-prefix.js";
 import { recordInboundSession } from "../../channels/session.js";
-import { readSessionUpdatedAt, resolveStorePath } from "../../config/sessions.js";
-import { resolveChunkMode } from "../../auto-reply/chunk.js";
+import { createTypingCallbacks } from "../../channels/typing.js";
 import { resolveMarkdownTableMode } from "../../config/markdown-tables.js";
+import { readSessionUpdatedAt, resolveStorePath } from "../../config/sessions.js";
 import { danger, logVerbose, shouldLogVerbose } from "../../globals.js";
 import { buildAgentSessionKey } from "../../routing/resolve-route.js";
 import { resolveThreadSessionKeys } from "../../routing/session-key.js";
 import { truncateUtf16Safe } from "../../utils.js";
 import { reactMessageDiscord, removeReactionDiscord } from "../send.js";
 import { normalizeDiscordSlug } from "./allow-list.js";
-import { formatDiscordUserTag, resolveTimestampMs } from "./format.js";
+import { resolveTimestampMs } from "./format.js";
 import { buildDiscordMediaPayload, resolveDiscordMessageText, resolveMediaList, } from "./message-utils.js";
 import { buildDirectLabel, buildGuildLabel, resolveReplyContext } from "./reply-context.js";
 import { deliverDiscordReply } from "./reply-delivery.js";
 import { resolveDiscordAutoThreadReplyPlan, resolveDiscordThreadStarter } from "./threading.js";
 import { sendTyping } from "./typing.js";
 export async function processDiscordMessage(ctx) {
-    const { cfg, discordConfig, accountId, token, runtime, guildHistories, historyLimit, mediaMaxBytes, textLimit, replyToMode, ackReactionScope, message, author, data, client, channelInfo, channelName, isGuildMessage, isDirectMessage, isGroupDm, baseText, messageText, shouldRequireMention, canDetectMention, effectiveWasMentioned, shouldBypassMention, threadChannel, threadParentId, threadParentName, threadParentType, threadName, displayChannelSlug, guildInfo, guildSlug, channelConfig, baseSessionKey, route, commandAuthorized, } = ctx;
+    const { cfg, discordConfig, accountId, token, runtime, guildHistories, historyLimit, mediaMaxBytes, textLimit, replyToMode, ackReactionScope, message, author, sender, data, client, channelInfo, channelName, isGuildMessage, isDirectMessage, isGroupDm, baseText, messageText, shouldRequireMention, canDetectMention, effectiveWasMentioned, shouldBypassMention, threadChannel, threadParentId, threadParentName, threadParentType, threadName, displayChannelSlug, guildInfo, guildSlug, channelConfig, baseSessionKey, route, commandAuthorized, } = ctx;
     const mediaList = await resolveMediaList(message, mediaMaxBytes);
     const text = messageText;
     if (!text) {
@@ -61,11 +61,7 @@ export async function processDiscordMessage(ctx) {
             channelName: channelName ?? message.channelId,
             channelId: message.channelId,
         });
-    const senderTag = formatDiscordUserTag(author);
-    const senderDisplay = data.member?.nickname ?? author.globalName ?? author.username;
-    const senderLabel = senderDisplay && senderTag && senderDisplay !== senderTag
-        ? `${senderDisplay} (${senderTag})`
-        : (senderDisplay ?? senderTag ?? author.id);
+    const senderLabel = sender.label;
     const isForumParent = threadParentType === ChannelType.GuildForum || threadParentType === ChannelType.GuildMedia;
     const forumParentSlug = isForumParent && threadParentName ? normalizeDiscordSlug(threadParentName) : "";
     const threadChannelId = threadChannel?.id;
@@ -74,6 +70,13 @@ export async function processDiscordMessage(ctx) {
     const groupChannel = isGuildMessage && displayChannelSlug ? `#${displayChannelSlug}` : undefined;
     const groupSubject = isDirectMessage ? undefined : groupChannel;
     const channelDescription = channelInfo?.topic?.trim();
+    const senderName = sender.isPluralKit
+        ? (sender.name ?? author.username)
+        : (data.member?.nickname ?? author.globalName ?? author.username);
+    const senderUsername = sender.isPluralKit
+        ? (sender.tag ?? sender.name ?? author.username)
+        : author.username;
+    const senderTag = sender.tag;
     const systemPromptParts = [
         channelDescription ? `Channel topic: ${channelDescription}` : null,
         channelConfig?.systemPrompt?.trim() || null,
@@ -198,10 +201,10 @@ export async function processDiscordMessage(ctx) {
         AccountId: route.accountId,
         ChatType: isDirectMessage ? "direct" : "channel",
         ConversationLabel: fromLabel,
-        SenderName: data.member?.nickname ?? author.globalName ?? author.username,
-        SenderId: author.id,
-        SenderUsername: author.username,
-        SenderTag: formatDiscordUserTag(author),
+        SenderName: senderName,
+        SenderId: sender.id,
+        SenderUsername: senderUsername,
+        SenderTag: senderTag,
         GroupSubject: groupSubject,
         GroupChannel: groupChannel,
         GroupSystemPrompt: isGuildMessage ? groupSystemPrompt : undefined,

package/dist/discord/monitor/native-command.js

@@ -3,17 +3,17 @@ import { ApplicationCommandOptionType, ButtonStyle } from "discord-api-types/v10
 import { resolveEffectiveMessagesConfig, resolveHumanDelayConfig } from "../../agents/identity.js";
 import { resolveChunkMode, resolveTextChunkLimit } from "../../auto-reply/chunk.js";
 import { buildCommandTextFromArgs, findCommandByNativeName, listChatCommands, parseCommandArgs, resolveCommandArgChoices, resolveCommandArgMenu, serializeCommandArgs, } from "../../auto-reply/commands-registry.js";
-import { dispatchReplyWithDispatcher } from "../../auto-reply/reply/provider-dispatcher.js";
 import { finalizeInboundContext } from "../../auto-reply/reply/inbound-context.js";
+import { dispatchReplyWithDispatcher } from "../../auto-reply/reply/provider-dispatcher.js";
+import { resolveCommandAuthorizedFromAuthorizers } from "../../channels/command-gating.js";
 import { buildPairingReply } from "../../pairing/pairing-messages.js";
 import { readChannelAllowFromStore, upsertChannelPairingRequest, } from "../../pairing/pairing-store.js";
 import { resolveAgentRoute } from "../../routing/resolve-route.js";
 import { loadWebMedia } from "../../web/media.js";
 import { chunkDiscordTextWithMode } from "../chunk.js";
-import { resolveCommandAuthorizedFromAuthorizers } from "../../channels/command-gating.js";
 import { allowListMatches, isDiscordGroupAllowedByPolicy, normalizeDiscordAllowList, normalizeDiscordSlug, resolveDiscordChannelConfigWithFallback, resolveDiscordGuildEntry, resolveDiscordUserAllowed, } from "./allow-list.js";
-import { formatDiscordUserTag } from "./format.js";
 import { resolveDiscordChannelInfo } from "./message-utils.js";
+import { resolveDiscordSenderIdentity } from "./sender-identity.js";
 import { resolveDiscordThreadParentInfo } from "./threading.js";
 function buildDiscordCommandOptions(params) {
     const { command, cfg } = params;
@@ -368,6 +368,7 @@ async function dispatchDiscordCommandInteraction(params) {
     if (!user) {
         return;
     }
+    const sender = resolveDiscordSenderIdentity({ author: user, pluralkitInfo: null });
     const channel = interaction.channel;
     const channelType = channel?.type;
     const isDirectMessage = channelType === ChannelType.DM;
@@ -381,12 +382,13 @@ async function dispatchDiscordCommandInteraction(params) {
     const ownerAllowList = normalizeDiscordAllowList(discordConfig?.dm?.allowFrom ?? [], [
         "discord:",
         "user:",
+        "pk:",
     ]);
     const ownerOk = ownerAllowList && user
         ? allowListMatches(ownerAllowList, {
-            id: user.id,
-            name: user.username,
-            tag: formatDiscordUserTag(user),
+            id: sender.id,
+            name: sender.name,
+            tag: sender.tag,
         })
         : false;
     const guildInfo = resolveDiscordGuildEntry({
@@ -458,12 +460,12 @@ async function dispatchDiscordCommandInteraction(params) {
         if (dmPolicy !== "open") {
             const storeAllowFrom = await readChannelAllowFromStore("discord").catch(() => []);
             const effectiveAllowFrom = [...(discordConfig?.dm?.allowFrom ?? []), ...storeAllowFrom];
-            const allowList = normalizeDiscordAllowList(effectiveAllowFrom, ["discord:", "user:"]);
+            const allowList = normalizeDiscordAllowList(effectiveAllowFrom, ["discord:", "user:", "pk:"]);
             const permitted = allowList
                 ? allowListMatches(allowList, {
-                    id: user.id,
-                    name: user.username,
-                    tag: formatDiscordUserTag(user),
+                    id: sender.id,
+                    name: sender.name,
+                    tag: sender.tag,
                 })
                 : false;
             if (!permitted) {
@@ -473,8 +475,8 @@ async function dispatchDiscordCommandInteraction(params) {
                         channel: "discord",
                         id: user.id,
                         meta: {
-                            tag: formatDiscordUserTag(user),
-                            name: user.username ?? undefined,
+                            tag: sender.tag,
+                            name: sender.name,
                         },
                     });
                     if (created) {
@@ -499,9 +501,9 @@ async function dispatchDiscordCommandInteraction(params) {
         const userOk = hasUserAllowlist
             ? resolveDiscordUserAllowed({
                 allowList: channelUsers,
-                userId: user.id,
-                userName: user.username,
-                userTag: formatDiscordUserTag(user),
+                userId: sender.id,
+                userName: sender.name,
+                userTag: sender.tag,
             })
             : false;
         const authorizers = useAccessGroups
@@ -566,6 +568,7 @@ async function dispatchDiscordCommandInteraction(params) {
             kind: isDirectMessage ? "dm" : isGroupDm ? "group" : "channel",
             id: isDirectMessage ? user.id : channelId,
         },
+        parentPeer: threadParentId ? { kind: "channel", id: threadParentId } : undefined,
     });
     const conversationLabel = isDirectMessage ? (user.globalName ?? user.username) : channelId;
     const ctxPayload = finalizeInboundContext({
@@ -599,7 +602,7 @@ async function dispatchDiscordCommandInteraction(params) {
         SenderName: user.globalName ?? user.username,
         SenderId: user.id,
         SenderUsername: user.username,
-        SenderTag: formatDiscordUserTag(user),
+        SenderTag: sender.tag,
         Provider: "discord",
         Surface: "discord",
         WasMentioned: true,

package/dist/discord/monitor/provider.js

@@ -1,7 +1,7 @@
-import { inspect } from "node:util";
 import { Client } from "@buape/carbon";
 import { GatewayIntents, GatewayPlugin } from "@buape/carbon/gateway";
 import { Routes } from "discord-api-types/v10";
+import { inspect } from "node:util";
 import { resolveTextChunkLimit } from "../../auto-reply/chunk.js";
 import { listNativeCommandSpecsForConfig } from "../../auto-reply/commands-registry.js";
 import { listSkillCommandsForAgents } from "../../auto-reply/skill-commands.js";
@@ -19,10 +19,10 @@ import { fetchDiscordApplicationId } from "../probe.js";
 import { resolveDiscordChannelAllowlist } from "../resolve-channels.js";
 import { resolveDiscordUserAllowlist } from "../resolve-users.js";
 import { normalizeDiscordToken } from "../token.js";
+import { createExecApprovalButton, DiscordExecApprovalHandler } from "./exec-approvals.js";
 import { DiscordMessageListener, DiscordPresenceListener, DiscordReactionListener, DiscordReactionRemoveListener, registerDiscordListener, } from "./listeners.js";
 import { createDiscordMessageHandler } from "./message-handler.js";
 import { createDiscordCommandArgFallbackButton, createDiscordNativeCommand, } from "./native-command.js";
-import { createExecApprovalButton, DiscordExecApprovalHandler } from "./exec-approvals.js";
 function summarizeAllowList(list) {
     if (!list || list.length === 0) {
         return "any";

package/dist/discord/monitor/reply-context.d.ts

@@ -5,7 +5,7 @@ export declare function resolveReplyContext(message: Message, resolveDiscordMess
 }) => string, options?: {
     envelope?: EnvelopeFormatOptions;
 }): string | null;
-export declare function buildDirectLabel(author: User): string;
+export declare function buildDirectLabel(author: User, tagOverride?: string): string;
 export declare function buildGuildLabel(params: {
     guild?: Guild;
     channelName: string;

package/dist/discord/monitor/reply-context.js

@@ -1,5 +1,6 @@
 import { formatAgentEnvelope } from "../../auto-reply/envelope.js";
-import { formatDiscordUserTag, resolveTimestampMs } from "./format.js";
+import { resolveTimestampMs } from "./format.js";
+import { resolveDiscordSenderIdentity } from "./sender-identity.js";
 export function resolveReplyContext(message, resolveDiscordMessageText, options) {
     const referenced = message.referencedMessage;
     if (!referenced?.author) {
@@ -11,8 +12,12 @@ export function resolveReplyContext(message, resolveDiscordMessageText, options)
     if (!referencedText) {
         return null;
     }
-    const fromLabel = referenced.author ? buildDirectLabel(referenced.author) : "Unknown";
-    const body = `${referencedText}\n[discord message id: ${referenced.id} channel: ${referenced.channelId} from: ${formatDiscordUserTag(referenced.author)} user id:${referenced.author?.id ?? "unknown"}]`;
+    const sender = resolveDiscordSenderIdentity({
+        author: referenced.author,
+        pluralkitInfo: null,
+    });
+    const fromLabel = referenced.author ? buildDirectLabel(referenced.author, sender.tag) : "Unknown";
+    const body = `${referencedText}\n[discord message id: ${referenced.id} channel: ${referenced.channelId} from: ${sender.tag ?? sender.label} user id:${sender.id}]`;
     return formatAgentEnvelope({
         channel: "Discord",
         from: fromLabel,
@@ -21,9 +26,9 @@ export function resolveReplyContext(message, resolveDiscordMessageText, options)
         envelope: options?.envelope,
     });
 }
-export function buildDirectLabel(author) {
-    const username = formatDiscordUserTag(author);
-    return `${username} user id:${author.id}`;
+export function buildDirectLabel(author, tagOverride) {
+    const username = tagOverride?.trim() || resolveDiscordSenderIdentity({ author, pluralkitInfo: null }).tag;
+    return `${username ?? "unknown"} user id:${author.id}`;
 }
 export function buildGuildLabel(params) {
     const { guild, channelName, channelId } = params;

package/dist/discord/monitor/sender-identity.d.ts

@@ -0,0 +1,31 @@
+import type { User } from "@buape/carbon";
+import type { PluralKitMessageInfo } from "../pluralkit.js";
+export type DiscordSenderIdentity = {
+    id: string;
+    name?: string;
+    tag?: string;
+    label: string;
+    isPluralKit: boolean;
+    pluralkit?: {
+        memberId: string;
+        memberName?: string;
+        systemId?: string;
+        systemName?: string;
+    };
+};
+type DiscordWebhookMessageLike = {
+    webhookId?: string | null;
+    webhook_id?: string | null;
+};
+export declare function resolveDiscordWebhookId(message: DiscordWebhookMessageLike): string | null;
+export declare function resolveDiscordSenderIdentity(params: {
+    author: User;
+    member?: any;
+    pluralkitInfo?: PluralKitMessageInfo | null;
+}): DiscordSenderIdentity;
+export declare function resolveDiscordSenderLabel(params: {
+    author: User;
+    member?: any;
+    pluralkitInfo?: PluralKitMessageInfo | null;
+}): string;
+export {};

package/dist/discord/monitor/sender-identity.js

@@ -0,0 +1,45 @@
+import { formatDiscordUserTag } from "./format.js";
+export function resolveDiscordWebhookId(message) {
+    const candidate = message.webhookId ?? message.webhook_id;
+    return typeof candidate === "string" && candidate.trim() ? candidate.trim() : null;
+}
+export function resolveDiscordSenderIdentity(params) {
+    const pkInfo = params.pluralkitInfo ?? null;
+    const pkMember = pkInfo?.member ?? undefined;
+    const pkSystem = pkInfo?.system ?? undefined;
+    const memberId = pkMember?.id?.trim();
+    const memberNameRaw = pkMember?.display_name ?? pkMember?.name ?? "";
+    const memberName = memberNameRaw?.trim();
+    if (memberId && memberName) {
+        const systemName = pkSystem?.name?.trim();
+        const label = systemName ? `${memberName} (PK:${systemName})` : `${memberName} (PK)`;
+        return {
+            id: memberId,
+            name: memberName,
+            tag: pkMember?.name?.trim() || undefined,
+            label,
+            isPluralKit: true,
+            pluralkit: {
+                memberId,
+                memberName,
+                systemId: pkSystem?.id?.trim() || undefined,
+                systemName,
+            },
+        };
+    }
+    const senderTag = formatDiscordUserTag(params.author);
+    const senderDisplay = params.member?.nickname ?? params.author.globalName ?? params.author.username;
+    const senderLabel = senderDisplay && senderTag && senderDisplay !== senderTag
+        ? `${senderDisplay} (${senderTag})`
+        : (senderDisplay ?? senderTag ?? params.author.id);
+    return {
+        id: params.author.id,
+        name: params.author.username ?? undefined,
+        tag: senderTag,
+        label: senderLabel,
+        isPluralKit: false,
+    };
+}
+export function resolveDiscordSenderLabel(params) {
+    return resolveDiscordSenderIdentity(params).label;
+}

package/dist/discord/monitor/threading.d.ts

@@ -1,8 +1,8 @@
 import { ChannelType, type Client } from "@buape/carbon";
-import { createReplyReferencePlanner } from "../../auto-reply/reply/reply-reference.js";
 import type { ReplyToMode } from "../../config/config.js";
 import type { DiscordChannelConfigResolved } from "./allow-list.js";
 import type { DiscordMessageEvent } from "./listeners.js";
+import { createReplyReferencePlanner } from "../../auto-reply/reply/reply-reference.js";
 export type DiscordThreadChannel = {
     id: string;
     name?: string | null;

package/dist/discord/pluralkit.d.ts

@@ -0,0 +1,26 @@
+export type DiscordPluralKitConfig = {
+    enabled?: boolean;
+    token?: string;
+};
+export type PluralKitSystemInfo = {
+    id: string;
+    name?: string | null;
+    tag?: string | null;
+};
+export type PluralKitMemberInfo = {
+    id: string;
+    name?: string | null;
+    display_name?: string | null;
+};
+export type PluralKitMessageInfo = {
+    id: string;
+    original?: string | null;
+    sender?: string | null;
+    system?: PluralKitSystemInfo | null;
+    member?: PluralKitMemberInfo | null;
+};
+export declare function fetchPluralKitMessageInfo(params: {
+    messageId: string;
+    config?: DiscordPluralKitConfig;
+    fetcher?: typeof fetch;
+}): Promise<PluralKitMessageInfo | null>;

package/dist/discord/pluralkit.js

@@ -0,0 +1,27 @@
+import { resolveFetch } from "../infra/fetch.js";
+const PLURALKIT_API_BASE = "https://api.pluralkit.me/v2";
+export async function fetchPluralKitMessageInfo(params) {
+    if (!params.config?.enabled) {
+        return null;
+    }
+    const fetchImpl = resolveFetch(params.fetcher);
+    if (!fetchImpl) {
+        return null;
+    }
+    const headers = {};
+    if (params.config.token?.trim()) {
+        headers.Authorization = params.config.token.trim();
+    }
+    const res = await fetchImpl(`${PLURALKIT_API_BASE}/messages/${params.messageId}`, {
+        headers,
+    });
+    if (res.status === 404) {
+        return null;
+    }
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        const detail = text.trim() ? `: ${text.trim()}` : "";
+        throw new Error(`PluralKit API failed (${res.status})${detail}`);
+    }
+    return (await res.json());
+}