@ihazz/bitrix24 1.1.1 → 1.1.3

package/dist/src/channel.js

@@ -0,0 +1,2324 @@
+import { createHash } from 'node:crypto';
+import { basename } from 'node:path';
+import { listAccountIds, resolveAccount, getConfig } from './config.js';
+import { Bitrix24Api } from './api.js';
+import { SendService } from './send-service.js';
+import { MediaService } from './media-service.js';
+import { InboundHandler } from './inbound-handler.js';
+import { PollingService } from './polling-service.js';
+import { normalizeAllowEntry, normalizeAllowList, checkAccessWithPairing, getWebhookUserId, } from './access-control.js';
+import { checkGroupAccessPassive, checkGroupAccessWithPairing, resolveAgentWatchRules, resolveGroupAccess, } from './group-access.js';
+import { DEFAULT_AVATAR_BASE64 } from './bot-avatar.js';
+import { Bitrix24ApiError, createVerboseLogger, defaultLogger, CHANNEL_PREFIX_RE } from './utils.js';
+import { getBitrix24Runtime } from './runtime.js';
+import { OPENCLAW_COMMANDS, buildCommandsHelpText, formatModelsCommandReply } from './commands.js';
+import { accessApproved, accessDenied, groupPairingPending, mediaDownloadFailed, groupChatUnsupported, onboardingMessage, ownerAndAllowedUsersOnly, personalBotOwnerOnly, watchOwnerDmNotice, } from './i18n.js';
+import { HistoryCache } from './history-cache.js';
+const PHASE_STATUS_DURATION_SECONDS = 8;
+const PHASE_STATUS_REFRESH_GRACE_MS = 1000;
+const THINKING_STATUS_DURATION_SECONDS = 30;
+const THINKING_STATUS_REFRESH_GRACE_MS = 6000;
+const DIRECT_TEXT_COALESCE_DEBOUNCE_MS = 200;
+const DIRECT_TEXT_COALESCE_MAX_WAIT_MS = 5000;
+const ACCESS_DENIED_NOTICE_COOLDOWN_MS = 60000;
+const AUTO_BOT_CODE_MAX_CANDIDATES = 100;
+const MEDIA_DOWNLOAD_CONCURRENCY = 2;
+const MAX_WEBHOOK_BODY_BYTES = 1024 * 1024;
+const DEFAULT_HISTORY_LIMIT = 100;
+const HISTORY_CACHE_MAX_KEYS = 1000;
+const HISTORY_CONTEXT_MARKER = '[Chat messages since your last reply - for context]';
+const CROSS_CHAT_HISTORY_LIMIT = 20;
+const ACCESS_DENIED_REACTION = 'crossMark';
+const BOT_MESSAGE_WATCH_REACTION = 'eyes';
+const FORWARDED_CONTEXT_RANGE = 5;
+const REGISTERED_COMMANDS = new Set(OPENCLAW_COMMANDS.map((command) => command.command));
+// ─── Emoji → B24 reaction code mapping ──────────────────────────────────
+// B24 uses named reaction codes, not Unicode emoji.
+// Map common Unicode emoji to their B24 equivalents.
+const EMOJI_TO_B24_REACTION = {
+    '👍': 'like',
+    '👎': 'dislike',
+    '😂': 'faceWithTearsOfJoy',
+    '❤️': 'redHeart',
+    '❤': 'redHeart',
+    '😐': 'neutralFace',
+    '🔥': 'fire',
+    '😢': 'cry',
+    '🙂': 'slightlySmilingFace',
+    '😉': 'winkingFace',
+    '😆': 'laugh',
+    '😘': 'kiss',
+    '😲': 'wonder',
+    '🙁': 'slightlyFrowningFace',
+    '😭': 'loudlyCryingFace',
+    '😛': 'faceWithStuckOutTongue',
+    '😜': 'faceWithStuckOutTongueAndWinkingEye',
+    '😎': 'smilingFaceWithSunglasses',
+    '😕': 'confusedFace',
+    '😳': 'flushedFace',
+    '🤔': 'thinkingFace',
+    '😠': 'angry',
+    '😈': 'smilingFaceWithHorns',
+    '🤒': 'faceWithThermometer',
+    '🤦': 'facepalm',
+    '💩': 'poo',
+    '💪': 'flexedBiceps',
+    '👏': 'clappingHands',
+    '🖐️': 'raisedHand',
+    '🖐': 'raisedHand',
+    '😍': 'smilingFaceWithHeartEyes',
+    '🥰': 'smilingFaceWithHearts',
+    '🥺': 'pleadingFace',
+    '😌': 'relievedFace',
+    '🙏': 'foldedHands',
+    '👌': 'okHand',
+    '🤘': 'signHorns',
+    '🤟': 'loveYouGesture',
+    '🤡': 'clownFace',
+    '🥳': 'partyingFace',
+    '❓': 'questionMark',
+    '❗': 'exclamationMark',
+    '💡': 'lightBulb',
+    '💣': 'bomb',
+    '💤': 'sleepingSymbol',
+    '❌': 'crossMark',
+    '✅': 'whiteHeavyCheckMark',
+    '👀': 'eyes',
+    '🤝': 'handshake',
+    '💯': 'hundredPoints',
+};
+// All valid B24 reaction codes (for pass-through when code is used directly)
+const B24_REACTION_CODES = new Set(Object.values(EMOJI_TO_B24_REACTION));
+/**
+ * Resolve an emoji or B24 reaction code to a valid B24 reaction code.
+ * Returns null if the emoji/code is not supported.
+ */
+function resolveB24Reaction(emojiOrCode) {
+    const trimmed = emojiOrCode.trim();
+    if (B24_REACTION_CODES.has(trimmed))
+        return trimmed;
+    return EMOJI_TO_B24_REACTION[trimmed] ?? null;
+}
+function toMessageId(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+function escapeBbCodeText(value) {
+    return value
+        .replace(/\[/g, '(')
+        .replace(/\]/g, ')');
+}
+function buildChatContextUrl(dialogId, messageId, chatName) {
+    const dialogParam = encodeURIComponent(dialogId);
+    const messageParam = encodeURIComponent(messageId);
+    const label = escapeBbCodeText(chatName);
+    return `[URL=/online/?IM_DIALOG=${dialogParam}&IM_MESSAGE=${messageParam}]${label}[/URL]`;
+}
+function buildTopicsBbCode(topics) {
+    if (!topics || topics.length === 0) {
+        return undefined;
+    }
+    return topics
+        .map((topic) => topic.trim())
+        .filter(Boolean)
+        .map((topic) => `[b]${escapeBbCodeText(topic)}[/b]`)
+        .join(', ');
+}
+function formatQuoteTimestamp(timestamp, language) {
+    const locale = (language ?? 'ru').toLowerCase().slice(0, 2);
+    const value = timestamp ?? Date.now();
+    try {
+        return new Intl.DateTimeFormat(locale, {
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+        }).format(new Date(value)).replace(',', '');
+    }
+    catch {
+        return new Intl.DateTimeFormat('ru', {
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+        }).format(new Date(value)).replace(',', '');
+    }
+}
+function buildWatchQuoteText(params) {
+    const separator = '------------------------------------------------------';
+    const senderLine = `${escapeBbCodeText(params.senderName)} [${formatQuoteTimestamp(params.timestamp, params.language)}] ${params.anchor}`;
+    const body = escapeBbCodeText(params.body);
+    return [
+        separator,
+        senderLine,
+        body,
+        separator,
+    ].join('\n');
+}
+async function notifyStatus(sendService, sendCtx, config, statusMessageCode, duration = PHASE_STATUS_DURATION_SECONDS) {
+    if (config.showTyping === false)
+        return;
+    await sendService.sendStatus(sendCtx, statusMessageCode, duration);
+}
+function createReplyStatusHeartbeat(params) {
+    const { sendService, sendCtx, config } = params;
+    let timer = null;
+    let stopped = false;
+    let inFlight = false;
+    let activeTick = null;
+    let nextHeartbeatAt = Date.now();
+    const scheduleNext = () => {
+        if (stopped || config.showTyping === false)
+            return;
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        const delay = Math.max(0, nextHeartbeatAt - Date.now());
+        timer = setTimeout(() => {
+            void runTick();
+        }, delay);
+    };
+    const holdFor = (durationSeconds, graceMs = PHASE_STATUS_REFRESH_GRACE_MS) => {
+        const holdMs = Math.max(0, (durationSeconds * 1000) - graceMs);
+        const holdUntil = Date.now() + holdMs;
+        if (holdUntil > nextHeartbeatAt) {
+            nextHeartbeatAt = holdUntil;
+        }
+        if (timer) {
+            scheduleNext();
+        }
+    };
+    const runTick = () => {
+        const tick = (async () => {
+            if (stopped || inFlight || config.showTyping === false)
+                return;
+            if (Date.now() < nextHeartbeatAt) {
+                scheduleNext();
+                return;
+            }
+            inFlight = true;
+            try {
+                await notifyStatus(sendService, sendCtx, config, 'IMBOT_AGENT_ACTION_THINKING', THINKING_STATUS_DURATION_SECONDS);
+            }
+            finally {
+                inFlight = false;
+                nextHeartbeatAt = Date.now() + ((THINKING_STATUS_DURATION_SECONDS * 1000) - THINKING_STATUS_REFRESH_GRACE_MS);
+                scheduleNext();
+            }
+        })();
+        activeTick = tick;
+        void tick.finally(() => {
+            if (activeTick === tick) {
+                activeTick = null;
+            }
+        });
+        return tick;
+    };
+    return {
+        start: async () => {
+            if (stopped || timer || config.showTyping === false)
+                return;
+            if (Date.now() >= nextHeartbeatAt) {
+                await runTick();
+                return;
+            }
+            scheduleNext();
+        },
+        stop: () => {
+            stopped = true;
+            if (!timer)
+                return;
+            clearTimeout(timer);
+            timer = null;
+        },
+        stopAndWait: async () => {
+            stopped = true;
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            if (activeTick) {
+                await activeTick;
+            }
+        },
+        holdFor,
+    };
+}
+export function canCoalesceDirectMessage(msgCtx, config) {
+    return msgCtx.isDm
+        && config.dmPolicy !== 'pairing'
+        && msgCtx.media.length === 0
+        && !msgCtx.replyToMessageId
+        && !msgCtx.isForwarded
+        && msgCtx.text.trim().length > 0
+        && !msgCtx.text.trim().startsWith('/');
+}
+export function mergeBufferedDirectMessages(messages) {
+    const first = messages[0];
+    const last = messages[messages.length - 1];
+    return {
+        ...first,
+        text: messages
+            .map((message) => message.text.trim())
+            .filter(Boolean)
+            .join('\n'),
+        messageId: last.messageId,
+        language: last.language ?? first.language,
+        raw: last.raw,
+    };
+}
+export function mergeForwardedMessageContext(previousMsgCtx, forwardedMsgCtx) {
+    const previousText = previousMsgCtx.text.trim();
+    const forwardedText = forwardedMsgCtx.text.trim();
+    const mergedText = [
+        previousText ? '[User question about the forwarded message]' : '',
+        previousText,
+        previousText ? '[/User question]' : '',
+        forwardedText,
+    ].filter(Boolean).join('\n\n');
+    return {
+        ...forwardedMsgCtx,
+        text: mergedText,
+        media: [...previousMsgCtx.media, ...forwardedMsgCtx.media],
+        language: forwardedMsgCtx.language ?? previousMsgCtx.language,
+        replyToMessageId: undefined,
+        isForwarded: false,
+    };
+}
+export function resolveDirectMessageCoalesceDelay(params) {
+    const debounceMs = params.debounceMs ?? DIRECT_TEXT_COALESCE_DEBOUNCE_MS;
+    const maxWaitMs = params.maxWaitMs ?? DIRECT_TEXT_COALESCE_MAX_WAIT_MS;
+    const elapsedMs = Math.max(0, params.now - params.startedAt);
+    const remainingMs = Math.max(0, maxWaitMs - elapsedMs);
+    return Math.min(debounceMs, remainingMs);
+}
+export function shouldSkipJoinChatWelcome(params) {
+    if (!params.dialogId) {
+        return false;
+    }
+    if (params.chatType === 'chat' || params.chatType === 'open') {
+        return false;
+    }
+    const policy = params.dmPolicy ?? 'webhookUser';
+    const webhookUserId = getWebhookUserId(params.webhookUrl);
+    return policy === 'webhookUser'
+        && Boolean(webhookUserId)
+        && normalizeAllowEntry(params.dialogId) !== webhookUserId;
+}
+async function mapWithConcurrency(items, concurrency, worker) {
+    if (items.length === 0) {
+        return [];
+    }
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    const poolSize = Math.max(1, Math.min(concurrency, items.length));
+    const runners = Array.from({ length: poolSize }, async () => {
+        while (nextIndex < items.length) {
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+            results[currentIndex] = await worker(items[currentIndex], currentIndex);
+        }
+    });
+    await Promise.all(runners);
+    return results;
+}
+function resolveSecurityConfig(params) {
+    if (params.account?.config) {
+        return params.account.config;
+    }
+    if (params.cfg) {
+        return resolveAccount(params.cfg, params.accountId).config;
+    }
+    return {};
+}
+function resolveHistoryLimit(config) {
+    return Math.max(0, config.historyLimit ?? DEFAULT_HISTORY_LIMIT);
+}
+export function resolveConversationRef(params) {
+    const dialogId = String(params.dialogId);
+    return {
+        dialogId,
+        address: `bitrix24:${dialogId}`,
+        historyKey: `${params.accountId}:${dialogId}`,
+        peer: {
+            kind: params.isDirect ? 'direct' : 'group',
+            id: dialogId,
+        },
+    };
+}
+export function buildConversationSessionKey(routeSessionKey, conversation) {
+    return `${routeSessionKey}:${conversation.address}`;
+}
+function buildHistoryBody(msgCtx) {
+    const text = msgCtx.text.trim();
+    if (text) {
+        return text;
+    }
+    if (msgCtx.media.length === 0) {
+        return '';
+    }
+    const hasImage = msgCtx.media.some((mediaItem) => mediaItem.type === 'image');
+    return hasImage ? '<media:image>' : '<media:document>';
+}
+function buildConversationMeta(msgCtx) {
+    return {
+        dialogId: msgCtx.chatId,
+        chatId: msgCtx.chatInternalId,
+        chatName: msgCtx.chatName,
+        chatType: msgCtx.chatType,
+        isGroup: msgCtx.isGroup,
+        lastActivityAt: msgCtx.timestamp ?? Date.now(),
+    };
+}
+function appendMessageToHistory(params) {
+    const historyBody = (params.body ?? buildHistoryBody(params.msgCtx)).trim();
+    if (!historyBody) {
+        return;
+    }
+    params.historyCache.append({
+        key: params.historyKey,
+        limit: params.historyLimit,
+        entry: {
+            messageId: params.msgCtx.messageId,
+            sender: params.msgCtx.senderName,
+            senderId: params.msgCtx.senderId,
+            body: historyBody,
+            timestamp: params.msgCtx.timestamp ?? Date.now(),
+            wasMentioned: params.msgCtx.wasMentioned,
+            eventScope: params.msgCtx.eventScope ?? 'bot',
+        },
+        meta: buildConversationMeta(params.msgCtx),
+    });
+}
+function formatHistoryEntry(params) {
+    const idSuffix = params.messageId ? ` [id:${params.messageId}]` : '';
+    return `[${params.sender}] ${params.body}${idSuffix}`;
+}
+function buildHistoryContext(params) {
+    if (params.entries.length === 0) {
+        return params.currentBody;
+    }
+    const historyText = params.entries
+        .map((entry) => formatHistoryEntry(entry))
+        .join('\n');
+    return [
+        HISTORY_CONTEXT_MARKER,
+        historyText,
+        '',
+        params.currentBody,
+    ].join('\n');
+}
+function formatReplyContext(params) {
+    if (!params.replyEntry) {
+        return params.body;
+    }
+    return [
+        params.body,
+        '',
+        `[Replying to ${params.replyEntry.sender} id:${params.replyEntry.messageId}]`,
+        params.replyEntry.body,
+        '[/Replying]',
+    ].filter(Boolean).join('\n');
+}
+function resolveFetchedUserName(usersById, authorId) {
+    return usersById.get(authorId)?.name?.trim() || `User ${authorId}`;
+}
+function resolveFetchedMessageBody(text) {
+    const trimmed = text.trim();
+    return trimmed.length > 0 ? trimmed : '<empty message>';
+}
+function formatFetchedForwardContext(params) {
+    const usersById = new Map(params.context.users.map((user) => [user.id, user]));
+    const lines = params.context.messages
+        .filter((message) => message.id !== params.currentMessageId)
+        .map((message) => {
+        const sender = resolveFetchedUserName(usersById, message.authorId);
+        const body = resolveFetchedMessageBody(message.text);
+        return `[${sender} id:${message.id}] ${body}`;
+    })
+        .filter(Boolean);
+    if (lines.length === 0) {
+        return '';
+    }
+    return [
+        '[Bitrix24 surrounding context around this forwarded message - not the forwarded message body]',
+        ...lines,
+        '[/Bitrix24 surrounding context]',
+    ].join('\n');
+}
+function extractMentionedChatIds(text) {
+    const matches = [...text.matchAll(/\[CHAT=(?:chat)?(\d+)(?:[^\]]*)\][\s\S]*?\[\/CHAT\]/gi)];
+    return [...new Set(matches.map((match) => match[1]).filter(Boolean))];
+}
+function formatReferencedGroupHistory(params) {
+    const chatId = params.conversation.chatId ?? params.conversation.dialogId.replace(/^chat/i, '');
+    const chatName = params.conversation.chatName ?? params.conversation.dialogId;
+    const header = `[Visible group chat history: [CHAT=${chatId}]${chatName}[/CHAT]]`;
+    if (params.entries.length === 0) {
+        return [
+            header,
+            'No messages from this chat are currently available in RAM memory.',
+        ].join('\n');
+    }
+    return [
+        header,
+        ...params.entries.map((entry) => formatHistoryEntry(entry)),
+    ].join('\n');
+}
+function buildCrossChatMemoryContext(params) {
+    const chatMentions = extractMentionedChatIds(params.query);
+    if (chatMentions.length === 0) {
+        return undefined;
+    }
+    const visibleGroupChats = params.historyCache
+        .listConversations()
+        .filter((conversation) => conversation.isGroup)
+        .sort((left, right) => (right.lastActivityAt ?? 0) - (left.lastActivityAt ?? 0));
+    const referencedChats = visibleGroupChats.filter((conversation) => {
+        const chatId = conversation.chatId ?? '';
+        return chatMentions.includes(chatId);
+    });
+    const sections = [];
+    if (referencedChats.length > 0) {
+        sections.push(...referencedChats.map((conversation) => formatReferencedGroupHistory({
+            conversation,
+            entries: params.historyCache.get(conversation.key, CROSS_CHAT_HISTORY_LIMIT),
+        })));
+    }
+    else if (chatMentions.length > 0) {
+        sections.push('[Referenced group chats]\nThe requested group chat mention is not available in RAM memory right now.');
+    }
+    return [
+        '[OpenClaw cross-chat memory]',
+        'The following Bitrix24 group chat memory is already available to you from RAM history.',
+        'Use it as trusted context for your answer.',
+        'Do not say that you only see the current chat if chats or messages are listed below.',
+        'Do not call tools to list chats when this memory block already contains the answer.',
+        '',
+        '[BEGIN OPENCLAW CROSS-CHAT MEMORY]',
+        sections.join('\n\n'),
+        '[END OPENCLAW CROSS-CHAT MEMORY]',
+    ].join('\n');
+}
+function buildAccessDeniedNotice(lang, policy, params) {
+    const effectivePolicy = policy ?? 'webhookUser';
+    if (effectivePolicy === 'webhookUser') {
+        return personalBotOwnerOnly(lang);
+    }
+    if (params?.hasAllowList) {
+        return ownerAndAllowedUsersOnly(lang);
+    }
+    return accessDenied(lang);
+}
+function normalizeTopicText(text) {
+    return text.toLowerCase().replace(/\s+/g, ' ').trim();
+}
+function tokenizeTopicText(text) {
+    return normalizeTopicText(text)
+        .split(/[^a-zа-яё0-9]+/i)
+        .filter(Boolean);
+}
+function matchesWatchTopic(messageText, topic) {
+    const normalizedMessage = normalizeTopicText(messageText);
+    const normalizedTopic = normalizeTopicText(topic);
+    if (!normalizedMessage || !normalizedTopic) {
+        return false;
+    }
+    if (normalizedMessage.includes(normalizedTopic)) {
+        return true;
+    }
+    const messageTokens = tokenizeTopicText(messageText);
+    const topicTokens = tokenizeTopicText(topic);
+    return topicTokens.length > 0
+        && topicTokens.every((topicToken) => messageTokens.some((messageToken) => messageToken.startsWith(topicToken)));
+}
+function findMatchingWatchRule(msgCtx, watchRules) {
+    if (!Array.isArray(watchRules) || watchRules.length === 0) {
+        return undefined;
+    }
+    const senderId = normalizeAllowEntry(msgCtx.senderId);
+    return watchRules.find((rule) => {
+        const ruleUserId = normalizeAllowEntry(rule.userId);
+        if (ruleUserId !== '*' && ruleUserId !== senderId) {
+            return false;
+        }
+        if (!Array.isArray(rule.topics) || rule.topics.length === 0) {
+            return true;
+        }
+        return rule.topics.some((topic) => matchesWatchTopic(msgCtx.text, topic));
+    });
+}
+class BufferedDirectMessageCoalescer {
+    entries = new Map();
+    debounceMs;
+    maxWaitMs;
+    onFlush;
+    logger;
+    destroyed = false;
+    constructor(params) {
+        this.debounceMs = params.debounceMs;
+        this.maxWaitMs = params.maxWaitMs;
+        this.onFlush = params.onFlush;
+        this.logger = params.logger;
+    }
+    enqueue(accountId, msgCtx) {
+        const key = this.getKey(accountId, msgCtx.chatId);
+        const current = this.entries.get(key);
+        if (current) {
+            clearTimeout(current.timer);
+            current.messages.push(msgCtx);
+            current.timer = this.createTimer(key, current.startedAt);
+            this.logger.debug('Buffered direct message appended', {
+                chatId: msgCtx.chatId,
+                bufferedCount: current.messages.length,
+            });
+            return;
+        }
+        const startedAt = Date.now();
+        this.entries.set(key, {
+            messages: [msgCtx],
+            startedAt,
+            timer: this.createTimer(key, startedAt),
+        });
+        this.logger.debug('Buffered direct message started', { chatId: msgCtx.chatId });
+    }
+    async flush(accountId, dialogId) {
+        await this.flushKey(this.getKey(accountId, dialogId));
+    }
+    take(accountId, dialogId) {
+        const key = this.getKey(accountId, dialogId);
+        const entry = this.entries.get(key);
+        if (!entry)
+            return null;
+        clearTimeout(entry.timer);
+        this.entries.delete(key);
+        this.logger.debug('Taking buffered direct messages', {
+            chatId: dialogId,
+            bufferedCount: entry.messages.length,
+        });
+        return entry.messages.length === 1
+            ? entry.messages[0]
+            : mergeBufferedDirectMessages(entry.messages);
+    }
+    async flushAll() {
+        for (const key of [...this.entries.keys()]) {
+            await this.flushKey(key);
+        }
+    }
+    destroy() {
+        this.destroyed = true;
+        for (const entry of this.entries.values()) {
+            clearTimeout(entry.timer);
+        }
+        this.entries.clear();
+    }
+    getKey(accountId, dialogId) {
+        return `${accountId}:${dialogId}`;
+    }
+    createTimer(key, startedAt) {
+        const delayMs = resolveDirectMessageCoalesceDelay({
+            startedAt,
+            now: Date.now(),
+            debounceMs: this.debounceMs,
+            maxWaitMs: this.maxWaitMs,
+        });
+        return setTimeout(() => {
+            void this.flushKey(key);
+        }, delayMs);
+    }
+    async flushKey(key) {
+        const entry = this.entries.get(key);
+        if (!entry || this.destroyed)
+            return;
+        clearTimeout(entry.timer);
+        this.entries.delete(key);
+        const msgCtx = entry.messages.length === 1
+            ? entry.messages[0]
+            : mergeBufferedDirectMessages(entry.messages);
+        try {
+            this.logger.debug('Flushing buffered direct messages', {
+                chatId: msgCtx.chatId,
+                bufferedCount: entry.messages.length,
+            });
+            await this.onFlush(msgCtx);
+        }
+        catch (err) {
+            this.logger.error('Failed to flush buffered direct messages', err);
+        }
+    }
+}
+let gatewayState = null;
+export function __setGatewayStateForTests(state) {
+    gatewayState = state;
+}
+// ─── Default command keyboard ────────────────────────────────────────────────
+/** Default keyboard shown with command responses and welcome messages. */
+export const DEFAULT_COMMAND_KEYBOARD = [
+    { TEXT: 'Help', COMMAND: 'help', BG_COLOR_TOKEN: 'primary', DISPLAY: 'LINE' },
+    { TEXT: 'Status', COMMAND: 'status', DISPLAY: 'LINE' },
+    { TEXT: 'Commands', COMMAND: 'commands', DISPLAY: 'LINE' },
+    { TYPE: 'NEWLINE' },
+    { TEXT: 'New session', COMMAND: 'new', DISPLAY: 'LINE' },
+    { TEXT: 'Models', COMMAND: 'models', DISPLAY: 'LINE' },
+];
+function parseRegisteredCommandTrigger(callbackData) {
+    const trimmed = callbackData.trim();
+    const isSlashCommand = trimmed.startsWith('/');
+    const normalized = trimmed.replace(/^\/+/, '');
+    if (!normalized) {
+        return undefined;
+    }
+    const [commandName, ...params] = normalized.split(/\s+/);
+    if (!isSlashCommand && !REGISTERED_COMMANDS.has(commandName)) {
+        return undefined;
+    }
+    return {
+        command: commandName,
+        ...(params.length > 0 ? { commandParams: params.join(' ') } : {}),
+    };
+}
+/**
+ * Convert OpenClaw button rows to B24 flat KEYBOARD array.
+ */
+export function convertButtonsToKeyboard(input) {
+    // Normalize: accept both [[btn, btn], [btn]] (rows) and [btn, btn] (flat)
+    const isNested = input.length > 0 && Array.isArray(input[0]);
+    const rows = isNested
+        ? input
+        : [input];
+    const keyboard = [];
+    for (let i = 0; i < rows.length; i++) {
+        for (const btn of rows[i]) {
+            const b24Btn = { TEXT: btn.text, DISPLAY: 'LINE' };
+            const parsedCommand = btn.callback_data
+                ? parseRegisteredCommandTrigger(btn.callback_data)
+                : undefined;
+            if (parsedCommand) {
+                b24Btn.COMMAND = parsedCommand.command;
+                if (parsedCommand.commandParams) {
+                    b24Btn.COMMAND_PARAMS = parsedCommand.commandParams;
+                }
+            }
+            else if (btn.callback_data) {
+                b24Btn.ACTION = 'SEND';
+                // Always use button text as ACTION_VALUE so the user sees readable text in chat,
+                // not opaque English identifiers like "answer_piano"
+                b24Btn.ACTION_VALUE = btn.text;
+            }
+            if (btn.style === 'primary') {
+                b24Btn.BG_COLOR_TOKEN = 'primary';
+            }
+            else if (btn.style === 'attention' || btn.style === 'danger') {
+                b24Btn.BG_COLOR_TOKEN = 'alert';
+            }
+            keyboard.push(b24Btn);
+        }
+        if (i < rows.length - 1) {
+            keyboard.push({ TYPE: 'NEWLINE' });
+        }
+    }
+    return keyboard;
+}
+/**
+ * Extract B24 keyboard from a dispatcher payload's channelData.
+ */
+export function extractKeyboardFromPayload(payload) {
+    const cd = payload.channelData;
+    if (!cd)
+        return undefined;
+    const b24Data = cd.bitrix24;
+    if (b24Data?.keyboard?.length) {
+        return b24Data.keyboard;
+    }
+    const tgData = cd.telegram;
+    if (tgData?.buttons?.length) {
+        return convertButtonsToKeyboard(tgData.buttons);
+    }
+    return undefined;
+}
+/**
+ * Extract inline button JSON embedded in message text by the agent.
+ *
+ * Agents (especially GPT-4o) sometimes embed button markup directly in text
+ * as `[[{...},{...}]]` instead of using tool call parameters.
+ * This function detects such patterns, extracts the keyboard, and returns
+ * cleaned text without the JSON fragment.
+ */
+export function extractInlineButtonsFromText(text) {
+    // Match [[...]] containing JSON array of button objects
+    const match = text.match(/\[\[\s*(\{[\s\S]*?\}(?:\s*,\s*\{[\s\S]*?\})*)\s*\]\]/);
+    if (!match)
+        return undefined;
+    try {
+        const parsed = JSON.parse(`[${match[1]}]`);
+        if (!Array.isArray(parsed) || parsed.length === 0)
+            return undefined;
+        // Validate it looks like button objects (must have "text" property)
+        if (!parsed.every((b) => typeof b === 'object' && b !== null && 'text' in b))
+            return undefined;
+        // Wrap in rows array (single row)
+        const buttons = [parsed];
+        const keyboard = convertButtonsToKeyboard(buttons);
+        const cleanText = text.replace(match[0], '').trim();
+        return { cleanText, keyboard };
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizeCommandReplyPayload(params) {
+    const { commandName, commandParams, text, language } = params;
+    if (commandName === 'models' && commandParams.trim() === '') {
+        const formattedText = formatModelsCommandReply(text, language);
+        if (formattedText) {
+            return { text: formattedText, convertMarkdown: false };
+        }
+    }
+    return { text };
+}
+/**
+ * Determine effective event mode from config.
+ */
+function resolveEventMode(config) {
+    return config.eventMode ?? (config.callbackUrl ? 'webhook' : 'fetch');
+}
+/**
+ * Generate a stable botToken from webhookUrl if not configured.
+ */
+function resolveBotToken(config) {
+    if (config.botToken)
+        return config.botToken;
+    if (!config.webhookUrl)
+        return null;
+    // Derive a stable token from webhookUrl (md5, max 32 chars — platform limit)
+    return createHash('md5').update(config.webhookUrl).digest('hex');
+}
+export function buildBotCodeCandidates(config, maxCandidates = AUTO_BOT_CODE_MAX_CANDIDATES) {
+    if (config.botCode) {
+        return [config.botCode];
+    }
+    const webhookUserId = getWebhookUserId(config.webhookUrl);
+    const baseCode = webhookUserId ? `openclaw_${webhookUserId}` : 'openclaw';
+    const safeMaxCandidates = Math.max(1, maxCandidates);
+    return Array.from({ length: safeMaxCandidates }, (_value, index) => {
+        return index === 0 ? baseCode : `${baseCode}_${index + 1}`;
+    });
+}
+function isBotCodeAlreadyTakenError(error) {
+    return error instanceof Bitrix24ApiError && error.code === 'BOT_CODE_ALREADY_TAKEN';
+}
+function isFreshBotRegistration(bot) {
+    return ((bot.countMessage ?? 0) === 0 &&
+        (bot.countCommand ?? 0) === 0 &&
+        (bot.countChat ?? 0) === 0 &&
+        (bot.countUser ?? 0) === 0);
+}
+async function sendInitialWelcomeToWebhookOwner(params) {
+    const { config, bot, sendService, language, welcomedDialogs, logger } = params;
+    const ownerId = getWebhookUserId(config.webhookUrl);
+    if (!ownerId || !config.webhookUrl || welcomedDialogs.has(ownerId)) {
+        return;
+    }
+    const sendCtx = {
+        webhookUrl: config.webhookUrl,
+        bot,
+        dialogId: ownerId,
+    };
+    const isPairing = config.dmPolicy === 'pairing';
+    const text = onboardingMessage(language, config.botName ?? 'OpenClaw', config.dmPolicy);
+    const options = isPairing ? undefined : { keyboard: DEFAULT_COMMAND_KEYBOARD };
+    try {
+        await sendService.sendText(sendCtx, text, options);
+        welcomedDialogs.add(ownerId);
+        logger.info('Initial welcome sent to webhook owner', {
+            dialogId: ownerId,
+            language: language ?? 'en',
+        });
+    }
+    catch (err) {
+        logger.warn('Failed to send initial welcome to webhook owner', err);
+    }
+}
+/**
+ * Register or update the bot using imbot.v2.Bot.register / Bot.update.
+ */
+async function ensureBotRegistered(api, config, botToken, eventMode, logger) {
+    const { webhookUrl, callbackUrl, botName } = config;
+    if (!webhookUrl)
+        return null;
+    if (eventMode === 'webhook' && !callbackUrl) {
+        logger.warn('callbackUrl not configured for webhook mode — skipping bot registration');
+        return null;
+    }
+    const name = botName ?? 'OpenClaw';
+    const botCodeCandidates = buildBotCodeCandidates(config);
+    // Check if bot already exists via imbot.v2.Bot.list
+    try {
+        const listResult = await api.listBots(webhookUrl, botToken);
+        const existing = botCodeCandidates
+            .map((candidate) => listResult.bots.find((botItem) => botItem.code === candidate))
+            .find(Boolean);
+        if (existing) {
+            logger.info(`Bot "${existing.code}" already registered (ID=${existing.id}), updating`);
+            const bot = { botId: existing.id, botToken };
+            const updateFields = {
+                properties: {
+                    name,
+                    workPosition: 'AI Assistant',
+                    avatar: config.botAvatar || DEFAULT_AVATAR_BASE64,
+                },
+                eventMode,
+            };
+            if (eventMode === 'webhook' && callbackUrl) {
+                updateFields.webhookUrl = callbackUrl;
+            }
+            await api.updateBot(webhookUrl, bot, updateFields);
+            return {
+                botId: existing.id,
+                language: existing.language,
+                isNew: false,
+            };
+        }
+    }
+    catch (err) {
+        logger.warn('Failed to list existing bots, will try to register', err);
+    }
+    // Register new bot via imbot.v2.Bot.register
+    for (const code of botCodeCandidates) {
+        try {
+            const registerFields = {
+                code,
+                properties: {
+                    name,
+                    workPosition: 'AI Assistant',
+                    avatar: config.botAvatar || DEFAULT_AVATAR_BASE64,
+                },
+                type: 'personal',
+                eventMode,
+            };
+            if (eventMode === 'webhook' && callbackUrl) {
+                registerFields.webhookUrl = callbackUrl;
+            }
+            const result = await api.registerBot(webhookUrl, botToken, registerFields);
+            logger.info(`Bot "${code}" registered in ${eventMode} mode (ID=${result.bot.id})`);
+            return {
+                botId: result.bot.id,
+                language: result.bot.language,
+                isNew: isFreshBotRegistration(result.bot),
+            };
+        }
+        catch (err) {
+            if (!config.botCode && isBotCodeAlreadyTakenError(err)) {
+                logger.warn(`Bot code "${code}" already taken, trying next candidate`);
+                continue;
+            }
+            logger.error('Failed to register bot', err);
+            return null;
+        }
+    }
+    logger.error('Failed to register bot: exhausted automatic bot code candidates');
+    return null;
+}
+/**
+ * Register OpenClaw slash commands with imbot.v2.Command.register.
+ * V2 Command.register is idempotent and doesn't need EVENT_COMMAND_ADD URL.
+ */
+async function ensureCommandsRegistered(api, config, bot, logger) {
+    const { webhookUrl } = config;
+    if (!webhookUrl)
+        return;
+    let registered = 0;
+    let skipped = 0;
+    for (const cmd of OPENCLAW_COMMANDS) {
+        try {
+            await api.registerCommand(webhookUrl, bot, {
+                command: cmd.command,
+                title: { en: cmd.en, ru: cmd.ru },
+                ...(cmd.params ? { params: { en: cmd.params, ru: cmd.params } } : {}),
+            });
+            registered++;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes('WRONG_REQUEST') || msg.includes('already')) {
+                skipped++;
+            }
+            else {
+                logger.warn(`Failed to register command /${cmd.command}`, err);
+            }
+        }
+    }
+    logger.info(`Commands sync: ${registered} registered, ${skipped} already existed (total ${OPENCLAW_COMMANDS.length})`);
+}
+/**
+ * Handle an incoming HTTP request on the webhook route (V2 webhook mode).
+ */
+export async function handleWebhookRequest(req, res) {
+    if (req.method !== 'POST') {
+        res.statusCode = 405;
+        res.end('Method Not Allowed');
+        return;
+    }
+    if (!gatewayState) {
+        res.statusCode = 503;
+        res.end('Channel not started');
+        return;
+    }
+    if (gatewayState.eventMode === 'fetch') {
+        res.statusCode = 200;
+        res.end('FETCH mode active');
+        return;
+    }
+    // Read raw body
+    const chunks = [];
+    let bodySize = 0;
+    for await (const chunk of req) {
+        const buffer = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+        chunks.push(buffer);
+        bodySize += buffer.length;
+        if (bodySize > MAX_WEBHOOK_BODY_BYTES) {
+            res.statusCode = 413;
+            res.end('Payload Too Large');
+            req.destroy();
+            return;
+        }
+    }
+    const body = Buffer.concat(chunks).toString('utf-8');
+    try {
+        const handled = await gatewayState.inboundHandler.handleWebhook(body);
+        if (!handled) {
+            res.statusCode = 400;
+            res.end('Invalid webhook payload');
+            return;
+        }
+        res.statusCode = 200;
+        res.setHeader('Content-Type', 'application/json');
+        res.end(JSON.stringify({ status: 'ok' }));
+    }
+    catch (err) {
+        defaultLogger.error('Error handling Bitrix24 V2 webhook', err);
+        res.statusCode = 500;
+        res.end('Webhook processing failed');
+    }
+}
+// ─── Outbound adapter helpers ────────────────────────────────────────────────
+function resolveOutboundSendCtx(params) {
+    const { config } = resolveAccount(params.cfg, params.accountId);
+    if (!config.webhookUrl || !gatewayState)
+        return null;
+    return {
+        webhookUrl: config.webhookUrl,
+        bot: gatewayState.bot,
+        dialogId: params.to,
+    };
+}
+function collectOutboundMediaUrls(input) {
+    const mediaUrls = [];
+    if (input.mediaUrl) {
+        mediaUrls.push(input.mediaUrl);
+    }
+    if (input.payload?.mediaUrl) {
+        mediaUrls.push(input.payload.mediaUrl);
+    }
+    if (Array.isArray(input.payload?.mediaUrls)) {
+        mediaUrls.push(...input.payload.mediaUrls.filter((item) => typeof item === 'string'));
+    }
+    return [...new Set(mediaUrls)];
+}
+async function uploadOutboundMedia(params) {
+    let lastMessageId = '';
+    let message = params.initialMessage;
+    for (const mediaUrl of params.mediaUrls) {
+        const result = await params.mediaService.uploadMediaToChat({
+            localPath: mediaUrl,
+            fileName: basename(mediaUrl),
+            webhookUrl: params.sendCtx.webhookUrl,
+            bot: params.sendCtx.bot,
+            dialogId: params.sendCtx.dialogId,
+            message: message || undefined,
+        });
+        if (!result.ok) {
+            throw new Error(`Failed to upload media: ${basename(mediaUrl)}`);
+        }
+        if (result.messageId) {
+            lastMessageId = String(result.messageId);
+        }
+        message = undefined;
+    }
+    return lastMessageId;
+}
+/**
+ * The Bitrix24 channel plugin object.
+ */
+export const bitrix24Plugin = {
+    id: 'bitrix24',
+    meta: {
+        id: 'bitrix24',
+        label: 'Bitrix24',
+        selectionLabel: 'Bitrix24 (Messenger)',
+        docsPath: '/channels/bitrix24',
+        docsLabel: 'bitrix24',
+        blurb: 'Connect to Bitrix24 Messenger via chat bot REST API (V2).',
+        aliases: ['b24', 'bx24'],
+    },
+    capabilities: {
+        chatTypes: ['direct', 'group'],
+        media: true,
+        reactions: true,
+        threads: false,
+        nativeCommands: true,
+        inlineButtons: 'all',
+    },
+    messaging: {
+        normalizeTarget: (raw) => raw.trim().replace(CHANNEL_PREFIX_RE, ''),
+        targetResolver: {
+            hint: 'Use a numeric chat/dialog ID, e.g. "1" or "chat42".',
+            looksLikeId: (raw, _normalized) => {
+                const stripped = raw.trim().replace(CHANNEL_PREFIX_RE, '');
+                return /^\d+$/.test(stripped);
+            },
+        },
+    },
+    config: {
+        listAccountIds: (cfg) => listAccountIds(cfg),
+        resolveAccount: (cfg, accountId) => resolveAccount(cfg, accountId),
+    },
+    security: {
+        resolveDmPolicy: (params) => {
+            const securityConfig = resolveSecurityConfig(params);
+            const policy = securityConfig.dmPolicy ?? 'webhookUser';
+            return {
+                policy,
+                allowFrom: normalizeAllowList(securityConfig.allowFrom),
+                policyPath: 'channels.bitrix24.dmPolicy',
+                allowFromPath: 'channels.bitrix24.allowFrom',
+                approveHint: 'openclaw pairing approve bitrix24 <CODE>',
+                normalizeEntry: (raw) => raw.replace(CHANNEL_PREFIX_RE, ''),
+            };
+        },
+        normalizeAllowFrom: (entry) => entry.replace(CHANNEL_PREFIX_RE, ''),
+    },
+    pairing: {
+        idLabel: 'bitrix24UserId',
+        normalizeAllowEntry: (entry) => normalizeAllowEntry(entry),
+        notifyApproval: async (params) => {
+            const { config: acctCfg } = resolveAccount(params.cfg);
+            if (!acctCfg.webhookUrl || !gatewayState)
+                return;
+            const sendCtx = {
+                webhookUrl: acctCfg.webhookUrl,
+                bot: gatewayState.bot,
+                dialogId: params.id,
+            };
+            try {
+                await gatewayState.sendService.sendText(sendCtx, `\u2705 ${accessApproved(undefined)}`);
+            }
+            catch (err) {
+                defaultLogger.warn('Failed to notify approved Bitrix24 user', err);
+            }
+        },
+    },
+    outbound: {
+        deliveryMode: 'direct',
+        textChunkLimit: 4000,
+        sendText: async (ctx) => {
+            const sendCtx = resolveOutboundSendCtx(ctx);
+            if (!sendCtx || !gatewayState)
+                throw new Error('Bitrix24 gateway not started');
+            // Agent may embed button JSON in text as [[{...}]]
+            let text = ctx.text;
+            let keyboard;
+            const extracted = extractInlineButtonsFromText(text);
+            if (extracted) {
+                text = extracted.cleanText;
+                keyboard = extracted.keyboard;
+            }
+            const result = await gatewayState.sendService.sendText(sendCtx, text, keyboard ? { keyboard } : undefined);
+            return { messageId: String(result.messageId ?? '') };
+        },
+        sendMedia: async (ctx) => {
+            const sendCtx = resolveOutboundSendCtx(ctx);
+            if (!sendCtx || !gatewayState)
+                throw new Error('Bitrix24 gateway not started');
+            const mediaUrls = collectOutboundMediaUrls({ mediaUrl: ctx.mediaUrl });
+            if (mediaUrls.length > 0) {
+                const messageId = await uploadOutboundMedia({
+                    mediaService: gatewayState.mediaService,
+                    sendCtx,
+                    mediaUrls,
+                    initialMessage: ctx.text,
+                });
+                return { messageId };
+            }
+            if (ctx.text) {
+                const result = await gatewayState.sendService.sendText(sendCtx, ctx.text);
+                return { messageId: String(result.messageId ?? '') };
+            }
+            return { messageId: '' };
+        },
+        sendPayload: async (ctx) => {
+            const sendCtx = resolveOutboundSendCtx(ctx);
+            if (!sendCtx || !gatewayState)
+                throw new Error('Bitrix24 gateway not started');
+            const keyboard = ctx.payload?.channelData
+                ? extractKeyboardFromPayload({ channelData: ctx.payload.channelData })
+                : undefined;
+            const mediaUrls = collectOutboundMediaUrls({
+                mediaUrl: ctx.mediaUrl,
+                payload: ctx.payload,
+            });
+            if (mediaUrls.length > 0) {
+                const uploadedMessageId = await uploadOutboundMedia({
+                    mediaService: gatewayState.mediaService,
+                    sendCtx,
+                    mediaUrls,
+                });
+                if (ctx.text) {
+                    const result = await gatewayState.sendService.sendText(sendCtx, ctx.text, keyboard ? { keyboard } : undefined);
+                    return { messageId: String(result.messageId ?? uploadedMessageId) };
+                }
+                return { messageId: uploadedMessageId };
+            }
+            if (ctx.text) {
+                const result = await gatewayState.sendService.sendText(sendCtx, ctx.text, keyboard ? { keyboard } : undefined);
+                return { messageId: String(result.messageId ?? '') };
+            }
+            return { messageId: '' };
+        },
+    },
+    // ─── Actions (agent-driven: reactions, etc.) ────────────────────────────
+    actions: {
+        listActions: (_params) => {
+            return ['react', 'send'];
+        },
+        supportsAction: (params) => {
+            return params.action === 'react' || params.action === 'send';
+        },
+        handleAction: async (ctx) => {
+            // Helper: wrap payload as gateway-compatible tool result
+            const toolResult = (payload) => ({
+                content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+                details: payload,
+            });
+            // ─── Send with buttons ──────────────────────────────────────────────
+            if (ctx.action === 'send') {
+                // Only intercept send when buttons are present; otherwise let gateway handle normally
+                const rawButtons = ctx.params.buttons;
+                if (!rawButtons)
+                    return null;
+                const { config } = resolveAccount(ctx.cfg, ctx.accountId);
+                if (!config.webhookUrl || !gatewayState)
+                    return null;
+                const bot = gatewayState.bot;
+                const to = String(ctx.params.to ?? ctx.to ?? '').trim();
+                if (!to) {
+                    defaultLogger.warn('handleAction send: no "to" in params or ctx, falling back to gateway');
+                    return null;
+                }
+                const sendCtx = { webhookUrl: config.webhookUrl, bot, dialogId: to };
+                const message = String(ctx.params.message ?? '').trim();
+                // Parse buttons: may be array or JSON string
+                let buttons;
+                try {
+                    const parsed = typeof rawButtons === 'string' ? JSON.parse(rawButtons) : rawButtons;
+                    if (Array.isArray(parsed))
+                        buttons = parsed;
+                }
+                catch {
+                    // invalid buttons JSON — send without keyboard
+                }
+                const keyboard = buttons?.length ? convertButtonsToKeyboard(buttons) : undefined;
+                try {
+                    const result = await gatewayState.sendService.sendText(sendCtx, message || ' ', keyboard ? { keyboard } : undefined);
+                    return toolResult({
+                        channel: 'bitrix24',
+                        to,
+                        via: 'direct',
+                        mediaUrl: null,
+                        result: { messageId: String(result.messageId ?? '') },
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    return toolResult({ ok: false, error: errMsg });
+                }
+            }
+            // ─── React ────────────────────────────────────────────────────────────
+            if (ctx.action !== 'react')
+                return null;
+            const { config } = resolveAccount(ctx.cfg, ctx.accountId);
+            if (!config.webhookUrl || !gatewayState) {
+                return toolResult({ ok: false, reason: 'not_started', hint: 'Bitrix24 gateway not started. Do not retry.' });
+            }
+            const bot = gatewayState.bot;
+            const api = gatewayState.api;
+            const params = ctx.params;
+            // Resolve messageId: explicit param → toolContext.currentMessageId fallback
+            const toolContext = ctx.toolContext;
+            const rawMessageId = params.messageId ?? params.message_id ?? toolContext?.currentMessageId;
+            const messageId = Number(rawMessageId);
+            if (!Number.isFinite(messageId) || messageId <= 0) {
+                return toolResult({ ok: false, reason: 'missing_message_id', hint: 'Valid messageId is required for Bitrix24 reactions. Do not retry.' });
+            }
+            const emoji = String(params.emoji ?? '').trim();
+            const remove = params.remove === true || params.remove === 'true';
+            if (remove) {
+                // Remove reaction — need to know which one
+                const reactionCode = emoji ? resolveB24Reaction(emoji) : null;
+                if (!reactionCode) {
+                    return toolResult({ ok: false, reason: 'missing_emoji', hint: 'Emoji is required to remove a Bitrix24 reaction.' });
+                }
+                try {
+                    await api.deleteReaction(config.webhookUrl, bot, messageId, reactionCode);
+                    return toolResult({ ok: true, removed: true });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    return toolResult({ ok: false, reason: 'error', hint: `Failed to remove reaction: ${errMsg}. Do not retry.` });
+                }
+            }
+            // Add reaction
+            if (!emoji) {
+                return toolResult({ ok: false, reason: 'missing_emoji', hint: 'Emoji is required for Bitrix24 reactions.' });
+            }
+            const reactionCode = resolveB24Reaction(emoji);
+            if (!reactionCode) {
+                return toolResult({
+                    ok: false,
+                    reason: 'REACTION_NOT_FOUND',
+                    emoji,
+                    hint: `Emoji "${emoji}" is not supported for Bitrix24 reactions. Add it to your reaction disallow list so you do not try it again.`,
+                });
+            }
+            try {
+                await api.addReaction(config.webhookUrl, bot, messageId, reactionCode);
+                return toolResult({ ok: true, added: emoji });
+            }
+            catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                const isAlreadySet = errMsg.includes('REACTION_ALREADY_SET');
+                if (isAlreadySet) {
+                    return toolResult({ ok: true, added: emoji, warning: 'Reaction already set.' });
+                }
+                return toolResult({ ok: false, reason: 'error', emoji, hint: `Reaction failed: ${errMsg}. Do not retry.` });
+            }
+        },
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            // Guard: only one account can run at a time (singleton gateway)
+            if (gatewayState !== null) {
+                throw new Error(`Bitrix24 channel already started for account "${gatewayState.accountId}". ` +
+                    `Cannot start account "${ctx.accountId}" concurrently.`);
+            }
+            const config = getConfig(ctx.cfg, ctx.accountId);
+            const logger = createVerboseLogger(ctx.log ?? defaultLogger, Boolean(config.verboseLog));
+            if (!config.webhookUrl) {
+                logger.warn(`[${ctx.accountId}] no webhookUrl configured, skipping`);
+                return;
+            }
+            // Safe to use without ! after this point
+            const webhookUrl = config.webhookUrl;
+            logger.info(`[${ctx.accountId}] starting Bitrix24 channel`);
+            const api = new Bitrix24Api({ logger });
+            const botToken = resolveBotToken(config);
+            if (!botToken) {
+                logger.error(`[${ctx.accountId}] cannot derive botToken — webhookUrl is missing`);
+                api.destroy();
+                return;
+            }
+            const welcomedDialogs = new Set();
+            const dialogNoticeTimestamps = new Map();
+            const historyCache = new HistoryCache({ maxKeys: HISTORY_CACHE_MAX_KEYS });
+            // Cleanup stale denied dialog entries once per day
+            const DENIED_CLEANUP_INTERVAL_MS = 24 * 60 * 60 * 1000;
+            const deniedCleanupTimer = setInterval(() => {
+                dialogNoticeTimestamps.clear();
+            }, DENIED_CLEANUP_INTERVAL_MS);
+            if (deniedCleanupTimer && typeof deniedCleanupTimer === 'object' && 'unref' in deniedCleanupTimer) {
+                deniedCleanupTimer.unref();
+            }
+            // Determine event mode
+            const eventMode = resolveEventMode(config);
+            logger.info(`[${ctx.accountId}] event mode: ${eventMode}`);
+            // Register or update bot on the B24 portal (V2 API)
+            const botRegistration = await ensureBotRegistered(api, config, botToken, eventMode, logger);
+            if (!botRegistration) {
+                logger.error(`[${ctx.accountId}] bot registration failed, cannot start`);
+                clearInterval(deniedCleanupTimer);
+                api.destroy();
+                return;
+            }
+            const bot = { botId: botRegistration.botId, botToken };
+            const webhookOwnerId = getWebhookUserId(config.webhookUrl);
+            // Sync user event subscription with agent mode setting
+            if (eventMode === 'fetch') {
+                try {
+                    if (config.agentMode) {
+                        await api.subscribeUserEvents(webhookUrl);
+                        logger.info('User events subscription active (agent mode)');
+                    }
+                    else {
+                        await api.unsubscribeUserEvents(webhookUrl);
+                        logger.debug('User events unsubscribed (agent mode off)');
+                    }
+                }
+                catch (err) {
+                    logger.warn('Failed to sync user events subscription', err);
+                }
+            }
+            const sendService = new SendService(api, logger);
+            const mediaService = new MediaService(api, logger);
+            const hydrateReplyEntry = async (replyToMessageId) => {
+                const bitrixMessageId = toMessageId(replyToMessageId);
+                if (!bitrixMessageId) {
+                    return undefined;
+                }
+                try {
+                    const result = await api.getMessage(webhookUrl, bot, bitrixMessageId);
+                    return {
+                        sender: result.user?.name?.trim() || `User ${result.message.authorId}`,
+                        body: resolveFetchedMessageBody(result.message.text),
+                        messageId: String(result.message.id),
+                    };
+                }
+                catch (err) {
+                    logger.debug('Failed to hydrate reply context from Bitrix24 API', {
+                        replyToMessageId,
+                        error: err,
+                    });
+                    return undefined;
+                }
+            };
+            const hydrateForwardedMessageContext = async (msgCtx) => {
+                const currentMessageId = toMessageId(msgCtx.messageId);
+                if (!currentMessageId) {
+                    return {
+                        ...msgCtx,
+                        isForwarded: false,
+                    };
+                }
+                try {
+                    const result = await api.getMessageContext(webhookUrl, bot, currentMessageId, FORWARDED_CONTEXT_RANGE);
+                    const currentMessage = result.messages.find((message) => message.id === currentMessageId);
+                    const currentBody = resolveFetchedMessageBody(currentMessage?.text ?? msgCtx.text);
+                    const fetchedContext = formatFetchedForwardContext({
+                        context: result,
+                        currentMessageId,
+                    });
+                    if (!currentBody && !fetchedContext) {
+                        return {
+                            ...msgCtx,
+                            isForwarded: false,
+                        };
+                    }
+                    return {
+                        ...msgCtx,
+                        text: [
+                            currentBody ? '[Forwarded message body]' : '',
+                            currentBody,
+                            currentBody ? '[/Forwarded message body]' : '',
+                            fetchedContext,
+                        ].filter(Boolean).join('\n\n'),
+                        isForwarded: false,
+                    };
+                }
+                catch (err) {
+                    logger.debug('Failed to hydrate forwarded message context from Bitrix24 API', {
+                        messageId: msgCtx.messageId,
+                        chatId: msgCtx.chatId,
+                        error: err,
+                    });
+                    return {
+                        ...msgCtx,
+                        isForwarded: false,
+                    };
+                }
+            };
+            const processAllowedMessage = async (msgCtx) => {
+                const runtime = getBitrix24Runtime();
+                const cfg = runtime.config.loadConfig();
+                const conversation = resolveConversationRef({
+                    accountId: ctx.accountId,
+                    dialogId: msgCtx.chatId,
+                    isDirect: msgCtx.isDm,
+                });
+                const sendCtx = {
+                    webhookUrl,
+                    bot,
+                    dialogId: conversation.dialogId,
+                };
+                const historyKey = conversation.historyKey;
+                const historyLimit = resolveHistoryLimit(config);
+                const fallbackHistoryBody = buildHistoryBody(msgCtx);
+                let downloadedMedia = [];
+                let historyRecorded = false;
+                const recordHistory = (bodyOverride) => {
+                    if (historyRecorded) {
+                        return;
+                    }
+                    const historyBody = (bodyOverride ?? fallbackHistoryBody).trim();
+                    if (!historyBody) {
+                        return;
+                    }
+                    appendMessageToHistory({
+                        historyCache,
+                        historyKey,
+                        historyLimit,
+                        msgCtx,
+                        body: historyBody,
+                    });
+                    historyRecorded = true;
+                };
+                try {
+                    const replyStatusHeartbeat = createReplyStatusHeartbeat({
+                        sendService,
+                        sendCtx,
+                        config,
+                    });
+                    // Download media files if present
+                    let mediaFields = {};
+                    if (msgCtx.media.length > 0) {
+                        await notifyStatus(sendService, sendCtx, config, 'IMBOT_AGENT_ACTION_PROCESSING');
+                        replyStatusHeartbeat.holdFor(PHASE_STATUS_DURATION_SECONDS);
+                        downloadedMedia = (await mapWithConcurrency(msgCtx.media, MEDIA_DOWNLOAD_CONCURRENCY, (mediaItem) => mediaService.downloadMedia({
+                            fileId: mediaItem.id,
+                            fileName: mediaItem.name,
+                            extension: mediaItem.extension,
+                            webhookUrl,
+                            bot,
+                            dialogId: conversation.dialogId,
+                        }))).filter(Boolean);
+                        if (downloadedMedia.length > 0) {
+                            mediaFields = {
+                                MediaPath: downloadedMedia[0].path,
+                                MediaType: downloadedMedia[0].contentType,
+                                MediaUrl: downloadedMedia[0].path,
+                                MediaPaths: downloadedMedia.map((mediaItem) => mediaItem.path),
+                                MediaUrls: downloadedMedia.map((mediaItem) => mediaItem.path),
+                                MediaTypes: downloadedMedia.map((mediaItem) => mediaItem.contentType),
+                            };
+                        }
+                        else {
+                            const fileNames = msgCtx.media.map((mediaItem) => mediaItem.name).join(', ');
+                            logger.warn('All media downloads failed, notifying user', { fileNames });
+                            recordHistory();
+                            await sendService.sendText(sendCtx, mediaDownloadFailed(msgCtx.language, fileNames));
+                            return;
+                        }
+                    }
+                    else {
+                        await notifyStatus(sendService, sendCtx, config, 'IMBOT_AGENT_ACTION_ANALYZING');
+                        replyStatusHeartbeat.holdFor(PHASE_STATUS_DURATION_SECONDS);
+                    }
+                    // Use placeholder body for media-only messages
+                    let body = msgCtx.text;
+                    if (!body && msgCtx.media.length > 0) {
+                        const hasImage = downloadedMedia.some((mediaItem) => mediaItem.contentType.startsWith('image/'))
+                            || msgCtx.media.some((mediaItem) => mediaItem.type === 'image');
+                        body = hasImage ? '<media:image>' : '<media:document>';
+                    }
+                    const previousEntries = historyCache.get(historyKey, historyLimit);
+                    const replyEntry = historyCache.findByMessageId(historyKey, msgCtx.replyToMessageId)
+                        ?? await hydrateReplyEntry(msgCtx.replyToMessageId);
+                    const bodyWithReply = formatReplyContext({
+                        body,
+                        replyEntry,
+                    });
+                    const crossChatContext = buildCrossChatMemoryContext({
+                        query: bodyWithReply,
+                        historyCache,
+                    });
+                    const bodyForAgent = crossChatContext
+                        ? [crossChatContext, bodyWithReply].filter(Boolean).join('\n\n')
+                        : bodyWithReply;
+                    const combinedBody = msgCtx.isGroup
+                        ? buildHistoryContext({
+                            entries: previousEntries,
+                            currentBody: bodyForAgent,
+                        })
+                        : bodyForAgent;
+                    recordHistory(body);
+                    // Resolve which agent handles this conversation
+                    const route = runtime.channel.routing.resolveAgentRoute({
+                        cfg,
+                        channel: 'bitrix24',
+                        accountId: ctx.accountId,
+                        peer: conversation.peer,
+                    });
+                    logger.debug('Resolved route', {
+                        sessionKey: route.sessionKey,
+                        agentId: route.agentId,
+                        matchedBy: route.matchedBy,
+                    });
+                    const inboundCtx = runtime.channel.reply.finalizeInboundContext({
+                        Body: combinedBody,
+                        BodyForAgent: bodyForAgent,
+                        InboundHistory: msgCtx.isGroup && previousEntries.length > 0
+                            ? previousEntries.map((entry) => ({
+                                sender: entry.sender,
+                                body: entry.body,
+                                timestamp: entry.timestamp,
+                            }))
+                            : undefined,
+                        RawBody: body,
+                        From: conversation.address,
+                        To: conversation.address,
+                        SessionKey: buildConversationSessionKey(route.sessionKey, conversation),
+                        AccountId: route.accountId,
+                        ChatType: msgCtx.isDm ? 'direct' : 'group',
+                        ConversationLabel: msgCtx.senderName,
+                        SenderName: msgCtx.senderName,
+                        SenderId: msgCtx.senderId,
+                        Provider: 'bitrix24',
+                        Surface: 'bitrix24',
+                        MessageSid: msgCtx.messageId,
+                        Timestamp: msgCtx.timestamp ?? Date.now(),
+                        ReplyToId: replyEntry?.messageId ?? msgCtx.replyToMessageId,
+                        ReplyToBody: replyEntry?.body,
+                        ReplyToSender: replyEntry?.sender,
+                        WasMentioned: msgCtx.wasMentioned ?? false,
+                        CommandAuthorized: true,
+                        OriginatingChannel: 'bitrix24',
+                        OriginatingTo: conversation.address,
+                        ...mediaFields,
+                    });
+                    try {
+                        await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+                            ctx: inboundCtx,
+                            cfg,
+                            dispatcherOptions: {
+                                deliver: async (payload) => {
+                                    await replyStatusHeartbeat.stopAndWait();
+                                    const mediaUrls = payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
+                                    if (mediaUrls.length > 0) {
+                                        await uploadOutboundMedia({
+                                            mediaService,
+                                            sendCtx,
+                                            mediaUrls,
+                                        });
+                                    }
+                                    if (payload.text) {
+                                        let text = payload.text;
+                                        let keyboard = extractKeyboardFromPayload(payload);
+                                        // Fallback: agent may embed button JSON in text as [[{...}]]
+                                        if (!keyboard) {
+                                            const extracted = extractInlineButtonsFromText(text);
+                                            if (extracted) {
+                                                text = extracted.cleanText;
+                                                keyboard = extracted.keyboard;
+                                            }
+                                        }
+                                        await sendService.sendText(sendCtx, text, keyboard ? { keyboard } : undefined);
+                                    }
+                                },
+                                onReplyStart: async () => {
+                                    await replyStatusHeartbeat.start();
+                                },
+                                onError: (err) => {
+                                    logger.error('Error delivering reply to B24', err);
+                                },
+                            },
+                        });
+                    }
+                    catch (err) {
+                        logger.error('Error dispatching message to agent', { senderId: msgCtx.senderId, chatId: msgCtx.chatId, error: err });
+                    }
+                    finally {
+                        replyStatusHeartbeat.stop();
+                    }
+                }
+                finally {
+                    await mediaService.cleanupDownloadedMedia(downloadedMedia.map((mediaItem) => mediaItem.path));
+                }
+            };
+            const directTextCoalescer = new BufferedDirectMessageCoalescer({
+                debounceMs: DIRECT_TEXT_COALESCE_DEBOUNCE_MS,
+                maxWaitMs: DIRECT_TEXT_COALESCE_MAX_WAIT_MS,
+                onFlush: processAllowedMessage,
+                logger,
+            });
+            const maybeSendDialogNotice = async (noticeKey, sendCtx, text) => {
+                const now = Date.now();
+                const lastSentAt = dialogNoticeTimestamps.get(noticeKey) ?? 0;
+                if ((now - lastSentAt) < ACCESS_DENIED_NOTICE_COOLDOWN_MS) {
+                    return;
+                }
+                dialogNoticeTimestamps.set(noticeKey, now);
+                try {
+                    await sendService.sendText(sendCtx, text, { convertMarkdown: false });
+                }
+                catch (err) {
+                    logger.warn('Failed to send dialog notice', err);
+                }
+            };
+            const maybeReactToDeniedMention = async (msgCtx) => {
+                if (!msgCtx.isGroup || !msgCtx.wasMentioned) {
+                    return;
+                }
+                const messageId = toMessageId(msgCtx.messageId);
+                if (!messageId) {
+                    return;
+                }
+                try {
+                    await api.addReaction(webhookUrl, bot, messageId, ACCESS_DENIED_REACTION);
+                }
+                catch (err) {
+                    logger.debug('Failed to add access-denied reaction', {
+                        chatId: msgCtx.chatId,
+                        messageId: msgCtx.messageId,
+                        error: err,
+                    });
+                }
+            };
+            const maybeReactToBotMessageReaction = async (reactionCtx) => {
+                if (reactionCtx.action !== 'set') {
+                    return;
+                }
+                const botId = String(bot.botId);
+                if (reactionCtx.senderId === botId || reactionCtx.messageAuthorId !== botId) {
+                    return;
+                }
+                const messageId = toMessageId(reactionCtx.messageId);
+                if (!messageId) {
+                    return;
+                }
+                try {
+                    await api.addReaction(webhookUrl, bot, messageId, BOT_MESSAGE_WATCH_REACTION);
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    if (errMsg.includes('REACTION_ALREADY_SET')) {
+                        logger.debug('Watch reaction already set on bot message', {
+                            chatId: reactionCtx.dialogId,
+                            messageId: reactionCtx.messageId,
+                        });
+                        return;
+                    }
+                    logger.warn('Failed to add watch reaction to bot message', {
+                        chatId: reactionCtx.dialogId,
+                        messageId: reactionCtx.messageId,
+                        error: err,
+                    });
+                }
+            };
+            const notifyWebhookOwnerAboutWatchMatch = async (msgCtx, watchRule) => {
+                const ownerId = webhookOwnerId;
+                const forwardedMessageId = toMessageId(msgCtx.messageId);
+                if (!ownerId || !forwardedMessageId) {
+                    logger.warn('Skipping owner watch notification: missing owner dialog or message id', {
+                        ownerId,
+                        messageId: msgCtx.messageId,
+                        chatId: msgCtx.chatId,
+                    });
+                    return false;
+                }
+                const ownerSendCtx = {
+                    webhookUrl,
+                    bot,
+                    dialogId: ownerId,
+                };
+                const noticeText = watchOwnerDmNotice(msgCtx.language, {
+                    chatRef: buildChatContextUrl(msgCtx.chatId, msgCtx.messageId, msgCtx.isDm
+                        ? (msgCtx.senderName || msgCtx.chatName || msgCtx.chatId)
+                        : (msgCtx.chatName ?? msgCtx.chatId)),
+                    topicsRef: buildTopicsBbCode(watchRule.topics),
+                    sourceKind: msgCtx.isDm ? 'dm' : 'chat',
+                });
+                try {
+                    await sendService.sendText(ownerSendCtx, noticeText, {
+                        convertMarkdown: false,
+                    });
+                    if (msgCtx.eventScope === 'user' && msgCtx.isDm) {
+                        const quoteText = buildWatchQuoteText({
+                            senderName: msgCtx.senderName || msgCtx.chatName || msgCtx.chatId,
+                            language: msgCtx.language,
+                            timestamp: msgCtx.timestamp,
+                            anchor: `#${msgCtx.chatId}:${ownerId}/${msgCtx.messageId}`,
+                            body: msgCtx.text.trim(),
+                        });
+                        await sendService.sendText(ownerSendCtx, quoteText, {
+                            convertMarkdown: false,
+                        });
+                        return true;
+                    }
+                    await api.sendMessage(webhookUrl, bot, ownerId, null, { forwardMessages: [forwardedMessageId] });
+                    return true;
+                }
+                catch (err) {
+                    logger.warn('Failed to send owner watch notification with native forward', err);
+                    return false;
+                }
+            };
+            // Register slash commands (runs in background)
+            ensureCommandsRegistered(api, config, bot, logger).catch((err) => {
+                logger.warn('Command registration failed', err);
+            });
+            if (botRegistration.isNew) {
+                await sendInitialWelcomeToWebhookOwner({
+                    config,
+                    bot,
+                    sendService,
+                    language: botRegistration.language,
+                    welcomedDialogs,
+                    logger,
+                });
+            }
+            const inboundHandler = new InboundHandler({
+                config,
+                logger,
+                onReactionChange: async (reactionCtx) => {
+                    await maybeReactToBotMessageReaction(reactionCtx);
+                },
+                onMessage: async (msgCtx) => {
+                    logger.info('Inbound message', {
+                        senderId: msgCtx.senderId,
+                        chatId: msgCtx.chatId,
+                        messageId: msgCtx.messageId,
+                        textLen: msgCtx.text.length,
+                    });
+                    const pendingForwardContext = msgCtx.isForwarded
+                        ? directTextCoalescer.take(ctx.accountId, msgCtx.chatId)
+                        : null;
+                    const runtime = getBitrix24Runtime();
+                    // Pairing-aware access control
+                    const sendCtx = {
+                        webhookUrl,
+                        bot,
+                        dialogId: msgCtx.chatId,
+                    };
+                    const conversation = resolveConversationRef({
+                        accountId: ctx.accountId,
+                        dialogId: msgCtx.chatId,
+                        isDirect: msgCtx.isDm,
+                    });
+                    const historyKey = conversation.historyKey;
+                    const historyLimit = resolveHistoryLimit(config);
+                    const groupAccess = msgCtx.isGroup
+                        ? resolveGroupAccess({
+                            config,
+                            dialogId: msgCtx.chatId,
+                            chatId: msgCtx.chatInternalId,
+                        })
+                        : null;
+                    const agentWatchRules = config.agentMode && msgCtx.eventScope === 'user'
+                        ? resolveAgentWatchRules({
+                            config,
+                            dialogId: msgCtx.chatId,
+                            chatId: msgCtx.chatInternalId,
+                        })
+                        : [];
+                    const watchRule = msgCtx.isGroup && groupAccess?.groupAllowed
+                        ? findMatchingWatchRule(msgCtx, groupAccess?.watch)
+                        : undefined;
+                    const activeWatchRule = watchRule?.mode === 'notifyOwnerDm'
+                        && webhookOwnerId
+                        && msgCtx.senderId === webhookOwnerId
+                        ? undefined
+                        : watchRule;
+                    const agentWatchRule = msgCtx.eventScope === 'user'
+                        ? findMatchingWatchRule(msgCtx, agentWatchRules)
+                        : undefined;
+                    /** Shorthand: record message in RAM history for this dialog. */
+                    const recordHistory = (body) => appendMessageToHistory({ historyCache, historyKey, historyLimit, msgCtx, body });
+                    if (msgCtx.eventScope === 'user') {
+                        const isBotDialogUserEvent = msgCtx.isDm && msgCtx.chatId === String(bot.botId);
+                        const isBotAuthoredUserEvent = msgCtx.senderId === String(bot.botId);
+                        if (isBotDialogUserEvent || isBotAuthoredUserEvent) {
+                            logger.debug('Skipping agent-mode user event for bot-owned conversation', {
+                                senderId: msgCtx.senderId,
+                                chatId: msgCtx.chatId,
+                                messageId: msgCtx.messageId,
+                                isBotDialogUserEvent,
+                                isBotAuthoredUserEvent,
+                            });
+                            return;
+                        }
+                        recordHistory();
+                        if (webhookOwnerId && msgCtx.senderId !== webhookOwnerId && agentWatchRule?.mode === 'notifyOwnerDm') {
+                            await notifyWebhookOwnerAboutWatchMatch(msgCtx, agentWatchRule);
+                            logger.debug('User-event watch matched and notified webhook owner in DM', {
+                                senderId: msgCtx.senderId,
+                                chatId: msgCtx.chatId,
+                                messageId: msgCtx.messageId,
+                            });
+                        }
+                        return;
+                    }
+                    if (msgCtx.isGroup && groupAccess?.groupPolicy === 'disabled') {
+                        logger.info('Group chat is disabled by policy, leaving chat', {
+                            chatId: msgCtx.chatId,
+                            senderId: msgCtx.senderId,
+                        });
+                        try {
+                            await sendService.sendText(sendCtx, groupChatUnsupported(msgCtx.language));
+                            await api.leaveChat(webhookUrl, bot, msgCtx.chatId);
+                        }
+                        catch (err) {
+                            logger.error('Failed to leave disabled group chat', err);
+                        }
+                        return;
+                    }
+                    await sendService.markRead(sendCtx, toMessageId(msgCtx.messageId));
+                    if (msgCtx.isGroup
+                        && !activeWatchRule
+                        && groupAccess?.requireMention
+                        && !msgCtx.wasMentioned) {
+                        recordHistory();
+                        logger.info('Skipping group message without mention', {
+                            chatId: msgCtx.chatId,
+                            senderId: msgCtx.senderId,
+                            messageId: msgCtx.messageId,
+                        });
+                        return;
+                    }
+                    if (activeWatchRule?.mode === 'notifyOwnerDm') {
+                        recordHistory();
+                        await notifyWebhookOwnerAboutWatchMatch(msgCtx, activeWatchRule);
+                        logger.debug('Group watch matched and notified webhook owner in DM', {
+                            senderId: msgCtx.senderId,
+                            chatId: msgCtx.chatId,
+                            messageId: msgCtx.messageId,
+                        });
+                        return;
+                    }
+                    const accessResult = activeWatchRule
+                        ? 'allow'
+                        : msgCtx.isGroup
+                            ? await checkGroupAccessWithPairing({
+                                senderId: msgCtx.senderId,
+                                dialogId: msgCtx.chatId,
+                                chatId: msgCtx.chatInternalId,
+                                config,
+                                runtime,
+                                accountId: ctx.accountId,
+                                pairingAdapter: bitrix24Plugin.pairing,
+                                logger,
+                            })
+                            : await checkAccessWithPairing({
+                                senderId: msgCtx.senderId,
+                                dialogId: msgCtx.chatId,
+                                isDirect: msgCtx.isDm,
+                                config,
+                                runtime,
+                                accountId: ctx.accountId,
+                                pairingAdapter: bitrix24Plugin.pairing,
+                                sendReply: async (text) => {
+                                    await sendService.sendText(sendCtx, text, { convertMarkdown: false });
+                                },
+                                logger,
+                            });
+                    if (accessResult === 'deny') {
+                        if (msgCtx.isGroup) {
+                            recordHistory();
+                            if (!msgCtx.wasMentioned) {
+                                logger.debug('Group message blocked silently without mention', {
+                                    senderId: msgCtx.senderId,
+                                    chatId: msgCtx.chatId,
+                                    messageId: msgCtx.messageId,
+                                });
+                                return;
+                            }
+                        }
+                        await maybeReactToDeniedMention(msgCtx);
+                        const noticeKey = msgCtx.isDm
+                            ? `deny:${msgCtx.chatId}`
+                            : `group-deny:${msgCtx.chatId}:${msgCtx.senderId}`;
+                        const policy = msgCtx.isDm
+                            ? config.dmPolicy
+                            : groupAccess?.groupPolicy;
+                        await maybeSendDialogNotice(noticeKey, sendCtx, buildAccessDeniedNotice(msgCtx.language, policy, {
+                            hasAllowList: msgCtx.isDm
+                                ? normalizeAllowList(config.allowFrom).length > 0
+                                : Boolean(groupAccess?.senderAllowFrom.length),
+                        }));
+                        logger.debug('Message blocked (deny)', { senderId: msgCtx.senderId, chatId: msgCtx.chatId });
+                        return;
+                    }
+                    if (accessResult === 'pairing') {
+                        if (msgCtx.isGroup) {
+                            recordHistory();
+                            await maybeSendDialogNotice(`group-pairing:${msgCtx.chatId}:${msgCtx.senderId}`, sendCtx, groupPairingPending(msgCtx.language));
+                        }
+                        logger.debug(`Message blocked (${accessResult})`, { senderId: msgCtx.senderId });
+                        return;
+                    }
+                    await sendService.sendTyping(sendCtx);
+                    if (msgCtx.isForwarded) {
+                        if (pendingForwardContext) {
+                            const hydratedForwardContext = await hydrateForwardedMessageContext(msgCtx);
+                            const mergedForwardContext = mergeForwardedMessageContext(pendingForwardContext, hydratedForwardContext);
+                            await processAllowedMessage(mergedForwardContext);
+                            return;
+                        }
+                        logger.info('Hydrating forwarded message context from Bitrix24 API', {
+                            senderId: msgCtx.senderId,
+                            chatId: msgCtx.chatId,
+                            messageId: msgCtx.messageId,
+                        });
+                        await processAllowedMessage(await hydrateForwardedMessageContext(msgCtx));
+                        return;
+                    }
+                    if (canCoalesceDirectMessage(msgCtx, config)) {
+                        directTextCoalescer.enqueue(ctx.accountId, msgCtx);
+                        return;
+                    }
+                    await directTextCoalescer.flush(ctx.accountId, msgCtx.chatId);
+                    await processAllowedMessage(msgCtx);
+                },
+                onCommand: async (cmdCtx) => {
+                    const { commandId, commandName, commandParams, commandText, senderId, dialogId, chatId, chatType, messageId, } = cmdCtx;
+                    const isDm = chatType === 'P';
+                    const conversation = resolveConversationRef({
+                        accountId: ctx.accountId,
+                        dialogId,
+                        isDirect: isDm,
+                    });
+                    logger.info('Inbound command', {
+                        commandId,
+                        commandName,
+                        commandParams,
+                        commandText,
+                        senderId,
+                        dialogId,
+                        chatId,
+                        conversationDialogId: conversation.dialogId,
+                    });
+                    const sendCtx = {
+                        webhookUrl,
+                        bot,
+                        dialogId: conversation.dialogId,
+                    };
+                    let runtime;
+                    let cfg;
+                    try {
+                        runtime = getBitrix24Runtime();
+                        cfg = runtime.config.loadConfig();
+                    }
+                    catch (err) {
+                        logger.error('Failed to get runtime/config for command', err);
+                        return;
+                    }
+                    const commandMessageId = toMessageId(messageId);
+                    const commandSendCtx = commandMessageId
+                        ? {
+                            ...sendCtx,
+                            commandId,
+                            messageId: commandMessageId,
+                            commandDialogId: dialogId,
+                        }
+                        : null;
+                    const groupAccess = !isDm
+                        ? resolveGroupAccess({
+                            config,
+                            dialogId,
+                            chatId,
+                        })
+                        : null;
+                    // Access control
+                    let accessResult;
+                    try {
+                        accessResult = !isDm
+                            ? await checkGroupAccessWithPairing({
+                                senderId,
+                                dialogId,
+                                chatId,
+                                config,
+                                runtime,
+                                accountId: ctx.accountId,
+                                pairingAdapter: bitrix24Plugin.pairing,
+                                logger,
+                            })
+                            : await checkAccessWithPairing({
+                                senderId,
+                                dialogId,
+                                isDirect: isDm,
+                                config,
+                                runtime,
+                                accountId: ctx.accountId,
+                                pairingAdapter: bitrix24Plugin.pairing,
+                                sendReply: async (text) => {
+                                    if (commandSendCtx) {
+                                        await sendService.answerCommandText(commandSendCtx, text, { convertMarkdown: false });
+                                        return;
+                                    }
+                                    await sendService.sendText(sendCtx, text, { convertMarkdown: false });
+                                },
+                                logger,
+                            });
+                    }
+                    catch (err) {
+                        logger.error('Access check failed for command', err);
+                        return;
+                    }
+                    if (!commandMessageId || !commandSendCtx) {
+                        logger.warn('Command event has invalid messageId, skipping response', { commandId, messageId, dialogId });
+                        return;
+                    }
+                    if (!isDm && groupAccess?.groupPolicy === 'disabled') {
+                        await sendService.answerCommandText(commandSendCtx, groupChatUnsupported(cmdCtx.language), { convertMarkdown: false });
+                        return;
+                    }
+                    await sendService.sendStatus(sendCtx, 'IMBOT_AGENT_ACTION_THINKING', 8);
+                    if (accessResult === 'deny') {
+                        await sendService.markRead(sendCtx, commandMessageId);
+                        await sendService.answerCommandText(commandSendCtx, buildAccessDeniedNotice(cmdCtx.language, isDm ? config.dmPolicy : groupAccess?.groupPolicy, {
+                            hasAllowList: isDm
+                                ? normalizeAllowList(config.allowFrom).length > 0
+                                : Boolean(groupAccess?.senderAllowFrom.length),
+                        }), { convertMarkdown: false });
+                        logger.debug('Command blocked (deny)', { senderId, dialogId });
+                        return;
+                    }
+                    await sendService.markRead(sendCtx, commandMessageId);
+                    if (accessResult === 'pairing') {
+                        if (!isDm) {
+                            await sendService.answerCommandText(commandSendCtx, groupPairingPending(cmdCtx.language), { convertMarkdown: false });
+                        }
+                        logger.debug(`Command blocked (${accessResult})`, { senderId });
+                        return;
+                    }
+                    await directTextCoalescer.flush(ctx.accountId, conversation.dialogId);
+                    if (commandName === 'help' || commandName === 'commands') {
+                        await sendService.answerCommandText(commandSendCtx, buildCommandsHelpText(cmdCtx.language, { concise: commandName === 'help' }), { keyboard: DEFAULT_COMMAND_KEYBOARD, convertMarkdown: false });
+                        return;
+                    }
+                    const route = runtime.channel.routing.resolveAgentRoute({
+                        cfg,
+                        channel: 'bitrix24',
+                        accountId: ctx.accountId,
+                        peer: conversation.peer,
+                    });
+                    const slashSessionKey = `bitrix24:slash:${senderId}:${Date.now()}`;
+                    const inboundCtx = runtime.channel.reply.finalizeInboundContext({
+                        Body: commandText,
+                        BodyForAgent: commandText,
+                        RawBody: commandText,
+                        CommandBody: commandText,
+                        CommandAuthorized: true,
+                        CommandSource: 'native',
+                        CommandTargetSessionKey: buildConversationSessionKey(route.sessionKey, conversation),
+                        From: conversation.address,
+                        To: `slash:${senderId}`,
+                        SessionKey: slashSessionKey,
+                        AccountId: route.accountId,
+                        ChatType: isDm ? 'direct' : 'group',
+                        ConversationLabel: senderId,
+                        SenderName: senderId,
+                        SenderId: senderId,
+                        Provider: 'bitrix24',
+                        Surface: 'bitrix24',
+                        MessageSid: messageId,
+                        Timestamp: Date.now(),
+                        WasMentioned: true,
+                        OriginatingChannel: 'bitrix24',
+                        OriginatingTo: conversation.address,
+                    });
+                    const replyStatusHeartbeat = createReplyStatusHeartbeat({
+                        sendService,
+                        sendCtx,
+                        config,
+                    });
+                    let commandReplyDelivered = false;
+                    try {
+                        await replyStatusHeartbeat.start();
+                        await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+                            ctx: inboundCtx,
+                            cfg,
+                            dispatcherOptions: {
+                                deliver: async (payload) => {
+                                    await replyStatusHeartbeat.stopAndWait();
+                                    if (payload.text) {
+                                        const keyboard = extractKeyboardFromPayload(payload) ?? DEFAULT_COMMAND_KEYBOARD;
+                                        const formattedPayload = normalizeCommandReplyPayload({
+                                            commandName,
+                                            commandParams,
+                                            text: payload.text,
+                                            language: cmdCtx.language,
+                                        });
+                                        if (!commandReplyDelivered) {
+                                            commandReplyDelivered = true;
+                                            await sendService.answerCommandText(commandSendCtx, formattedPayload.text, {
+                                                keyboard,
+                                                convertMarkdown: formattedPayload.convertMarkdown,
+                                            });
+                                            return;
+                                        }
+                                        await sendService.sendText(sendCtx, formattedPayload.text, {
+                                            keyboard,
+                                            convertMarkdown: formattedPayload.convertMarkdown,
+                                        });
+                                    }
+                                },
+                                onReplyStart: async () => {
+                                    await replyStatusHeartbeat.start();
+                                },
+                                onError: (err) => {
+                                    logger.error('Error delivering command reply to B24', err);
+                                },
+                            },
+                        });
+                    }
+                    catch (err) {
+                        logger.error('Error dispatching command to agent', { commandName, senderId, dialogId, error: err });
+                    }
+                    finally {
+                        replyStatusHeartbeat.stop();
+                    }
+                },
+                onJoinChat: async (joinCtx) => {
+                    const { senderId, dialogId, chatId, chatType, language } = joinCtx;
+                    logger.info('Bot joined chat', { senderId, dialogId, chatId, chatType });
+                    if (!dialogId)
+                        return;
+                    const isGroupChat = chatType === 'chat' || chatType === 'open';
+                    const groupAccess = isGroupChat
+                        ? resolveGroupAccess({ config, dialogId, chatId })
+                        : null;
+                    if (!isGroupChat && shouldSkipJoinChatWelcome({
+                        dialogId,
+                        chatType,
+                        webhookUrl,
+                        dmPolicy: config.dmPolicy,
+                    })) {
+                        logger.info('Skipping welcome for non-owner dialog in webhookUser mode', { dialogId });
+                        return;
+                    }
+                    const sendCtx = {
+                        webhookUrl,
+                        bot,
+                        dialogId,
+                    };
+                    if (isGroupChat && (!groupAccess?.groupAllowed || groupAccess.groupPolicy === 'disabled')) {
+                        logger.info('Group chat blocked by policy, leaving', { dialogId });
+                        try {
+                            await sendService.sendText(sendCtx, groupChatUnsupported(language));
+                            await api.leaveChat(webhookUrl, bot, dialogId);
+                        }
+                        catch (err) {
+                            logger.error('Failed to leave group chat', err);
+                        }
+                        return;
+                    }
+                    if (isGroupChat) {
+                        const runtime = getBitrix24Runtime();
+                        const inviterAccessResult = await checkGroupAccessPassive({
+                            senderId,
+                            dialogId,
+                            chatId,
+                            config,
+                            runtime,
+                            accountId: ctx.accountId,
+                            logger,
+                        });
+                        if (inviterAccessResult !== 'allow') {
+                            const noticeText = inviterAccessResult === 'pairing'
+                                ? groupPairingPending(language)
+                                : buildAccessDeniedNotice(language, groupAccess?.groupPolicy, {
+                                    hasAllowList: Boolean(groupAccess?.senderAllowFrom.length),
+                                });
+                            logger.info('Leaving group chat invited by user without access', {
+                                dialogId,
+                                chatId,
+                                senderId,
+                                inviterAccessResult,
+                            });
+                            try {
+                                await sendService.sendText(sendCtx, noticeText, { convertMarkdown: false });
+                                await api.leaveChat(webhookUrl, bot, dialogId);
+                            }
+                            catch (err) {
+                                logger.error('Failed to leave group chat after inviter access check', err);
+                            }
+                            return;
+                        }
+                        logger.info('Group chat enabled by policy, skipping auto-welcome', { dialogId });
+                        return;
+                    }
+                    if (welcomedDialogs.has(dialogId)) {
+                        logger.info('Skipping duplicate welcome for already welcomed dialog', { dialogId });
+                        return;
+                    }
+                    // Send welcome message
+                    const isPairing = config.dmPolicy === 'pairing';
+                    const text = onboardingMessage(language, config.botName ?? 'OpenClaw', config.dmPolicy);
+                    try {
+                        await sendService.sendText(sendCtx, text, isPairing ? undefined : { keyboard: DEFAULT_COMMAND_KEYBOARD });
+                        welcomedDialogs.add(dialogId);
+                        logger.info('Welcome message sent', { dialogId });
+                    }
+                    catch (err) {
+                        logger.error('Failed to send welcome message', err);
+                    }
+                },
+                onBotDelete: async (_data) => {
+                    logger.info('Bot deleted from portal');
+                },
+            });
+            gatewayState = { accountId: ctx.accountId, api, bot, sendService, mediaService, inboundHandler, eventMode };
+            logger.info(`[${ctx.accountId}] Bitrix24 channel started (${eventMode} mode)`);
+            // ─── Mode-specific lifecycle ──────────────────────────────────
+            if (eventMode === 'fetch') {
+                // FETCH mode: start polling loop (blocks until abort)
+                const pollingService = new PollingService({
+                    api,
+                    webhookUrl,
+                    bot,
+                    accountId: ctx.accountId,
+                    pollingIntervalMs: config.pollingIntervalMs ?? 3000,
+                    pollingFastIntervalMs: config.pollingFastIntervalMs ?? 100,
+                    withUserEvents: Boolean(config.agentMode),
+                    onEvent: async (event) => {
+                        const fetchCtx = {
+                            webhookUrl,
+                            botId: bot.botId,
+                            botToken: bot.botToken,
+                        };
+                        await inboundHandler.handleFetchEvent(event, fetchCtx);
+                    },
+                    abortSignal: ctx.abortSignal,
+                    logger,
+                });
+                try {
+                    await pollingService.start();
+                }
+                finally {
+                    logger.info(`[${ctx.accountId}] Bitrix24 channel stopping (fetch)`);
+                    clearInterval(deniedCleanupTimer);
+                    await directTextCoalescer.flushAll();
+                    directTextCoalescer.destroy();
+                    inboundHandler.destroy();
+                    api.destroy();
+                    gatewayState = null;
+                }
+            }
+            else {
+                // WEBHOOK mode: keep alive until abort signal
+                return new Promise((resolve) => {
+                    ctx.abortSignal.addEventListener('abort', () => {
+                        const cleanup = async () => {
+                            logger.info(`[${ctx.accountId}] Bitrix24 channel stopping (webhook)`);
+                            clearInterval(deniedCleanupTimer);
+                            // Flush with timeout to prevent hanging
+                            await Promise.race([
+                                directTextCoalescer.flushAll(),
+                                new Promise((r) => setTimeout(r, 5000)),
+                            ]);
+                            directTextCoalescer.destroy();
+                            inboundHandler.destroy();
+                            api.destroy();
+                            gatewayState = null;
+                        };
+                        cleanup().catch((err) => {
+                            logger.error('Webhook cleanup error', err);
+                        }).finally(() => resolve());
+                    });
+                });
+            }
+        },
+    },
+};
+//# sourceMappingURL=channel.js.map