@fased/fased 0.1.41 → 0.1.43

package/dist/plugin-sdk/monitor-38DGeIwS.js

@@ -1,4528 +0,0 @@
-import { $ as formatModelsAvailableHeader, $n as resolveTelegramInlineButtonsScope, A as clearHistoryEntriesIfEnabled, C as buildPairingReply, Ct as enqueueSystemEvent, E as DEFAULT_GROUP_HISTORY_LIMIT, F as recordInboundSession, Gt as hasControlCommand, H as createInboundDebouncer, I as removeAckReactionAfterReply, Jt as buildMentionRegexes, K as resolveEnvelopeFormatOptions, L as shouldAckReaction, N as recordPendingHistoryEntryIfEnabled, Nt as registerUnhandledRejectionHandler, O as buildPendingHistoryContextFromMap, Q as buildModelsProviderData, Qt as formatReasoningMessage, Sn as readJsonBodyWithLimit, T as sleepWithAbort, Tt as resolveChannelConfigWrites, U as resolveInboundDebounceMs, W as formatInboundEnvelope, Yt as matchesMentionWithExplicit, Z as resolveStoredModelOverride, _r as resolveControlCommandGate, at as buildCommandsPaginationKeyboard, b as logInboundDrop, bt as buildCommandsMessagePaginated, c as loadModelCatalog, en as stripReasoningTagsFromText, et as buildModelsKeyboard, f as createTypingCallbacks, gr as resolveCommandAuthorizedFromAuthorizers, it as parseModelCallbackData, l as modelSupportsVision, m as resolveMentionGatingWithBypass, nn as isInsideCode, nt as calculateTotalPages, qt as isAbortRequestText, rr as waitForAbortSignal, rt as getModelsPageSize, s as findModelInCatalog, sr as createDedupeCache, tn as findCodeRegions, tt as buildProviderKeyboard, w as computeBackoff, x as logTypingFailure, xr as resolveOpenProviderRuntimeGroupPolicy, xt as formatDurationPrecise, y as logAckFailure, z as dispatchReplyWithBufferedBlockDispatcher } from "./pi-embedded-runner-Dum71Tdo.js";
-import { C as recordSessionMetaFromInbound, Dt as resolveTelegramAccount, Rt as resolveChannelGroupPolicy, S as readSessionUpdatedAt, fn as executePluginCommand, hn as matchPluginCommand, pn as getPluginCommandSpecs, x as loadSessionStore, zt as resolveChannelGroupRequireMention } from "./runtime-BPyuAmka.js";
-import { i as defaultRuntime, r as createNonExitingRuntime, t as createSubsystemLogger } from "./subsystem-DBPNbQDQ.js";
-import { i as logVerbose, l as warn, p as getChildLogger, s as shouldLogVerbose, t as danger } from "./globals-B_jjtAje.js";
-import { s as resolveStateDir } from "./paths-BEmvSyOV.js";
-import "./utils-CYk9EKoq.js";
-import { Gt as resolveDefaultModelForAgent, Nt as resolveAgentMaxConcurrent, cr as formatErrorMessage, h as resolveTelegramCustomCommands, lr as formatUncaughtError, m as normalizeTelegramCommandName, n as loadConfig, p as TELEGRAM_COMMAND_NAME_PATTERN, s as writeConfigFile } from "./config-DtqAN2L3.js";
-import { a as resolveAgentDir, u as resolveDefaultAgentId } from "./agent-scope-kIJqg5PA.js";
-import { p as normalizeAccountId$1, u as resolveThreadSessionKeys } from "./session-key-HSJ2KQTc.js";
-import "./accounts-D7_p-Ivb.js";
-import "./accounts-DTdM1xcj.js";
-import "./accounts-RT6y7n3H.js";
-import "./tokens-CQRTq-NN.js";
-import "./allow-list-C9N6FKeC.js";
-import "./redact-CwCz68Mi.js";
-import "./github-copilot-token-Dgug856m.js";
-import { n as retryAsync } from "./retry-DycQ4ymF.js";
-import { l as resolveStorePath } from "./paths-B88DQEK8.js";
-import "./optional-runtime-dependency-szS49voX.js";
-import "./fetch-guard-DTKgMN9f.js";
-import "./send-DRGzRdI3.js";
-import { C as isSenderAllowed, D as formatLocationText, E as resolveSenderAllowMatch, K as firstDefined, O as toLocationContext, S as resolveTelegramThreadSpec, T as normalizeDmAllowFromWithStore, V as upsertChannelPairingRequest, _ as resolveTelegramForumThreadId, a as buildSenderLabel, b as resolveTelegramReplyId, c as buildTelegramGroupPeerId, d as buildTypingThreadParams, f as describeReplyTarget, g as normalizeForwardedContext, h as hasBotMention, i as buildGroupLabel, l as buildTelegramParentPeer, m as extractTelegramLocation, o as buildSenderName, p as expandTextLinks, s as buildTelegramGroupFrom, u as buildTelegramThreadParams, v as resolveTelegramGroupAllowFromContext, w as normalizeAllowFrom, x as resolveTelegramStreamMode, y as resolveTelegramMediaPlaceholder, z as readChannelAllowFromStore } from "./wsl-PXrdWitE.js";
-import { c as resolveChunkMode, i as chunkMarkdownTextWithMode, l as resolveTextChunkLimit } from "./chunk-M2d7r-Zt.js";
-import { a as resolveAckReaction, n as createReplyPrefixOptions } from "./reply-prefix-DqlCqHXT.js";
-import { n as listSkillCommandsForAgents } from "./skill-commands-CkgGmWBS.js";
-import { c as logWebhookError, d as startDiagnosticHeartbeat, f as stopDiagnosticHeartbeat, l as logWebhookProcessed, m as isDiagnosticsEnabled, u as logWebhookReceived } from "./diagnostic-CuhHqubd.js";
-import "./diagnostic-session-state-Zw87xFym.js";
-import { E as mediaKindFromMime, c as MediaFetchError, l as fetchRemoteMedia, m as getAgentScopedMediaLocalRoots, n as loadWebMedia, x as isGifMedia } from "./media-Cxw-xLGU.js";
-import "./pi-model-discovery-yifTIDIn.js";
-import "./runtime-dependency-Csswyv5r.js";
-import "./path-alias-guards-CcQroDXQ.js";
-import "./fs-safe-BPYS6-j1.js";
-import { n as resolveMarkdownTableMode } from "./markdown-tables-CCSD52rA.js";
-import "./send-D7tr-EsH.js";
-import { a as saveMediaBuffer } from "./outbound-attachment-C-jSFaEB.js";
-import "./fetch-D70syO9t.js";
-import "./thread-bindings.state-CNT2vxm3.js";
-import "./memory-search-J6AYuENR.js";
-import "./manager-D2kZ0Cps.js";
-import "./query-expansion-VePrajug.js";
-import "./common-Cpw-vuuM.js";
-import { C as isNativeCommandsExplicitlyDisabled, E as resolveNativeSkillsEnabled, T as resolveNativeCommandsEnabled, c as listNativeCommandSpecsForConfig, d as parseCommandArgs, p as resolveCommandArgMenu, r as findCommandByNativeName, s as listNativeCommandSpecs, t as buildCommandTextFromArgs, u as normalizeCommandBody } from "./commands-registry-CdT-nl7v.js";
-import { t as finalizeInboundContext } from "./inbound-context-Daf9i2Me.js";
-import "./directory-live-BxSH0XXX.js";
-import "./targets-cA134MEE.js";
-import "./sandbox-paths-CkTERCrj.js";
-import { n as resolveAgentRoute } from "./resolve-route-CNhTJG_2.js";
-import "./render-C9LkRUhd.js";
-import "./tables-CJE8kB35.js";
-import { n as recordChannelActivity } from "./channel-activity-Cf5sKkfd.js";
-import { _ as splitTelegramCaption, d as isRecoverableTelegramNetworkError, f as markdownToTelegramChunks, g as resolveTelegramFetch, h as wrapFileReferencesInHtml, i as editMessageTelegram, l as resolveTelegramVoiceSend, m as renderTelegramHtmlText, p as markdownToTelegramHtml, t as buildInlineKeyboard, u as wasSentByBot, v as withTelegramApiErrorLogging } from "./send-BzFdvD_i.js";
-import "./retry-policy-sM01QZT2.js";
-import { t as makeProxyFetch } from "./proxy-CKQOQYAl.js";
-import { i as getCachedSticker, n as describeStickerImage, t as cacheSticker } from "./sticker-cache-CJDzqowL.js";
-import { i as createStatusReactionController, n as DEFAULT_EMOJIS, t as createFinalizableDraftLifecycle } from "./draft-stream-controls-v_5gdUYG.js";
-import path from "node:path";
-import os from "node:os";
-import fs from "node:fs/promises";
-import crypto from "node:crypto";
-import { createServer } from "node:http";
-import { API_CONSTANTS, Bot, GrammyError, InputFile, webhookCallback } from "grammy";
-import { run, sequentialize } from "@grammyjs/runner";
-import { apiThrottler } from "@grammyjs/transformer-throttler";
-
-//#region src/telegram/allowed-updates.ts
-function resolveTelegramAllowedUpdates() {
-	const updates = [...API_CONSTANTS.DEFAULT_UPDATE_TYPES];
-	if (!updates.includes("message_reaction")) updates.push("message_reaction");
-	if (!updates.includes("channel_post")) updates.push("channel_post");
-	return updates;
-}
-
-//#endregion
-//#region src/telegram/bot-updates.ts
-const MEDIA_GROUP_TIMEOUT_MS = 500;
-const RECENT_TELEGRAM_UPDATE_TTL_MS = 5 * 6e4;
-const RECENT_TELEGRAM_UPDATE_MAX = 2e3;
-const resolveTelegramUpdateId = (ctx) => ctx.update?.update_id ?? ctx.update_id;
-const buildTelegramUpdateKey = (ctx) => {
-	const updateId = resolveTelegramUpdateId(ctx);
-	if (typeof updateId === "number") return `update:${updateId}`;
-	const callbackId = ctx.callbackQuery?.id;
-	if (callbackId) return `callback:${callbackId}`;
-	const msg = ctx.message ?? ctx.channelPost ?? ctx.editedChannelPost ?? ctx.update?.message ?? ctx.update?.edited_message ?? ctx.update?.channel_post ?? ctx.update?.edited_channel_post ?? ctx.callbackQuery?.message;
-	const chatId = msg?.chat?.id;
-	const messageId = msg?.message_id;
-	if (typeof chatId !== "undefined" && typeof messageId === "number") return `message:${chatId}:${messageId}`;
-};
-const createTelegramUpdateDedupe = () => createDedupeCache({
-	ttlMs: RECENT_TELEGRAM_UPDATE_TTL_MS,
-	maxSize: RECENT_TELEGRAM_UPDATE_MAX
-});
-
-//#endregion
-//#region src/telegram/bot/delivery.ts
-const PARSE_ERR_RE = /can't parse entities|parse entities|find end of the entity/i;
-const EMPTY_TEXT_ERR_RE = /message text is empty/i;
-const VOICE_FORBIDDEN_RE = /VOICE_MESSAGES_FORBIDDEN/;
-const FILE_TOO_BIG_RE = /file is too big/i;
-const TELEGRAM_MEDIA_SSRF_POLICY = {
-	allowedHostnames: ["api.telegram.org"],
-	allowRfc2544BenchmarkRange: true
-};
-async function deliverReplies(params) {
-	const { replies, chatId, runtime, bot, replyToMode, textLimit, thread, linkPreview, replyQuoteText } = params;
-	const chunkMode = params.chunkMode ?? "length";
-	let hasReplied = false;
-	let hasDelivered = false;
-	const markDelivered = () => {
-		hasDelivered = true;
-	};
-	const chunkText = (markdown) => {
-		const markdownChunks = chunkMode === "newline" ? chunkMarkdownTextWithMode(markdown, textLimit, chunkMode) : [markdown];
-		const chunks = [];
-		for (const chunk of markdownChunks) {
-			const nested = markdownToTelegramChunks(chunk, textLimit, { tableMode: params.tableMode });
-			if (!nested.length && chunk) {
-				chunks.push({
-					html: wrapFileReferencesInHtml(markdownToTelegramHtml(chunk, {
-						tableMode: params.tableMode,
-						wrapFileRefs: false
-					})),
-					text: chunk
-				});
-				continue;
-			}
-			chunks.push(...nested);
-		}
-		return chunks;
-	};
-	for (const reply of replies) {
-		const hasMedia = Boolean(reply?.mediaUrl) || (reply?.mediaUrls?.length ?? 0) > 0;
-		if (!reply?.text && !hasMedia) {
-			if (reply?.audioAsVoice) {
-				logVerbose("telegram reply has audioAsVoice without media/text; skipping");
-				continue;
-			}
-			runtime.error?.(danger("reply missing text/media"));
-			continue;
-		}
-		const replyToId = replyToMode === "off" ? void 0 : resolveTelegramReplyId(reply.replyToId);
-		const replyToMessageIdForPayload = replyToId && (replyToMode === "all" || !hasReplied) ? replyToId : void 0;
-		const mediaList = reply.mediaUrls?.length ? reply.mediaUrls : reply.mediaUrl ? [reply.mediaUrl] : [];
-		const telegramData = reply.channelData?.telegram;
-		const replyMarkup = buildInlineKeyboard(telegramData?.buttons);
-		if (mediaList.length === 0) {
-			const chunks = chunkText(reply.text || "");
-			let sentTextChunk = false;
-			for (let i = 0; i < chunks.length; i += 1) {
-				const chunk = chunks[i];
-				if (!chunk) continue;
-				const shouldAttachButtons = i === 0 && replyMarkup;
-				const chunkReplyToMessageId = replyToMode === "all" || i === 0 ? replyToMessageIdForPayload : void 0;
-				await sendTelegramText(bot, chatId, chunk.html, runtime, {
-					replyToMessageId: chunkReplyToMessageId,
-					replyQuoteText,
-					thread,
-					textMode: "html",
-					plainText: chunk.text,
-					linkPreview,
-					replyMarkup: shouldAttachButtons ? replyMarkup : void 0
-				});
-				sentTextChunk = true;
-				markDelivered();
-			}
-			if (replyToMessageIdForPayload && !hasReplied && sentTextChunk) hasReplied = true;
-			continue;
-		}
-		let first = true;
-		let pendingFollowUpText;
-		for (const mediaUrl of mediaList) {
-			const isFirstMedia = first;
-			const media = await loadWebMedia(mediaUrl, { localRoots: params.mediaLocalRoots });
-			const kind = mediaKindFromMime(media.contentType ?? void 0);
-			const isGif = isGifMedia({
-				contentType: media.contentType,
-				fileName: media.fileName
-			});
-			const fileName = media.fileName ?? (isGif ? "animation.gif" : "file");
-			const file = new InputFile(media.buffer, fileName);
-			const { caption, followUpText } = splitTelegramCaption(isFirstMedia ? reply.text ?? void 0 : void 0);
-			const htmlCaption = caption ? renderTelegramHtmlText(caption, { tableMode: params.tableMode }) : void 0;
-			if (followUpText) pendingFollowUpText = followUpText;
-			first = false;
-			const replyToMessageId = replyToMode === "all" || isFirstMedia ? replyToMessageIdForPayload : void 0;
-			const shouldAttachButtonsToMedia = isFirstMedia && replyMarkup && !followUpText;
-			const mediaParams = {
-				caption: htmlCaption,
-				...htmlCaption ? { parse_mode: "HTML" } : {},
-				...shouldAttachButtonsToMedia ? { reply_markup: replyMarkup } : {},
-				...buildTelegramSendParams({
-					replyToMessageId,
-					thread
-				})
-			};
-			if (isGif) {
-				await withTelegramApiErrorLogging({
-					operation: "sendAnimation",
-					runtime,
-					fn: () => bot.api.sendAnimation(chatId, file, { ...mediaParams })
-				});
-				markDelivered();
-			} else if (kind === "image") {
-				await withTelegramApiErrorLogging({
-					operation: "sendPhoto",
-					runtime,
-					fn: () => bot.api.sendPhoto(chatId, file, { ...mediaParams })
-				});
-				markDelivered();
-			} else if (kind === "video") {
-				await withTelegramApiErrorLogging({
-					operation: "sendVideo",
-					runtime,
-					fn: () => bot.api.sendVideo(chatId, file, { ...mediaParams })
-				});
-				markDelivered();
-			} else if (kind === "audio") {
-				const { useVoice } = resolveTelegramVoiceSend({
-					wantsVoice: reply.audioAsVoice === true,
-					contentType: media.contentType,
-					fileName,
-					logFallback: logVerbose
-				});
-				if (useVoice) {
-					await params.onVoiceRecording?.();
-					try {
-						await withTelegramApiErrorLogging({
-							operation: "sendVoice",
-							runtime,
-							shouldLog: (err) => !isVoiceMessagesForbidden(err),
-							fn: () => bot.api.sendVoice(chatId, file, { ...mediaParams })
-						});
-						markDelivered();
-					} catch (voiceErr) {
-						if (isVoiceMessagesForbidden(voiceErr)) {
-							const fallbackText = reply.text;
-							if (!fallbackText || !fallbackText.trim()) throw voiceErr;
-							logVerbose("telegram sendVoice forbidden (recipient has voice messages blocked in privacy settings); falling back to text");
-							await sendTelegramVoiceFallbackText({
-								bot,
-								chatId,
-								runtime,
-								text: fallbackText,
-								chunkText,
-								replyToId: replyToMessageIdForPayload,
-								replyToMode,
-								thread,
-								linkPreview,
-								replyMarkup,
-								replyQuoteText
-							});
-							if (replyToMessageIdForPayload && !hasReplied) hasReplied = true;
-							markDelivered();
-							continue;
-						}
-						throw voiceErr;
-					}
-				} else {
-					await withTelegramApiErrorLogging({
-						operation: "sendAudio",
-						runtime,
-						fn: () => bot.api.sendAudio(chatId, file, { ...mediaParams })
-					});
-					markDelivered();
-				}
-			} else {
-				await withTelegramApiErrorLogging({
-					operation: "sendDocument",
-					runtime,
-					fn: () => bot.api.sendDocument(chatId, file, { ...mediaParams })
-				});
-				markDelivered();
-			}
-			if (replyToMessageId && !hasReplied) hasReplied = true;
-			if (pendingFollowUpText && isFirstMedia) {
-				const chunks = chunkText(pendingFollowUpText);
-				for (let i = 0; i < chunks.length; i += 1) {
-					const chunk = chunks[i];
-					const followUpReplyToMessageId = replyToMode === "all" ? replyToMessageIdForPayload : void 0;
-					await sendTelegramText(bot, chatId, chunk.html, runtime, {
-						replyToMessageId: followUpReplyToMessageId,
-						thread,
-						textMode: "html",
-						plainText: chunk.text,
-						linkPreview,
-						replyMarkup: i === 0 ? replyMarkup : void 0
-					});
-					markDelivered();
-				}
-				pendingFollowUpText = void 0;
-			}
-			if (replyToMessageIdForPayload && !hasReplied) hasReplied = true;
-		}
-	}
-	return { delivered: hasDelivered };
-}
-async function resolveMedia(ctx, maxBytes, token, proxyFetch) {
-	const msg = ctx.message;
-	const downloadAndSaveTelegramFile = async (filePath, fetchImpl) => {
-		const fetched = await fetchRemoteMedia({
-			url: `https://api.telegram.org/file/bot${token}/${filePath}`,
-			fetchImpl,
-			filePathHint: filePath,
-			maxBytes,
-			ssrfPolicy: TELEGRAM_MEDIA_SSRF_POLICY
-		});
-		const originalName = fetched.fileName ?? filePath;
-		return saveMediaBuffer(fetched.buffer, fetched.contentType, "inbound", maxBytes, originalName);
-	};
-	if (msg.sticker) {
-		const sticker = msg.sticker;
-		if (sticker.is_animated || sticker.is_video) {
-			logVerbose("telegram: skipping animated/video sticker (only static stickers supported)");
-			return null;
-		}
-		if (!sticker.file_id) return null;
-		try {
-			const file = await ctx.getFile();
-			if (!file.file_path) {
-				logVerbose("telegram: getFile returned no file_path for sticker");
-				return null;
-			}
-			const fetchImpl = proxyFetch ?? globalThis.fetch;
-			if (!fetchImpl) {
-				logVerbose("telegram: fetch not available for sticker download");
-				return null;
-			}
-			const saved = await downloadAndSaveTelegramFile(file.file_path, fetchImpl);
-			const cached = sticker.file_unique_id ? getCachedSticker(sticker.file_unique_id) : null;
-			if (cached) {
-				logVerbose(`telegram: sticker cache hit for ${sticker.file_unique_id}`);
-				const fileId = sticker.file_id ?? cached.fileId;
-				const emoji = sticker.emoji ?? cached.emoji;
-				const setName = sticker.set_name ?? cached.setName;
-				if (fileId !== cached.fileId || emoji !== cached.emoji || setName !== cached.setName) cacheSticker({
-					...cached,
-					fileId,
-					emoji,
-					setName
-				});
-				return {
-					path: saved.path,
-					contentType: saved.contentType,
-					placeholder: "<media:sticker>",
-					stickerMetadata: {
-						emoji,
-						setName,
-						fileId,
-						fileUniqueId: sticker.file_unique_id,
-						cachedDescription: cached.description
-					}
-				};
-			}
-			return {
-				path: saved.path,
-				contentType: saved.contentType,
-				placeholder: "<media:sticker>",
-				stickerMetadata: {
-					emoji: sticker.emoji ?? void 0,
-					setName: sticker.set_name ?? void 0,
-					fileId: sticker.file_id,
-					fileUniqueId: sticker.file_unique_id
-				}
-			};
-		} catch (err) {
-			logVerbose(`telegram: failed to process sticker: ${String(err)}`);
-			return null;
-		}
-	}
-	if (!(msg.photo?.[msg.photo.length - 1] ?? msg.video ?? msg.video_note ?? msg.document ?? msg.audio ?? msg.voice)?.file_id) return null;
-	let file;
-	try {
-		file = await retryAsync(() => ctx.getFile(), {
-			attempts: 3,
-			minDelayMs: 1e3,
-			maxDelayMs: 4e3,
-			jitter: .2,
-			label: "telegram:getFile",
-			shouldRetry: isRetryableGetFileError,
-			onRetry: ({ attempt, maxAttempts }) => logVerbose(`telegram: getFile retry ${attempt}/${maxAttempts}`)
-		});
-	} catch (err) {
-		if (isFileTooBigError(err)) {
-			logVerbose(warn("telegram: getFile failed - file exceeds Telegram Bot API 20MB limit; skipping attachment"));
-			return null;
-		}
-		logVerbose(`telegram: getFile failed after retries: ${String(err)}`);
-		return null;
-	}
-	if (!file.file_path) throw new Error("Telegram getFile returned no file_path");
-	const fetchImpl = proxyFetch ?? globalThis.fetch;
-	if (!fetchImpl) throw new Error("fetch is not available; set channels.telegram.proxy in config");
-	const saved = await downloadAndSaveTelegramFile(file.file_path, fetchImpl);
-	const placeholder = resolveTelegramMediaPlaceholder(msg) ?? "<media:document>";
-	return {
-		path: saved.path,
-		contentType: saved.contentType,
-		placeholder
-	};
-}
-function isVoiceMessagesForbidden(err) {
-	if (err instanceof GrammyError) return VOICE_FORBIDDEN_RE.test(err.description);
-	return VOICE_FORBIDDEN_RE.test(formatErrorMessage(err));
-}
-/**
-* Returns true if the error is Telegram's "file is too big" error.
-* This happens when trying to download files >20MB via the Bot API.
-* Unlike network errors, this is a permanent error and should not be retried.
-*/
-function isFileTooBigError(err) {
-	if (err instanceof GrammyError) return FILE_TOO_BIG_RE.test(err.description);
-	return FILE_TOO_BIG_RE.test(formatErrorMessage(err));
-}
-/**
-* Returns true if the error is a transient network error that should be retried.
-* Returns false for permanent errors like "file is too big" (400 Bad Request).
-*/
-function isRetryableGetFileError(err) {
-	if (isFileTooBigError(err)) return false;
-	return true;
-}
-async function sendTelegramVoiceFallbackText(opts) {
-	const chunks = opts.chunkText(opts.text);
-	for (let i = 0; i < chunks.length; i += 1) {
-		const chunk = chunks[i];
-		const chunkReplyToId = opts.replyToMode === "all" || i === 0 ? opts.replyToId : void 0;
-		await sendTelegramText(opts.bot, opts.chatId, chunk.html, opts.runtime, {
-			replyToMessageId: chunkReplyToId,
-			replyQuoteText: opts.replyQuoteText,
-			thread: opts.thread,
-			textMode: "html",
-			plainText: chunk.text,
-			linkPreview: opts.linkPreview,
-			replyMarkup: i === 0 ? opts.replyMarkup : void 0
-		});
-	}
-}
-function buildTelegramSendParams(opts) {
-	const threadParams = buildTelegramThreadParams(opts?.thread);
-	const params = {};
-	if (opts?.replyToMessageId) params.reply_to_message_id = opts.replyToMessageId;
-	if (threadParams) params.message_thread_id = threadParams.message_thread_id;
-	return params;
-}
-async function sendTelegramText(bot, chatId, text, runtime, opts) {
-	const baseParams = buildTelegramSendParams({
-		replyToMessageId: opts?.replyToMessageId,
-		thread: opts?.thread
-	});
-	const linkPreviewOptions = opts?.linkPreview ?? true ? void 0 : { is_disabled: true };
-	const htmlText = (opts?.textMode ?? "markdown") === "html" ? text : markdownToTelegramHtml(text);
-	const fallbackText = opts?.plainText ?? text;
-	const hasFallbackText = fallbackText.trim().length > 0;
-	const sendPlainFallback = async () => {
-		const res = await withTelegramApiErrorLogging({
-			operation: "sendMessage",
-			runtime,
-			fn: () => bot.api.sendMessage(chatId, fallbackText, {
-				...linkPreviewOptions ? { link_preview_options: linkPreviewOptions } : {},
-				...opts?.replyMarkup ? { reply_markup: opts.replyMarkup } : {},
-				...baseParams
-			})
-		});
-		runtime.log?.(`telegram sendMessage ok chat=${chatId} message=${res.message_id} (plain)`);
-		return res.message_id;
-	};
-	if (!htmlText.trim()) {
-		if (!hasFallbackText) throw new Error("telegram sendMessage failed: empty formatted text and empty plain fallback");
-		return await sendPlainFallback();
-	}
-	try {
-		const res = await withTelegramApiErrorLogging({
-			operation: "sendMessage",
-			runtime,
-			shouldLog: (err) => {
-				const errText = formatErrorMessage(err);
-				return !PARSE_ERR_RE.test(errText) && !EMPTY_TEXT_ERR_RE.test(errText);
-			},
-			fn: () => bot.api.sendMessage(chatId, htmlText, {
-				parse_mode: "HTML",
-				...linkPreviewOptions ? { link_preview_options: linkPreviewOptions } : {},
-				...opts?.replyMarkup ? { reply_markup: opts.replyMarkup } : {},
-				...baseParams
-			})
-		});
-		runtime.log?.(`telegram sendMessage ok chat=${chatId} message=${res.message_id}`);
-		return res.message_id;
-	} catch (err) {
-		const errText = formatErrorMessage(err);
-		if (PARSE_ERR_RE.test(errText) || EMPTY_TEXT_ERR_RE.test(errText)) {
-			if (!hasFallbackText) throw err;
-			runtime.log?.(`telegram formatted send failed; retrying without formatting: ${errText}`);
-			return await sendPlainFallback();
-		}
-		throw err;
-	}
-}
-
-//#endregion
-//#region src/telegram/dm-access.ts
-function resolveTelegramSenderIdentity(msg, chatId) {
-	const from = msg.from;
-	const userId = from?.id != null ? String(from.id) : null;
-	return {
-		username: from?.username ?? "",
-		userId,
-		candidateId: userId ?? String(chatId),
-		firstName: from?.first_name,
-		lastName: from?.last_name
-	};
-}
-async function enforceTelegramDmAccess(params) {
-	const { isGroup, dmPolicy, msg, chatId, effectiveDmAllow, accountId, bot, logger } = params;
-	if (isGroup) return true;
-	if (dmPolicy === "disabled") return false;
-	if (dmPolicy === "open") return true;
-	const sender = resolveTelegramSenderIdentity(msg, chatId);
-	const allowMatch = resolveSenderAllowMatch({
-		allow: effectiveDmAllow,
-		senderId: sender.candidateId,
-		senderUsername: sender.username
-	});
-	const allowMatchMeta = `matchKey=${allowMatch.matchKey ?? "none"} matchSource=${allowMatch.matchSource ?? "none"}`;
-	if (effectiveDmAllow.hasWildcard || effectiveDmAllow.hasEntries && allowMatch.allowed) return true;
-	if (dmPolicy === "pairing") {
-		try {
-			const telegramUserId = sender.userId ?? sender.candidateId;
-			const { code, created } = await upsertChannelPairingRequest({
-				channel: "telegram",
-				id: telegramUserId,
-				accountId,
-				meta: {
-					username: sender.username || void 0,
-					firstName: sender.firstName,
-					lastName: sender.lastName
-				}
-			});
-			if (created) {
-				logger.info({
-					chatId: String(chatId),
-					senderUserId: sender.userId ?? void 0,
-					username: sender.username || void 0,
-					firstName: sender.firstName,
-					lastName: sender.lastName,
-					matchKey: allowMatch.matchKey ?? "none",
-					matchSource: allowMatch.matchSource ?? "none"
-				}, "telegram pairing request");
-				await withTelegramApiErrorLogging({
-					operation: "sendMessage",
-					fn: () => bot.api.sendMessage(chatId, buildPairingReply({
-						channel: "telegram",
-						idLine: `Your Telegram user id: ${telegramUserId}`,
-						code
-					}))
-				});
-			}
-		} catch (err) {
-			logVerbose(`telegram pairing reply failed for chat ${chatId}: ${String(err)}`);
-		}
-		return false;
-	}
-	logVerbose(`Blocked unauthorized telegram sender ${sender.candidateId} (dmPolicy=${dmPolicy}, ${allowMatchMeta})`);
-	return false;
-}
-
-//#endregion
-//#region src/telegram/group-access.ts
-const evaluateTelegramGroupBaseAccess = (params) => {
-	if (!params.isGroup) return { allowed: true };
-	if (params.groupConfig?.enabled === false) return {
-		allowed: false,
-		reason: "group-disabled"
-	};
-	if (params.topicConfig?.enabled === false) return {
-		allowed: false,
-		reason: "topic-disabled"
-	};
-	if (!params.enforceAllowOverride || !params.hasGroupAllowOverride) return { allowed: true };
-	if (!params.effectiveGroupAllow.hasEntries) return {
-		allowed: false,
-		reason: "group-override-unauthorized"
-	};
-	const senderId = params.senderId ?? "";
-	if (params.requireSenderForAllowOverride && !senderId) return {
-		allowed: false,
-		reason: "group-override-unauthorized"
-	};
-	if (!isSenderAllowed({
-		allow: params.effectiveGroupAllow,
-		senderId,
-		senderUsername: params.senderUsername ?? ""
-	})) return {
-		allowed: false,
-		reason: "group-override-unauthorized"
-	};
-	return { allowed: true };
-};
-const resolveTelegramRuntimeGroupPolicy = (params) => resolveOpenProviderRuntimeGroupPolicy({
-	providerConfigPresent: params.providerConfigPresent,
-	groupPolicy: params.groupPolicy,
-	defaultGroupPolicy: params.defaultGroupPolicy
-});
-const evaluateTelegramGroupPolicyAccess = (params) => {
-	const { groupPolicy: runtimeFallbackPolicy } = resolveTelegramRuntimeGroupPolicy({
-		providerConfigPresent: params.cfg.channels?.telegram !== void 0,
-		groupPolicy: params.telegramCfg.groupPolicy,
-		defaultGroupPolicy: params.cfg.channels?.defaults?.groupPolicy
-	});
-	const fallbackPolicy = firstDefined(params.telegramCfg.groupPolicy, params.cfg.channels?.defaults?.groupPolicy) ?? runtimeFallbackPolicy;
-	const groupPolicy = params.useTopicAndGroupOverrides ? firstDefined(params.topicConfig?.groupPolicy, params.groupConfig?.groupPolicy, params.telegramCfg.groupPolicy, params.cfg.channels?.defaults?.groupPolicy) ?? runtimeFallbackPolicy : fallbackPolicy;
-	if (!params.isGroup || !params.enforcePolicy) return {
-		allowed: true,
-		groupPolicy
-	};
-	if (groupPolicy === "disabled") return {
-		allowed: false,
-		reason: "group-policy-disabled",
-		groupPolicy
-	};
-	if (groupPolicy === "allowlist" && params.enforceAllowlistAuthorization) {
-		const senderId = params.senderId ?? "";
-		if (params.requireSenderForAllowlistAuthorization && !senderId) return {
-			allowed: false,
-			reason: "group-policy-allowlist-no-sender",
-			groupPolicy
-		};
-		if (!params.allowEmptyAllowlistEntries && !params.effectiveGroupAllow.hasEntries) return {
-			allowed: false,
-			reason: "group-policy-allowlist-empty",
-			groupPolicy
-		};
-		const senderUsername = params.senderUsername ?? "";
-		if (!isSenderAllowed({
-			allow: params.effectiveGroupAllow,
-			senderId,
-			senderUsername
-		})) return {
-			allowed: false,
-			reason: "group-policy-allowlist-unauthorized",
-			groupPolicy
-		};
-	}
-	if (params.checkChatAllowlist) {
-		const groupAllowlist = params.resolveGroupPolicy(params.chatId);
-		if (groupAllowlist.allowlistEnabled && !groupAllowlist.allowed) return {
-			allowed: false,
-			reason: "group-chat-not-allowed",
-			groupPolicy
-		};
-	}
-	return {
-		allowed: true,
-		groupPolicy
-	};
-};
-
-//#endregion
-//#region src/telegram/group-migration.ts
-function resolveAccountGroups(cfg, accountId) {
-	if (!accountId) return {};
-	const normalized = normalizeAccountId$1(accountId);
-	const accounts = cfg.channels?.telegram?.accounts;
-	if (!accounts || typeof accounts !== "object") return {};
-	const exact = accounts[normalized];
-	if (exact?.groups) return { groups: exact.groups };
-	const matchKey = Object.keys(accounts).find((key) => key.toLowerCase() === normalized.toLowerCase());
-	return { groups: matchKey ? accounts[matchKey]?.groups : void 0 };
-}
-function migrateTelegramGroupsInPlace(groups, oldChatId, newChatId) {
-	if (!groups) return {
-		migrated: false,
-		skippedExisting: false
-	};
-	if (oldChatId === newChatId) return {
-		migrated: false,
-		skippedExisting: false
-	};
-	if (!Object.hasOwn(groups, oldChatId)) return {
-		migrated: false,
-		skippedExisting: false
-	};
-	if (Object.hasOwn(groups, newChatId)) return {
-		migrated: false,
-		skippedExisting: true
-	};
-	groups[newChatId] = groups[oldChatId];
-	delete groups[oldChatId];
-	return {
-		migrated: true,
-		skippedExisting: false
-	};
-}
-function migrateTelegramGroupConfig(params) {
-	const scopes = [];
-	let migrated = false;
-	let skippedExisting = false;
-	const migrationTargets = [{
-		scope: "account",
-		groups: resolveAccountGroups(params.cfg, params.accountId).groups
-	}, {
-		scope: "global",
-		groups: params.cfg.channels?.telegram?.groups
-	}];
-	for (const target of migrationTargets) {
-		const result = migrateTelegramGroupsInPlace(target.groups, params.oldChatId, params.newChatId);
-		if (result.migrated) {
-			migrated = true;
-			scopes.push(target.scope);
-		}
-		if (result.skippedExisting) skippedExisting = true;
-	}
-	return {
-		migrated,
-		skippedExisting,
-		scopes
-	};
-}
-
-//#endregion
-//#region src/telegram/bot-handlers.ts
-function isMediaSizeLimitError(err) {
-	const errMsg = String(err);
-	return errMsg.includes("exceeds") && errMsg.includes("MB limit");
-}
-function isRecoverableMediaGroupError(err) {
-	return err instanceof MediaFetchError || isMediaSizeLimitError(err);
-}
-function hasInboundMedia(msg) {
-	return Boolean(msg.media_group_id) || Array.isArray(msg.photo) && msg.photo.length > 0 || Boolean(msg.video ?? msg.video_note ?? msg.document ?? msg.audio ?? msg.voice ?? msg.sticker);
-}
-function hasReplyTargetMedia(msg) {
-	const externalReply = msg.external_reply;
-	const replyTarget = msg.reply_to_message ?? externalReply;
-	return Boolean(replyTarget && hasInboundMedia(replyTarget));
-}
-function resolveInboundMediaFileId(msg) {
-	return msg.sticker?.file_id ?? msg.photo?.[msg.photo.length - 1]?.file_id ?? msg.video?.file_id ?? msg.video_note?.file_id ?? msg.document?.file_id ?? msg.audio?.file_id ?? msg.voice?.file_id;
-}
-const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, mediaMaxBytes, telegramCfg, allowFrom, groupAllowFrom, resolveGroupPolicy, resolveTelegramGroupConfig, shouldSkipUpdate, processMessage, logger }) => {
-	const DEFAULT_TEXT_FRAGMENT_MAX_GAP_MS = 1500;
-	const TELEGRAM_TEXT_FRAGMENT_START_THRESHOLD_CHARS = 4e3;
-	const TELEGRAM_TEXT_FRAGMENT_MAX_GAP_MS = typeof opts.testTimings?.textFragmentGapMs === "number" && Number.isFinite(opts.testTimings.textFragmentGapMs) ? Math.max(10, Math.floor(opts.testTimings.textFragmentGapMs)) : DEFAULT_TEXT_FRAGMENT_MAX_GAP_MS;
-	const TELEGRAM_TEXT_FRAGMENT_MAX_ID_GAP = 1;
-	const TELEGRAM_TEXT_FRAGMENT_MAX_PARTS = 12;
-	const TELEGRAM_TEXT_FRAGMENT_MAX_TOTAL_CHARS = 5e4;
-	const mediaGroupTimeoutMs = typeof opts.testTimings?.mediaGroupFlushMs === "number" && Number.isFinite(opts.testTimings.mediaGroupFlushMs) ? Math.max(10, Math.floor(opts.testTimings.mediaGroupFlushMs)) : MEDIA_GROUP_TIMEOUT_MS;
-	const mediaGroupBuffer = /* @__PURE__ */ new Map();
-	let mediaGroupProcessing = Promise.resolve();
-	const textFragmentBuffer = /* @__PURE__ */ new Map();
-	let textFragmentProcessing = Promise.resolve();
-	const debounceMs = resolveInboundDebounceMs({
-		cfg,
-		channel: "telegram"
-	});
-	const FORWARD_BURST_DEBOUNCE_MS = 80;
-	const resolveTelegramDebounceLane = (msg) => {
-		const forwardMeta = msg;
-		return forwardMeta.forward_origin ?? forwardMeta.forward_from ?? forwardMeta.forward_from_chat ?? forwardMeta.forward_sender_name ?? forwardMeta.forward_date ? "forward" : "default";
-	};
-	const buildSyntheticTextMessage = (params) => ({
-		...params.base,
-		...params.from ? { from: params.from } : {},
-		text: params.text,
-		caption: void 0,
-		caption_entities: void 0,
-		entities: void 0,
-		...params.date != null ? { date: params.date } : {}
-	});
-	const buildSyntheticContext = (ctx, message) => {
-		const getFile = typeof ctx.getFile === "function" ? ctx.getFile.bind(ctx) : async () => ({});
-		return {
-			message,
-			me: ctx.me,
-			getFile
-		};
-	};
-	const inboundDebouncer = createInboundDebouncer({
-		debounceMs,
-		resolveDebounceMs: (entry) => entry.debounceLane === "forward" ? FORWARD_BURST_DEBOUNCE_MS : debounceMs,
-		buildKey: (entry) => entry.debounceKey,
-		shouldDebounce: (entry) => {
-			const text = entry.msg.text ?? entry.msg.caption ?? "";
-			const hasText = text.trim().length > 0;
-			if (hasText && hasControlCommand(text, cfg, { botUsername: entry.botUsername })) return false;
-			if (entry.debounceLane === "forward") return true;
-			return entry.allMedia.length === 0 && hasText;
-		},
-		onFlush: async (entries) => {
-			const last = entries.at(-1);
-			if (!last) return;
-			if (entries.length === 1) {
-				const replyMedia = await resolveReplyMediaForMessage(last.ctx, last.msg);
-				await processMessage(last.ctx, last.allMedia, last.storeAllowFrom, void 0, replyMedia);
-				return;
-			}
-			const combinedText = entries.map((entry) => entry.msg.text ?? entry.msg.caption ?? "").filter(Boolean).join("\n");
-			const combinedMedia = entries.flatMap((entry) => entry.allMedia);
-			if (!combinedText.trim() && combinedMedia.length === 0) return;
-			const first = entries[0];
-			const baseCtx = first.ctx;
-			const syntheticMessage = buildSyntheticTextMessage({
-				base: first.msg,
-				text: combinedText,
-				date: last.msg.date ?? first.msg.date
-			});
-			const messageIdOverride = last.msg.message_id ? String(last.msg.message_id) : void 0;
-			const syntheticCtx = buildSyntheticContext(baseCtx, syntheticMessage);
-			const replyMedia = await resolveReplyMediaForMessage(baseCtx, syntheticMessage);
-			await processMessage(syntheticCtx, combinedMedia, first.storeAllowFrom, messageIdOverride ? { messageIdOverride } : void 0, replyMedia);
-		},
-		onError: (err) => {
-			runtime.error?.(danger(`telegram debounce flush failed: ${String(err)}`));
-		}
-	});
-	const resolveTelegramSessionState = (params) => {
-		const resolvedThreadId = params.resolvedThreadId ?? resolveTelegramForumThreadId({
-			isForum: params.isForum,
-			messageThreadId: params.messageThreadId
-		});
-		const peerId = params.isGroup ? buildTelegramGroupPeerId(params.chatId, resolvedThreadId) : String(params.chatId);
-		const parentPeer = buildTelegramParentPeer({
-			isGroup: params.isGroup,
-			resolvedThreadId,
-			chatId: params.chatId
-		});
-		const route = resolveAgentRoute({
-			cfg,
-			channel: "telegram",
-			accountId,
-			peer: {
-				kind: params.isGroup ? "group" : "direct",
-				id: peerId
-			},
-			parentPeer
-		});
-		const baseSessionKey = route.sessionKey;
-		const dmThreadId = !params.isGroup ? params.messageThreadId : void 0;
-		const sessionKey = (dmThreadId != null ? resolveThreadSessionKeys({
-			baseSessionKey,
-			threadId: String(dmThreadId)
-		}) : null)?.sessionKey ?? baseSessionKey;
-		const store = loadSessionStore(resolveStorePath(cfg.session?.store, { agentId: route.agentId }));
-		const entry = store[sessionKey];
-		const storedOverride = resolveStoredModelOverride({
-			sessionEntry: entry,
-			sessionStore: store,
-			sessionKey
-		});
-		if (storedOverride) return {
-			agentId: route.agentId,
-			sessionEntry: entry,
-			model: storedOverride.provider ? `${storedOverride.provider}/${storedOverride.model}` : storedOverride.model
-		};
-		const provider = entry?.modelProvider?.trim();
-		const model = entry?.model?.trim();
-		if (provider && model) return {
-			agentId: route.agentId,
-			sessionEntry: entry,
-			model: `${provider}/${model}`
-		};
-		const modelCfg = cfg.agents?.defaults?.model;
-		return {
-			agentId: route.agentId,
-			sessionEntry: entry,
-			model: typeof modelCfg === "string" ? modelCfg : modelCfg?.primary
-		};
-	};
-	const processMediaGroup = async (entry) => {
-		try {
-			entry.messages.sort((a, b) => a.msg.message_id - b.msg.message_id);
-			const primaryEntry = entry.messages.find((m) => m.msg.caption || m.msg.text) ?? entry.messages[0];
-			const allMedia = [];
-			for (const { ctx } of entry.messages) {
-				let media;
-				try {
-					media = await resolveMedia(ctx, mediaMaxBytes, opts.token, opts.proxyFetch);
-				} catch (mediaErr) {
-					if (!isRecoverableMediaGroupError(mediaErr)) throw mediaErr;
-					runtime.log?.(warn(`media group: skipping photo that failed to fetch: ${String(mediaErr)}`));
-					continue;
-				}
-				if (media) allMedia.push({
-					path: media.path,
-					contentType: media.contentType,
-					stickerMetadata: media.stickerMetadata
-				});
-			}
-			const storeAllowFrom = await loadStoreAllowFrom();
-			const replyMedia = await resolveReplyMediaForMessage(primaryEntry.ctx, primaryEntry.msg);
-			await processMessage(primaryEntry.ctx, allMedia, storeAllowFrom, void 0, replyMedia);
-		} catch (err) {
-			runtime.error?.(danger(`media group handler failed: ${String(err)}`));
-		}
-	};
-	const flushTextFragments = async (entry) => {
-		try {
-			entry.messages.sort((a, b) => a.msg.message_id - b.msg.message_id);
-			const first = entry.messages[0];
-			const last = entry.messages.at(-1);
-			if (!first || !last) return;
-			const combinedText = entry.messages.map((m) => m.msg.text ?? "").join("");
-			if (!combinedText.trim()) return;
-			const syntheticMessage = buildSyntheticTextMessage({
-				base: first.msg,
-				text: combinedText,
-				date: last.msg.date ?? first.msg.date
-			});
-			const storeAllowFrom = await loadStoreAllowFrom();
-			const baseCtx = first.ctx;
-			await processMessage(buildSyntheticContext(baseCtx, syntheticMessage), [], storeAllowFrom, { messageIdOverride: String(last.msg.message_id) });
-		} catch (err) {
-			runtime.error?.(danger(`text fragment handler failed: ${String(err)}`));
-		}
-	};
-	const queueTextFragmentFlush = async (entry) => {
-		textFragmentProcessing = textFragmentProcessing.then(async () => {
-			await flushTextFragments(entry);
-		}).catch(() => void 0);
-		await textFragmentProcessing;
-	};
-	const runTextFragmentFlush = async (entry) => {
-		textFragmentBuffer.delete(entry.key);
-		await queueTextFragmentFlush(entry);
-	};
-	const scheduleTextFragmentFlush = (entry) => {
-		clearTimeout(entry.timer);
-		entry.timer = setTimeout(async () => {
-			await runTextFragmentFlush(entry);
-		}, TELEGRAM_TEXT_FRAGMENT_MAX_GAP_MS);
-	};
-	const loadStoreAllowFrom = async () => readChannelAllowFromStore("telegram", process.env, accountId).catch(() => []);
-	const resolveReplyMediaForMessage = async (ctx, msg) => {
-		const replyMessage = msg.reply_to_message;
-		if (!replyMessage || !hasInboundMedia(replyMessage)) return [];
-		const replyFileId = resolveInboundMediaFileId(replyMessage);
-		if (!replyFileId) return [];
-		try {
-			const media = await resolveMedia({
-				message: replyMessage,
-				me: ctx.me,
-				getFile: async () => await bot.api.getFile(replyFileId)
-			}, mediaMaxBytes, opts.token, opts.proxyFetch);
-			if (!media) return [];
-			return [{
-				path: media.path,
-				contentType: media.contentType,
-				stickerMetadata: media.stickerMetadata
-			}];
-		} catch (err) {
-			logger.warn({
-				chatId: msg.chat.id,
-				error: String(err)
-			}, "reply media fetch failed");
-			return [];
-		}
-	};
-	const isAllowlistAuthorized = (allow, senderId, senderUsername) => allow.hasWildcard || allow.hasEntries && isSenderAllowed({
-		allow,
-		senderId,
-		senderUsername
-	});
-	const shouldSkipGroupMessage = (params) => {
-		const { isGroup, chatId, chatTitle, resolvedThreadId, senderId, senderUsername, effectiveGroupAllow, hasGroupAllowOverride, groupConfig, topicConfig } = params;
-		const baseAccess = evaluateTelegramGroupBaseAccess({
-			isGroup,
-			groupConfig,
-			topicConfig,
-			hasGroupAllowOverride,
-			effectiveGroupAllow,
-			senderId,
-			senderUsername,
-			enforceAllowOverride: true,
-			requireSenderForAllowOverride: true
-		});
-		if (!baseAccess.allowed) {
-			if (baseAccess.reason === "group-disabled") {
-				logVerbose(`Blocked telegram group ${chatId} (group disabled)`);
-				return true;
-			}
-			if (baseAccess.reason === "topic-disabled") {
-				logVerbose(`Blocked telegram topic ${chatId} (${resolvedThreadId ?? "unknown"}) (topic disabled)`);
-				return true;
-			}
-			logVerbose(`Blocked telegram group sender ${senderId || "unknown"} (group allowFrom override)`);
-			return true;
-		}
-		if (!isGroup) return false;
-		const policyAccess = evaluateTelegramGroupPolicyAccess({
-			isGroup,
-			chatId,
-			cfg,
-			telegramCfg,
-			topicConfig,
-			groupConfig,
-			effectiveGroupAllow,
-			senderId,
-			senderUsername,
-			resolveGroupPolicy,
-			enforcePolicy: true,
-			useTopicAndGroupOverrides: true,
-			enforceAllowlistAuthorization: true,
-			allowEmptyAllowlistEntries: false,
-			requireSenderForAllowlistAuthorization: true,
-			checkChatAllowlist: true
-		});
-		if (!policyAccess.allowed) {
-			if (policyAccess.reason === "group-policy-disabled") {
-				logVerbose("Blocked telegram group message (groupPolicy: disabled)");
-				return true;
-			}
-			if (policyAccess.reason === "group-policy-allowlist-no-sender") {
-				logVerbose("Blocked telegram group message (no sender ID, groupPolicy: allowlist)");
-				return true;
-			}
-			if (policyAccess.reason === "group-policy-allowlist-empty") {
-				logVerbose("Blocked telegram group message (groupPolicy: allowlist, no group allowlist entries)");
-				return true;
-			}
-			if (policyAccess.reason === "group-policy-allowlist-unauthorized") {
-				logVerbose(`Blocked telegram group message from ${senderId} (groupPolicy: allowlist)`);
-				return true;
-			}
-			logger.info({
-				chatId,
-				title: chatTitle,
-				reason: "not-allowed"
-			}, "skipping group message");
-			return true;
-		}
-		return false;
-	};
-	const TELEGRAM_EVENT_AUTH_RULES = {
-		reaction: {
-			enforceDirectAuthorization: true,
-			enforceGroupAllowlistAuthorization: false,
-			deniedDmReason: "reaction unauthorized by dm policy/allowlist",
-			deniedGroupReason: "reaction unauthorized by group allowlist"
-		},
-		"callback-scope": {
-			enforceDirectAuthorization: false,
-			enforceGroupAllowlistAuthorization: false,
-			deniedDmReason: "callback unauthorized by inlineButtonsScope",
-			deniedGroupReason: "callback unauthorized by inlineButtonsScope"
-		},
-		"callback-allowlist": {
-			enforceDirectAuthorization: true,
-			enforceGroupAllowlistAuthorization: false,
-			deniedDmReason: "callback unauthorized by inlineButtonsScope allowlist",
-			deniedGroupReason: "callback unauthorized by inlineButtonsScope allowlist"
-		}
-	};
-	const resolveTelegramEventAuthorizationContext = async (params) => {
-		return {
-			dmPolicy: telegramCfg.dmPolicy ?? "pairing",
-			...params.groupAllowContext ?? await resolveTelegramGroupAllowFromContext({
-				chatId: params.chatId,
-				accountId,
-				isForum: params.isForum,
-				messageThreadId: params.messageThreadId,
-				groupAllowFrom,
-				resolveTelegramGroupConfig
-			})
-		};
-	};
-	const authorizeTelegramEventSender = (params) => {
-		const { chatId, chatTitle, isGroup, senderId, senderUsername, mode, context } = params;
-		const { dmPolicy, resolvedThreadId, storeAllowFrom, groupConfig, topicConfig, effectiveGroupAllow, hasGroupAllowOverride } = context;
-		const { enforceDirectAuthorization, enforceGroupAllowlistAuthorization, deniedDmReason, deniedGroupReason } = TELEGRAM_EVENT_AUTH_RULES[mode];
-		if (shouldSkipGroupMessage({
-			isGroup,
-			chatId,
-			chatTitle,
-			resolvedThreadId,
-			senderId,
-			senderUsername,
-			effectiveGroupAllow,
-			hasGroupAllowOverride,
-			groupConfig,
-			topicConfig
-		})) return {
-			allowed: false,
-			reason: "group-policy"
-		};
-		if (!isGroup && enforceDirectAuthorization) {
-			if (dmPolicy === "disabled") {
-				logVerbose(`Blocked telegram direct event from ${senderId || "unknown"} (${deniedDmReason})`);
-				return {
-					allowed: false,
-					reason: "direct-disabled"
-				};
-			}
-			if (dmPolicy !== "open") {
-				if (!isAllowlistAuthorized(normalizeDmAllowFromWithStore({
-					allowFrom,
-					storeAllowFrom,
-					dmPolicy
-				}), senderId, senderUsername)) {
-					logVerbose(`Blocked telegram direct sender ${senderId || "unknown"} (${deniedDmReason})`);
-					return {
-						allowed: false,
-						reason: "direct-unauthorized"
-					};
-				}
-			}
-		}
-		if (isGroup && enforceGroupAllowlistAuthorization) {
-			if (!isAllowlistAuthorized(effectiveGroupAllow, senderId, senderUsername)) {
-				logVerbose(`Blocked telegram group sender ${senderId || "unknown"} (${deniedGroupReason})`);
-				return {
-					allowed: false,
-					reason: "group-unauthorized"
-				};
-			}
-		}
-		return { allowed: true };
-	};
-	bot.on("message_reaction", async (ctx) => {
-		try {
-			const reaction = ctx.messageReaction;
-			if (!reaction) return;
-			if (shouldSkipUpdate(ctx)) return;
-			const chatId = reaction.chat.id;
-			const messageId = reaction.message_id;
-			const user = reaction.user;
-			const senderId = user?.id != null ? String(user.id) : "";
-			const senderUsername = user?.username ?? "";
-			const isGroup = reaction.chat.type === "group" || reaction.chat.type === "supergroup";
-			const isForum = reaction.chat.is_forum === true;
-			const reactionMode = telegramCfg.reactionNotifications ?? "own";
-			if (reactionMode === "off") return;
-			if (user?.is_bot) return;
-			if (reactionMode === "own" && !wasSentByBot(chatId, messageId)) return;
-			const eventAuthContext = await resolveTelegramEventAuthorizationContext({
-				chatId,
-				isForum
-			});
-			if (!authorizeTelegramEventSender({
-				chatId,
-				chatTitle: reaction.chat.title,
-				isGroup,
-				senderId,
-				senderUsername,
-				mode: "reaction",
-				context: eventAuthContext
-			}).allowed) return;
-			const oldEmojis = new Set(reaction.old_reaction.filter((r) => r.type === "emoji").map((r) => r.emoji));
-			const addedReactions = reaction.new_reaction.filter((r) => r.type === "emoji").filter((r) => !oldEmojis.has(r.emoji));
-			if (addedReactions.length === 0) return;
-			const senderName = user ? [user.first_name, user.last_name].filter(Boolean).join(" ").trim() || user.username : void 0;
-			const senderUsernameLabel = user?.username ? `@${user.username}` : void 0;
-			let senderLabel = senderName;
-			if (senderName && senderUsernameLabel) senderLabel = `${senderName} (${senderUsernameLabel})`;
-			else if (!senderName && senderUsernameLabel) senderLabel = senderUsernameLabel;
-			if (!senderLabel && user?.id) senderLabel = `id:${user.id}`;
-			senderLabel = senderLabel || "unknown";
-			const resolvedThreadId = isForum ? resolveTelegramForumThreadId({
-				isForum,
-				messageThreadId: void 0
-			}) : void 0;
-			const peerId = isGroup ? buildTelegramGroupPeerId(chatId, resolvedThreadId) : String(chatId);
-			const parentPeer = buildTelegramParentPeer({
-				isGroup,
-				resolvedThreadId,
-				chatId
-			});
-			const sessionKey = resolveAgentRoute({
-				cfg: loadConfig(),
-				channel: "telegram",
-				accountId,
-				peer: {
-					kind: isGroup ? "group" : "direct",
-					id: peerId
-				},
-				parentPeer
-			}).sessionKey;
-			for (const r of addedReactions) {
-				const emoji = r.emoji;
-				const text = `Telegram reaction added: ${emoji} by ${senderLabel} on msg ${messageId}`;
-				enqueueSystemEvent(text, {
-					sessionKey,
-					contextKey: `telegram:reaction:add:${chatId}:${messageId}:${user?.id ?? "anon"}:${emoji}`
-				});
-				logVerbose(`telegram: reaction event enqueued: ${text}`);
-			}
-		} catch (err) {
-			runtime.error?.(danger(`telegram reaction handler failed: ${String(err)}`));
-		}
-	});
-	const processInboundMessage = async (params) => {
-		const { ctx, msg, chatId, resolvedThreadId, storeAllowFrom, sendOversizeWarning, oversizeLogMessage } = params;
-		const text = typeof msg.text === "string" ? msg.text : void 0;
-		const isCommandLike = (text ?? "").trim().startsWith("/");
-		if (text && !isCommandLike) {
-			const nowMs = Date.now();
-			const senderId = msg.from?.id != null ? String(msg.from.id) : "unknown";
-			const key = `text:${chatId}:${resolvedThreadId ?? "main"}:${senderId}`;
-			const existing = textFragmentBuffer.get(key);
-			if (existing) {
-				const last = existing.messages.at(-1);
-				const lastMsgId = last?.msg.message_id;
-				const lastReceivedAtMs = last?.receivedAtMs ?? nowMs;
-				const idGap = typeof lastMsgId === "number" ? msg.message_id - lastMsgId : Infinity;
-				const timeGapMs = nowMs - lastReceivedAtMs;
-				if (idGap > 0 && idGap <= TELEGRAM_TEXT_FRAGMENT_MAX_ID_GAP && timeGapMs >= 0 && timeGapMs <= TELEGRAM_TEXT_FRAGMENT_MAX_GAP_MS) {
-					const nextTotalChars = existing.messages.reduce((sum, m) => sum + (m.msg.text?.length ?? 0), 0) + text.length;
-					if (existing.messages.length + 1 <= TELEGRAM_TEXT_FRAGMENT_MAX_PARTS && nextTotalChars <= TELEGRAM_TEXT_FRAGMENT_MAX_TOTAL_CHARS) {
-						existing.messages.push({
-							msg,
-							ctx,
-							receivedAtMs: nowMs
-						});
-						scheduleTextFragmentFlush(existing);
-						return;
-					}
-				}
-				clearTimeout(existing.timer);
-				textFragmentBuffer.delete(key);
-				textFragmentProcessing = textFragmentProcessing.then(async () => {
-					await flushTextFragments(existing);
-				}).catch(() => void 0);
-				await textFragmentProcessing;
-			}
-			if (text.length >= TELEGRAM_TEXT_FRAGMENT_START_THRESHOLD_CHARS) {
-				const entry = {
-					key,
-					messages: [{
-						msg,
-						ctx,
-						receivedAtMs: nowMs
-					}],
-					timer: setTimeout(() => {}, TELEGRAM_TEXT_FRAGMENT_MAX_GAP_MS)
-				};
-				textFragmentBuffer.set(key, entry);
-				scheduleTextFragmentFlush(entry);
-				return;
-			}
-		}
-		const mediaGroupId = msg.media_group_id;
-		if (mediaGroupId) {
-			const existing = mediaGroupBuffer.get(mediaGroupId);
-			if (existing) {
-				clearTimeout(existing.timer);
-				existing.messages.push({
-					msg,
-					ctx
-				});
-				existing.timer = setTimeout(async () => {
-					mediaGroupBuffer.delete(mediaGroupId);
-					mediaGroupProcessing = mediaGroupProcessing.then(async () => {
-						await processMediaGroup(existing);
-					}).catch(() => void 0);
-					await mediaGroupProcessing;
-				}, mediaGroupTimeoutMs);
-			} else {
-				const entry = {
-					messages: [{
-						msg,
-						ctx
-					}],
-					timer: setTimeout(async () => {
-						mediaGroupBuffer.delete(mediaGroupId);
-						mediaGroupProcessing = mediaGroupProcessing.then(async () => {
-							await processMediaGroup(entry);
-						}).catch(() => void 0);
-						await mediaGroupProcessing;
-					}, mediaGroupTimeoutMs)
-				};
-				mediaGroupBuffer.set(mediaGroupId, entry);
-			}
-			return;
-		}
-		let media = null;
-		try {
-			media = await resolveMedia(ctx, mediaMaxBytes, opts.token, opts.proxyFetch);
-		} catch (mediaErr) {
-			if (isMediaSizeLimitError(mediaErr)) {
-				if (sendOversizeWarning) {
-					const limitMb = Math.round(mediaMaxBytes / (1024 * 1024));
-					await withTelegramApiErrorLogging({
-						operation: "sendMessage",
-						runtime,
-						fn: () => bot.api.sendMessage(chatId, `⚠️ File too large. Maximum size is ${limitMb}MB.`, { reply_to_message_id: msg.message_id })
-					}).catch(() => {});
-				}
-				logger.warn({
-					chatId,
-					error: String(mediaErr)
-				}, oversizeLogMessage);
-				return;
-			}
-			logger.warn({
-				chatId,
-				error: String(mediaErr)
-			}, "media fetch failed");
-			await withTelegramApiErrorLogging({
-				operation: "sendMessage",
-				runtime,
-				fn: () => bot.api.sendMessage(chatId, "⚠️ Failed to download media. Please try again.", { reply_to_message_id: msg.message_id })
-			}).catch(() => {});
-			return;
-		}
-		const hasText = Boolean((msg.text ?? msg.caption ?? "").trim());
-		if (msg.sticker && !media && !hasText) {
-			logVerbose("telegram: skipping sticker-only message (unsupported sticker type)");
-			return;
-		}
-		const allMedia = media ? [{
-			path: media.path,
-			contentType: media.contentType,
-			stickerMetadata: media.stickerMetadata
-		}] : [];
-		const senderId = msg.from?.id ? String(msg.from.id) : "";
-		const conversationKey = resolvedThreadId != null ? `${chatId}:topic:${resolvedThreadId}` : String(chatId);
-		const debounceLane = resolveTelegramDebounceLane(msg);
-		const debounceKey = senderId ? `telegram:${accountId ?? "default"}:${conversationKey}:${senderId}:${debounceLane}` : null;
-		await inboundDebouncer.enqueue({
-			ctx,
-			msg,
-			allMedia,
-			storeAllowFrom,
-			debounceKey,
-			debounceLane,
-			botUsername: ctx.me?.username
-		});
-	};
-	bot.on("callback_query", async (ctx) => {
-		const callback = ctx.callbackQuery;
-		if (!callback) return;
-		if (shouldSkipUpdate(ctx)) return;
-		await withTelegramApiErrorLogging({
-			operation: "answerCallbackQuery",
-			runtime,
-			fn: typeof ctx.answerCallbackQuery === "function" ? () => ctx.answerCallbackQuery() : () => bot.api.answerCallbackQuery(callback.id)
-		}).catch(() => {});
-		try {
-			const data = (callback.data ?? "").trim();
-			const callbackMessage = callback.message;
-			if (!data || !callbackMessage) return;
-			const editCallbackMessage = async (text, params) => {
-				if (typeof ctx.editMessageText === "function") return await ctx.editMessageText(text, params);
-				return await bot.api.editMessageText(callbackMessage.chat.id, callbackMessage.message_id, text, params);
-			};
-			const deleteCallbackMessage = async () => {
-				if (typeof ctx.deleteMessage === "function") return await ctx.deleteMessage();
-				return await bot.api.deleteMessage(callbackMessage.chat.id, callbackMessage.message_id);
-			};
-			const replyToCallbackChat = async (text, params) => {
-				if (typeof ctx.reply === "function") return await ctx.reply(text, params);
-				return await bot.api.sendMessage(callbackMessage.chat.id, text, params);
-			};
-			const inlineButtonsScope = resolveTelegramInlineButtonsScope({
-				cfg,
-				accountId
-			});
-			if (inlineButtonsScope === "off") return;
-			const chatId = callbackMessage.chat.id;
-			const isGroup = callbackMessage.chat.type === "group" || callbackMessage.chat.type === "supergroup";
-			if (inlineButtonsScope === "dm" && isGroup) return;
-			if (inlineButtonsScope === "group" && !isGroup) return;
-			const messageThreadId = callbackMessage.message_thread_id;
-			const isForum = callbackMessage.chat.is_forum === true;
-			const eventAuthContext = await resolveTelegramEventAuthorizationContext({
-				chatId,
-				isForum,
-				messageThreadId
-			});
-			const { resolvedThreadId, storeAllowFrom } = eventAuthContext;
-			const senderId = callback.from?.id ? String(callback.from.id) : "";
-			const senderUsername = callback.from?.username ?? "";
-			const authorizationMode = inlineButtonsScope === "allowlist" ? "callback-allowlist" : "callback-scope";
-			if (!authorizeTelegramEventSender({
-				chatId,
-				chatTitle: callbackMessage.chat.title,
-				isGroup,
-				senderId,
-				senderUsername,
-				mode: authorizationMode,
-				context: eventAuthContext
-			}).allowed) return;
-			const paginationMatch = data.match(/^commands_page_(\d+|noop)(?::(.+))?$/);
-			if (paginationMatch) {
-				const pageValue = paginationMatch[1];
-				if (pageValue === "noop") return;
-				const page = Number.parseInt(pageValue, 10);
-				if (Number.isNaN(page) || page < 1) return;
-				const agentId = paginationMatch[2]?.trim() || resolveDefaultAgentId(cfg) || void 0;
-				const result = buildCommandsMessagePaginated(cfg, listSkillCommandsForAgents({
-					cfg,
-					agentIds: agentId ? [agentId] : void 0
-				}), {
-					page,
-					surface: "telegram"
-				});
-				const keyboard = result.totalPages > 1 ? buildInlineKeyboard(buildCommandsPaginationKeyboard(result.currentPage, result.totalPages, agentId)) : void 0;
-				try {
-					await editCallbackMessage(result.text, keyboard ? { reply_markup: keyboard } : void 0);
-				} catch (editErr) {
-					if (!String(editErr).includes("message is not modified")) throw editErr;
-				}
-				return;
-			}
-			const modelCallback = parseModelCallbackData(data);
-			if (modelCallback) {
-				const { byProvider, providers } = await buildModelsProviderData(cfg);
-				const editMessageWithButtons = async (text, buttons) => {
-					const keyboard = buildInlineKeyboard(buttons);
-					try {
-						await editCallbackMessage(text, keyboard ? { reply_markup: keyboard } : void 0);
-					} catch (editErr) {
-						const errStr = String(editErr);
-						if (errStr.includes("no text in the message")) {
-							try {
-								await deleteCallbackMessage();
-							} catch {}
-							await replyToCallbackChat(text, keyboard ? { reply_markup: keyboard } : void 0);
-						} else if (!errStr.includes("message is not modified")) throw editErr;
-					}
-				};
-				if (modelCallback.type === "providers" || modelCallback.type === "back") {
-					if (providers.length === 0) {
-						await editMessageWithButtons("No providers available.", []);
-						return;
-					}
-					await editMessageWithButtons("Select a provider:", buildProviderKeyboard(providers.map((p) => ({
-						id: p,
-						count: byProvider.get(p)?.size ?? 0
-					}))));
-					return;
-				}
-				if (modelCallback.type === "list") {
-					const { provider, page } = modelCallback;
-					const modelSet = byProvider.get(provider);
-					if (!modelSet || modelSet.size === 0) {
-						const buttons = buildProviderKeyboard(providers.map((p) => ({
-							id: p,
-							count: byProvider.get(p)?.size ?? 0
-						})));
-						await editMessageWithButtons(`Unknown provider: ${provider}\n\nSelect a provider:`, buttons);
-						return;
-					}
-					const models = [...modelSet].toSorted();
-					const pageSize = getModelsPageSize();
-					const totalPages = calculateTotalPages(models.length, pageSize);
-					const safePage = Math.max(1, Math.min(page, totalPages));
-					const sessionState = resolveTelegramSessionState({
-						chatId,
-						isGroup,
-						isForum,
-						messageThreadId,
-						resolvedThreadId
-					});
-					const currentModel = sessionState.model;
-					const buttons = buildModelsKeyboard({
-						provider,
-						models,
-						currentModel,
-						currentPage: safePage,
-						totalPages,
-						pageSize
-					});
-					await editMessageWithButtons(formatModelsAvailableHeader({
-						provider,
-						total: models.length,
-						cfg,
-						agentDir: resolveAgentDir(cfg, sessionState.agentId),
-						sessionEntry: sessionState.sessionEntry
-					}), buttons);
-					return;
-				}
-				if (modelCallback.type === "select") {
-					const { provider, model } = modelCallback;
-					await processMessage(buildSyntheticContext(ctx, buildSyntheticTextMessage({
-						base: callbackMessage,
-						from: callback.from,
-						text: `/model ${provider}/${model}`
-					})), [], storeAllowFrom, {
-						forceWasMentioned: true,
-						messageIdOverride: callback.id
-					});
-					return;
-				}
-				return;
-			}
-			await processMessage(buildSyntheticContext(ctx, buildSyntheticTextMessage({
-				base: callbackMessage,
-				from: callback.from,
-				text: data
-			})), [], storeAllowFrom, {
-				forceWasMentioned: true,
-				messageIdOverride: callback.id
-			});
-		} catch (err) {
-			runtime.error?.(danger(`callback handler failed: ${String(err)}`));
-		}
-	});
-	bot.on("message:migrate_to_chat_id", async (ctx) => {
-		try {
-			const msg = ctx.message;
-			if (!msg?.migrate_to_chat_id) return;
-			if (shouldSkipUpdate(ctx)) return;
-			const oldChatId = String(msg.chat.id);
-			const newChatId = String(msg.migrate_to_chat_id);
-			const chatTitle = msg.chat.title ?? "Unknown";
-			runtime.log?.(warn(`[telegram] Group migrated: "${chatTitle}" ${oldChatId} → ${newChatId}`));
-			if (!resolveChannelConfigWrites({
-				cfg,
-				channelId: "telegram",
-				accountId
-			})) {
-				runtime.log?.(warn("[telegram] Config writes disabled; skipping group config migration."));
-				return;
-			}
-			const currentConfig = loadConfig();
-			const migration = migrateTelegramGroupConfig({
-				cfg: currentConfig,
-				accountId,
-				oldChatId,
-				newChatId
-			});
-			if (migration.migrated) {
-				runtime.log?.(warn(`[telegram] Migrating group config from ${oldChatId} to ${newChatId}`));
-				migrateTelegramGroupConfig({
-					cfg,
-					accountId,
-					oldChatId,
-					newChatId
-				});
-				await writeConfigFile(currentConfig);
-				runtime.log?.(warn(`[telegram] Group config migrated and saved successfully`));
-			} else if (migration.skippedExisting) runtime.log?.(warn(`[telegram] Group config already exists for ${newChatId}; leaving ${oldChatId} unchanged`));
-			else runtime.log?.(warn(`[telegram] No config found for old group ID ${oldChatId}, migration logged only`));
-		} catch (err) {
-			runtime.error?.(danger(`[telegram] Group migration handler failed: ${String(err)}`));
-		}
-	});
-	const handleInboundMessageLike = async (event) => {
-		try {
-			if (shouldSkipUpdate(event.ctxForDedupe)) return;
-			const { dmPolicy, resolvedThreadId, storeAllowFrom, groupConfig, topicConfig, effectiveGroupAllow, hasGroupAllowOverride } = await resolveTelegramEventAuthorizationContext({
-				chatId: event.chatId,
-				isForum: event.isForum,
-				messageThreadId: event.messageThreadId
-			});
-			const effectiveDmAllow = normalizeDmAllowFromWithStore({
-				allowFrom,
-				storeAllowFrom,
-				dmPolicy
-			});
-			if (event.requireConfiguredGroup && (!groupConfig || groupConfig.enabled === false)) {
-				logVerbose(`Blocked telegram channel ${event.chatId} (channel disabled)`);
-				return;
-			}
-			if (shouldSkipGroupMessage({
-				isGroup: event.isGroup,
-				chatId: event.chatId,
-				chatTitle: event.msg.chat.title,
-				resolvedThreadId,
-				senderId: event.senderId,
-				senderUsername: event.senderUsername,
-				effectiveGroupAllow,
-				hasGroupAllowOverride,
-				groupConfig,
-				topicConfig
-			})) return;
-			if (!event.isGroup && (hasInboundMedia(event.msg) || hasReplyTargetMedia(event.msg))) {
-				if (!await enforceTelegramDmAccess({
-					isGroup: event.isGroup,
-					dmPolicy,
-					msg: event.msg,
-					chatId: event.chatId,
-					effectiveDmAllow,
-					accountId,
-					bot,
-					logger
-				})) return;
-			}
-			await processInboundMessage({
-				ctx: event.ctx,
-				msg: event.msg,
-				chatId: event.chatId,
-				resolvedThreadId,
-				storeAllowFrom,
-				sendOversizeWarning: event.sendOversizeWarning,
-				oversizeLogMessage: event.oversizeLogMessage
-			});
-		} catch (err) {
-			runtime.error?.(danger(`${event.errorMessage}: ${String(err)}`));
-		}
-	};
-	bot.on("message", async (ctx) => {
-		const msg = ctx.message;
-		if (!msg) return;
-		await handleInboundMessageLike({
-			ctxForDedupe: ctx,
-			ctx: buildSyntheticContext(ctx, msg),
-			msg,
-			chatId: msg.chat.id,
-			isGroup: msg.chat.type === "group" || msg.chat.type === "supergroup",
-			isForum: msg.chat.is_forum === true,
-			messageThreadId: msg.message_thread_id,
-			senderId: msg.from?.id != null ? String(msg.from.id) : "",
-			senderUsername: msg.from?.username ?? "",
-			requireConfiguredGroup: false,
-			sendOversizeWarning: true,
-			oversizeLogMessage: "media exceeds size limit",
-			errorMessage: "handler failed"
-		});
-	});
-	bot.on("channel_post", async (ctx) => {
-		const post = ctx.channelPost;
-		if (!post) return;
-		const chatId = post.chat.id;
-		const syntheticFrom = post.sender_chat ? {
-			id: post.sender_chat.id,
-			is_bot: true,
-			first_name: post.sender_chat.title || "Channel",
-			username: post.sender_chat.username
-		} : {
-			id: chatId,
-			is_bot: true,
-			first_name: post.chat.title || "Channel",
-			username: post.chat.username
-		};
-		const syntheticMsg = {
-			...post,
-			from: post.from ?? syntheticFrom,
-			chat: {
-				...post.chat,
-				type: "supergroup"
-			}
-		};
-		await handleInboundMessageLike({
-			ctxForDedupe: ctx,
-			ctx: buildSyntheticContext(ctx, syntheticMsg),
-			msg: syntheticMsg,
-			chatId,
-			isGroup: true,
-			isForum: false,
-			senderId: post.sender_chat?.id != null ? String(post.sender_chat.id) : post.from?.id != null ? String(post.from.id) : "",
-			senderUsername: post.sender_chat?.username ?? post.from?.username ?? "",
-			requireConfiguredGroup: true,
-			sendOversizeWarning: false,
-			oversizeLogMessage: "channel post media exceeds size limit",
-			errorMessage: "channel_post handler failed"
-		});
-	});
-};
-
-//#endregion
-//#region src/telegram/group-config-helpers.ts
-function resolveTelegramGroupPromptSettings(params) {
-	const skillFilter = firstDefined(params.topicConfig?.skills, params.groupConfig?.skills);
-	const systemPromptParts = [params.groupConfig?.systemPrompt?.trim() || null, params.topicConfig?.systemPrompt?.trim() || null].filter((entry) => Boolean(entry));
-	return {
-		skillFilter,
-		groupSystemPrompt: systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : void 0
-	};
-}
-
-//#endregion
-//#region src/telegram/status-reaction-variants.ts
-const TELEGRAM_GENERIC_REACTION_FALLBACKS = [
-	"👍",
-	"👀",
-	"🔥"
-];
-const TELEGRAM_SUPPORTED_REACTION_EMOJIS = new Set([
-	"❤",
-	"👍",
-	"👎",
-	"🔥",
-	"🥰",
-	"👏",
-	"😁",
-	"🤔",
-	"🤯",
-	"😱",
-	"🤬",
-	"😢",
-	"🎉",
-	"🤩",
-	"🤮",
-	"💩",
-	"🙏",
-	"👌",
-	"🕊",
-	"🤡",
-	"🥱",
-	"🥴",
-	"😍",
-	"🐳",
-	"❤‍🔥",
-	"🌚",
-	"🌭",
-	"💯",
-	"🤣",
-	"⚡",
-	"🍌",
-	"🏆",
-	"💔",
-	"🤨",
-	"😐",
-	"🍓",
-	"🍾",
-	"💋",
-	"🖕",
-	"😈",
-	"😴",
-	"😭",
-	"🤓",
-	"👻",
-	"👨‍💻",
-	"👀",
-	"🎃",
-	"🙈",
-	"😇",
-	"😨",
-	"🤝",
-	"✍",
-	"🤗",
-	"🫡",
-	"🎅",
-	"🎄",
-	"☃",
-	"💅",
-	"🤪",
-	"🗿",
-	"🆒",
-	"💘",
-	"🙉",
-	"🦄",
-	"😘",
-	"💊",
-	"🙊",
-	"😎",
-	"👾",
-	"🤷‍♂",
-	"🤷",
-	"🤷‍♀",
-	"😡"
-]);
-const TELEGRAM_STATUS_REACTION_VARIANTS = {
-	queued: [
-		"👀",
-		"👍",
-		"🔥"
-	],
-	thinking: [
-		"🤔",
-		"🤓",
-		"👀"
-	],
-	tool: [
-		"🔥",
-		"⚡",
-		"👍"
-	],
-	coding: [
-		"👨‍💻",
-		"🔥",
-		"⚡"
-	],
-	web: [
-		"⚡",
-		"🔥",
-		"👍"
-	],
-	done: [
-		"👍",
-		"🎉",
-		"💯"
-	],
-	error: [
-		"😱",
-		"😨",
-		"🤯"
-	],
-	stallSoft: [
-		"🥱",
-		"😴",
-		"🤔"
-	],
-	stallHard: [
-		"😨",
-		"😱",
-		"⚡"
-	]
-};
-const STATUS_REACTION_EMOJI_KEYS = [
-	"queued",
-	"thinking",
-	"tool",
-	"coding",
-	"web",
-	"done",
-	"error",
-	"stallSoft",
-	"stallHard"
-];
-function normalizeEmoji(value) {
-	const trimmed = value?.trim();
-	return trimmed ? trimmed : void 0;
-}
-function toUniqueNonEmpty(values) {
-	return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
-}
-function resolveTelegramStatusReactionEmojis(params) {
-	const { overrides } = params;
-	const queuedFallback = normalizeEmoji(params.initialEmoji) ?? DEFAULT_EMOJIS.queued;
-	return {
-		queued: normalizeEmoji(overrides?.queued) ?? queuedFallback,
-		thinking: normalizeEmoji(overrides?.thinking) ?? DEFAULT_EMOJIS.thinking,
-		tool: normalizeEmoji(overrides?.tool) ?? DEFAULT_EMOJIS.tool,
-		coding: normalizeEmoji(overrides?.coding) ?? DEFAULT_EMOJIS.coding,
-		web: normalizeEmoji(overrides?.web) ?? DEFAULT_EMOJIS.web,
-		done: normalizeEmoji(overrides?.done) ?? DEFAULT_EMOJIS.done,
-		error: normalizeEmoji(overrides?.error) ?? DEFAULT_EMOJIS.error,
-		stallSoft: normalizeEmoji(overrides?.stallSoft) ?? DEFAULT_EMOJIS.stallSoft,
-		stallHard: normalizeEmoji(overrides?.stallHard) ?? DEFAULT_EMOJIS.stallHard
-	};
-}
-function buildTelegramStatusReactionVariants(emojis) {
-	const variantsByRequested = /* @__PURE__ */ new Map();
-	for (const key of STATUS_REACTION_EMOJI_KEYS) {
-		const requested = normalizeEmoji(emojis[key]);
-		if (!requested) continue;
-		const candidates = toUniqueNonEmpty([requested, ...TELEGRAM_STATUS_REACTION_VARIANTS[key] ?? []]);
-		variantsByRequested.set(requested, candidates);
-	}
-	return variantsByRequested;
-}
-function isTelegramSupportedReactionEmoji(emoji) {
-	return TELEGRAM_SUPPORTED_REACTION_EMOJIS.has(emoji);
-}
-function extractTelegramAllowedEmojiReactions(chat) {
-	if (!chat || typeof chat !== "object") return;
-	if (!Object.prototype.hasOwnProperty.call(chat, "available_reactions")) return;
-	const availableReactions = chat.available_reactions;
-	if (availableReactions == null) return null;
-	if (!Array.isArray(availableReactions)) return /* @__PURE__ */ new Set();
-	const allowed = /* @__PURE__ */ new Set();
-	for (const reaction of availableReactions) {
-		if (!reaction || typeof reaction !== "object") continue;
-		const typedReaction = reaction;
-		if (typedReaction.type !== "emoji" || typeof typedReaction.emoji !== "string") continue;
-		const emoji = typedReaction.emoji.trim();
-		if (emoji) allowed.add(emoji);
-	}
-	return allowed;
-}
-async function resolveTelegramAllowedEmojiReactions(params) {
-	const fromMessage = extractTelegramAllowedEmojiReactions(params.chat);
-	if (fromMessage !== void 0) return fromMessage;
-	if (params.getChat) try {
-		const fromLookup = extractTelegramAllowedEmojiReactions(await params.getChat(params.chatId));
-		if (fromLookup !== void 0) return fromLookup;
-	} catch {
-		return null;
-	}
-	return null;
-}
-function resolveTelegramReactionVariant(params) {
-	const requestedEmoji = normalizeEmoji(params.requestedEmoji);
-	if (!requestedEmoji) return;
-	const variants = toUniqueNonEmpty([...params.variantsByRequestedEmoji.get(requestedEmoji) ?? [requestedEmoji], ...TELEGRAM_GENERIC_REACTION_FALLBACKS]);
-	for (const candidate of variants) if ((params.allowedEmojiReactions == null || params.allowedEmojiReactions.has(candidate)) && isTelegramSupportedReactionEmoji(candidate)) return candidate;
-}
-
-//#endregion
-//#region src/telegram/bot-message-context.ts
-async function resolveStickerVisionSupport$1(params) {
-	try {
-		const catalog = await loadModelCatalog({ config: params.cfg });
-		const defaultModel = resolveDefaultModelForAgent({
-			cfg: params.cfg,
-			agentId: params.agentId
-		});
-		const entry = findModelInCatalog(catalog, defaultModel.provider, defaultModel.model);
-		if (!entry) return false;
-		return modelSupportsVision(entry);
-	} catch {
-		return false;
-	}
-}
-const buildTelegramMessageContext = async ({ primaryCtx, allMedia, replyMedia = [], storeAllowFrom, options, bot, cfg, account, historyLimit, groupHistories, dmPolicy, allowFrom, groupAllowFrom, ackReactionScope, logger, resolveGroupActivation, resolveGroupRequireMention, resolveTelegramGroupConfig, sendChatActionHandler }) => {
-	const msg = primaryCtx.message;
-	const chatId = msg.chat.id;
-	const isGroup = msg.chat.type === "group" || msg.chat.type === "supergroup";
-	const messageThreadId = msg.message_thread_id;
-	const isForum = msg.chat.is_forum === true;
-	const threadSpec = resolveTelegramThreadSpec({
-		isGroup,
-		isForum,
-		messageThreadId
-	});
-	const resolvedThreadId = threadSpec.scope === "forum" ? threadSpec.id : void 0;
-	const replyThreadId = threadSpec.id;
-	const { groupConfig, topicConfig } = resolveTelegramGroupConfig(chatId, resolvedThreadId);
-	const peerId = isGroup ? buildTelegramGroupPeerId(chatId, resolvedThreadId) : String(chatId);
-	const parentPeer = buildTelegramParentPeer({
-		isGroup,
-		resolvedThreadId,
-		chatId
-	});
-	const route = resolveAgentRoute({
-		cfg: loadConfig(),
-		channel: "telegram",
-		accountId: account.accountId,
-		peer: {
-			kind: isGroup ? "group" : "direct",
-			id: peerId
-		},
-		parentPeer
-	});
-	const baseSessionKey = route.sessionKey;
-	const dmThreadId = threadSpec.scope === "dm" ? threadSpec.id : void 0;
-	const sessionKey = (dmThreadId != null ? resolveThreadSessionKeys({
-		baseSessionKey,
-		threadId: String(dmThreadId)
-	}) : null)?.sessionKey ?? baseSessionKey;
-	const mentionRegexes = buildMentionRegexes(cfg, route.agentId);
-	const effectiveDmAllow = normalizeDmAllowFromWithStore({
-		allowFrom,
-		storeAllowFrom,
-		dmPolicy
-	});
-	const groupAllowOverride = firstDefined(topicConfig?.allowFrom, groupConfig?.allowFrom);
-	const effectiveGroupAllow = normalizeAllowFrom(groupAllowOverride ?? groupAllowFrom);
-	const hasGroupAllowOverride = typeof groupAllowOverride !== "undefined";
-	const senderId = msg.from?.id ? String(msg.from.id) : "";
-	const senderUsername = msg.from?.username ?? "";
-	const baseAccess = evaluateTelegramGroupBaseAccess({
-		isGroup,
-		groupConfig,
-		topicConfig,
-		hasGroupAllowOverride,
-		effectiveGroupAllow,
-		senderId,
-		senderUsername,
-		enforceAllowOverride: true,
-		requireSenderForAllowOverride: false
-	});
-	if (!baseAccess.allowed) {
-		if (baseAccess.reason === "group-disabled") {
-			logVerbose(`Blocked telegram group ${chatId} (group disabled)`);
-			return null;
-		}
-		if (baseAccess.reason === "topic-disabled") {
-			logVerbose(`Blocked telegram topic ${chatId} (${resolvedThreadId ?? "unknown"}) (topic disabled)`);
-			return null;
-		}
-		logVerbose(`Blocked telegram group sender ${senderId || "unknown"} (group allowFrom override)`);
-		return null;
-	}
-	const activationOverride = resolveGroupActivation({
-		chatId,
-		messageThreadId: resolvedThreadId,
-		sessionKey,
-		agentId: route.agentId
-	});
-	const baseRequireMention = resolveGroupRequireMention(chatId);
-	const requireMention = firstDefined(activationOverride, topicConfig?.requireMention, groupConfig?.requireMention, baseRequireMention);
-	const sendTyping = async () => {
-		await withTelegramApiErrorLogging({
-			operation: "sendChatAction",
-			fn: () => sendChatActionHandler.sendChatAction(chatId, "typing", buildTypingThreadParams(replyThreadId))
-		});
-	};
-	const sendRecordVoice = async () => {
-		try {
-			await withTelegramApiErrorLogging({
-				operation: "sendChatAction",
-				fn: () => sendChatActionHandler.sendChatAction(chatId, "record_voice", buildTypingThreadParams(replyThreadId))
-			});
-		} catch (err) {
-			logVerbose(`telegram record_voice cue failed for chat ${chatId}: ${String(err)}`);
-		}
-	};
-	if (!await enforceTelegramDmAccess({
-		isGroup,
-		dmPolicy,
-		msg,
-		chatId,
-		effectiveDmAllow,
-		accountId: account.accountId,
-		bot,
-		logger
-	})) return null;
-	recordChannelActivity({
-		channel: "telegram",
-		accountId: account.accountId,
-		direction: "inbound"
-	});
-	const botUsername = primaryCtx.me?.username?.toLowerCase();
-	const allowForCommands = isGroup ? effectiveGroupAllow : effectiveDmAllow;
-	const senderAllowedForCommands = isSenderAllowed({
-		allow: allowForCommands,
-		senderId,
-		senderUsername
-	});
-	const useAccessGroups = cfg.commands?.useAccessGroups !== false;
-	const hasControlCommandInMessage = hasControlCommand(msg.text ?? msg.caption ?? "", cfg, { botUsername });
-	const commandGate = resolveControlCommandGate({
-		useAccessGroups,
-		authorizers: [{
-			configured: allowForCommands.hasEntries,
-			allowed: senderAllowedForCommands
-		}],
-		allowTextCommands: true,
-		hasControlCommand: hasControlCommandInMessage
-	});
-	const commandAuthorized = commandGate.commandAuthorized;
-	const historyKey = isGroup ? buildTelegramGroupPeerId(chatId, resolvedThreadId) : void 0;
-	let placeholder = resolveTelegramMediaPlaceholder(msg) ?? "";
-	const cachedStickerDescription = allMedia[0]?.stickerMetadata?.cachedDescription;
-	const stickerSupportsVision = msg.sticker ? await resolveStickerVisionSupport$1({
-		cfg,
-		agentId: route.agentId
-	}) : false;
-	const stickerCacheHit = Boolean(cachedStickerDescription) && !stickerSupportsVision;
-	if (stickerCacheHit) {
-		const emoji = allMedia[0]?.stickerMetadata?.emoji;
-		const setName = allMedia[0]?.stickerMetadata?.setName;
-		const stickerContext = [emoji, setName ? `from "${setName}"` : null].filter(Boolean).join(" ");
-		placeholder = `[Sticker${stickerContext ? ` ${stickerContext}` : ""}] ${cachedStickerDescription}`;
-	}
-	const locationData = extractTelegramLocation(msg);
-	const locationText = locationData ? formatLocationText(locationData) : void 0;
-	const rawText = expandTextLinks(msg.text ?? msg.caption ?? "", msg.entities ?? msg.caption_entities).trim();
-	const hasUserText = Boolean(rawText || locationText);
-	let rawBody = [rawText, locationText].filter(Boolean).join("\n").trim();
-	if (!rawBody) rawBody = placeholder;
-	if (!rawBody && allMedia.length === 0) return null;
-	let bodyText = rawBody;
-	const hasAudio = allMedia.some((media) => media.contentType?.startsWith("audio/"));
-	let preflightTranscript;
-	if (isGroup && requireMention && hasAudio && !hasUserText && mentionRegexes.length > 0) try {
-		const { transcribeFirstAudio } = await import("./audio-preflight-Chxqjwxe.js");
-		preflightTranscript = await transcribeFirstAudio({
-			ctx: {
-				MediaPaths: allMedia.length > 0 ? allMedia.map((m) => m.path) : void 0,
-				MediaTypes: allMedia.length > 0 ? allMedia.map((m) => m.contentType).filter(Boolean) : void 0
-			},
-			cfg,
-			agentDir: void 0
-		});
-	} catch (err) {
-		logVerbose(`telegram: audio preflight transcription failed: ${String(err)}`);
-	}
-	if (hasAudio && bodyText === "<media:audio>" && preflightTranscript) bodyText = preflightTranscript;
-	if (!bodyText && allMedia.length > 0) if (hasAudio) bodyText = preflightTranscript || "<media:audio>";
-	else bodyText = `<media:image>${allMedia.length > 1 ? ` (${allMedia.length} images)` : ""}`;
-	const hasAnyMention = (msg.entities ?? msg.caption_entities ?? []).some((ent) => ent.type === "mention");
-	const explicitlyMentioned = botUsername ? hasBotMention(msg, botUsername) : false;
-	const computedWasMentioned = matchesMentionWithExplicit({
-		text: msg.text ?? msg.caption ?? "",
-		mentionRegexes,
-		explicit: {
-			hasAnyMention,
-			isExplicitlyMentioned: explicitlyMentioned,
-			canResolveExplicit: Boolean(botUsername)
-		},
-		transcript: preflightTranscript
-	});
-	const wasMentioned = options?.forceWasMentioned === true ? true : computedWasMentioned;
-	if (isGroup && commandGate.shouldBlock) {
-		logInboundDrop({
-			log: logVerbose,
-			channel: "telegram",
-			reason: "control command (unauthorized)",
-			target: senderId ?? "unknown"
-		});
-		return null;
-	}
-	const botId = primaryCtx.me?.id;
-	const replyFromId = msg.reply_to_message?.from?.id;
-	const implicitMention = botId != null && replyFromId === botId;
-	const canDetectMention = Boolean(botUsername) || mentionRegexes.length > 0;
-	const mentionGate = resolveMentionGatingWithBypass({
-		isGroup,
-		requireMention: Boolean(requireMention),
-		canDetectMention,
-		wasMentioned,
-		implicitMention: isGroup && Boolean(requireMention) && implicitMention,
-		hasAnyMention,
-		allowTextCommands: true,
-		hasControlCommand: hasControlCommandInMessage,
-		commandAuthorized
-	});
-	const effectiveWasMentioned = mentionGate.effectiveWasMentioned;
-	if (isGroup && requireMention && canDetectMention) {
-		if (mentionGate.shouldSkip) {
-			logger.info({
-				chatId,
-				reason: "no-mention"
-			}, "skipping group message");
-			recordPendingHistoryEntryIfEnabled({
-				historyMap: groupHistories,
-				historyKey: historyKey ?? "",
-				limit: historyLimit,
-				entry: historyKey ? {
-					sender: buildSenderLabel(msg, senderId || chatId),
-					body: rawBody,
-					timestamp: msg.date ? msg.date * 1e3 : void 0,
-					messageId: typeof msg.message_id === "number" ? String(msg.message_id) : void 0
-				} : null
-			});
-			return null;
-		}
-	}
-	const ackReaction = resolveAckReaction(cfg, route.agentId, {
-		channel: "telegram",
-		accountId: account.accountId
-	});
-	const removeAckAfterReply = cfg.messages?.removeAckAfterReply ?? false;
-	const shouldAckReaction$1 = () => Boolean(ackReaction && shouldAckReaction({
-		scope: ackReactionScope,
-		isDirect: !isGroup,
-		isGroup,
-		isMentionableGroup: isGroup,
-		requireMention: Boolean(requireMention),
-		canDetectMention,
-		effectiveWasMentioned,
-		shouldBypassMention: mentionGate.shouldBypassMention
-	}));
-	const api = bot.api;
-	const reactionApi = typeof api.setMessageReaction === "function" ? api.setMessageReaction.bind(api) : null;
-	const getChatApi = typeof api.getChat === "function" ? api.getChat.bind(api) : null;
-	const statusReactionsConfig = cfg.messages?.statusReactions;
-	const statusReactionsEnabled = statusReactionsConfig?.enabled === true && Boolean(reactionApi) && shouldAckReaction$1();
-	const resolvedStatusReactionEmojis = resolveTelegramStatusReactionEmojis({
-		initialEmoji: ackReaction,
-		overrides: statusReactionsConfig?.emojis
-	});
-	const statusReactionVariantsByEmoji = buildTelegramStatusReactionVariants(resolvedStatusReactionEmojis);
-	let allowedStatusReactionEmojisPromise = null;
-	const statusReactionController = statusReactionsEnabled && msg.message_id ? createStatusReactionController({
-		enabled: true,
-		adapter: { setReaction: async (emoji) => {
-			if (reactionApi) {
-				if (!allowedStatusReactionEmojisPromise) allowedStatusReactionEmojisPromise = resolveTelegramAllowedEmojiReactions({
-					chat: msg.chat,
-					chatId,
-					getChat: getChatApi ?? void 0
-				}).catch((err) => {
-					logVerbose(`telegram status-reaction available_reactions lookup failed for chat ${chatId}: ${String(err)}`);
-					return null;
-				});
-				const resolvedEmoji = resolveTelegramReactionVariant({
-					requestedEmoji: emoji,
-					variantsByRequestedEmoji: statusReactionVariantsByEmoji,
-					allowedEmojiReactions: await allowedStatusReactionEmojisPromise
-				});
-				if (!resolvedEmoji) return;
-				await reactionApi(chatId, msg.message_id, [{
-					type: "emoji",
-					emoji: resolvedEmoji
-				}]);
-			}
-		} },
-		initialEmoji: ackReaction,
-		emojis: resolvedStatusReactionEmojis,
-		timing: statusReactionsConfig?.timing,
-		onError: (err) => {
-			logVerbose(`telegram status-reaction error for chat ${chatId}: ${String(err)}`);
-		}
-	}) : null;
-	const ackReactionPromise = statusReactionController ? shouldAckReaction$1() ? Promise.resolve(statusReactionController.setQueued()).then(() => true, () => false) : null : shouldAckReaction$1() && msg.message_id && reactionApi ? withTelegramApiErrorLogging({
-		operation: "setMessageReaction",
-		fn: () => reactionApi(chatId, msg.message_id, [{
-			type: "emoji",
-			emoji: ackReaction
-		}])
-	}).then(() => true, (err) => {
-		logVerbose(`telegram react failed for chat ${chatId}: ${String(err)}`);
-		return false;
-	}) : null;
-	const replyTarget = describeReplyTarget(msg);
-	const forwardOrigin = normalizeForwardedContext(msg);
-	const replyForwardAnnotation = replyTarget?.forwardedFrom ? `[Forwarded from ${replyTarget.forwardedFrom.from}${replyTarget.forwardedFrom.date ? ` at ${(/* @__PURE__ */ new Date(replyTarget.forwardedFrom.date * 1e3)).toISOString()}` : ""}]\n` : "";
-	const replySuffix = replyTarget ? replyTarget.kind === "quote" ? `\n\n[Quoting ${replyTarget.sender}${replyTarget.id ? ` id:${replyTarget.id}` : ""}]\n${replyForwardAnnotation}"${replyTarget.body}"\n[/Quoting]` : `\n\n[Replying to ${replyTarget.sender}${replyTarget.id ? ` id:${replyTarget.id}` : ""}]\n${replyForwardAnnotation}${replyTarget.body}\n[/Replying]` : "";
-	const forwardPrefix = forwardOrigin ? `[Forwarded from ${forwardOrigin.from}${forwardOrigin.date ? ` at ${(/* @__PURE__ */ new Date(forwardOrigin.date * 1e3)).toISOString()}` : ""}]\n` : "";
-	const groupLabel = isGroup ? buildGroupLabel(msg, chatId, resolvedThreadId) : void 0;
-	const senderName = buildSenderName(msg);
-	const conversationLabel = isGroup ? groupLabel ?? `group:${chatId}` : buildSenderLabel(msg, senderId || chatId);
-	const storePath = resolveStorePath(cfg.session?.store, { agentId: route.agentId });
-	const envelopeOptions = resolveEnvelopeFormatOptions(cfg);
-	const previousTimestamp = readSessionUpdatedAt({
-		storePath,
-		sessionKey
-	});
-	const body = formatInboundEnvelope({
-		channel: "Telegram",
-		from: conversationLabel,
-		timestamp: msg.date ? msg.date * 1e3 : void 0,
-		body: `${forwardPrefix}${bodyText}${replySuffix}`,
-		chatType: isGroup ? "group" : "direct",
-		sender: {
-			name: senderName,
-			username: senderUsername || void 0,
-			id: senderId || void 0
-		},
-		previousTimestamp,
-		envelope: envelopeOptions
-	});
-	let combinedBody = body;
-	if (isGroup && historyKey && historyLimit > 0) combinedBody = buildPendingHistoryContextFromMap({
-		historyMap: groupHistories,
-		historyKey,
-		limit: historyLimit,
-		currentMessage: combinedBody,
-		formatEntry: (entry) => formatInboundEnvelope({
-			channel: "Telegram",
-			from: groupLabel ?? `group:${chatId}`,
-			timestamp: entry.timestamp,
-			body: `${entry.body} [id:${entry.messageId ?? "unknown"} chat:${chatId}]`,
-			chatType: "group",
-			senderLabel: entry.sender,
-			envelope: envelopeOptions
-		})
-	});
-	const { skillFilter, groupSystemPrompt } = resolveTelegramGroupPromptSettings({
-		groupConfig,
-		topicConfig
-	});
-	const commandBody = normalizeCommandBody(rawBody, { botUsername });
-	const inboundHistory = isGroup && historyKey && historyLimit > 0 ? (groupHistories.get(historyKey) ?? []).map((entry) => ({
-		sender: entry.sender,
-		body: entry.body,
-		timestamp: entry.timestamp
-	})) : void 0;
-	const contextMedia = [...stickerCacheHit ? [] : allMedia, ...replyMedia];
-	const ctxPayload = finalizeInboundContext({
-		Body: combinedBody,
-		BodyForAgent: bodyText,
-		InboundHistory: inboundHistory,
-		RawBody: rawBody,
-		CommandBody: commandBody,
-		From: isGroup ? buildTelegramGroupFrom(chatId, resolvedThreadId) : `telegram:${chatId}`,
-		To: `telegram:${chatId}`,
-		SessionKey: sessionKey,
-		AccountId: route.accountId,
-		ChatType: isGroup ? "group" : "direct",
-		ConversationLabel: conversationLabel,
-		GroupSubject: isGroup ? msg.chat.title ?? void 0 : void 0,
-		GroupSystemPrompt: isGroup ? groupSystemPrompt : void 0,
-		SenderName: senderName,
-		SenderId: senderId || void 0,
-		SenderUsername: senderUsername || void 0,
-		Provider: "telegram",
-		Surface: "telegram",
-		MessageSid: options?.messageIdOverride ?? String(msg.message_id),
-		ReplyToId: replyTarget?.id,
-		ReplyToBody: replyTarget?.body,
-		ReplyToSender: replyTarget?.sender,
-		ReplyToIsQuote: replyTarget?.kind === "quote" ? true : void 0,
-		ReplyToForwardedFrom: replyTarget?.forwardedFrom?.from,
-		ReplyToForwardedFromType: replyTarget?.forwardedFrom?.fromType,
-		ReplyToForwardedFromId: replyTarget?.forwardedFrom?.fromId,
-		ReplyToForwardedFromUsername: replyTarget?.forwardedFrom?.fromUsername,
-		ReplyToForwardedFromTitle: replyTarget?.forwardedFrom?.fromTitle,
-		ReplyToForwardedDate: replyTarget?.forwardedFrom?.date ? replyTarget.forwardedFrom.date * 1e3 : void 0,
-		ForwardedFrom: forwardOrigin?.from,
-		ForwardedFromType: forwardOrigin?.fromType,
-		ForwardedFromId: forwardOrigin?.fromId,
-		ForwardedFromUsername: forwardOrigin?.fromUsername,
-		ForwardedFromTitle: forwardOrigin?.fromTitle,
-		ForwardedFromSignature: forwardOrigin?.fromSignature,
-		ForwardedFromChatType: forwardOrigin?.fromChatType,
-		ForwardedFromMessageId: forwardOrigin?.fromMessageId,
-		ForwardedDate: forwardOrigin?.date ? forwardOrigin.date * 1e3 : void 0,
-		Timestamp: msg.date ? msg.date * 1e3 : void 0,
-		WasMentioned: isGroup ? effectiveWasMentioned : void 0,
-		MediaPath: contextMedia.length > 0 ? contextMedia[0]?.path : void 0,
-		MediaType: contextMedia.length > 0 ? contextMedia[0]?.contentType : void 0,
-		MediaUrl: contextMedia.length > 0 ? contextMedia[0]?.path : void 0,
-		MediaPaths: contextMedia.length > 0 ? contextMedia.map((m) => m.path) : void 0,
-		MediaUrls: contextMedia.length > 0 ? contextMedia.map((m) => m.path) : void 0,
-		MediaTypes: contextMedia.length > 0 ? contextMedia.map((m) => m.contentType).filter(Boolean) : void 0,
-		Sticker: allMedia[0]?.stickerMetadata,
-		StickerMediaIncluded: allMedia[0]?.stickerMetadata ? !stickerCacheHit : void 0,
-		...locationData ? toLocationContext(locationData) : void 0,
-		CommandAuthorized: commandAuthorized,
-		MessageThreadId: threadSpec.id,
-		IsForum: isForum,
-		OriginatingChannel: "telegram",
-		OriginatingTo: `telegram:${chatId}`
-	});
-	await recordInboundSession({
-		storePath,
-		sessionKey: ctxPayload.SessionKey ?? sessionKey,
-		ctx: ctxPayload,
-		updateLastRoute: !isGroup ? {
-			sessionKey: route.mainSessionKey,
-			channel: "telegram",
-			to: `telegram:${chatId}`,
-			accountId: route.accountId,
-			threadId: dmThreadId != null ? String(dmThreadId) : void 0
-		} : void 0,
-		onRecordError: (err) => {
-			logVerbose(`telegram: failed updating session meta: ${String(err)}`);
-		}
-	});
-	if (replyTarget && shouldLogVerbose()) {
-		const preview = replyTarget.body.replace(/\s+/g, " ").slice(0, 120);
-		logVerbose(`telegram reply-context: replyToId=${replyTarget.id} replyToSender=${replyTarget.sender} replyToBody="${preview}"`);
-	}
-	if (forwardOrigin && shouldLogVerbose()) logVerbose(`telegram forward-context: forwardedFrom="${forwardOrigin.from}" type=${forwardOrigin.fromType}`);
-	if (shouldLogVerbose()) {
-		const preview = body.slice(0, 200).replace(/\n/g, "\\n");
-		const mediaInfo = allMedia.length > 1 ? ` mediaCount=${allMedia.length}` : "";
-		const topicInfo = resolvedThreadId != null ? ` topic=${resolvedThreadId}` : "";
-		logVerbose(`telegram inbound: chatId=${chatId} from=${ctxPayload.From} len=${body.length}${mediaInfo}${topicInfo} preview="${preview}"`);
-	}
-	return {
-		ctxPayload,
-		primaryCtx,
-		msg,
-		chatId,
-		isGroup,
-		resolvedThreadId,
-		threadSpec,
-		replyThreadId,
-		isForum,
-		historyKey,
-		historyLimit,
-		groupHistories,
-		route,
-		skillFilter,
-		sendTyping,
-		sendRecordVoice,
-		ackReactionPromise,
-		reactionApi,
-		removeAckAfterReply,
-		statusReactionController,
-		accountId: account.accountId
-	};
-};
-
-//#endregion
-//#region src/telegram/draft-stream.ts
-const TELEGRAM_STREAM_MAX_CHARS = 4096;
-const DEFAULT_THROTTLE_MS = 1e3;
-function createTelegramDraftStream(params) {
-	const maxChars = Math.min(params.maxChars ?? TELEGRAM_STREAM_MAX_CHARS, TELEGRAM_STREAM_MAX_CHARS);
-	const throttleMs = Math.max(250, params.throttleMs ?? DEFAULT_THROTTLE_MS);
-	const minInitialChars = params.minInitialChars;
-	const chatId = params.chatId;
-	const threadParams = buildTelegramThreadParams(params.thread);
-	const replyParams = params.replyToMessageId != null ? {
-		...threadParams,
-		reply_to_message_id: params.replyToMessageId
-	} : threadParams;
-	const streamState = {
-		stopped: false,
-		final: false
-	};
-	let streamMessageId;
-	let lastSentText = "";
-	let lastSentParseMode;
-	let generation = 0;
-	const sendOrEditStreamMessage = async (text) => {
-		if (streamState.stopped && !streamState.final) return false;
-		const trimmed = text.trimEnd();
-		if (!trimmed) return false;
-		const rendered = params.renderText?.(trimmed) ?? { text: trimmed };
-		const renderedText = rendered.text.trimEnd();
-		const renderedParseMode = rendered.parseMode;
-		if (!renderedText) return false;
-		if (renderedText.length > maxChars) {
-			streamState.stopped = true;
-			params.warn?.(`telegram stream preview stopped (text length ${renderedText.length} > ${maxChars})`);
-			return false;
-		}
-		if (renderedText === lastSentText && renderedParseMode === lastSentParseMode) return true;
-		const sendGeneration = generation;
-		if (typeof streamMessageId !== "number" && minInitialChars != null && !streamState.final) {
-			if (renderedText.length < minInitialChars) return false;
-		}
-		lastSentText = renderedText;
-		lastSentParseMode = renderedParseMode;
-		try {
-			if (typeof streamMessageId === "number") {
-				if (renderedParseMode) await params.api.editMessageText(chatId, streamMessageId, renderedText, { parse_mode: renderedParseMode });
-				else await params.api.editMessageText(chatId, streamMessageId, renderedText);
-				return true;
-			}
-			const sendParams = renderedParseMode ? {
-				...replyParams,
-				parse_mode: renderedParseMode
-			} : replyParams;
-			const sentMessageId = (await params.api.sendMessage(chatId, renderedText, sendParams))?.message_id;
-			if (typeof sentMessageId !== "number" || !Number.isFinite(sentMessageId)) {
-				streamState.stopped = true;
-				params.warn?.("telegram stream preview stopped (missing message id from sendMessage)");
-				return false;
-			}
-			const normalizedMessageId = Math.trunc(sentMessageId);
-			if (sendGeneration !== generation) {
-				params.onSupersededPreview?.({
-					messageId: normalizedMessageId,
-					textSnapshot: renderedText,
-					parseMode: renderedParseMode
-				});
-				return true;
-			}
-			streamMessageId = normalizedMessageId;
-			return true;
-		} catch (err) {
-			streamState.stopped = true;
-			params.warn?.(`telegram stream preview failed: ${err instanceof Error ? err.message : String(err)}`);
-			return false;
-		}
-	};
-	const { loop, update, stop, clear } = createFinalizableDraftLifecycle({
-		throttleMs,
-		state: streamState,
-		sendOrEditStreamMessage,
-		readMessageId: () => streamMessageId,
-		clearMessageId: () => {
-			streamMessageId = void 0;
-		},
-		isValidMessageId: (value) => typeof value === "number" && Number.isFinite(value),
-		deleteMessage: async (messageId) => {
-			await params.api.deleteMessage(chatId, messageId);
-		},
-		onDeleteSuccess: (messageId) => {
-			params.log?.(`telegram stream preview deleted (chat=${chatId}, message=${messageId})`);
-		},
-		warn: params.warn,
-		warnPrefix: "telegram stream preview cleanup failed"
-	});
-	const forceNewMessage = () => {
-		generation += 1;
-		streamMessageId = void 0;
-		lastSentText = "";
-		lastSentParseMode = void 0;
-		loop.resetPending();
-		loop.resetThrottleWindow();
-	};
-	params.log?.(`telegram stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
-	return {
-		update,
-		flush: loop.flush,
-		messageId: () => streamMessageId,
-		clear,
-		stop,
-		forceNewMessage
-	};
-}
-
-//#endregion
-//#region src/telegram/lane-delivery.ts
-function createLaneDeliveryStateTracker() {
-	const state = {
-		delivered: false,
-		skippedNonSilent: 0,
-		failedNonSilent: 0
-	};
-	return {
-		markDelivered: () => {
-			state.delivered = true;
-		},
-		markNonSilentSkip: () => {
-			state.skippedNonSilent += 1;
-		},
-		markNonSilentFailure: () => {
-			state.failedNonSilent += 1;
-		},
-		snapshot: () => ({ ...state })
-	};
-}
-function createLaneTextDeliverer(params) {
-	const getLanePreviewText = (lane) => lane.lastPartialText;
-	const shouldSkipRegressivePreviewUpdate = (args) => {
-		const currentPreviewText = args.currentPreviewText;
-		if (currentPreviewText === void 0) return false;
-		return currentPreviewText.startsWith(args.text) && args.text.length < currentPreviewText.length && (args.skipRegressive === "always" || args.hadPreviewMessage);
-	};
-	const tryEditPreviewMessage = async (args) => {
-		try {
-			await params.editPreview({
-				laneName: args.laneName,
-				messageId: args.messageId,
-				text: args.text,
-				previewButtons: args.previewButtons,
-				context: args.context
-			});
-			if (args.updateLaneSnapshot) args.lane.lastPartialText = args.text;
-			params.markDelivered();
-			return true;
-		} catch (err) {
-			if (args.treatEditFailureAsDelivered) {
-				params.log(`telegram: ${args.laneName} preview ${args.context} edit failed after stop-created flush; treating as delivered (${String(err)})`);
-				params.markDelivered();
-				return true;
-			}
-			params.log(`telegram: ${args.laneName} preview ${args.context} edit failed; falling back to standard send (${String(err)})`);
-			return false;
-		}
-	};
-	const tryUpdatePreviewForLane = async ({ lane, laneName, text, previewButtons, stopBeforeEdit = false, updateLaneSnapshot = false, skipRegressive, context, previewMessageId: previewMessageIdOverride, previewTextSnapshot }) => {
-		if (!lane.stream) return false;
-		const lanePreviewMessageId = lane.stream.messageId();
-		const hadPreviewMessage = typeof previewMessageIdOverride === "number" || typeof lanePreviewMessageId === "number";
-		if (stopBeforeEdit && !hadPreviewMessage && context === "final") {
-			lane.stream.update(text);
-			await params.stopDraftLane(lane);
-			const previewMessageId = lane.stream.messageId();
-			if (typeof previewMessageId !== "number") return false;
-			if (shouldSkipRegressivePreviewUpdate({
-				currentPreviewText: previewTextSnapshot ?? getLanePreviewText(lane),
-				text,
-				skipRegressive,
-				hadPreviewMessage
-			})) {
-				params.markDelivered();
-				return true;
-			}
-			return tryEditPreviewMessage({
-				laneName,
-				messageId: previewMessageId,
-				text,
-				context,
-				previewButtons,
-				updateLaneSnapshot,
-				lane,
-				treatEditFailureAsDelivered: true
-			});
-		}
-		if (stopBeforeEdit) await params.stopDraftLane(lane);
-		const previewMessageId = typeof previewMessageIdOverride === "number" ? previewMessageIdOverride : lane.stream.messageId();
-		if (typeof previewMessageId !== "number") return false;
-		if (shouldSkipRegressivePreviewUpdate({
-			currentPreviewText: previewTextSnapshot ?? getLanePreviewText(lane),
-			text,
-			skipRegressive,
-			hadPreviewMessage
-		})) {
-			params.markDelivered();
-			return true;
-		}
-		return tryEditPreviewMessage({
-			laneName,
-			messageId: previewMessageId,
-			text,
-			context,
-			previewButtons,
-			updateLaneSnapshot,
-			lane,
-			treatEditFailureAsDelivered: false
-		});
-	};
-	const consumeArchivedAnswerPreviewForFinal = async ({ lane, text, payload, previewButtons, canEditViaPreview }) => {
-		const archivedPreview = params.archivedAnswerPreviews.shift();
-		if (!archivedPreview) return;
-		if (canEditViaPreview) {
-			if (await tryUpdatePreviewForLane({
-				lane,
-				laneName: "answer",
-				text,
-				previewButtons,
-				stopBeforeEdit: false,
-				skipRegressive: "existingOnly",
-				context: "final",
-				previewMessageId: archivedPreview.messageId,
-				previewTextSnapshot: archivedPreview.textSnapshot
-			})) return "preview-finalized";
-		}
-		try {
-			await params.deletePreviewMessage(archivedPreview.messageId);
-		} catch (err) {
-			params.log(`telegram: archived answer preview cleanup failed (${archivedPreview.messageId}): ${String(err)}`);
-		}
-		return await params.sendPayload(params.applyTextToPayload(payload, text)) ? "sent" : "skipped";
-	};
-	return async ({ laneName, text, payload, infoKind, previewButtons, allowPreviewUpdateForNonFinal = false }) => {
-		const lane = params.lanes[laneName];
-		const hasMedia = Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
-		const canEditViaPreview = !hasMedia && text.length > 0 && text.length <= params.draftMaxChars && !payload.isError;
-		if (infoKind === "final") {
-			if (laneName === "answer") {
-				const archivedResult = await consumeArchivedAnswerPreviewForFinal({
-					lane,
-					text,
-					payload,
-					previewButtons,
-					canEditViaPreview
-				});
-				if (archivedResult) return archivedResult;
-			}
-			if (canEditViaPreview && !params.finalizedPreviewByLane[laneName]) {
-				await params.flushDraftLane(lane);
-				if (laneName === "answer") {
-					const archivedResultAfterFlush = await consumeArchivedAnswerPreviewForFinal({
-						lane,
-						text,
-						payload,
-						previewButtons,
-						canEditViaPreview
-					});
-					if (archivedResultAfterFlush) return archivedResultAfterFlush;
-				}
-				if (await tryUpdatePreviewForLane({
-					lane,
-					laneName,
-					text,
-					previewButtons,
-					stopBeforeEdit: true,
-					skipRegressive: "existingOnly",
-					context: "final"
-				})) {
-					params.finalizedPreviewByLane[laneName] = true;
-					return "preview-finalized";
-				}
-			} else if (!hasMedia && !payload.isError && text.length > params.draftMaxChars) params.log(`telegram: preview final too long for edit (${text.length} > ${params.draftMaxChars}); falling back to standard send`);
-			await params.stopDraftLane(lane);
-			return await params.sendPayload(params.applyTextToPayload(payload, text)) ? "sent" : "skipped";
-		}
-		if (allowPreviewUpdateForNonFinal && canEditViaPreview) {
-			if (await tryUpdatePreviewForLane({
-				lane,
-				laneName,
-				text,
-				previewButtons,
-				stopBeforeEdit: false,
-				updateLaneSnapshot: true,
-				skipRegressive: "always",
-				context: "update"
-			})) return "preview-updated";
-		}
-		return await params.sendPayload(params.applyTextToPayload(payload, text)) ? "sent" : "skipped";
-	};
-}
-
-//#endregion
-//#region src/telegram/reasoning-lane-coordinator.ts
-const REASONING_MESSAGE_PREFIX = "Reasoning:\n";
-const REASONING_TAG_PREFIXES = [
-	"<think",
-	"<thinking",
-	"<thought",
-	"<antthinking",
-	"</think",
-	"</thinking",
-	"</thought",
-	"</antthinking"
-];
-const THINKING_TAG_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought|antthinking)\b[^<>]*>/gi;
-function extractThinkingFromTaggedStreamOutsideCode(text) {
-	if (!text) return "";
-	const codeRegions = findCodeRegions(text);
-	let result = "";
-	let lastIndex = 0;
-	let inThinking = false;
-	THINKING_TAG_RE.lastIndex = 0;
-	for (const match of text.matchAll(THINKING_TAG_RE)) {
-		const idx = match.index ?? 0;
-		if (isInsideCode(idx, codeRegions)) continue;
-		if (inThinking) result += text.slice(lastIndex, idx);
-		inThinking = !(match[1] === "/");
-		lastIndex = idx + match[0].length;
-	}
-	if (inThinking) result += text.slice(lastIndex);
-	return result.trim();
-}
-function isPartialReasoningTagPrefix(text) {
-	const trimmed = text.trimStart().toLowerCase();
-	if (!trimmed.startsWith("<")) return false;
-	if (trimmed.includes(">")) return false;
-	return REASONING_TAG_PREFIXES.some((prefix) => prefix.startsWith(trimmed));
-}
-function splitTelegramReasoningText(text) {
-	if (typeof text !== "string") return {};
-	const trimmed = text.trim();
-	if (isPartialReasoningTagPrefix(trimmed)) return {};
-	if (trimmed.startsWith(REASONING_MESSAGE_PREFIX) && trimmed.length > 11) return { reasoningText: trimmed };
-	const taggedReasoning = extractThinkingFromTaggedStreamOutsideCode(text);
-	const strippedAnswer = stripReasoningTagsFromText(text, {
-		mode: "strict",
-		trim: "both"
-	});
-	if (!taggedReasoning && strippedAnswer === text) return { answerText: text };
-	return {
-		reasoningText: taggedReasoning ? formatReasoningMessage(taggedReasoning) : void 0,
-		answerText: strippedAnswer || void 0
-	};
-}
-function createTelegramReasoningStepState() {
-	let reasoningStatus = "none";
-	let bufferedFinalAnswer;
-	const noteReasoningHint = () => {
-		if (reasoningStatus === "none") reasoningStatus = "hinted";
-	};
-	const noteReasoningDelivered = () => {
-		reasoningStatus = "delivered";
-	};
-	const shouldBufferFinalAnswer = () => {
-		return reasoningStatus === "hinted" && !bufferedFinalAnswer;
-	};
-	const bufferFinalAnswer = (value) => {
-		bufferedFinalAnswer = value;
-	};
-	const takeBufferedFinalAnswer = () => {
-		const value = bufferedFinalAnswer;
-		bufferedFinalAnswer = void 0;
-		return value;
-	};
-	const resetForNextStep = () => {
-		reasoningStatus = "none";
-		bufferedFinalAnswer = void 0;
-	};
-	return {
-		noteReasoningHint,
-		noteReasoningDelivered,
-		shouldBufferFinalAnswer,
-		bufferFinalAnswer,
-		takeBufferedFinalAnswer,
-		resetForNextStep
-	};
-}
-
-//#endregion
-//#region src/telegram/bot-message-dispatch.ts
-const EMPTY_RESPONSE_FALLBACK$1 = "No response generated. Please try again.";
-/** Minimum chars before sending first streaming message (improves push notification UX) */
-const DRAFT_MIN_INITIAL_CHARS = 30;
-const PROGRESS_DRAFT_LABEL = "Working";
-function formatTelegramProgressToolName(name) {
-	const normalized = name?.trim();
-	if (!normalized) return "Tool";
-	return normalized.replace(/[_-]+/g, " ").split(/\s+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
-}
-function formatTelegramToolProgressDraft(payload) {
-	return `${PROGRESS_DRAFT_LABEL}\n\`🛠️ ${formatTelegramProgressToolName(payload.name)}\``;
-}
-async function resolveStickerVisionSupport(cfg, agentId) {
-	try {
-		const catalog = await loadModelCatalog({ config: cfg });
-		const defaultModel = resolveDefaultModelForAgent({
-			cfg,
-			agentId
-		});
-		const entry = findModelInCatalog(catalog, defaultModel.provider, defaultModel.model);
-		if (!entry) return false;
-		return modelSupportsVision(entry);
-	} catch {
-		return false;
-	}
-}
-function pruneStickerMediaFromContext(ctxPayload, opts) {
-	if (opts?.stickerMediaIncluded === false) return;
-	const nextMediaPaths = Array.isArray(ctxPayload.MediaPaths) ? ctxPayload.MediaPaths.slice(1) : void 0;
-	const nextMediaUrls = Array.isArray(ctxPayload.MediaUrls) ? ctxPayload.MediaUrls.slice(1) : void 0;
-	const nextMediaTypes = Array.isArray(ctxPayload.MediaTypes) ? ctxPayload.MediaTypes.slice(1) : void 0;
-	ctxPayload.MediaPaths = nextMediaPaths && nextMediaPaths.length > 0 ? nextMediaPaths : void 0;
-	ctxPayload.MediaUrls = nextMediaUrls && nextMediaUrls.length > 0 ? nextMediaUrls : void 0;
-	ctxPayload.MediaTypes = nextMediaTypes && nextMediaTypes.length > 0 ? nextMediaTypes : void 0;
-	ctxPayload.MediaPath = ctxPayload.MediaPaths?.[0];
-	ctxPayload.MediaUrl = ctxPayload.MediaUrls?.[0] ?? ctxPayload.MediaPath;
-	ctxPayload.MediaType = ctxPayload.MediaTypes?.[0];
-}
-function resolveTelegramReasoningLevel(params) {
-	const { cfg, sessionKey, agentId } = params;
-	if (!sessionKey) return "off";
-	try {
-		const store = loadSessionStore(resolveStorePath(cfg.session?.store, { agentId }), { skipCache: true });
-		const level = (store[sessionKey.toLowerCase()] ?? store[sessionKey])?.reasoningLevel;
-		if (level === "on" || level === "stream") return level;
-	} catch {}
-	return "off";
-}
-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, statusReactionController } = context;
-	const draftMaxChars = Math.min(textLimit, 4096);
-	const tableMode = resolveMarkdownTableMode({
-		cfg,
-		channel: "telegram",
-		accountId: route.accountId
-	});
-	const renderDraftPreview = (text) => ({
-		text: renderTelegramHtmlText(text, { tableMode }),
-		parseMode: "HTML"
-	});
-	const accountBlockStreamingEnabled = typeof telegramCfg.blockStreaming === "boolean" ? telegramCfg.blockStreaming : cfg.agents?.defaults?.blockStreamingDefault === "on";
-	const resolvedReasoningLevel = resolveTelegramReasoningLevel({
-		cfg,
-		sessionKey: ctxPayload.SessionKey,
-		agentId: route.agentId
-	});
-	const forceBlockStreamingForReasoning = resolvedReasoningLevel === "on";
-	const streamReasoningDraft = resolvedReasoningLevel === "stream";
-	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 : void 0;
-	const draftMinInitialChars = DRAFT_MIN_INITIAL_CHARS;
-	const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, route.agentId);
-	const archivedAnswerPreviews = [];
-	const archivedReasoningPreviewIds = [];
-	const createDraftLane = (laneName, enabled) => {
-		return {
-			stream: enabled ? createTelegramDraftStream({
-				api: bot.api,
-				chatId,
-				maxChars: draftMaxChars,
-				thread: threadSpec,
-				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
-					});
-				} : void 0,
-				log: logVerbose,
-				warn: logVerbose
-			}) : void 0,
-			lastPartialText: "",
-			hasStreamedMessage: false
-		};
-	};
-	const lanes = {
-		answer: createDraftLane("answer", canStreamAnswerDraft),
-		reasoning: createDraftLane("reasoning", canStreamReasoningDraft)
-	};
-	const answerLane = lanes.answer;
-	const reasoningLane = lanes.reasoning;
-	const progressDraftsEnabled = telegramCfg.streaming === "progress" && Boolean(answerLane.stream);
-	let splitReasoningOnNextStream = false;
-	const reasoningStepState = createTelegramReasoningStepState();
-	const splitTextIntoLaneSegments = (text) => {
-		const split = splitTelegramReasoningText(text);
-		const segments = [];
-		const suppressReasoning = resolvedReasoningLevel === "off";
-		if (split.reasoningText && !suppressReasoning) segments.push({
-			lane: "reasoning",
-			text: split.reasoningText
-		});
-		if (split.answerText) segments.push({
-			lane: "answer",
-			text: split.answerText
-		});
-		return {
-			segments,
-			suppressedReasoningOnly: Boolean(split.reasoningText) && suppressReasoning && !split.answerText
-		};
-	};
-	const resetDraftLaneState = (lane) => {
-		lane.lastPartialText = "";
-		lane.hasStreamedMessage = false;
-	};
-	const updateDraftFromPartial = (lane, text) => {
-		const laneStream = lane.stream;
-		if (!laneStream || !text) return;
-		if (text === lane.lastPartialText) return;
-		lane.hasStreamedMessage = true;
-		if (lane.lastPartialText && lane.lastPartialText.startsWith(text) && text.length < lane.lastPartialText.length) return;
-		lane.lastPartialText = text;
-		laneStream.update(text);
-	};
-	const pushToolProgressDraft = async (payload) => {
-		if (!progressDraftsEnabled || !answerLane.stream) return;
-		const text = formatTelegramToolProgressDraft(payload);
-		answerLane.stream.update(text);
-		answerLane.lastPartialText = text;
-		answerLane.hasStreamedMessage = true;
-		await answerLane.stream.flush();
-	};
-	const ingestDraftLaneSegments = (text) => {
-		const split = splitTextIntoLaneSegments(text);
-		for (const segment of split.segments) {
-			if (segment.lane === "reasoning") {
-				reasoningStepState.noteReasoningHint();
-				reasoningStepState.noteReasoningDelivered();
-			}
-			updateDraftFromPartial(lanes[segment.lane], segment.text);
-		}
-	};
-	const flushDraftLane = async (lane) => {
-		if (!lane.stream) return;
-		await lane.stream.flush();
-	};
-	const disableBlockStreaming = !previewStreamingEnabled ? true : forceBlockStreamingForReasoning ? false : typeof telegramCfg.blockStreaming === "boolean" ? !telegramCfg.blockStreaming : canStreamAnswerDraft ? true : void 0;
-	const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
-		cfg,
-		agentId: route.agentId,
-		channel: "telegram",
-		accountId: route.accountId
-	});
-	const chunkMode = resolveChunkMode(cfg, "telegram", route.accountId);
-	const sticker = ctxPayload.Sticker;
-	if (sticker?.fileId && sticker.fileUniqueId && ctxPayload.MediaPath) {
-		const agentDir = resolveAgentDir(cfg, route.agentId);
-		const stickerSupportsVision = await resolveStickerVisionSupport(cfg, route.agentId);
-		let description = sticker.cachedDescription ?? null;
-		if (!description) description = await describeStickerImage({
-			imagePath: ctxPayload.MediaPath,
-			cfg,
-			agentDir,
-			agentId: route.agentId
-		});
-		if (description) {
-			const stickerContext = [sticker.emoji, sticker.setName ? `from "${sticker.setName}"` : null].filter(Boolean).join(" ");
-			const formattedDesc = `[Sticker${stickerContext ? ` ${stickerContext}` : ""}] ${description}`;
-			sticker.cachedDescription = description;
-			if (!stickerSupportsVision) {
-				ctxPayload.Body = formattedDesc;
-				ctxPayload.BodyForAgent = formattedDesc;
-				pruneStickerMediaFromContext(ctxPayload, { stickerMediaIncluded: ctxPayload.StickerMediaIncluded });
-			}
-			if (sticker.fileId) {
-				cacheSticker({
-					fileId: sticker.fileId,
-					fileUniqueId: sticker.fileUniqueId,
-					emoji: sticker.emoji,
-					setName: sticker.setName,
-					description,
-					cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
-					receivedFrom: ctxPayload.From
-				});
-				logVerbose(`telegram: cached sticker description for ${sticker.fileUniqueId}`);
-			} else logVerbose(`telegram: skipped sticker cache (missing fileId)`);
-		}
-	}
-	const replyQuoteText = ctxPayload.ReplyToIsQuote && ctxPayload.ReplyToBody ? ctxPayload.ReplyToBody.trim() || void 0 : void 0;
-	const deliveryState = createLaneDeliveryStateTracker();
-	const finalizedPreviewByLane = {
-		answer: false,
-		reasoning: false
-	};
-	const clearGroupHistory = () => {
-		if (isGroup && historyKey) clearHistoryEntriesIfEnabled({
-			historyMap: groupHistories,
-			historyKey,
-			limit: historyLimit
-		});
-	};
-	const deliveryBaseOptions = {
-		chatId: String(chatId),
-		token: opts.token,
-		runtime,
-		bot,
-		mediaLocalRoots,
-		replyToMode,
-		textLimit,
-		thread: threadSpec,
-		tableMode,
-		chunkMode,
-		linkPreview: telegramCfg.linkPreview,
-		replyQuoteText
-	};
-	const applyTextToPayload = (payload, text) => {
-		if (payload.text === text) return payload;
-		return {
-			...payload,
-			text
-		};
-	};
-	const sendPayload = async (payload) => {
-		const result = await deliverReplies({
-			...deliveryBaseOptions,
-			replies: [payload],
-			onVoiceRecording: sendRecordVoice
-		});
-		if (result.delivered) deliveryState.markDelivered();
-		return result.delivered;
-	};
-	const deliverLaneText = createLaneTextDeliverer({
-		lanes,
-		archivedAnswerPreviews,
-		finalizedPreviewByLane,
-		draftMaxChars,
-		applyTextToPayload,
-		sendPayload,
-		flushDraftLane,
-		stopDraftLane: async (lane) => {
-			await lane.stream?.stop();
-		},
-		editPreview: async ({ messageId, text, previewButtons }) => {
-			await editMessageTelegram(chatId, messageId, text, {
-				api: bot.api,
-				cfg,
-				accountId: route.accountId,
-				linkPreview: telegramCfg.linkPreview,
-				buttons: previewButtons
-			});
-		},
-		deletePreviewMessage: async (messageId) => {
-			await bot.api.deleteMessage(chatId, messageId);
-		},
-		log: logVerbose,
-		markDelivered: () => {
-			deliveryState.markDelivered();
-		}
-	});
-	let queuedFinal = false;
-	if (statusReactionController) statusReactionController.setThinking();
-	const typingCallbacks = createTypingCallbacks({
-		start: sendTyping,
-		onStartError: (err) => {
-			logTypingFailure({
-				log: logVerbose,
-				channel: "telegram",
-				target: String(chatId),
-				error: err
-			});
-		}
-	});
-	try {
-		({queuedFinal} = await dispatchReplyWithBufferedBlockDispatcher({
-			ctx: ctxPayload,
-			cfg,
-			dispatcherOptions: {
-				...prefixOptions,
-				typingCallbacks,
-				deliver: async (payload, info) => {
-					const previewButtons = (payload.channelData?.telegram)?.buttons;
-					const split = splitTextIntoLaneSegments(payload.text);
-					const segments = split.segments;
-					const hasMedia = Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
-					const flushBufferedFinalAnswer = async () => {
-						const buffered = reasoningStepState.takeBufferedFinalAnswer();
-						if (!buffered) return;
-						const bufferedButtons = (buffered.payload.channelData?.telegram)?.buttons;
-						await deliverLaneText({
-							laneName: "answer",
-							text: buffered.text,
-							payload: buffered.payload,
-							infoKind: "final",
-							previewButtons: bufferedButtons
-						});
-						reasoningStepState.resetForNextStep();
-					};
-					for (const segment of segments) {
-						if (segment.lane === "answer" && info.kind === "final" && reasoningStepState.shouldBufferFinalAnswer()) {
-							reasoningStepState.bufferFinalAnswer({
-								payload,
-								text: segment.text
-							});
-							continue;
-						}
-						if (segment.lane === "reasoning") reasoningStepState.noteReasoningHint();
-						const result = await deliverLaneText({
-							laneName: segment.lane,
-							text: segment.text,
-							payload,
-							infoKind: info.kind,
-							previewButtons,
-							allowPreviewUpdateForNonFinal: segment.lane === "reasoning"
-						});
-						if (segment.lane === "reasoning") {
-							if (result !== "skipped") {
-								reasoningStepState.noteReasoningDelivered();
-								await flushBufferedFinalAnswer();
-							}
-							continue;
-						}
-						if (info.kind === "final") {
-							if (reasoningLane.hasStreamedMessage) finalizedPreviewByLane.reasoning = true;
-							reasoningStepState.resetForNextStep();
-						}
-					}
-					if (segments.length > 0) return;
-					if (split.suppressedReasoningOnly) {
-						if (hasMedia) await sendPayload(typeof payload.text === "string" ? {
-							...payload,
-							text: ""
-						} : payload);
-						if (info.kind === "final") await flushBufferedFinalAnswer();
-						return;
-					}
-					if (info.kind === "final") {
-						await answerLane.stream?.stop();
-						await reasoningLane.stream?.stop();
-						reasoningStepState.resetForNextStep();
-					}
-					if (!(hasMedia || typeof payload.text !== "string" || payload.text.length > 0)) {
-						if (info.kind === "final") await flushBufferedFinalAnswer();
-						return;
-					}
-					await sendPayload(payload);
-					if (info.kind === "final") await flushBufferedFinalAnswer();
-				},
-				onSkip: (_payload, info) => {
-					if (info.reason !== "silent") deliveryState.markNonSilentSkip();
-				},
-				onError: (err, info) => {
-					deliveryState.markNonSilentFailure();
-					runtime.error?.(danger(`telegram ${info.kind} reply failed: ${String(err)}`));
-				}
-			},
-			replyOptions: {
-				skillFilter,
-				disableBlockStreaming,
-				allowProgressCallbacksWhenSourceDeliverySuppressed: progressDraftsEnabled ? true : void 0,
-				onPartialReply: answerLane.stream || reasoningLane.stream ? (payload) => ingestDraftLaneSegments(payload.text) : void 0,
-				onReasoningStream: reasoningLane.stream ? (payload) => {
-					if (splitReasoningOnNextStream) {
-						reasoningLane.stream?.forceNewMessage();
-						resetDraftLaneState(reasoningLane);
-						splitReasoningOnNextStream = false;
-					}
-					ingestDraftLaneSegments(payload.text);
-				} : void 0,
-				onAssistantMessageStart: answerLane.stream ? async () => {
-					reasoningStepState.resetForNextStep();
-					if (answerLane.hasStreamedMessage) {
-						const previewMessageId = answerLane.stream?.messageId();
-						if (typeof previewMessageId === "number" && !finalizedPreviewByLane.answer) archivedAnswerPreviews.push({
-							messageId: previewMessageId,
-							textSnapshot: answerLane.lastPartialText
-						});
-						answerLane.stream?.forceNewMessage();
-					}
-					resetDraftLaneState(answerLane);
-					finalizedPreviewByLane.answer = false;
-				} : void 0,
-				onReasoningEnd: reasoningLane.stream ? () => {
-					splitReasoningOnNextStream = reasoningLane.hasStreamedMessage;
-				} : void 0,
-				onToolStart: progressDraftsEnabled || statusReactionController ? async (payload) => {
-					const progressPromise = pushToolProgressDraft(payload);
-					if (statusReactionController) await statusReactionController.setTool(payload.name);
-					await progressPromise;
-				} : void 0,
-				onModelSelected
-			}
-		}));
-	} finally {
-		const streamCleanupStates = /* @__PURE__ */ new Map();
-		const lanesToCleanup = [{
-			laneName: "answer",
-			lane: answerLane
-		}, {
-			laneName: "reasoning",
-			lane: reasoningLane
-		}];
-		for (const laneState of lanesToCleanup) {
-			const stream = laneState.lane.stream;
-			if (!stream) continue;
-			const shouldClear = !finalizedPreviewByLane[laneState.laneName];
-			const existing = streamCleanupStates.get(stream);
-			if (!existing) {
-				streamCleanupStates.set(stream, { shouldClear });
-				continue;
-			}
-			existing.shouldClear = existing.shouldClear && shouldClear;
-		}
-		for (const [stream, cleanupState] of streamCleanupStates) {
-			await stream.stop();
-			if (cleanupState.shouldClear) 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;
-	const deliverySummary = deliveryState.snapshot();
-	if (!deliverySummary.delivered && (deliverySummary.skippedNonSilent > 0 || deliverySummary.failedNonSilent > 0)) sentFallback = (await deliverReplies({
-		replies: [{ text: EMPTY_RESPONSE_FALLBACK$1 }],
-		...deliveryBaseOptions
-	})).delivered;
-	const hasFinalResponse = queuedFinal || sentFallback;
-	if (statusReactionController && !hasFinalResponse) statusReactionController.setError().catch((err) => {
-		logVerbose(`telegram: status reaction error finalize failed: ${String(err)}`);
-	});
-	if (!hasFinalResponse) {
-		clearGroupHistory();
-		return;
-	}
-	if (statusReactionController) 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();
-};
-
-//#endregion
-//#region src/telegram/bot-message.ts
-const createTelegramMessageProcessor = (deps) => {
-	const { bot, cfg, account, telegramCfg, historyLimit, groupHistories, dmPolicy, allowFrom, groupAllowFrom, ackReactionScope, logger, resolveGroupActivation, resolveGroupRequireMention, resolveTelegramGroupConfig, sendChatActionHandler, runtime, replyToMode, streamMode, textLimit, opts } = deps;
-	return async (primaryCtx, allMedia, storeAllowFrom, options, replyMedia) => {
-		const context = await buildTelegramMessageContext({
-			primaryCtx,
-			allMedia,
-			replyMedia,
-			storeAllowFrom,
-			options,
-			bot,
-			cfg,
-			account,
-			historyLimit,
-			groupHistories,
-			dmPolicy,
-			allowFrom,
-			groupAllowFrom,
-			ackReactionScope,
-			logger,
-			resolveGroupActivation,
-			resolveGroupRequireMention,
-			resolveTelegramGroupConfig,
-			sendChatActionHandler
-		});
-		if (!context) return;
-		await dispatchTelegramMessage({
-			context,
-			bot,
-			cfg,
-			runtime,
-			replyToMode,
-			streamMode,
-			textLimit,
-			telegramCfg,
-			opts
-		});
-	};
-};
-
-//#endregion
-//#region src/telegram/bot-native-command-menu.ts
-const TELEGRAM_MAX_COMMANDS = 100;
-const TELEGRAM_COMMAND_RETRY_RATIO = .8;
-function isBotCommandsTooMuchError(err) {
-	if (!err) return false;
-	const pattern = /\bBOT_COMMANDS_TOO_MUCH\b/i;
-	if (typeof err === "string") return pattern.test(err);
-	if (err instanceof Error) {
-		if (pattern.test(err.message)) return true;
-	}
-	if (typeof err === "object") {
-		const maybe = err;
-		if (typeof maybe.description === "string" && pattern.test(maybe.description)) return true;
-		if (typeof maybe.message === "string" && pattern.test(maybe.message)) return true;
-	}
-	return false;
-}
-function buildPluginTelegramMenuCommands(params) {
-	const { specs, existingCommands } = params;
-	const commands = [];
-	const issues = [];
-	const pluginCommandNames = /* @__PURE__ */ new Set();
-	for (const spec of specs) {
-		const normalized = normalizeTelegramCommandName(spec.name);
-		if (!normalized || !TELEGRAM_COMMAND_NAME_PATTERN.test(normalized)) {
-			issues.push(`Plugin command "/${spec.name}" is invalid for Telegram (use a-z, 0-9, underscore; max 32 chars).`);
-			continue;
-		}
-		const description = spec.description.trim();
-		if (!description) {
-			issues.push(`Plugin command "/${normalized}" is missing a description.`);
-			continue;
-		}
-		if (existingCommands.has(normalized)) {
-			if (pluginCommandNames.has(normalized)) issues.push(`Plugin command "/${normalized}" is duplicated.`);
-			else issues.push(`Plugin command "/${normalized}" conflicts with an existing Telegram command.`);
-			continue;
-		}
-		pluginCommandNames.add(normalized);
-		existingCommands.add(normalized);
-		commands.push({
-			command: normalized,
-			description
-		});
-	}
-	return {
-		commands,
-		issues
-	};
-}
-function buildCappedTelegramMenuCommands(params) {
-	const { allCommands } = params;
-	const maxCommands = params.maxCommands ?? TELEGRAM_MAX_COMMANDS;
-	const totalCommands = allCommands.length;
-	const overflowCount = Math.max(0, totalCommands - maxCommands);
-	return {
-		commandsToRegister: allCommands.slice(0, maxCommands),
-		totalCommands,
-		maxCommands,
-		overflowCount
-	};
-}
-function syncTelegramMenuCommands(params) {
-	const { bot, runtime, commandsToRegister } = params;
-	const sync = async () => {
-		if (typeof bot.api.deleteMyCommands === "function") await withTelegramApiErrorLogging({
-			operation: "deleteMyCommands",
-			runtime,
-			fn: () => bot.api.deleteMyCommands()
-		}).catch(() => {});
-		if (commandsToRegister.length === 0) return;
-		let retryCommands = commandsToRegister;
-		while (retryCommands.length > 0) try {
-			await withTelegramApiErrorLogging({
-				operation: "setMyCommands",
-				runtime,
-				fn: () => bot.api.setMyCommands(retryCommands)
-			});
-			return;
-		} catch (err) {
-			if (!isBotCommandsTooMuchError(err)) throw err;
-			const nextCount = Math.floor(retryCommands.length * TELEGRAM_COMMAND_RETRY_RATIO);
-			const reducedCount = nextCount < retryCommands.length ? nextCount : retryCommands.length - 1;
-			if (reducedCount <= 0) {
-				runtime.error?.("Telegram rejected native command registration (BOT_COMMANDS_TOO_MUCH); leaving menu empty. Reduce commands or disable channels.telegram.commands.native.");
-				return;
-			}
-			runtime.log?.(`Telegram rejected ${retryCommands.length} commands (BOT_COMMANDS_TOO_MUCH); retrying with ${reducedCount}.`);
-			retryCommands = retryCommands.slice(0, reducedCount);
-		}
-	};
-	sync().catch((err) => {
-		runtime.error?.(`Telegram command sync failed: ${String(err)}`);
-	});
-}
-
-//#endregion
-//#region src/telegram/bot-native-commands.ts
-const EMPTY_RESPONSE_FALLBACK = "No response generated. Please try again.";
-async function resolveTelegramCommandAuth(params) {
-	const { msg, bot, cfg, accountId, telegramCfg, allowFrom, groupAllowFrom, useAccessGroups, resolveGroupPolicy, resolveTelegramGroupConfig, requireAuth } = params;
-	const chatId = msg.chat.id;
-	const isGroup = msg.chat.type === "group" || msg.chat.type === "supergroup";
-	const messageThreadId = msg.message_thread_id;
-	const isForum = msg.chat.is_forum === true;
-	const { resolvedThreadId, storeAllowFrom, groupConfig, topicConfig, effectiveGroupAllow, hasGroupAllowOverride } = await resolveTelegramGroupAllowFromContext({
-		chatId,
-		accountId,
-		isForum,
-		messageThreadId,
-		groupAllowFrom,
-		resolveTelegramGroupConfig
-	});
-	const senderId = msg.from?.id ? String(msg.from.id) : "";
-	const senderUsername = msg.from?.username ?? "";
-	const sendAuthMessage = async (text) => {
-		await withTelegramApiErrorLogging({
-			operation: "sendMessage",
-			fn: () => bot.api.sendMessage(chatId, text)
-		});
-		return null;
-	};
-	const rejectNotAuthorized = async () => {
-		return await sendAuthMessage("You are not authorized to use this command.");
-	};
-	const baseAccess = evaluateTelegramGroupBaseAccess({
-		isGroup,
-		groupConfig,
-		topicConfig,
-		hasGroupAllowOverride,
-		effectiveGroupAllow,
-		senderId,
-		senderUsername,
-		enforceAllowOverride: requireAuth,
-		requireSenderForAllowOverride: true
-	});
-	if (!baseAccess.allowed) {
-		if (baseAccess.reason === "group-disabled") return await sendAuthMessage("This group is disabled.");
-		if (baseAccess.reason === "topic-disabled") return await sendAuthMessage("This topic is disabled.");
-		return await rejectNotAuthorized();
-	}
-	const policyAccess = evaluateTelegramGroupPolicyAccess({
-		isGroup,
-		chatId,
-		cfg,
-		telegramCfg,
-		topicConfig,
-		groupConfig,
-		effectiveGroupAllow,
-		senderId,
-		senderUsername,
-		resolveGroupPolicy,
-		enforcePolicy: useAccessGroups,
-		useTopicAndGroupOverrides: false,
-		enforceAllowlistAuthorization: requireAuth,
-		allowEmptyAllowlistEntries: true,
-		requireSenderForAllowlistAuthorization: true,
-		checkChatAllowlist: useAccessGroups
-	});
-	if (!policyAccess.allowed) {
-		if (policyAccess.reason === "group-policy-disabled") return await sendAuthMessage("Telegram group commands are disabled.");
-		if (policyAccess.reason === "group-policy-allowlist-no-sender" || policyAccess.reason === "group-policy-allowlist-unauthorized") return await rejectNotAuthorized();
-		if (policyAccess.reason === "group-chat-not-allowed") return await sendAuthMessage("This group is not allowed.");
-	}
-	const dmAllow = normalizeDmAllowFromWithStore({
-		allowFrom,
-		storeAllowFrom: isGroup ? [] : storeAllowFrom,
-		dmPolicy: telegramCfg.dmPolicy ?? "pairing"
-	});
-	const senderAllowed = isSenderAllowed({
-		allow: dmAllow,
-		senderId,
-		senderUsername
-	});
-	const commandAuthorized = resolveCommandAuthorizedFromAuthorizers({
-		useAccessGroups,
-		authorizers: [{
-			configured: dmAllow.hasEntries,
-			allowed: senderAllowed
-		}],
-		modeWhenAccessGroupsOff: "configured"
-	});
-	if (requireAuth && !commandAuthorized) return await rejectNotAuthorized();
-	return {
-		chatId,
-		isGroup,
-		isForum,
-		resolvedThreadId,
-		senderId,
-		senderUsername,
-		groupConfig,
-		topicConfig,
-		commandAuthorized
-	};
-}
-const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, telegramCfg, allowFrom, groupAllowFrom, replyToMode, textLimit, useAccessGroups, nativeEnabled, nativeSkillsEnabled, nativeDisabledExplicit, resolveGroupPolicy, resolveTelegramGroupConfig, shouldSkipUpdate, opts }) => {
-	const boundRoute = nativeEnabled && nativeSkillsEnabled ? resolveAgentRoute({
-		cfg,
-		channel: "telegram",
-		accountId
-	}) : null;
-	const boundAgentIds = boundRoute ? [boundRoute.agentId] : null;
-	const skillCommands = nativeEnabled && nativeSkillsEnabled ? listSkillCommandsForAgents(boundAgentIds ? {
-		cfg,
-		agentIds: boundAgentIds
-	} : { cfg }) : [];
-	const nativeCommands = nativeEnabled ? listNativeCommandSpecsForConfig(cfg, {
-		skillCommands,
-		provider: "telegram"
-	}) : [];
-	const reservedCommands = new Set(listNativeCommandSpecs().map((command) => normalizeTelegramCommandName(command.name)));
-	for (const command of skillCommands) reservedCommands.add(command.name.toLowerCase());
-	const customResolution = resolveTelegramCustomCommands({
-		commands: telegramCfg.customCommands,
-		reservedCommands
-	});
-	for (const issue of customResolution.issues) runtime.error?.(danger(issue.message));
-	const customCommands = customResolution.commands;
-	const pluginCatalog = buildPluginTelegramMenuCommands({
-		specs: getPluginCommandSpecs(),
-		existingCommands: new Set([...nativeCommands.map((command) => normalizeTelegramCommandName(command.name)), ...customCommands.map((command) => command.command)].map((command) => command.toLowerCase()))
-	});
-	for (const issue of pluginCatalog.issues) runtime.error?.(danger(issue));
-	const { commandsToRegister, totalCommands, maxCommands, overflowCount } = buildCappedTelegramMenuCommands({ allCommands: [
-		...nativeCommands.map((command) => {
-			const normalized = normalizeTelegramCommandName(command.name);
-			if (!TELEGRAM_COMMAND_NAME_PATTERN.test(normalized)) {
-				runtime.error?.(danger(`Native command "${command.name}" is invalid for Telegram (resolved to "${normalized}"). Skipping.`));
-				return null;
-			}
-			return {
-				command: normalized,
-				description: command.description
-			};
-		}).filter((cmd) => cmd !== null),
-		...nativeEnabled ? pluginCatalog.commands : [],
-		...customCommands
-	] });
-	if (overflowCount > 0) runtime.log?.(`Telegram limits bots to ${maxCommands} commands. ${totalCommands} configured; registering first ${maxCommands}. Use channels.telegram.commands.native: false to disable, or reduce plugin/skill/custom commands.`);
-	syncTelegramMenuCommands({
-		bot,
-		runtime,
-		commandsToRegister
-	});
-	const resolveCommandRuntimeContext = (params) => {
-		const { msg, isGroup, isForum, resolvedThreadId } = params;
-		const chatId = msg.chat.id;
-		const messageThreadId = msg.message_thread_id;
-		const threadSpec = resolveTelegramThreadSpec({
-			isGroup,
-			isForum,
-			messageThreadId
-		});
-		const parentPeer = buildTelegramParentPeer({
-			isGroup,
-			resolvedThreadId,
-			chatId
-		});
-		const route = resolveAgentRoute({
-			cfg,
-			channel: "telegram",
-			accountId,
-			peer: {
-				kind: isGroup ? "group" : "direct",
-				id: isGroup ? buildTelegramGroupPeerId(chatId, resolvedThreadId) : String(chatId)
-			},
-			parentPeer
-		});
-		return {
-			chatId,
-			threadSpec,
-			route,
-			mediaLocalRoots: getAgentScopedMediaLocalRoots(cfg, route.agentId),
-			tableMode: resolveMarkdownTableMode({
-				cfg,
-				channel: "telegram",
-				accountId: route.accountId
-			}),
-			chunkMode: resolveChunkMode(cfg, "telegram", route.accountId)
-		};
-	};
-	const buildCommandDeliveryBaseOptions = (params) => ({
-		chatId: String(params.chatId),
-		token: opts.token,
-		runtime,
-		bot,
-		mediaLocalRoots: params.mediaLocalRoots,
-		replyToMode,
-		textLimit,
-		thread: params.threadSpec,
-		tableMode: params.tableMode,
-		chunkMode: params.chunkMode,
-		linkPreview: telegramCfg.linkPreview
-	});
-	if (commandsToRegister.length > 0 || pluginCatalog.commands.length > 0) if (typeof bot.command !== "function") logVerbose("telegram: bot.command unavailable; skipping native handlers");
-	else {
-		for (const command of nativeCommands) {
-			const normalizedCommandName = normalizeTelegramCommandName(command.name);
-			bot.command(normalizedCommandName, async (ctx) => {
-				const msg = ctx.message;
-				if (!msg) return;
-				if (shouldSkipUpdate(ctx)) return;
-				const auth = await resolveTelegramCommandAuth({
-					msg,
-					bot,
-					cfg,
-					accountId,
-					telegramCfg,
-					allowFrom,
-					groupAllowFrom,
-					useAccessGroups,
-					resolveGroupPolicy,
-					resolveTelegramGroupConfig,
-					requireAuth: true
-				});
-				if (!auth) return;
-				const { chatId, isGroup, isForum, resolvedThreadId, senderId, senderUsername, groupConfig, topicConfig, commandAuthorized } = auth;
-				const { threadSpec, route, mediaLocalRoots, tableMode, chunkMode } = resolveCommandRuntimeContext({
-					msg,
-					isGroup,
-					isForum,
-					resolvedThreadId
-				});
-				const deliveryBaseOptions = buildCommandDeliveryBaseOptions({
-					chatId,
-					mediaLocalRoots,
-					threadSpec,
-					tableMode,
-					chunkMode
-				});
-				const threadParams = buildTelegramThreadParams(threadSpec) ?? {};
-				const commandDefinition = findCommandByNativeName(command.name, "telegram");
-				const rawText = ctx.match?.trim() ?? "";
-				const commandArgs = commandDefinition ? parseCommandArgs(commandDefinition, rawText) : rawText ? { raw: rawText } : void 0;
-				const prompt = commandDefinition ? buildCommandTextFromArgs(commandDefinition, commandArgs) : rawText ? `/${command.name} ${rawText}` : `/${command.name}`;
-				const menu = commandDefinition ? resolveCommandArgMenu({
-					command: commandDefinition,
-					args: commandArgs,
-					cfg
-				}) : null;
-				if (menu && commandDefinition) {
-					const title = menu.title ?? `Choose ${menu.arg.description || menu.arg.name} for /${commandDefinition.nativeName ?? commandDefinition.key}.`;
-					const rows = [];
-					for (let i = 0; i < menu.choices.length; i += 2) {
-						const slice = menu.choices.slice(i, i + 2);
-						rows.push(slice.map((choice) => {
-							const args = { values: { [menu.arg.name]: choice.value } };
-							return {
-								text: choice.label,
-								callback_data: buildCommandTextFromArgs(commandDefinition, args)
-							};
-						}));
-					}
-					const replyMarkup = buildInlineKeyboard(rows);
-					await withTelegramApiErrorLogging({
-						operation: "sendMessage",
-						runtime,
-						fn: () => bot.api.sendMessage(chatId, title, {
-							...replyMarkup ? { reply_markup: replyMarkup } : {},
-							...threadParams
-						})
-					});
-					return;
-				}
-				const baseSessionKey = route.sessionKey;
-				const dmThreadId = threadSpec.scope === "dm" ? threadSpec.id : void 0;
-				const sessionKey = (dmThreadId != null ? resolveThreadSessionKeys({
-					baseSessionKey,
-					threadId: String(dmThreadId)
-				}) : null)?.sessionKey ?? baseSessionKey;
-				const { skillFilter, groupSystemPrompt } = resolveTelegramGroupPromptSettings({
-					groupConfig,
-					topicConfig
-				});
-				const conversationLabel = isGroup ? msg.chat.title ? `${msg.chat.title} id:${chatId}` : `group:${chatId}` : buildSenderName(msg) ?? String(senderId || chatId);
-				const ctxPayload = finalizeInboundContext({
-					Body: prompt,
-					BodyForAgent: prompt,
-					RawBody: prompt,
-					CommandBody: prompt,
-					CommandArgs: commandArgs,
-					From: isGroup ? buildTelegramGroupFrom(chatId, resolvedThreadId) : `telegram:${chatId}`,
-					To: `slash:${senderId || chatId}`,
-					ChatType: isGroup ? "group" : "direct",
-					ConversationLabel: conversationLabel,
-					GroupSubject: isGroup ? msg.chat.title ?? void 0 : void 0,
-					GroupSystemPrompt: isGroup ? groupSystemPrompt : void 0,
-					SenderName: buildSenderName(msg),
-					SenderId: senderId || void 0,
-					SenderUsername: senderUsername || void 0,
-					Surface: "telegram",
-					Provider: "telegram",
-					MessageSid: String(msg.message_id),
-					Timestamp: msg.date ? msg.date * 1e3 : void 0,
-					WasMentioned: true,
-					CommandAuthorized: commandAuthorized,
-					CommandSource: "native",
-					SessionKey: `telegram:slash:${senderId || chatId}`,
-					AccountId: route.accountId,
-					CommandTargetSessionKey: sessionKey,
-					MessageThreadId: threadSpec.id,
-					IsForum: isForum,
-					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 : void 0;
-				const deliveryState = {
-					delivered: false,
-					skippedNonSilent: 0
-				};
-				const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
-					cfg,
-					agentId: route.agentId,
-					channel: "telegram",
-					accountId: route.accountId
-				});
-				await dispatchReplyWithBufferedBlockDispatcher({
-					ctx: ctxPayload,
-					cfg,
-					dispatcherOptions: {
-						...prefixOptions,
-						deliver: async (payload, _info) => {
-							if ((await deliverReplies({
-								replies: [payload],
-								...deliveryBaseOptions
-							})).delivered) deliveryState.delivered = true;
-						},
-						onSkip: (_payload, info) => {
-							if (info.reason !== "silent") deliveryState.skippedNonSilent += 1;
-						},
-						onError: (err, info) => {
-							runtime.error?.(danger(`telegram slash ${info.kind} reply failed: ${String(err)}`));
-						}
-					},
-					replyOptions: {
-						skillFilter,
-						disableBlockStreaming,
-						onModelSelected
-					}
-				});
-				if (!deliveryState.delivered && deliveryState.skippedNonSilent > 0) await deliverReplies({
-					replies: [{ text: EMPTY_RESPONSE_FALLBACK }],
-					...deliveryBaseOptions
-				});
-			});
-		}
-		for (const pluginCommand of pluginCatalog.commands) bot.command(pluginCommand.command, async (ctx) => {
-			const msg = ctx.message;
-			if (!msg) return;
-			if (shouldSkipUpdate(ctx)) return;
-			const chatId = msg.chat.id;
-			const rawText = ctx.match?.trim() ?? "";
-			const commandBody = `/${pluginCommand.command}${rawText ? ` ${rawText}` : ""}`;
-			const match = matchPluginCommand(commandBody);
-			if (!match) {
-				await withTelegramApiErrorLogging({
-					operation: "sendMessage",
-					runtime,
-					fn: () => bot.api.sendMessage(chatId, "Command not found.")
-				});
-				return;
-			}
-			const auth = await resolveTelegramCommandAuth({
-				msg,
-				bot,
-				cfg,
-				accountId,
-				telegramCfg,
-				allowFrom,
-				groupAllowFrom,
-				useAccessGroups,
-				resolveGroupPolicy,
-				resolveTelegramGroupConfig,
-				requireAuth: match.command.requireAuth !== false
-			});
-			if (!auth) return;
-			const { senderId, commandAuthorized, isGroup, isForum, resolvedThreadId } = auth;
-			const { threadSpec, mediaLocalRoots, tableMode, chunkMode } = resolveCommandRuntimeContext({
-				msg,
-				isGroup,
-				isForum,
-				resolvedThreadId
-			});
-			const deliveryBaseOptions = buildCommandDeliveryBaseOptions({
-				chatId,
-				mediaLocalRoots,
-				threadSpec,
-				tableMode,
-				chunkMode
-			});
-			const from = isGroup ? buildTelegramGroupFrom(chatId, threadSpec.id) : `telegram:${chatId}`;
-			const to = `telegram:${chatId}`;
-			await deliverReplies({
-				replies: [await executePluginCommand({
-					command: match.command,
-					args: match.args,
-					senderId,
-					channel: "telegram",
-					isAuthorizedSender: commandAuthorized,
-					commandBody,
-					config: cfg,
-					from,
-					to,
-					accountId,
-					messageThreadId: threadSpec.id
-				})],
-				...deliveryBaseOptions
-			});
-		});
-	}
-	else if (nativeDisabledExplicit) withTelegramApiErrorLogging({
-		operation: "setMyCommands",
-		runtime,
-		fn: () => bot.api.setMyCommands([])
-	}).catch(() => {});
-};
-
-//#endregion
-//#region src/telegram/sendchataction-401-backoff.ts
-const BACKOFF_POLICY = {
-	initialMs: 1e3,
-	maxMs: 3e5,
-	factor: 2,
-	jitter: .1
-};
-function is401Error(error) {
-	if (!error) return false;
-	const message = error instanceof Error ? error.message : JSON.stringify(error);
-	return message.includes("401") || message.toLowerCase().includes("unauthorized");
-}
-/**
-* Creates a GLOBAL (per-account) handler for sendChatAction that tracks 401 errors
-* across all message contexts. This prevents the infinite loop that caused Telegram
-* to delete bots (issue #27092).
-*
-* When a 401 occurs, exponential backoff is applied (1s → 2s → 4s → ... → 5min).
-* After maxConsecutive401 failures (default 10), all sendChatAction calls are
-* suspended until reset() is called.
-*/
-function createTelegramSendChatActionHandler({ sendChatActionFn, logger, maxConsecutive401 = 10 }) {
-	let consecutive401Failures = 0;
-	let suspended = false;
-	const reset = () => {
-		consecutive401Failures = 0;
-		suspended = false;
-	};
-	const sendChatAction = async (chatId, action, threadParams) => {
-		if (suspended) return;
-		if (consecutive401Failures > 0) {
-			const backoffMs = computeBackoff(BACKOFF_POLICY, consecutive401Failures);
-			logger(`sendChatAction backoff: waiting ${backoffMs}ms before retry (failure ${consecutive401Failures}/${maxConsecutive401})`);
-			await sleepWithAbort(backoffMs);
-		}
-		try {
-			await sendChatActionFn(chatId, action, threadParams);
-			if (consecutive401Failures > 0) {
-				logger(`sendChatAction recovered after ${consecutive401Failures} consecutive 401 failures`);
-				consecutive401Failures = 0;
-			}
-		} catch (error) {
-			if (is401Error(error)) {
-				consecutive401Failures++;
-				if (consecutive401Failures >= maxConsecutive401) {
-					suspended = true;
-					logger(`CRITICAL: sendChatAction suspended after ${consecutive401Failures} consecutive 401 errors. Bot token is likely invalid. Telegram may DELETE the bot if requests continue. Replace the token and restart: fased channels restart telegram`);
-				} else logger(`sendChatAction 401 error (${consecutive401Failures}/${maxConsecutive401}). Retrying with exponential backoff.`);
-			}
-			throw error;
-		}
-	};
-	return {
-		sendChatAction,
-		isSuspended: () => suspended,
-		reset
-	};
-}
-
-//#endregion
-//#region src/telegram/bot.ts
-const TELEGRAM_CONTROL_COMMANDS = new Set(["/status"]);
-function isTelegramControlRequestText(rawText, options) {
-	if (!rawText) return false;
-	if (isAbortRequestText(rawText, options)) return true;
-	const normalized = normalizeCommandBody(rawText, options).trim().toLowerCase();
-	return TELEGRAM_CONTROL_COMMANDS.has(normalized);
-}
-function getTelegramSequentialKey(ctx) {
-	const reaction = ctx.update?.message_reaction;
-	if (reaction?.chat?.id) return `telegram:${reaction.chat.id}`;
-	const msg = ctx.message ?? ctx.channelPost ?? ctx.editedChannelPost ?? ctx.update?.message ?? ctx.update?.edited_message ?? ctx.update?.channel_post ?? ctx.update?.edited_channel_post ?? ctx.update?.callback_query?.message;
-	const chatId = msg?.chat?.id ?? ctx.chat?.id;
-	const rawText = msg?.text ?? msg?.caption;
-	const botUsername = ctx.me?.username;
-	if (isTelegramControlRequestText(rawText, botUsername ? { botUsername } : void 0)) {
-		if (typeof chatId === "number") return `telegram:${chatId}:control`;
-		return "telegram:control";
-	}
-	const isGroup = msg?.chat?.type === "group" || msg?.chat?.type === "supergroup";
-	const messageThreadId = msg?.message_thread_id;
-	const isForum = msg?.chat?.is_forum;
-	const threadId = isGroup ? resolveTelegramForumThreadId({
-		isForum,
-		messageThreadId
-	}) : messageThreadId;
-	if (typeof chatId === "number") return threadId != null ? `telegram:${chatId}:topic:${threadId}` : `telegram:${chatId}`;
-	return "telegram:unknown";
-}
-function createTelegramBot(opts) {
-	const runtime = opts.runtime ?? createNonExitingRuntime();
-	const cfg = opts.config ?? loadConfig();
-	const account = resolveTelegramAccount({
-		cfg,
-		accountId: opts.accountId
-	});
-	const telegramCfg = account.config;
-	const fetchImpl = resolveTelegramFetch(opts.proxyFetch, { network: telegramCfg.network });
-	const shouldProvideFetch = Boolean(fetchImpl);
-	const fetchForClient = fetchImpl;
-	const timeoutSeconds = typeof telegramCfg?.timeoutSeconds === "number" && Number.isFinite(telegramCfg.timeoutSeconds) ? Math.max(1, Math.floor(telegramCfg.timeoutSeconds)) : void 0;
-	const client = shouldProvideFetch || timeoutSeconds ? {
-		...shouldProvideFetch && fetchImpl ? { fetch: fetchForClient } : {},
-		...timeoutSeconds ? { timeoutSeconds } : {}
-	} : void 0;
-	const bot = new Bot(opts.token, client ? { client } : void 0);
-	bot.api.config.use(apiThrottler());
-	bot.catch((err) => {
-		runtime.error?.(danger(`telegram bot error: ${formatUncaughtError(err)}`));
-	});
-	const recentUpdates = createTelegramUpdateDedupe();
-	const initialUpdateId = typeof opts.updateOffset?.lastUpdateId === "number" ? opts.updateOffset.lastUpdateId : null;
-	const pendingUpdateIds = /* @__PURE__ */ new Set();
-	let highestCompletedUpdateId = initialUpdateId;
-	let highestPersistedUpdateId = initialUpdateId;
-	const maybePersistSafeWatermark = () => {
-		if (typeof opts.updateOffset?.onUpdateId !== "function") return;
-		if (highestCompletedUpdateId === null) return;
-		let safe = highestCompletedUpdateId;
-		if (pendingUpdateIds.size > 0) {
-			let minPending = null;
-			for (const id of pendingUpdateIds) if (minPending === null || id < minPending) minPending = id;
-			if (minPending !== null) safe = Math.min(safe, minPending - 1);
-		}
-		if (highestPersistedUpdateId !== null && safe <= highestPersistedUpdateId) return;
-		highestPersistedUpdateId = safe;
-		opts.updateOffset.onUpdateId(safe);
-	};
-	const shouldSkipUpdate = (ctx) => {
-		const updateId = resolveTelegramUpdateId(ctx);
-		const skipCutoff = highestPersistedUpdateId ?? initialUpdateId;
-		if (typeof updateId === "number" && skipCutoff !== null && updateId <= skipCutoff) return true;
-		const key = buildTelegramUpdateKey(ctx);
-		const skipped = recentUpdates.check(key);
-		if (skipped && key && shouldLogVerbose()) logVerbose(`telegram dedupe: skipped ${key}`);
-		return skipped;
-	};
-	bot.use(async (ctx, next) => {
-		const updateId = resolveTelegramUpdateId(ctx);
-		if (typeof updateId === "number") pendingUpdateIds.add(updateId);
-		try {
-			await next();
-		} finally {
-			if (typeof updateId === "number") {
-				pendingUpdateIds.delete(updateId);
-				if (highestCompletedUpdateId === null || updateId > highestCompletedUpdateId) highestCompletedUpdateId = updateId;
-				maybePersistSafeWatermark();
-			}
-		}
-	});
-	bot.use(sequentialize(getTelegramSequentialKey));
-	const rawUpdateLogger = createSubsystemLogger("gateway/channels/telegram/raw-update");
-	const MAX_RAW_UPDATE_CHARS = 8e3;
-	const MAX_RAW_UPDATE_STRING = 500;
-	const MAX_RAW_UPDATE_ARRAY = 20;
-	const stringifyUpdate = (update) => {
-		const seen = /* @__PURE__ */ new WeakSet();
-		return JSON.stringify(update ?? null, (key, value) => {
-			if (typeof value === "string" && value.length > MAX_RAW_UPDATE_STRING) return `${value.slice(0, MAX_RAW_UPDATE_STRING)}...`;
-			if (Array.isArray(value) && value.length > MAX_RAW_UPDATE_ARRAY) return [...value.slice(0, MAX_RAW_UPDATE_ARRAY), `...(${value.length - MAX_RAW_UPDATE_ARRAY} more)`];
-			if (value && typeof value === "object") {
-				if (seen.has(value)) return "[Circular]";
-				seen.add(value);
-			}
-			return value;
-		});
-	};
-	bot.use(async (ctx, next) => {
-		if (shouldLogVerbose()) try {
-			const raw = stringifyUpdate(ctx.update);
-			const preview = raw.length > MAX_RAW_UPDATE_CHARS ? `${raw.slice(0, MAX_RAW_UPDATE_CHARS)}...` : raw;
-			rawUpdateLogger.debug(`telegram update: ${preview}`);
-		} catch (err) {
-			rawUpdateLogger.debug(`telegram update log failed: ${String(err)}`);
-		}
-		await next();
-	});
-	const historyLimit = Math.max(0, telegramCfg.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT);
-	const groupHistories = /* @__PURE__ */ new Map();
-	const textLimit = resolveTextChunkLimit(cfg, "telegram", account.accountId);
-	const dmPolicy = telegramCfg.dmPolicy ?? "pairing";
-	const allowFrom = opts.allowFrom ?? telegramCfg.allowFrom;
-	const groupAllowFrom = opts.groupAllowFrom ?? telegramCfg.groupAllowFrom ?? (telegramCfg.allowFrom && telegramCfg.allowFrom.length > 0 ? telegramCfg.allowFrom : void 0) ?? (opts.allowFrom && opts.allowFrom.length > 0 ? opts.allowFrom : void 0);
-	const replyToMode = opts.replyToMode ?? telegramCfg.replyToMode ?? "off";
-	const nativeEnabled = resolveNativeCommandsEnabled({
-		providerId: "telegram",
-		providerSetting: telegramCfg.commands?.native,
-		globalSetting: cfg.commands?.native
-	});
-	const nativeSkillsEnabled = resolveNativeSkillsEnabled({
-		providerId: "telegram",
-		providerSetting: telegramCfg.commands?.nativeSkills,
-		globalSetting: cfg.commands?.nativeSkills
-	});
-	const nativeDisabledExplicit = isNativeCommandsExplicitlyDisabled({
-		providerSetting: telegramCfg.commands?.native,
-		globalSetting: cfg.commands?.native
-	});
-	const useAccessGroups = cfg.commands?.useAccessGroups !== false;
-	const ackReactionScope = cfg.messages?.ackReactionScope ?? "group-mentions";
-	const mediaMaxBytes = (opts.mediaMaxMb ?? telegramCfg.mediaMaxMb ?? 5) * 1024 * 1024;
-	const logger = getChildLogger({ module: "telegram-auto-reply" });
-	const streamMode = resolveTelegramStreamMode(telegramCfg);
-	const resolveGroupPolicy = (chatId) => resolveChannelGroupPolicy({
-		cfg,
-		channel: "telegram",
-		accountId: account.accountId,
-		groupId: String(chatId)
-	});
-	const resolveGroupActivation = (params) => {
-		const agentId = params.agentId ?? resolveDefaultAgentId(cfg);
-		const sessionKey = params.sessionKey ?? `agent:${agentId}:telegram:group:${buildTelegramGroupPeerId(params.chatId, params.messageThreadId)}`;
-		const storePath = resolveStorePath(cfg.session?.store, { agentId });
-		try {
-			const entry = loadSessionStore(storePath)[sessionKey];
-			if (entry?.groupActivation === "always") return false;
-			if (entry?.groupActivation === "mention") return true;
-		} catch (err) {
-			logVerbose(`Failed to load session for activation check: ${String(err)}`);
-		}
-	};
-	const resolveGroupRequireMention = (chatId) => resolveChannelGroupRequireMention({
-		cfg,
-		channel: "telegram",
-		accountId: account.accountId,
-		groupId: String(chatId),
-		requireMentionOverride: opts.requireMention,
-		overrideOrder: "after-config"
-	});
-	const resolveTelegramGroupConfig = (chatId, messageThreadId) => {
-		const groups = telegramCfg.groups;
-		if (!groups) return {
-			groupConfig: void 0,
-			topicConfig: void 0
-		};
-		const groupConfig = groups[String(chatId)] ?? groups["*"];
-		return {
-			groupConfig,
-			topicConfig: messageThreadId != null ? groupConfig?.topics?.[String(messageThreadId)] : void 0
-		};
-	};
-	const processMessage = createTelegramMessageProcessor({
-		bot,
-		cfg,
-		account,
-		telegramCfg,
-		historyLimit,
-		groupHistories,
-		dmPolicy,
-		allowFrom,
-		groupAllowFrom,
-		ackReactionScope,
-		logger,
-		resolveGroupActivation,
-		resolveGroupRequireMention,
-		resolveTelegramGroupConfig,
-		sendChatActionHandler: createTelegramSendChatActionHandler({
-			sendChatActionFn: (chatId, action, threadParams) => bot.api.sendChatAction(chatId, action, threadParams),
-			logger: (message) => logVerbose(`telegram: ${message}`)
-		}),
-		runtime,
-		replyToMode,
-		streamMode,
-		textLimit,
-		opts
-	});
-	registerTelegramNativeCommands({
-		bot,
-		cfg,
-		runtime,
-		accountId: account.accountId,
-		telegramCfg,
-		allowFrom,
-		groupAllowFrom,
-		replyToMode,
-		textLimit,
-		useAccessGroups,
-		nativeEnabled,
-		nativeSkillsEnabled,
-		nativeDisabledExplicit,
-		resolveGroupPolicy,
-		resolveTelegramGroupConfig,
-		shouldSkipUpdate,
-		opts
-	});
-	registerTelegramHandlers({
-		cfg,
-		accountId: account.accountId,
-		bot,
-		opts,
-		runtime,
-		mediaMaxBytes,
-		telegramCfg,
-		allowFrom,
-		groupAllowFrom,
-		resolveGroupPolicy,
-		resolveTelegramGroupConfig,
-		shouldSkipUpdate,
-		processMessage,
-		logger
-	});
-	return bot;
-}
-
-//#endregion
-//#region src/telegram/update-offset-store.ts
-const STORE_VERSION = 2;
-function normalizeAccountId(accountId) {
-	const trimmed = accountId?.trim();
-	if (!trimmed) return "default";
-	return trimmed.replace(/[^a-z0-9._-]+/gi, "_");
-}
-function resolveTelegramUpdateOffsetPath(accountId, env = process.env) {
-	const stateDir = resolveStateDir(env, os.homedir);
-	const normalized = normalizeAccountId(accountId);
-	return path.join(stateDir, "telegram", `update-offset-${normalized}.json`);
-}
-function extractBotIdFromToken(token) {
-	const trimmed = token?.trim();
-	if (!trimmed) return null;
-	const [rawBotId] = trimmed.split(":", 1);
-	if (!rawBotId || !/^\d+$/.test(rawBotId)) return null;
-	return rawBotId;
-}
-function safeParseState(raw) {
-	try {
-		const parsed = JSON.parse(raw);
-		if (parsed?.version !== STORE_VERSION && parsed?.version !== 1) return null;
-		if (parsed.lastUpdateId !== null && typeof parsed.lastUpdateId !== "number") return null;
-		if (parsed.version === STORE_VERSION && parsed.botId !== null && typeof parsed.botId !== "string") return null;
-		return {
-			version: STORE_VERSION,
-			lastUpdateId: parsed.lastUpdateId ?? null,
-			botId: parsed.version === STORE_VERSION ? parsed.botId ?? null : null
-		};
-	} catch {
-		return null;
-	}
-}
-async function readTelegramUpdateOffset(params) {
-	const filePath = resolveTelegramUpdateOffsetPath(params.accountId, params.env);
-	try {
-		const parsed = safeParseState(await fs.readFile(filePath, "utf-8"));
-		const expectedBotId = extractBotIdFromToken(params.botToken);
-		if (expectedBotId && parsed?.botId && parsed.botId !== expectedBotId) return null;
-		if (expectedBotId && parsed?.botId === null) return null;
-		return parsed?.lastUpdateId ?? null;
-	} catch (err) {
-		if (err.code === "ENOENT") return null;
-		return null;
-	}
-}
-async function writeTelegramUpdateOffset(params) {
-	const filePath = resolveTelegramUpdateOffsetPath(params.accountId, params.env);
-	const dir = path.dirname(filePath);
-	await fs.mkdir(dir, {
-		recursive: true,
-		mode: 448
-	});
-	const tmp = path.join(dir, `${path.basename(filePath)}.${crypto.randomUUID()}.tmp`);
-	const payload = {
-		version: STORE_VERSION,
-		lastUpdateId: params.updateId,
-		botId: extractBotIdFromToken(params.botToken)
-	};
-	await fs.writeFile(tmp, `${JSON.stringify(payload, null, 2)}\n`, { encoding: "utf-8" });
-	await fs.chmod(tmp, 384);
-	await fs.rename(tmp, filePath);
-}
-
-//#endregion
-//#region src/telegram/webhook.ts
-const TELEGRAM_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
-const TELEGRAM_WEBHOOK_BODY_TIMEOUT_MS = 3e4;
-const TELEGRAM_WEBHOOK_CALLBACK_TIMEOUT_MS = 1e4;
-async function listenHttpServer(params) {
-	await new Promise((resolve, reject) => {
-		const onError = (err) => {
-			params.server.off("error", onError);
-			reject(err);
-		};
-		params.server.once("error", onError);
-		params.server.listen(params.port, params.host, () => {
-			params.server.off("error", onError);
-			resolve();
-		});
-	});
-}
-function resolveWebhookPublicUrl(params) {
-	if (params.configuredPublicUrl) return params.configuredPublicUrl;
-	const address = params.server.address();
-	if (address && typeof address !== "string") return `http://${params.host === "0.0.0.0" || address.address === "0.0.0.0" || address.address === "::" ? "localhost" : address.address}:${address.port}${params.path}`;
-	return `http://${params.host === "0.0.0.0" ? "localhost" : params.host}:${params.port}${params.path}`;
-}
-async function initializeTelegramWebhookBot(params) {
-	const initSignal = params.abortSignal;
-	await withTelegramApiErrorLogging({
-		operation: "getMe",
-		runtime: params.runtime,
-		fn: () => params.bot.init(initSignal)
-	});
-}
-async function startTelegramWebhook(opts) {
-	const path = opts.path ?? "/telegram-webhook";
-	const healthPath = opts.healthPath ?? "/healthz";
-	const port = opts.port ?? 8787;
-	const host = opts.host ?? "127.0.0.1";
-	const secret = typeof opts.secret === "string" ? opts.secret.trim() : "";
-	if (!secret) throw new Error("Telegram webhook mode requires a non-empty secret token. Set channels.telegram.webhookSecret in your config.");
-	const runtime = opts.runtime ?? defaultRuntime;
-	const diagnosticsEnabled = isDiagnosticsEnabled(opts.config);
-	const bot = createTelegramBot({
-		token: opts.token,
-		runtime,
-		proxyFetch: opts.fetch,
-		config: opts.config,
-		accountId: opts.accountId
-	});
-	await initializeTelegramWebhookBot({
-		bot,
-		runtime,
-		abortSignal: opts.abortSignal
-	});
-	const handler = webhookCallback(bot, "callback", {
-		secretToken: secret,
-		onTimeout: "return",
-		timeoutMilliseconds: TELEGRAM_WEBHOOK_CALLBACK_TIMEOUT_MS
-	});
-	if (diagnosticsEnabled) startDiagnosticHeartbeat();
-	const server = createServer((req, res) => {
-		const respondText = (statusCode, text = "") => {
-			if (res.headersSent || res.writableEnded) return;
-			res.writeHead(statusCode, { "Content-Type": "text/plain; charset=utf-8" });
-			res.end(text);
-		};
-		if (req.url === healthPath) {
-			res.writeHead(200);
-			res.end("ok");
-			return;
-		}
-		if (req.url !== path || req.method !== "POST") {
-			res.writeHead(404);
-			res.end();
-			return;
-		}
-		const startTime = Date.now();
-		if (diagnosticsEnabled) logWebhookReceived({
-			channel: "telegram",
-			updateType: "telegram-post"
-		});
-		(async () => {
-			const body = await readJsonBodyWithLimit(req, {
-				maxBytes: TELEGRAM_WEBHOOK_MAX_BODY_BYTES,
-				timeoutMs: TELEGRAM_WEBHOOK_BODY_TIMEOUT_MS,
-				emptyObjectOnEmpty: false
-			});
-			if (!body.ok) {
-				if (body.code === "PAYLOAD_TOO_LARGE") {
-					respondText(413, body.error);
-					return;
-				}
-				if (body.code === "REQUEST_BODY_TIMEOUT") {
-					respondText(408, body.error);
-					return;
-				}
-				if (body.code === "CONNECTION_CLOSED") {
-					respondText(400, body.error);
-					return;
-				}
-				respondText(400, body.error);
-				return;
-			}
-			let replied = false;
-			const reply = async (json) => {
-				if (replied) return;
-				replied = true;
-				if (res.headersSent || res.writableEnded) return;
-				res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
-				res.end(json);
-			};
-			const unauthorized = async () => {
-				if (replied) return;
-				replied = true;
-				respondText(401, "unauthorized");
-			};
-			const secretHeaderRaw = req.headers["x-telegram-bot-api-secret-token"];
-			const secretHeader = Array.isArray(secretHeaderRaw) ? secretHeaderRaw[0] : secretHeaderRaw;
-			await handler(body.value, reply, secretHeader, unauthorized);
-			if (!replied) respondText(200);
-			if (diagnosticsEnabled) logWebhookProcessed({
-				channel: "telegram",
-				updateType: "telegram-post",
-				durationMs: Date.now() - startTime
-			});
-		})().catch((err) => {
-			const errMsg = formatErrorMessage(err);
-			if (diagnosticsEnabled) logWebhookError({
-				channel: "telegram",
-				updateType: "telegram-post",
-				error: errMsg
-			});
-			runtime.log?.(`webhook handler failed: ${errMsg}`);
-			respondText(500);
-		});
-	});
-	await listenHttpServer({
-		server,
-		port,
-		host
-	});
-	const boundAddress = server.address();
-	const boundPort = boundAddress && typeof boundAddress !== "string" ? boundAddress.port : port;
-	const publicUrl = resolveWebhookPublicUrl({
-		configuredPublicUrl: opts.publicUrl,
-		server,
-		path,
-		host,
-		port
-	});
-	try {
-		await withTelegramApiErrorLogging({
-			operation: "setWebhook",
-			runtime,
-			fn: () => bot.api.setWebhook(publicUrl, {
-				secret_token: secret,
-				allowed_updates: resolveTelegramAllowedUpdates()
-			})
-		});
-	} catch (err) {
-		server.close();
-		bot.stop();
-		if (diagnosticsEnabled) stopDiagnosticHeartbeat();
-		throw err;
-	}
-	runtime.log?.(`webhook local listener on http://${host}:${boundPort}${path}`);
-	runtime.log?.(`webhook advertised to telegram on ${publicUrl}`);
-	let shutDown = false;
-	const shutdown = () => {
-		if (shutDown) return;
-		shutDown = true;
-		withTelegramApiErrorLogging({
-			operation: "deleteWebhook",
-			runtime,
-			fn: () => bot.api.deleteWebhook({ drop_pending_updates: false })
-		}).catch(() => {});
-		server.close();
-		bot.stop();
-		if (diagnosticsEnabled) stopDiagnosticHeartbeat();
-	};
-	if (opts.abortSignal) opts.abortSignal.addEventListener("abort", shutdown, { once: true });
-	return {
-		server,
-		bot,
-		stop: shutdown
-	};
-}
-
-//#endregion
-//#region src/telegram/monitor.ts
-function createTelegramRunnerOptions(cfg) {
-	return {
-		sink: { concurrency: resolveAgentMaxConcurrent(cfg) },
-		runner: {
-			fetch: {
-				timeout: 30,
-				allowed_updates: resolveTelegramAllowedUpdates()
-			},
-			silent: true,
-			maxRetryTime: 3600 * 1e3,
-			retryInterval: "exponential"
-		}
-	};
-}
-const TELEGRAM_POLL_RESTART_POLICY = {
-	initialMs: 2e3,
-	maxMs: 3e4,
-	factor: 1.8,
-	jitter: .25
-};
-const isGetUpdatesConflict = (err) => {
-	if (!err || typeof err !== "object") return false;
-	const typed = err;
-	if ((typed.error_code ?? typed.errorCode) !== 409) return false;
-	return [
-		typed.method,
-		typed.description,
-		typed.message
-	].filter((value) => typeof value === "string").join(" ").toLowerCase().includes("getupdates");
-};
-/** Check if error is a Grammy HttpError (used to scope unhandled rejection handling) */
-const isGrammyHttpError = (err) => {
-	if (!err || typeof err !== "object") return false;
-	return err.name === "HttpError";
-};
-async function monitorTelegramProvider(opts = {}) {
-	const log = opts.runtime?.error ?? console.error;
-	let activeRunner;
-	let forceRestarted = false;
-	const unregisterHandler = registerUnhandledRejectionHandler((err) => {
-		const isNetworkError = isRecoverableTelegramNetworkError(err, { context: "polling" });
-		if (isGrammyHttpError(err) && isNetworkError) {
-			log(`[telegram] Suppressed network error: ${formatErrorMessage(err)}`);
-			return true;
-		}
-		if (isNetworkError && activeRunner && activeRunner.isRunning()) {
-			forceRestarted = true;
-			activeRunner.stop().catch(() => {});
-			log(`[telegram] Restarting polling after unhandled network error: ${formatErrorMessage(err)}`);
-			return true;
-		}
-		return false;
-	});
-	try {
-		const cfg = opts.config ?? loadConfig();
-		const account = resolveTelegramAccount({
-			cfg,
-			accountId: opts.accountId
-		});
-		const token = opts.token?.trim() || account.token;
-		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) : void 0);
-		let lastUpdateId = await readTelegramUpdateOffset({
-			accountId: account.accountId,
-			botToken: token
-		});
-		const persistUpdateId = async (updateId) => {
-			if (lastUpdateId !== null && updateId <= lastUpdateId) return;
-			lastUpdateId = updateId;
-			try {
-				await writeTelegramUpdateOffset({
-					accountId: account.accountId,
-					updateId,
-					botToken: token
-				});
-			} catch (err) {
-				(opts.runtime?.error ?? console.error)(`telegram: failed to persist update offset: ${String(err)}`);
-			}
-		};
-		if (opts.useWebhook) {
-			await startTelegramWebhook({
-				token,
-				accountId: account.accountId,
-				config: cfg,
-				path: opts.webhookPath,
-				port: opts.webhookPort,
-				secret: opts.webhookSecret ?? account.config.webhookSecret,
-				host: opts.webhookHost ?? account.config.webhookHost,
-				runtime: opts.runtime,
-				fetch: proxyFetch,
-				abortSignal: opts.abortSignal,
-				publicUrl: opts.webhookUrl
-			});
-			await waitForAbortSignal(opts.abortSignal);
-			return;
-		}
-		let restartAttempts = 0;
-		let webhookCleared = false;
-		const runnerOptions = createTelegramRunnerOptions(cfg);
-		const waitBeforeRestart = async (buildLine) => {
-			restartAttempts += 1;
-			const delayMs = computeBackoff(TELEGRAM_POLL_RESTART_POLICY, restartAttempts);
-			log(buildLine(formatDurationPrecise(delayMs)));
-			try {
-				await sleepWithAbort(delayMs, opts.abortSignal);
-			} catch (sleepErr) {
-				if (opts.abortSignal?.aborted) return false;
-				throw sleepErr;
-			}
-			return true;
-		};
-		const waitBeforeRetryOnRecoverableSetupError = async (err, logPrefix) => {
-			if (opts.abortSignal?.aborted) return false;
-			if (!isRecoverableTelegramNetworkError(err, { context: "unknown" })) throw err;
-			return waitBeforeRestart((delay) => `${logPrefix}: ${formatErrorMessage(err)}; retrying in ${delay}.`);
-		};
-		const createPollingBot = async () => {
-			try {
-				return createTelegramBot({
-					token,
-					runtime: opts.runtime,
-					proxyFetch,
-					config: cfg,
-					accountId: account.accountId,
-					updateOffset: {
-						lastUpdateId,
-						onUpdateId: persistUpdateId
-					}
-				});
-			} catch (err) {
-				if (!await waitBeforeRetryOnRecoverableSetupError(err, "Telegram setup network error")) return;
-				return;
-			}
-		};
-		const ensureWebhookCleanup = async (bot) => {
-			if (webhookCleared) return "ready";
-			try {
-				await withTelegramApiErrorLogging({
-					operation: "deleteWebhook",
-					runtime: opts.runtime,
-					fn: () => bot.api.deleteWebhook({ drop_pending_updates: false })
-				});
-				webhookCleared = true;
-				return "ready";
-			} catch (err) {
-				return await waitBeforeRetryOnRecoverableSetupError(err, "Telegram webhook cleanup failed") ? "retry" : "exit";
-			}
-		};
-		const runPollingCycle = async (bot) => {
-			const runner = run(bot, runnerOptions);
-			activeRunner = runner;
-			let stopPromise;
-			const stopRunner = () => {
-				stopPromise ??= Promise.resolve(runner.stop()).then(() => void 0).catch(() => {});
-				return stopPromise;
-			};
-			const stopOnAbort = () => {
-				if (opts.abortSignal?.aborted) stopRunner();
-			};
-			opts.abortSignal?.addEventListener("abort", stopOnAbort, { once: true });
-			try {
-				await runner.task();
-				if (opts.abortSignal?.aborted) return "exit";
-				const reason = forceRestarted ? "unhandled network error" : "runner stopped (maxRetryTime exceeded or graceful stop)";
-				forceRestarted = false;
-				return await waitBeforeRestart((delay) => `Telegram polling runner stopped (${reason}); restarting in ${delay}.`) ? "continue" : "exit";
-			} catch (err) {
-				forceRestarted = false;
-				if (opts.abortSignal?.aborted) throw err;
-				const isConflict = isGetUpdatesConflict(err);
-				const isRecoverable = isRecoverableTelegramNetworkError(err, { context: "polling" });
-				if (!isConflict && !isRecoverable) throw err;
-				const reason = isConflict ? "getUpdates conflict" : "network error";
-				const errMsg = formatErrorMessage(err);
-				return await waitBeforeRestart((delay) => `Telegram ${reason}: ${errMsg}; retrying in ${delay}.`) ? "continue" : "exit";
-			} finally {
-				opts.abortSignal?.removeEventListener("abort", stopOnAbort);
-				await stopRunner();
-			}
-		};
-		while (!opts.abortSignal?.aborted) {
-			const bot = await createPollingBot();
-			if (!bot) continue;
-			const cleanupState = await ensureWebhookCleanup(bot);
-			if (cleanupState === "retry") continue;
-			if (cleanupState === "exit") return;
-			if (await runPollingCycle(bot) === "exit") return;
-		}
-	} finally {
-		unregisterHandler();
-	}
-}
-
-//#endregion
-export { monitorTelegramProvider };