@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/telegram/bot-message-dispatch.js

@@ -1,7 +1,6 @@
 import { resolveAgentDir } from "../agents/agent-scope.js";
 import { findModelInCatalog, loadModelCatalog, modelSupportsVision, } from "../agents/model-catalog.js";
 import { resolveDefaultModelForAgent } from "../agents/model-selection.js";
-import { EmbeddedBlockChunker } from "../agents/pi-embedded-block-chunker.js";
 import { resolveChunkMode } from "../auto-reply/chunk.js";
 import { clearHistoryEntriesIfEnabled } from "../auto-reply/reply/history.js";
 import { dispatchReplyWithBufferedBlockDispatcher } from "../auto-reply/reply/provider-dispatcher.js";
@@ -14,7 +13,6 @@ import { loadSessionStore, resolveStorePath } from "../config/sessions.js";
 import { danger, logVerbose } from "../globals.js";
 import { getAgentScopedMediaLocalRoots } from "../media/local-roots.js";
 import { deliverReplies } from "./bot/delivery.js";
-import { resolveTelegramDraftStreamingChunking } from "./draft-chunking.js";
 import { createTelegramDraftStream } from "./draft-stream.js";
 import { renderTelegramHtmlText } from "./format.js";
 import { createTelegramReasoningStepState, splitTelegramReasoningText, } from "./reasoning-lane-coordinator.js";
@@ -57,7 +55,7 @@ function resolveTelegramReasoningLevel(params) {
     return "off";
 }
 export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, replyToMode, streamMode, textLimit, telegramCfg, opts, }) => {
-    const { ctxPayload, msg, chatId, isGroup, threadSpec, historyKey, historyLimit, groupHistories, route, skillFilter, sendTyping, sendRecordVoice, ackReactionPromise, reactionApi, removeAckAfterReply, } = context;
+    const { ctxPayload, msg, chatId, isGroup, threadSpec, historyKey, historyLimit, groupHistories, route, skillFilter, sendTyping, sendRecordVoice, ackReactionPromise, reactionApi, removeAckAfterReply, statusReactionController, } = context;
     const draftMaxChars = Math.min(textLimit, 4096);
     const tableMode = resolveMarkdownTableMode({
         cfg,
@@ -78,12 +76,15 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
     });
     const forceBlockStreamingForReasoning = resolvedReasoningLevel === "on";
     const streamReasoningDraft = resolvedReasoningLevel === "stream";
-    const canStreamAnswerDraft = streamMode !== "off" && !accountBlockStreamingEnabled && !forceBlockStreamingForReasoning;
+    const previewStreamingEnabled = streamMode !== "off";
+    const canStreamAnswerDraft = previewStreamingEnabled && !accountBlockStreamingEnabled && !forceBlockStreamingForReasoning;
     const canStreamReasoningDraft = canStreamAnswerDraft || streamReasoningDraft;
     const draftReplyToMessageId = replyToMode !== "off" && typeof msg.message_id === "number" ? msg.message_id : undefined;
-    const draftMinInitialChars = streamMode === "partial" || streamReasoningDraft ? 1 : DRAFT_MIN_INITIAL_CHARS;
+    const draftMinInitialChars = DRAFT_MIN_INITIAL_CHARS;
     const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, route.agentId);
-    const createDraftLane = (enabled) => {
+    const archivedAnswerPreviews = [];
+    const archivedReasoningPreviewIds = [];
+    const createDraftLane = (laneName, enabled) => {
         const stream = enabled
             ? createTelegramDraftStream({
                 api: bot.api,
@@ -93,24 +94,33 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
                 replyToMessageId: draftReplyToMessageId,
                 minInitialChars: draftMinInitialChars,
                 renderText: renderDraftPreview,
+                onSupersededPreview: laneName === "answer" || laneName === "reasoning"
+                    ? (preview) => {
+                        if (laneName === "reasoning") {
+                            if (!archivedReasoningPreviewIds.includes(preview.messageId)) {
+                                archivedReasoningPreviewIds.push(preview.messageId);
+                            }
+                            return;
+                        }
+                        archivedAnswerPreviews.push({
+                            messageId: preview.messageId,
+                            textSnapshot: preview.textSnapshot,
+                        });
+                    }
+                    : undefined,
                 log: logVerbose,
                 warn: logVerbose,
             })
             : undefined;
-        const chunker = stream && streamMode === "block"
-            ? new EmbeddedBlockChunker(resolveTelegramDraftStreamingChunking(cfg, route.accountId))
-            : undefined;
         return {
             stream,
             lastPartialText: "",
-            draftText: "",
             hasStreamedMessage: false,
-            chunker,
         };
     };
     const lanes = {
-        answer: createDraftLane(canStreamAnswerDraft),
-        reasoning: createDraftLane(canStreamReasoningDraft),
+        answer: createDraftLane("answer", canStreamAnswerDraft),
+        reasoning: createDraftLane("reasoning", canStreamReasoningDraft),
     };
     const answerLane = lanes.answer;
     const reasoningLane = lanes.reasoning;
@@ -129,9 +139,7 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
     };
     const resetDraftLaneState = (lane) => {
         lane.lastPartialText = "";
-        lane.draftText = "";
         lane.hasStreamedMessage = false;
-        lane.chunker?.reset();
     };
     const updateDraftFromPartial = (lane, text) => {
         const laneStream = lane.stream;
@@ -143,45 +151,16 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
         }
         // Mark that we've received streaming content (for forceNewMessage decision).
         lane.hasStreamedMessage = true;
-        if (streamMode === "partial") {
-            // Some providers briefly emit a shorter prefix snapshot (for example
-            // "Sure." -> "Sure" -> "Sure."). Keep the longer preview to avoid
-            // visible punctuation flicker.
-            if (lane.lastPartialText &&
-                lane.lastPartialText.startsWith(text) &&
-                text.length < lane.lastPartialText.length) {
-                return;
-            }
-            lane.lastPartialText = text;
-            laneStream.update(text);
+        // Some providers briefly emit a shorter prefix snapshot (for example
+        // "Sure." -> "Sure" -> "Sure."). Keep the longer preview to avoid
+        // visible punctuation flicker.
+        if (lane.lastPartialText &&
+            lane.lastPartialText.startsWith(text) &&
+            text.length < lane.lastPartialText.length) {
             return;
         }
-        let delta = text;
-        if (text.startsWith(lane.lastPartialText)) {
-            delta = text.slice(lane.lastPartialText.length);
-        }
-        else {
-            // Streaming buffer reset (or non-monotonic stream). Start fresh.
-            lane.chunker?.reset();
-            lane.draftText = "";
-        }
         lane.lastPartialText = text;
-        if (!delta) {
-            return;
-        }
-        if (!lane.chunker) {
-            lane.draftText = text;
-            laneStream.update(lane.draftText);
-            return;
-        }
-        lane.chunker.append(delta);
-        lane.chunker.drain({
-            force: false,
-            emit: (chunk) => {
-                lane.draftText += chunk;
-                laneStream.update(lane.draftText);
-            },
-        });
+        laneStream.update(text);
     };
     const ingestDraftLaneSegments = (text) => {
         for (const segment of splitTextIntoLaneSegments(text)) {
@@ -196,21 +175,9 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
         if (!lane.stream) {
             return;
         }
-        if (lane.chunker?.hasBuffered()) {
-            lane.chunker.drain({
-                force: true,
-                emit: (chunk) => {
-                    lane.draftText += chunk;
-                },
-            });
-            lane.chunker.reset();
-            if (lane.draftText) {
-                lane.stream.update(lane.draftText);
-            }
-        }
         await lane.stream.flush();
     };
-    const disableBlockStreaming = streamMode === "off"
+    const disableBlockStreaming = !previewStreamingEnabled
         ? true
         : forceBlockStreamingForReasoning
             ? false
@@ -309,21 +276,24 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
         linkPreview: telegramCfg.linkPreview,
         replyQuoteText,
     };
-    const getLanePreviewText = (lane) => streamMode === "block" ? lane.draftText : lane.lastPartialText;
+    const getLanePreviewText = (lane) => lane.lastPartialText;
     const tryUpdatePreviewForLane = async (params) => {
-        const { lane, laneName, text, previewButtons, stopBeforeEdit = false, updateLaneSnapshot = false, skipRegressive, context, } = params;
+        const { lane, laneName, text, previewButtons, stopBeforeEdit = false, updateLaneSnapshot = false, skipRegressive, context, previewMessageId: previewMessageIdOverride, previewTextSnapshot, } = params;
         if (!lane.stream) {
             return false;
         }
-        const hadPreviewMessage = typeof lane.stream.messageId() === "number";
+        const lanePreviewMessageId = lane.stream.messageId();
+        const hadPreviewMessage = typeof previewMessageIdOverride === "number" || typeof lanePreviewMessageId === "number";
         if (stopBeforeEdit) {
             await lane.stream.stop();
         }
-        const previewMessageId = lane.stream.messageId();
+        const previewMessageId = typeof previewMessageIdOverride === "number"
+            ? previewMessageIdOverride
+            : lane.stream.messageId();
         if (typeof previewMessageId !== "number") {
             return false;
         }
-        const currentPreviewText = getLanePreviewText(lane);
+        const currentPreviewText = previewTextSnapshot ?? getLanePreviewText(lane);
         const shouldSkipRegressive = Boolean(currentPreviewText) &&
             currentPreviewText.startsWith(text) &&
             text.length < currentPreviewText.length &&
@@ -343,7 +313,6 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
             });
             if (updateLaneSnapshot) {
                 lane.lastPartialText = text;
-                lane.draftText = text;
             }
             deliveryState.delivered = true;
             return true;
@@ -370,14 +339,68 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
         }
         return result.delivered;
     };
+    const consumeArchivedAnswerPreviewForFinal = async (params) => {
+        const archivedPreview = archivedAnswerPreviews.shift();
+        if (!archivedPreview) {
+            return undefined;
+        }
+        if (params.canEditViaPreview) {
+            const finalized = await tryUpdatePreviewForLane({
+                lane: params.lane,
+                laneName: "answer",
+                text: params.text,
+                previewButtons: params.previewButtons,
+                stopBeforeEdit: false,
+                skipRegressive: "existingOnly",
+                context: "final",
+                previewMessageId: archivedPreview.messageId,
+                previewTextSnapshot: archivedPreview.textSnapshot,
+            });
+            if (finalized) {
+                return "preview-finalized";
+            }
+        }
+        try {
+            await bot.api.deleteMessage(chatId, archivedPreview.messageId);
+        }
+        catch (err) {
+            logVerbose(`telegram: archived answer preview cleanup failed (${archivedPreview.messageId}): ${String(err)}`);
+        }
+        const delivered = await sendPayload(applyTextToPayload(params.payload, params.text));
+        return delivered ? "sent" : "skipped";
+    };
     const deliverLaneText = async (params) => {
         const { laneName, text, payload, infoKind, previewButtons, allowPreviewUpdateForNonFinal = false, } = params;
         const lane = lanes[laneName];
         const hasMedia = Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
         const canEditViaPreview = !hasMedia && text.length > 0 && text.length <= draftMaxChars && !payload.isError;
         if (infoKind === "final") {
+            if (laneName === "answer") {
+                const archivedResult = await consumeArchivedAnswerPreviewForFinal({
+                    lane,
+                    text,
+                    payload,
+                    previewButtons,
+                    canEditViaPreview,
+                });
+                if (archivedResult) {
+                    return archivedResult;
+                }
+            }
             if (canEditViaPreview && !finalizedPreviewByLane[laneName]) {
                 await flushDraftLane(lane);
+                if (laneName === "answer") {
+                    const archivedResultAfterFlush = await consumeArchivedAnswerPreviewForFinal({
+                        lane,
+                        text,
+                        payload,
+                        previewButtons,
+                        canEditViaPreview,
+                    });
+                    if (archivedResultAfterFlush) {
+                        return archivedResultAfterFlush;
+                    }
+                }
                 const finalized = await tryUpdatePreviewForLane({
                     lane,
                     laneName,
@@ -418,6 +441,9 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
         return delivered ? "sent" : "skipped";
     };
     let queuedFinal = false;
+    if (statusReactionController) {
+        void statusReactionController.setThinking();
+    }
     try {
         ({ queuedFinal } = await dispatchReplyWithBufferedBlockDispatcher({
             ctx: ctxPayload,
@@ -536,10 +562,16 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
                     }
                     : undefined,
                 onAssistantMessageStart: answerLane.stream
-                    ? () => {
+                    ? async () => {
                         reasoningStepState.resetForNextStep();
-                        // Keep answer blocks separated in block mode; partial mode keeps one answer lane.
-                        if (streamMode === "block" && answerLane.hasStreamedMessage) {
+                        if (answerLane.hasStreamedMessage) {
+                            const previewMessageId = answerLane.stream?.messageId();
+                            if (typeof previewMessageId === "number") {
+                                archivedAnswerPreviews.push({
+                                    messageId: previewMessageId,
+                                    textSnapshot: answerLane.lastPartialText,
+                                });
+                            }
                             answerLane.stream?.forceNewMessage();
                         }
                         resetDraftLaneState(answerLane);
@@ -551,6 +583,11 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
                         splitReasoningOnNextStream = reasoningLane.hasStreamedMessage;
                     }
                     : undefined,
+                onToolStart: statusReactionController
+                    ? async (payload) => {
+                        await statusReactionController.setTool(payload.name);
+                    }
+                    : undefined,
                 onModelSelected,
             },
         }));
@@ -581,6 +618,22 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
                 await stream.clear();
             }
         }
+        for (const archivedPreview of archivedAnswerPreviews) {
+            try {
+                await bot.api.deleteMessage(chatId, archivedPreview.messageId);
+            }
+            catch (err) {
+                logVerbose(`telegram: archived answer preview cleanup failed (${archivedPreview.messageId}): ${String(err)}`);
+            }
+        }
+        for (const messageId of archivedReasoningPreviewIds) {
+            try {
+                await bot.api.deleteMessage(chatId, messageId);
+            }
+            catch (err) {
+                logVerbose(`telegram: archived reasoning preview cleanup failed (${messageId}): ${String(err)}`);
+            }
+        }
     }
     let sentFallback = false;
     if (!deliveryState.delivered &&
@@ -592,26 +645,38 @@ export const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, repl
         sentFallback = result.delivered;
     }
     const hasFinalResponse = queuedFinal || sentFallback;
+    if (statusReactionController && !hasFinalResponse) {
+        void statusReactionController.setError().catch((err) => {
+            logVerbose(`telegram: status reaction error finalize failed: ${String(err)}`);
+        });
+    }
     if (!hasFinalResponse) {
         clearGroupHistory();
         return;
     }
-    removeAckReactionAfterReply({
-        removeAfterReply: removeAckAfterReply,
-        ackReactionPromise,
-        ackReactionValue: ackReactionPromise ? "ack" : null,
-        remove: () => reactionApi?.(chatId, msg.message_id ?? 0, []) ?? Promise.resolve(),
-        onError: (err) => {
-            if (!msg.message_id) {
-                return;
-            }
-            logAckFailure({
-                log: logVerbose,
-                channel: "telegram",
-                target: `${chatId}/${msg.message_id}`,
-                error: err,
-            });
-        },
-    });
+    if (statusReactionController) {
+        void statusReactionController.setDone().catch((err) => {
+            logVerbose(`telegram: status reaction finalize failed: ${String(err)}`);
+        });
+    }
+    else {
+        removeAckReactionAfterReply({
+            removeAfterReply: removeAckAfterReply,
+            ackReactionPromise,
+            ackReactionValue: ackReactionPromise ? "ack" : null,
+            remove: () => reactionApi?.(chatId, msg.message_id ?? 0, []) ?? Promise.resolve(),
+            onError: (err) => {
+                if (!msg.message_id) {
+                    return;
+                }
+                logAckFailure({
+                    log: logVerbose,
+                    channel: "telegram",
+                    target: `${chatId}/${msg.message_id}`,
+                    error: err,
+                });
+            },
+        });
+    }
     clearGroupHistory();
 };

package/dist/telegram/bot-native-commands.js

@@ -6,6 +6,7 @@ import { listSkillCommandsForAgents } from "../auto-reply/skill-commands.js";
 import { resolveCommandAuthorizedFromAuthorizers } from "../channels/command-gating.js";
 import { createReplyPrefixOptions } from "../channels/reply-prefix.js";
 import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
+import { recordSessionMetaFromInbound, resolveStorePath } from "../config/sessions.js";
 import { normalizeTelegramCommandName, resolveTelegramCustomCommands, TELEGRAM_COMMAND_NAME_PATTERN, } from "../config/telegram-custom-commands.js";
 import { danger, logVerbose } from "../globals.js";
 import { getAgentScopedMediaLocalRoots } from "../media/local-roots.js";
@@ -29,6 +30,7 @@ async function resolveTelegramCommandAuth(params) {
     const groupAllowContext = await resolveTelegramGroupAllowFromContext({
         chatId,
         accountId,
+        dmPolicy: telegramCfg.dmPolicy ?? "pairing",
         isForum,
         messageThreadId,
         groupAllowFrom,
@@ -100,6 +102,7 @@ async function resolveTelegramCommandAuth(params) {
     const dmAllow = normalizeAllowFromWithStore({
         allowFrom: allowFrom,
         storeAllowFrom,
+        dmPolicy: telegramCfg.dmPolicy ?? "pairing",
     });
     const senderAllowed = isSenderAllowed({
         allow: dmAllow,
@@ -377,6 +380,19 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         OriginatingChannel: "telegram",
                         OriginatingTo: `telegram:${chatId}`,
                     });
+                    const storePath = resolveStorePath(cfg.session?.store, {
+                        agentId: route.agentId,
+                    });
+                    try {
+                        await recordSessionMetaFromInbound({
+                            storePath,
+                            sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+                            ctx: ctxPayload,
+                        });
+                    }
+                    catch (err) {
+                        runtime.error?.(danger(`telegram slash: failed updating session meta: ${String(err)}`));
+                    }
                     const disableBlockStreaming = typeof telegramCfg.blockStreaming === "boolean"
                         ? !telegramCfg.blockStreaming
                         : undefined;

package/dist/telegram/draft-stream.js

@@ -16,6 +16,7 @@ export function createTelegramDraftStream(params) {
     let lastSentParseMode;
     let stopped = false;
     let isFinal = false;
+    let generation = 0;
     const sendOrEditStreamMessage = async (text) => {
         // Allow final flush even if stopped (e.g., after clear()).
         if (stopped && !isFinal) {
@@ -41,6 +42,7 @@ export function createTelegramDraftStream(params) {
         if (renderedText === lastSentText && renderedParseMode === lastSentParseMode) {
             return true;
         }
+        const sendGeneration = generation;
         // Debounce first preview send for better push notification quality.
         if (typeof streamMessageId !== "number" && minInitialChars != null && !isFinal) {
             if (renderedText.length < minInitialChars) {
@@ -74,7 +76,16 @@ export function createTelegramDraftStream(params) {
                 params.warn?.("telegram stream preview stopped (missing message id from sendMessage)");
                 return false;
             }
-            streamMessageId = Math.trunc(sentMessageId);
+            const normalizedMessageId = Math.trunc(sentMessageId);
+            if (sendGeneration !== generation) {
+                params.onSupersededPreview?.({
+                    messageId: normalizedMessageId,
+                    textSnapshot: renderedText,
+                    parseMode: renderedParseMode,
+                });
+                return true;
+            }
+            streamMessageId = normalizedMessageId;
             return true;
         }
         catch (err) {
@@ -116,10 +127,12 @@ export function createTelegramDraftStream(params) {
         }
     };
     const forceNewMessage = () => {
+        generation += 1;
         streamMessageId = undefined;
         lastSentText = "";
         lastSentParseMode = undefined;
         loop.resetPending();
+        loop.resetThrottleWindow();
     };
     params.log?.(`telegram stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
     return {

package/dist/telegram/inline-buttons.js

@@ -1,9 +1,9 @@
 import { listTelegramAccountIds, resolveTelegramAccount } from "./accounts.js";
-import { parseTelegramTarget } from "./targets.js";
 const DEFAULT_INLINE_BUTTONS_SCOPE = "allowlist";
 function normalizeInlineButtonsScope(value) {
-    if (typeof value !== "string")
+    if (typeof value !== "string") {
         return undefined;
+    }
     const trimmed = value.trim().toLowerCase();
     if (trimmed === "off" ||
         trimmed === "dm" ||
@@ -15,8 +15,9 @@ function normalizeInlineButtonsScope(value) {
     return undefined;
 }
 function resolveInlineButtonsScopeFromCapabilities(capabilities) {
-    if (!capabilities)
+    if (!capabilities) {
         return DEFAULT_INLINE_BUTTONS_SCOPE;
+    }
     if (Array.isArray(capabilities)) {
         const enabled = capabilities.some((entry) => String(entry).trim().toLowerCase() === "inlinebuttons");
         return enabled ? "all" : "off";
@@ -41,15 +42,4 @@ export function isTelegramInlineButtonsEnabled(params) {
     }
     return accountIds.some((accountId) => resolveTelegramInlineButtonsScope({ cfg: params.cfg, accountId }) !== "off");
 }
-export function resolveTelegramTargetChatType(target) {
-    if (!target.trim())
-        return "unknown";
-    const parsed = parseTelegramTarget(target);
-    const chatId = parsed.chatId.trim();
-    if (!chatId)
-        return "unknown";
-    if (/^-?\d+$/.test(chatId)) {
-        return chatId.startsWith("-") ? "group" : "direct";
-    }
-    return "unknown";
-}
+export { resolveTelegramTargetChatType } from "./targets.js";

package/dist/telegram/monitor.js

@@ -39,12 +39,14 @@ const TELEGRAM_POLL_RESTART_POLICY = {
     jitter: 0.25,
 };
 const isGetUpdatesConflict = (err) => {
-    if (!err || typeof err !== "object")
+    if (!err || typeof err !== "object") {
         return false;
+    }
     const typed = err;
     const errorCode = typed.error_code ?? typed.errorCode;
-    if (errorCode !== 409)
+    if (errorCode !== 409) {
         return false;
+    }
     const haystack = [typed.method, typed.description, typed.message]
         .filter((value) => typeof value === "string")
         .join(" ")
@@ -81,14 +83,14 @@ export async function monitorTelegramProvider(opts = {}) {
         if (!token) {
             throw new Error(`Telegram bot token missing for account "${account.accountId}" (set channels.telegram.accounts.${account.accountId}.botToken/tokenFile or TELEGRAM_BOT_TOKEN for default).`);
         }
-        const proxyFetch = opts.proxyFetch ??
-            (account.config.proxy ? makeProxyFetch(account.config.proxy) : undefined);
+        const proxyFetch = opts.proxyFetch ?? (account.config.proxy ? makeProxyFetch(account.config.proxy) : undefined);
         let lastUpdateId = await readTelegramUpdateOffset({
             accountId: account.accountId,
         });
         const persistUpdateId = async (updateId) => {
-            if (lastUpdateId !== null && updateId <= lastUpdateId)
+            if (lastUpdateId !== null && updateId <= lastUpdateId) {
                 return;
+            }
             lastUpdateId = updateId;
             try {
                 await writeTelegramUpdateOffset({
@@ -118,7 +120,8 @@ export async function monitorTelegramProvider(opts = {}) {
                 config: cfg,
                 path: opts.webhookPath,
                 port: opts.webhookPort,
-                secret: opts.webhookSecret,
+                secret: opts.webhookSecret ?? account.config.webhookSecret,
+                host: opts.webhookHost ?? account.config.webhookHost,
                 runtime: opts.runtime,
                 fetch: proxyFetch,
                 abortSignal: opts.abortSignal,
@@ -159,8 +162,9 @@ export async function monitorTelegramProvider(opts = {}) {
                     await sleepWithAbort(delayMs, opts.abortSignal);
                 }
                 catch (sleepErr) {
-                    if (opts.abortSignal?.aborted)
+                    if (opts.abortSignal?.aborted) {
                         return;
+                    }
                     throw sleepErr;
                 }
             }

package/dist/telegram/network-config.js

@@ -1,27 +1,39 @@
 import process from "node:process";
 import { isTruthyEnvValue } from "../infra/env.js";
+import { isWSL2Sync } from "../infra/wsl.js";
 export const TELEGRAM_DISABLE_AUTO_SELECT_FAMILY_ENV = "POOLBOT_TELEGRAM_DISABLE_AUTO_SELECT_FAMILY";
 export const TELEGRAM_ENABLE_AUTO_SELECT_FAMILY_ENV = "POOLBOT_TELEGRAM_ENABLE_AUTO_SELECT_FAMILY";
-const TELEGRAM_DISABLE_AUTO_SELECT_FAMILY_ENV_LEGACY = "CLAWDBOT_TELEGRAM_DISABLE_AUTO_SELECT_FAMILY";
-const TELEGRAM_ENABLE_AUTO_SELECT_FAMILY_ENV_LEGACY = "CLAWDBOT_TELEGRAM_ENABLE_AUTO_SELECT_FAMILY";
+let wsl2SyncCache;
+function isWSL2SyncCached() {
+    if (typeof wsl2SyncCache === "boolean") {
+        return wsl2SyncCache;
+    }
+    wsl2SyncCache = isWSL2Sync();
+    return wsl2SyncCache;
+}
 export function resolveTelegramAutoSelectFamilyDecision(params) {
     const env = params?.env ?? process.env;
     const nodeMajor = typeof params?.nodeMajor === "number"
         ? params.nodeMajor
         : Number(process.versions.node.split(".")[0]);
-    if (isTruthyEnvValue(env[TELEGRAM_ENABLE_AUTO_SELECT_FAMILY_ENV]) ||
-        isTruthyEnvValue(env[TELEGRAM_ENABLE_AUTO_SELECT_FAMILY_ENV_LEGACY])) {
+    if (isTruthyEnvValue(env[TELEGRAM_ENABLE_AUTO_SELECT_FAMILY_ENV])) {
         return { value: true, source: `env:${TELEGRAM_ENABLE_AUTO_SELECT_FAMILY_ENV}` };
     }
-    if (isTruthyEnvValue(env[TELEGRAM_DISABLE_AUTO_SELECT_FAMILY_ENV]) ||
-        isTruthyEnvValue(env[TELEGRAM_DISABLE_AUTO_SELECT_FAMILY_ENV_LEGACY])) {
+    if (isTruthyEnvValue(env[TELEGRAM_DISABLE_AUTO_SELECT_FAMILY_ENV])) {
         return { value: false, source: `env:${TELEGRAM_DISABLE_AUTO_SELECT_FAMILY_ENV}` };
     }
     if (typeof params?.network?.autoSelectFamily === "boolean") {
         return { value: params.network.autoSelectFamily, source: "config" };
     }
+    // WSL2 has unstable IPv6 connectivity; disable autoSelectFamily to use IPv4 directly
+    if (isWSL2SyncCached()) {
+        return { value: false, source: "default-wsl2" };
+    }
     if (Number.isFinite(nodeMajor) && nodeMajor >= 22) {
-        return { value: false, source: "default-node22" };
+        return { value: true, source: "default-node22" };
     }
     return { value: null };
 }
+export function resetTelegramNetworkConfigStateForTests() {
+    wsl2SyncCache = undefined;
+}

package/dist/telegram/send.js

@@ -27,6 +27,7 @@ const PARSE_ERR_RE = /can't parse entities|parse entities|find end of the entity
 const THREAD_NOT_FOUND_RE = /400:\s*Bad Request:\s*message thread not found/i;
 const MESSAGE_NOT_MODIFIED_RE = /400:\s*Bad Request:\s*message is not modified|MESSAGE_NOT_MODIFIED/i;
 const CHAT_NOT_FOUND_RE = /400: Bad Request: chat not found/i;
+const sendLogger = createSubsystemLogger("telegram/send");
 const diagLogger = createSubsystemLogger("telegram/diagnostic");
 function createTelegramHttpLogger(cfg) {
     const enabled = isDiagnosticFlagEnabled("telegram.http", cfg);
@@ -176,7 +177,7 @@ async function withTelegramHtmlParseFallback(params) {
             throw err;
         }
         if (params.verbose) {
-            console.warn(`telegram ${params.label} failed with HTML parse error, retrying as plain text: ${formatErrorMessage(err)}`);
+            sendLogger.warn(`telegram ${params.label} failed with HTML parse error, retrying as plain text: ${formatErrorMessage(err)}`);
         }
         return await params.requestPlain(`${params.label}-plain`);
     }
@@ -236,7 +237,7 @@ async function withTelegramThreadFallback(params, label, verbose, attempt) {
             throw err;
         }
         if (verbose) {
-            console.warn(`telegram ${label} failed with message_thread_id, retrying without thread: ${formatErrorMessage(err)}`);
+            sendLogger.warn(`telegram ${label} failed with message_thread_id, retrying without thread: ${formatErrorMessage(err)}`);
         }
         const retriedParams = removeMessageThreadIdParam(params);
         return await attempt(retriedParams, `${label}-threadless`);