@poolzin/pool-bot 2026.2.0 → 2026.2.1

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

@@ -1,6 +1,6 @@
 import { Button, ChannelType, Command, Row, } from "@buape/carbon";
 import { ApplicationCommandOptionType, ButtonStyle } from "discord-api-types/v10";
-import { resolveEffectiveMessagesConfig, resolveHumanDelayConfig } from "../../agents/identity.js";
+import { 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";
@@ -11,8 +11,10 @@ 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 { createReplyPrefixContext } from "../../channels/reply-prefix.js";
+import { buildUntrustedChannelMetadata } from "../../security/channel-metadata.js";
+import { allowListMatches, isDiscordGroupAllowedByPolicy, normalizeDiscordAllowList, normalizeDiscordSlug, resolveDiscordChannelConfigWithFallback, resolveDiscordGuildEntry, resolveDiscordOwnerAllowFrom, resolveDiscordUserAllowed, } from "./allow-list.js";
+import { resolveDiscordSenderIdentity } from "./sender-identity.js";
 import { resolveDiscordChannelInfo } from "./message-utils.js";
 import { resolveDiscordThreadParentInfo } from "./threading.js";
 function buildDiscordCommandOptions(params) {
@@ -357,6 +359,7 @@ async function dispatchDiscordCommandInteraction(params) {
     const user = interaction.user;
     if (!user)
         return;
+    const sender = resolveDiscordSenderIdentity({ author: user, pluralkitInfo: null });
     const channel = interaction.channel;
     const channelType = channel?.type;
     const isDirectMessage = channelType === ChannelType.DM;
@@ -370,12 +373,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({
@@ -447,12 +451,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) {
@@ -462,8 +466,8 @@ async function dispatchDiscordCommandInteraction(params) {
                         channel: "discord",
                         id: user.id,
                         meta: {
-                            tag: formatDiscordUserTag(user),
-                            name: user.username ?? undefined,
+                            tag: sender.tag,
+                            name: sender.name ?? undefined,
                         },
                     });
                     if (created) {
@@ -488,9 +492,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
@@ -555,10 +559,17 @@ 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 ownerAllowFrom = resolveDiscordOwnerAllowFrom({
+        channelConfig,
+        guildInfo,
+        sender: { id: sender.id, name: sender.name, tag: sender.tag },
+    });
     const ctxPayload = finalizeInboundContext({
         Body: prompt,
+        BodyForAgent: prompt,
         RawBody: prompt,
         CommandBody: prompt,
         CommandArgs: commandArgs,
@@ -576,19 +587,25 @@ async function dispatchDiscordCommandInteraction(params) {
         GroupSubject: isGuild ? interaction.guild?.name : undefined,
         GroupSystemPrompt: isGuild
             ? (() => {
-                const channelTopic = channel && "topic" in channel ? (channel.topic ?? undefined) : undefined;
-                const channelDescription = channelTopic?.trim();
-                const systemPromptParts = [
-                    channelDescription ? `Channel topic: ${channelDescription}` : null,
-                    channelConfig?.systemPrompt?.trim() || null,
-                ].filter((entry) => Boolean(entry));
+                const systemPromptParts = [channelConfig?.systemPrompt?.trim() || null].filter((entry) => Boolean(entry));
                 return systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : undefined;
             })()
             : undefined,
+        UntrustedContext: isGuild
+            ? (() => {
+                const channelTopic = channel && "topic" in channel ? (channel.topic ?? undefined) : undefined;
+                const untrustedChannelMetadata = buildUntrustedChannelMetadata({
+                    source: "discord",
+                    label: "Discord channel topic",
+                    entries: [channelTopic],
+                });
+                return untrustedChannelMetadata ? [untrustedChannelMetadata] : undefined;
+            })()
+            : undefined,
         SenderName: user.globalName ?? user.username,
         SenderId: user.id,
         SenderUsername: user.username,
-        SenderTag: formatDiscordUserTag(user),
+        SenderTag: sender.tag,
         Provider: "discord",
         Surface: "discord",
         WasMentioned: true,
@@ -596,13 +613,16 @@ async function dispatchDiscordCommandInteraction(params) {
         Timestamp: Date.now(),
         CommandAuthorized: commandAuthorized,
         CommandSource: "native",
+        OwnerAllowFrom: ownerAllowFrom,
     });
+    const prefixContext = createReplyPrefixContext({ cfg, agentId: route.agentId });
     let didReply = false;
     await dispatchReplyWithDispatcher({
         ctx: ctxPayload,
         cfg,
         dispatcherOptions: {
-            responsePrefix: resolveEffectiveMessagesConfig(cfg, route.agentId).responsePrefix,
+            responsePrefix: prefixContext.responsePrefix,
+            responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
             humanDelay: resolveHumanDelayConfig(cfg, route.agentId),
             deliver: async (payload) => {
                 try {
@@ -635,6 +655,7 @@ async function dispatchDiscordCommandInteraction(params) {
             disableBlockStreaming: typeof discordConfig?.blockStreaming === "boolean"
                 ? !discordConfig.blockStreaming
                 : undefined,
+            onModelSelected: prefixContext.onModelSelected,
         },
     });
 }

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/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());
+}

package/dist/discord/send.outbound.js

@@ -1,11 +1,25 @@
-import { Routes } from "discord-api-types/v10";
+import { ChannelType, Routes } from "discord-api-types/v10";
 import { resolveChunkMode } from "../auto-reply/chunk.js";
 import { loadConfig } from "../config/config.js";
 import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
 import { recordChannelActivity } from "../infra/channel-activity.js";
 import { convertMarkdownTables } from "../markdown/tables.js";
 import { resolveDiscordAccount } from "./accounts.js";
-import { buildDiscordSendError, createDiscordClient, normalizeDiscordPollInput, normalizeStickerIds, parseRecipient, resolveChannelId, sendDiscordMedia, sendDiscordText, } from "./send.shared.js";
+import { buildDiscordSendError, buildDiscordTextChunks, createDiscordClient, normalizeDiscordPollInput, normalizeStickerIds, parseAndResolveRecipient, resolveChannelId, sendDiscordMedia, sendDiscordText, } from "./send.shared.js";
+/** Discord thread names are capped at 100 characters. */
+const DISCORD_THREAD_NAME_LIMIT = 100;
+/** Derive a thread title from the first non-empty line of the message text. */
+function deriveForumThreadName(text) {
+    const firstLine = text
+        .split("\n")
+        .find((l) => l.trim())
+        ?.trim() ?? "";
+    return firstLine.slice(0, DISCORD_THREAD_NAME_LIMIT) || new Date().toISOString().slice(0, 16);
+}
+/** Forum/Media channels cannot receive regular messages; detect them here. */
+function isForumLikeType(channelType) {
+    return channelType === ChannelType.GuildForum || channelType === ChannelType.GuildMedia;
+}
 export async function sendMessageDiscord(to, text, opts = {}) {
     const cfg = loadConfig();
     const accountInfo = resolveDiscordAccount({
@@ -20,8 +34,81 @@ export async function sendMessageDiscord(to, text, opts = {}) {
     const chunkMode = resolveChunkMode(cfg, "discord", accountInfo.accountId);
     const textWithTables = convertMarkdownTables(text ?? "", tableMode);
     const { token, rest, request } = createDiscordClient(opts, cfg);
-    const recipient = parseRecipient(to);
+    const recipient = await parseAndResolveRecipient(to, opts.accountId);
     const { channelId } = await resolveChannelId(rest, recipient, request);
+    // Forum/Media channels reject POST /messages; auto-create a thread post instead.
+    let channelType;
+    try {
+        const channel = (await rest.get(Routes.channel(channelId)));
+        channelType = channel?.type;
+    }
+    catch {
+        // If we can't fetch the channel, fall through to the normal send path.
+    }
+    if (isForumLikeType(channelType)) {
+        const threadName = deriveForumThreadName(textWithTables);
+        const chunks = buildDiscordTextChunks(textWithTables, {
+            maxLinesPerMessage: accountInfo.config.maxLinesPerMessage,
+            chunkMode,
+        });
+        const starterContent = chunks[0]?.trim() ? chunks[0] : threadName;
+        const starterEmbeds = opts.embeds?.length ? opts.embeds : undefined;
+        let threadRes;
+        try {
+            threadRes = (await request(() => rest.post(Routes.threads(channelId), {
+                body: {
+                    name: threadName,
+                    message: {
+                        content: starterContent,
+                        ...(starterEmbeds ? { embeds: starterEmbeds } : {}),
+                    },
+                },
+            }), "forum-thread"));
+        }
+        catch (err) {
+            throw await buildDiscordSendError(err, {
+                channelId,
+                rest,
+                token,
+                hasMedia: Boolean(opts.mediaUrl),
+            });
+        }
+        const threadId = threadRes.id;
+        const messageId = threadRes.message?.id ?? threadId;
+        const resultChannelId = threadRes.message?.channel_id ?? threadId;
+        const remainingChunks = chunks.slice(1);
+        try {
+            if (opts.mediaUrl) {
+                const [mediaCaption, ...afterMediaChunks] = remainingChunks;
+                await sendDiscordMedia(rest, threadId, mediaCaption ?? "", opts.mediaUrl, undefined, request, accountInfo.config.maxLinesPerMessage, undefined, chunkMode);
+                for (const chunk of afterMediaChunks) {
+                    await sendDiscordText(rest, threadId, chunk, undefined, request, accountInfo.config.maxLinesPerMessage, undefined, chunkMode);
+                }
+            }
+            else {
+                for (const chunk of remainingChunks) {
+                    await sendDiscordText(rest, threadId, chunk, undefined, request, accountInfo.config.maxLinesPerMessage, undefined, chunkMode);
+                }
+            }
+        }
+        catch (err) {
+            throw await buildDiscordSendError(err, {
+                channelId: threadId,
+                rest,
+                token,
+                hasMedia: Boolean(opts.mediaUrl),
+            });
+        }
+        recordChannelActivity({
+            channel: "discord",
+            accountId: accountInfo.accountId,
+            direction: "outbound",
+        });
+        return {
+            messageId: messageId ? String(messageId) : "unknown",
+            channelId: String(resultChannelId ?? channelId),
+        };
+    }
     let result;
     try {
         if (opts.mediaUrl) {
@@ -52,7 +139,7 @@ export async function sendMessageDiscord(to, text, opts = {}) {
 export async function sendStickerDiscord(to, stickerIds, opts = {}) {
     const cfg = loadConfig();
     const { rest, request } = createDiscordClient(opts, cfg);
-    const recipient = parseRecipient(to);
+    const recipient = await parseAndResolveRecipient(to, opts.accountId);
     const { channelId } = await resolveChannelId(rest, recipient, request);
     const content = opts.content?.trim();
     const stickers = normalizeStickerIds(stickerIds);
@@ -70,7 +157,7 @@ export async function sendStickerDiscord(to, stickerIds, opts = {}) {
 export async function sendPollDiscord(to, poll, opts = {}) {
     const cfg = loadConfig();
     const { rest, request } = createDiscordClient(opts, cfg);
-    const recipient = parseRecipient(to);
+    const recipient = await parseAndResolveRecipient(to, opts.accountId);
     const { channelId } = await resolveChannelId(rest, recipient, request);
     const content = opts.content?.trim();
     const payload = normalizeDiscordPollInput(poll);

package/dist/discord/send.shared.js

@@ -9,7 +9,7 @@ import { resolveDiscordAccount } from "./accounts.js";
 import { chunkDiscordTextWithMode } from "./chunk.js";
 import { fetchChannelPermissionsDiscord, isThreadChannelType } from "./send.permissions.js";
 import { DiscordSendError } from "./send.types.js";
-import { parseDiscordTarget } from "./targets.js";
+import { parseDiscordTarget, resolveDiscordTarget } from "./targets.js";
 import { normalizeDiscordToken } from "./token.js";
 const DISCORD_TEXT_LIMIT = 2000;
 const DISCORD_MAX_STICKERS = 3;
@@ -19,8 +19,9 @@ const DISCORD_MISSING_PERMISSIONS = 50013;
 const DISCORD_CANNOT_DM = 50007;
 function resolveToken(params) {
     const explicit = normalizeDiscordToken(params.explicit);
-    if (explicit)
+    if (explicit) {
         return explicit;
+    }
     const fallback = normalizeDiscordToken(params.fallbackToken);
     if (!fallback) {
         throw new Error(`Discord bot token missing for account "${params.accountId}" (set discord.accounts.${params.accountId}.token or DISCORD_BOT_TOKEN for default).`);
@@ -68,6 +69,37 @@ function parseRecipient(raw) {
     }
     return { kind: target.kind, id: target.id };
 }
+/**
+ * Parse and resolve Discord recipient, including username lookup.
+ * This enables sending DMs by username (e.g., "john.doe") by querying
+ * the Discord directory to resolve usernames to user IDs.
+ *
+ * @param raw - The recipient string (username, ID, or known format)
+ * @param accountId - Discord account ID to use for directory lookup
+ * @returns Parsed DiscordRecipient with resolved user ID if applicable
+ */
+export async function parseAndResolveRecipient(raw, accountId) {
+    const cfg = loadConfig();
+    const accountInfo = resolveDiscordAccount({ cfg, accountId });
+    // First try to resolve using directory lookup (handles usernames)
+    const trimmed = raw.trim();
+    const parseOptions = {
+        ambiguousMessage: `Ambiguous Discord recipient "${trimmed}". Use "user:${trimmed}" for DMs or "channel:${trimmed}" for channel messages.`,
+    };
+    const resolved = await resolveDiscordTarget(raw, {
+        cfg,
+        accountId: accountInfo.accountId,
+    }, parseOptions);
+    if (resolved) {
+        return { kind: resolved.kind, id: resolved.id };
+    }
+    // Fallback to standard parsing (for channels, etc.)
+    const parsed = parseDiscordTarget(raw, parseOptions);
+    if (!parsed) {
+        throw new Error("Recipient is required for Discord sends");
+    }
+    return { kind: parsed.kind, id: parsed.id };
+}
 function normalizeStickerIds(raw) {
     const ids = raw.map((entry) => entry.trim()).filter(Boolean);
     if (ids.length === 0) {
@@ -102,29 +134,33 @@ function normalizeDiscordPollInput(input) {
     };
 }
 function getDiscordErrorCode(err) {
-    if (!err || typeof err !== "object")
+    if (!err || typeof err !== "object") {
         return undefined;
+    }
     const candidate = "code" in err && err.code !== undefined
         ? err.code
         : "rawError" in err && err.rawError && typeof err.rawError === "object"
             ? err.rawError.code
             : undefined;
-    if (typeof candidate === "number")
+    if (typeof candidate === "number") {
         return candidate;
+    }
     if (typeof candidate === "string" && /^\d+$/.test(candidate)) {
         return Number(candidate);
     }
     return undefined;
 }
 async function buildDiscordSendError(err, ctx) {
-    if (err instanceof DiscordSendError)
+    if (err instanceof DiscordSendError) {
         return err;
+    }
     const code = getDiscordErrorCode(err);
     if (code === DISCORD_CANNOT_DM) {
         return new DiscordSendError("discord dm failed: user blocks dms or privacy settings disallow it", { kind: "dm-blocked" });
     }
-    if (code !== DISCORD_MISSING_PERMISSIONS)
+    if (code !== DISCORD_MISSING_PERMISSIONS) {
         return err;
+    }
     let missing = [];
     try {
         const permissions = await fetchChannelPermissionsDiscord(ctx.channelId, {
@@ -165,18 +201,26 @@ async function resolveChannelId(rest, recipient, request) {
     }
     return { channelId: dmChannel.id, dm: true };
 }
+export function buildDiscordTextChunks(text, opts = {}) {
+    if (!text) {
+        return [];
+    }
+    const chunks = chunkDiscordTextWithMode(text, {
+        maxChars: opts.maxChars ?? DISCORD_TEXT_LIMIT,
+        maxLines: opts.maxLinesPerMessage,
+        chunkMode: opts.chunkMode,
+    });
+    if (!chunks.length && text) {
+        chunks.push(text);
+    }
+    return chunks;
+}
 async function sendDiscordText(rest, channelId, text, replyTo, request, maxLinesPerMessage, embeds, chunkMode) {
     if (!text.trim()) {
         throw new Error("Message must be non-empty for Discord sends");
     }
     const messageReference = replyTo ? { message_id: replyTo, fail_if_not_exists: false } : undefined;
-    const chunks = chunkDiscordTextWithMode(text, {
-        maxChars: DISCORD_TEXT_LIMIT,
-        maxLines: maxLinesPerMessage,
-        chunkMode,
-    });
-    if (!chunks.length && text)
-        chunks.push(text);
+    const chunks = buildDiscordTextChunks(text, { maxLinesPerMessage, chunkMode });
     if (chunks.length === 1) {
         const res = (await request(() => rest.post(Routes.channelMessages(channelId), {
             body: {
@@ -206,15 +250,7 @@ async function sendDiscordText(rest, channelId, text, replyTo, request, maxLines
 }
 async function sendDiscordMedia(rest, channelId, text, mediaUrl, replyTo, request, maxLinesPerMessage, embeds, chunkMode) {
     const media = await loadWebMedia(mediaUrl);
-    const chunks = text
-        ? chunkDiscordTextWithMode(text, {
-            maxChars: DISCORD_TEXT_LIMIT,
-            maxLines: maxLinesPerMessage,
-            chunkMode,
-        })
-        : [];
-    if (!chunks.length && text)
-        chunks.push(text);
+    const chunks = text ? buildDiscordTextChunks(text, { maxLinesPerMessage, chunkMode }) : [];
     const caption = chunks[0] ?? "";
     const messageReference = replyTo ? { message_id: replyTo, fail_if_not_exists: false } : undefined;
     const res = (await request(() => rest.post(Routes.channelMessages(channelId), {
@@ -231,8 +267,9 @@ async function sendDiscordMedia(rest, channelId, text, mediaUrl, replyTo, reques
         },
     }), "media"));
     for (const chunk of chunks.slice(1)) {
-        if (!chunk.trim())
+        if (!chunk.trim()) {
             continue;
+        }
         await sendDiscordText(rest, channelId, chunk, undefined, request, maxLinesPerMessage, undefined, chunkMode);
     }
     return res;

package/dist/discord/targets.js

@@ -1,8 +1,10 @@
 import { buildMessagingTarget, ensureTargetId, requireTargetKind, } from "../channels/targets.js";
+import { listDiscordDirectoryPeersLive } from "./directory-live.js";
 export function parseDiscordTarget(raw, options = {}) {
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return undefined;
+    }
     const mentionMatch = trimmed.match(/^<@!?(\d+)>$/);
     if (mentionMatch) {
         return buildMessagingTarget("user", mentionMatch[1], trimmed);
@@ -41,3 +43,84 @@ export function resolveDiscordChannelId(raw) {
     const target = parseDiscordTarget(raw, { defaultKind: "channel" });
     return requireTargetKind({ platform: "Discord", target, kind: "channel" });
 }
+/**
+ * Resolve a Discord username to user ID using the directory lookup.
+ * This enables sending DMs by username instead of requiring explicit user IDs.
+ *
+ * @param raw - The username or raw target string (e.g., "john.doe")
+ * @param options - Directory configuration params (cfg, accountId, limit)
+ * @param parseOptions - Messaging target parsing options (defaults, ambiguity message)
+ * @returns Parsed MessagingTarget with user ID, or undefined if not found
+ */
+export async function resolveDiscordTarget(raw, options, parseOptions = {}) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const likelyUsername = isLikelyUsername(trimmed);
+    const shouldLookup = isExplicitUserLookup(trimmed, parseOptions) || likelyUsername;
+    // Parse directly if it's already a known format. Use a safe parse so ambiguous
+    // numeric targets don't throw when we still want to attempt username lookup.
+    const directParse = safeParseDiscordTarget(trimmed, parseOptions);
+    if (directParse && directParse.kind !== "channel" && !likelyUsername) {
+        return directParse;
+    }
+    if (!shouldLookup) {
+        return directParse ?? parseDiscordTarget(trimmed, parseOptions);
+    }
+    // Try to resolve as a username via directory lookup
+    try {
+        const directoryEntries = await listDiscordDirectoryPeersLive({
+            ...options,
+            query: trimmed,
+            limit: 1,
+        });
+        const match = directoryEntries[0];
+        if (match && match.kind === "user") {
+            // Extract user ID from the directory entry (format: "user:<id>")
+            const userId = match.id.replace(/^user:/, "");
+            return buildMessagingTarget("user", userId, trimmed);
+        }
+    }
+    catch {
+        // Directory lookup failed - fall through to parse as-is
+        // This preserves existing behavior for channel names
+    }
+    // Fallback to original parsing (for channels, etc.)
+    return parseDiscordTarget(trimmed, parseOptions);
+}
+function safeParseDiscordTarget(input, options) {
+    try {
+        return parseDiscordTarget(input, options);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isExplicitUserLookup(input, options) {
+    if (/^<@!?(\d+)>$/.test(input)) {
+        return true;
+    }
+    if (/^(user:|discord:)/.test(input)) {
+        return true;
+    }
+    if (input.startsWith("@")) {
+        return true;
+    }
+    if (/^\d+$/.test(input)) {
+        return options.defaultKind === "user";
+    }
+    return false;
+}
+/**
+ * Check if a string looks like a Discord username (not a mention, prefix, or ID).
+ * Usernames typically don't start with special characters except underscore.
+ */
+function isLikelyUsername(input) {
+    // Skip if it's already a known format
+    if (/^(user:|channel:|discord:|@|<@!?)|[\d]+$/.test(input)) {
+        return false;
+    }
+    // Likely a username if it doesn't match known patterns
+    return true;
+}

package/dist/entry.js

@@ -3,32 +3,38 @@ import { spawn } from "node:child_process";
 import path from "node:path";
 import process from "node:process";
 import { applyCliProfileEnv, parseCliProfileArgs } from "./cli/profile.js";
-import { isTruthyEnvValue } from "./infra/env.js";
+import { isTruthyEnvValue, normalizeEnv } from "./infra/env.js";
 import { installProcessWarningFilter } from "./infra/warnings.js";
 import { attachChildProcessBridge } from "./process/child-process-bridge.js";
 process.title = "poolbot";
 installProcessWarningFilter();
+normalizeEnv();
 if (process.argv.includes("--no-color")) {
     process.env.NO_COLOR = "1";
     process.env.FORCE_COLOR = "0";
 }
 const EXPERIMENTAL_WARNING_FLAG = "--disable-warning=ExperimentalWarning";
-function hasExperimentalWarningSuppressed(nodeOptions) {
-    if (!nodeOptions)
-        return false;
-    return nodeOptions.includes(EXPERIMENTAL_WARNING_FLAG) || nodeOptions.includes("--no-warnings");
+function hasExperimentalWarningSuppressed() {
+    const nodeOptions = process.env.NODE_OPTIONS ?? "";
+    if (nodeOptions.includes(EXPERIMENTAL_WARNING_FLAG) || nodeOptions.includes("--no-warnings"))
+        return true;
+    for (const arg of process.execArgv) {
+        if (arg === EXPERIMENTAL_WARNING_FLAG || arg === "--no-warnings")
+            return true;
+    }
+    return false;
 }
 function ensureExperimentalWarningSuppressed() {
     if (isTruthyEnvValue(process.env.CLAWDBOT_NO_RESPAWN))
         return false;
     if (isTruthyEnvValue(process.env.CLAWDBOT_NODE_OPTIONS_READY))
         return false;
-    const nodeOptions = process.env.NODE_OPTIONS ?? "";
-    if (hasExperimentalWarningSuppressed(nodeOptions))
+    if (hasExperimentalWarningSuppressed())
         return false;
+    // Respawn guard (and keep recursion bounded if something goes wrong).
     process.env.CLAWDBOT_NODE_OPTIONS_READY = "1";
-    process.env.NODE_OPTIONS = `${nodeOptions} ${EXPERIMENTAL_WARNING_FLAG}`.trim();
-    const child = spawn(process.execPath, [...process.execArgv, ...process.argv.slice(1)], {
+    // Pass flag as a Node CLI option, not via NODE_OPTIONS (--disable-warning is disallowed in NODE_OPTIONS).
+    const child = spawn(process.execPath, [EXPERIMENTAL_WARNING_FLAG, ...process.execArgv, ...process.argv.slice(1)], {
         stdio: "inherit",
         env: process.env,
     });