@ihazz/bitrix24 1.1.12 → 1.1.14

package/dist/src/channel.js

@@ -14,8 +14,9 @@ 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, getCommandRegistrationPayload, } from './commands.js';
-import { accessApproved, accessDenied, commandKeyboardLabels, groupPairingPending, mediaDownloadFailed, groupChatUnsupported, newSessionReplyTexts, onboardingDisclaimerMessage, onboardingMessage, normalizeNewSessionReply, ownerAndAllowedUsersOnly, personalBotOwnerOnly, welcomeKeyboardLabels, watchOwnerDmNotice, } from './i18n.js';
+import { accessApproved, accessDenied, commandKeyboardLabels, emptyReplyFallback, groupPairingPending, mediaDownloadFailed, groupChatUnsupported, newSessionReplyTexts, onboardingDisclaimerMessage, onboardingMessage, normalizeNewSessionReply, ownerAndAllowedUsersOnly, personalBotOwnerOnly, welcomeKeyboardLabels, watchOwnerDmNotice, } from './i18n.js';
 import { HistoryCache } from './history-cache.js';
+import { markdownToBbCode } from './message-utils.js';
 const PHASE_STATUS_DURATION_SECONDS = 8;
 const PHASE_STATUS_REFRESH_GRACE_MS = 1000;
 const THINKING_STATUS_DURATION_SECONDS = 30;
@@ -23,6 +24,7 @@ const THINKING_STATUS_REFRESH_GRACE_MS = 6000;
 const DIRECT_TEXT_COALESCE_DEBOUNCE_MS = 200;
 const DIRECT_TEXT_COALESCE_MAX_WAIT_MS = 5000;
 const REPLY_FALLBACK_GRACE_MS = 750;
+const EMPTY_REPLY_FALLBACK_GRACE_MS = 15 * 1000;
 const ACCESS_DENIED_NOTICE_COOLDOWN_MS = 60000;
 const AUTO_BOT_CODE_MAX_CANDIDATES = 100;
 const MEDIA_DOWNLOAD_CONCURRENCY = 2;
@@ -37,7 +39,27 @@ const FORWARDED_CONTEXT_RANGE = 5;
 const ACTIVE_SESSION_NAMESPACE_TTL_MS = 180 * 24 * 60 * 60 * 1000;
 const ACTIVE_SESSION_NAMESPACE_MAX_KEYS = 1000;
 const ACTIVE_SESSION_NAMESPACE_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const NATIVE_FORWARD_ACK_TTL_MS = 60 * 1000;
+const NATIVE_REACTION_ACK_TTL_MS = 60 * 1000;
+const NATIVE_FORWARD_SUCCESS_REACTION = 'whiteHeavyCheckMark';
+const REACTION_TYPING_RESET_DURATION_SECONDS = 1;
+const GENERIC_OUTBOUND_FILE_NAME_RE = /^(translated?|translation|output|result|file|document)(?:[_-][a-z]{2,8})?$/i;
+const GENERIC_INBOUND_FILE_NAME_RE = /^(?:file[_-]\d+|[0-9a-f]{8,}(?:-[0-9a-f]{4,})*(?:_file[_-]?\d+)?)$/i;
+const RECENT_MEDIA_DELIVERY_TTL_MS = 60 * 1000;
+const RECENT_SUCCESSFUL_ACTION_TTL_MS = 60 * 1000;
+const RECENT_OUTBOUND_MESSAGE_TTL_MS = 30 * 60 * 1000;
+const RECENT_WATCH_NOTIFICATION_TTL_MS = 30 * 60 * 1000;
+const RECENT_INBOUND_MESSAGE_TTL_MS = 30 * 60 * 1000;
+const RECENT_INBOUND_MESSAGE_LIMIT = 20;
 const REGISTERED_COMMANDS = new Set(OPENCLAW_COMMANDS.map((command) => command.command));
+const pendingNativeForwardAcks = new Map();
+const pendingNativeReactionAcks = new Map();
+const recentSuccessfulMediaDeliveries = new Map();
+const recentSuccessfulActionsByMessage = new Map();
+const recentOutboundMessagesById = new Map();
+const recentWatchNotificationsByMessage = new Map();
+const recentInboundMessagesByDialog = new Map();
+const inboundMessageContextById = new Map();
 // ─── Emoji → B24 reaction code mapping ──────────────────────────────────
 // B24 uses named reaction codes, not Unicode emoji.
 // Map common Unicode emoji to their B24 equivalents.
@@ -109,6 +131,789 @@ function toMessageId(value) {
     const parsed = Number(value);
     return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
 }
+function resolveStateAccountId(accountId) {
+    const normalizedAccountId = typeof accountId === 'string'
+        ? accountId.trim()
+        : '';
+    if (normalizedAccountId) {
+        return normalizedAccountId;
+    }
+    const gatewayAccountId = gatewayState?.accountId?.trim();
+    return gatewayAccountId || 'default';
+}
+function buildAccountDialogScopeKey(accountId, dialogId) {
+    const normalizedDialogId = dialogId.trim();
+    if (!normalizedDialogId) {
+        return undefined;
+    }
+    return `${resolveStateAccountId(accountId)}:${normalizedDialogId}`;
+}
+function buildAccountMessageScopeKey(accountId, currentMessageId) {
+    const normalizedMessageId = toMessageId(currentMessageId);
+    if (!normalizedMessageId) {
+        return undefined;
+    }
+    return `${resolveStateAccountId(accountId)}:${normalizedMessageId}`;
+}
+function buildPendingNativeForwardAckKey(dialogId, currentMessageId, accountId) {
+    const dialogKey = buildAccountDialogScopeKey(accountId, dialogId);
+    const normalizedMessageId = toMessageId(currentMessageId);
+    if (!dialogKey || !normalizedMessageId) {
+        return undefined;
+    }
+    return `${dialogKey}:${normalizedMessageId}`;
+}
+function prunePendingNativeForwardAcks(now = Date.now()) {
+    for (const [key, expiresAt] of pendingNativeForwardAcks.entries()) {
+        if (!Number.isFinite(expiresAt) || expiresAt <= now) {
+            pendingNativeForwardAcks.delete(key);
+        }
+    }
+}
+function markPendingNativeForwardAck(dialogId, currentMessageId, accountId) {
+    const key = buildPendingNativeForwardAckKey(dialogId, currentMessageId, accountId);
+    if (!key) {
+        return;
+    }
+    prunePendingNativeForwardAcks();
+    pendingNativeForwardAcks.set(key, Date.now() + NATIVE_FORWARD_ACK_TTL_MS);
+}
+function consumePendingNativeForwardAck(dialogId, currentMessageId, accountId) {
+    const key = buildPendingNativeForwardAckKey(dialogId, currentMessageId, accountId);
+    if (!key) {
+        return false;
+    }
+    prunePendingNativeForwardAcks();
+    const expiresAt = pendingNativeForwardAcks.get(key);
+    if (!expiresAt) {
+        return false;
+    }
+    pendingNativeForwardAcks.delete(key);
+    return true;
+}
+function resolvePendingNativeForwardAckDialogId(currentMessageId, fallbackDialogId, accountId) {
+    const messageKey = buildAccountMessageScopeKey(accountId, currentMessageId);
+    if (!messageKey) {
+        return fallbackDialogId;
+    }
+    return inboundMessageContextById.get(messageKey)?.dialogId ?? fallbackDialogId;
+}
+function resolveRecentInboundDialogId(currentMessageId, accountId) {
+    const messageKey = buildAccountMessageScopeKey(accountId, currentMessageId);
+    if (!messageKey) {
+        return undefined;
+    }
+    pruneRecentInboundMessages();
+    return inboundMessageContextById.get(messageKey)?.dialogId;
+}
+function splitFileNameParts(fileName) {
+    const normalizedFileName = basename(fileName).trim();
+    const lastDotIndex = normalizedFileName.lastIndexOf('.');
+    if (lastDotIndex <= 0) {
+        return { stem: normalizedFileName, extension: '' };
+    }
+    return {
+        stem: normalizedFileName.slice(0, lastDotIndex).trim(),
+        extension: normalizedFileName.slice(lastDotIndex).trim(),
+    };
+}
+function normalizeSourceFileStem(stem) {
+    return stem
+        .trim()
+        .replace(/\s+\(\d+\)$/u, '')
+        .trim();
+}
+function isGenericOutboundFileName(fileName) {
+    const { stem } = splitFileNameParts(fileName);
+    return GENERIC_OUTBOUND_FILE_NAME_RE.test(stem);
+}
+function isSemanticInboundFileName(fileName) {
+    const { stem } = splitFileNameParts(fileName);
+    return Boolean(stem) && !GENERIC_INBOUND_FILE_NAME_RE.test(stem);
+}
+function inferTranslationSuffixFromBody(body) {
+    const normalizedBody = body.toLowerCase();
+    if (!/translate|translation|перевед|перевод/u.test(normalizedBody)) {
+        return undefined;
+    }
+    const languagePatterns = [
+        ['en', /english|английск/u],
+        ['ru', /russian|русск/u],
+        ['de', /german|немец/u],
+        ['fr', /french|француз/u],
+        ['es', /spanish|испан/u],
+        ['it', /italian|итальян/u],
+        ['pt', /portuguese|португал/u],
+        ['zh', /chinese|китай/u],
+        ['ja', /japanese|япон/u],
+        ['ko', /korean|корей/u],
+    ];
+    for (const [code, pattern] of languagePatterns) {
+        if (pattern.test(normalizedBody)) {
+            return `_${code}`;
+        }
+    }
+    return '_translated';
+}
+function inferTranslationSuffix(requestedFileName, body) {
+    const { stem } = splitFileNameParts(requestedFileName);
+    const suffixMatch = stem.match(/(?:^|[_-])(en|ru|de|fr|es|it|pt|zh|ja|ko)$/i);
+    if (suffixMatch?.[1]) {
+        return `_${suffixMatch[1].toLowerCase()}`;
+    }
+    return inferTranslationSuffixFromBody(body);
+}
+function resolveRecentInboundContext(params) {
+    pruneRecentInboundMessages();
+    const explicitKey = buildAccountMessageScopeKey(params.accountId, params.currentMessageId);
+    const explicitEntry = explicitKey ? inboundMessageContextById.get(explicitKey) : undefined;
+    if (explicitEntry) {
+        return explicitEntry;
+    }
+    const dialogKey = buildAccountDialogScopeKey(params.accountId, params.dialogId);
+    if (!dialogKey) {
+        return undefined;
+    }
+    const recentEntries = recentInboundMessagesByDialog.get(dialogKey);
+    if (!recentEntries?.length) {
+        return undefined;
+    }
+    for (let index = recentEntries.length - 1; index >= 0; index -= 1) {
+        const entry = recentEntries[index];
+        const messageKey = buildAccountMessageScopeKey(params.accountId, entry.messageId);
+        if (!messageKey) {
+            continue;
+        }
+        const inboundEntry = inboundMessageContextById.get(messageKey);
+        if (inboundEntry) {
+            return inboundEntry;
+        }
+    }
+    return undefined;
+}
+function resolveSemanticOutboundFileName(params) {
+    const requestedBaseName = basename(params.requestedFileName).trim();
+    if (!requestedBaseName || !isGenericOutboundFileName(requestedBaseName)) {
+        return requestedBaseName;
+    }
+    const inboundContext = resolveRecentInboundContext({
+        dialogId: params.dialogId,
+        currentMessageId: params.currentMessageId,
+        accountId: params.accountId,
+    });
+    if (!inboundContext || inboundContext.mediaNames.length !== 1) {
+        return requestedBaseName;
+    }
+    const sourceFileName = inboundContext.mediaNames[0];
+    if (!isSemanticInboundFileName(sourceFileName)) {
+        return requestedBaseName;
+    }
+    const { stem: sourceStemRaw, extension: sourceExtension } = splitFileNameParts(sourceFileName);
+    const { extension: requestedExtension } = splitFileNameParts(requestedBaseName);
+    const normalizedSourceStem = normalizeSourceFileStem(sourceStemRaw);
+    if (!normalizedSourceStem) {
+        return requestedBaseName;
+    }
+    const suffix = inferTranslationSuffix(requestedBaseName, inboundContext.body) ?? '';
+    const nextStem = suffix && !normalizedSourceStem.endsWith(suffix)
+        ? `${normalizedSourceStem}${suffix}`
+        : normalizedSourceStem;
+    const nextExtension = requestedExtension || sourceExtension;
+    return nextExtension ? `${nextStem}${nextExtension}` : nextStem;
+}
+async function maybeSendReactionTypingReset(params) {
+    const dialogId = typeof params.dialogId === 'string' ? params.dialogId.trim() : '';
+    if (!dialogId) {
+        return;
+    }
+    const sendTyping = params.sendService.sendTyping;
+    if (typeof sendTyping !== 'function') {
+        return;
+    }
+    try {
+        await sendTyping.call(params.sendService, { webhookUrl: params.webhookUrl, bot: params.bot, dialogId }, REACTION_TYPING_RESET_DURATION_SECONDS);
+    }
+    catch (error) {
+        defaultLogger.debug('Failed to send Bitrix24 reaction typing reset', {
+            dialogId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+async function maybeAddNativeForwardSuccessReaction(params) {
+    const messageId = toMessageId(params.currentMessageId);
+    if (!messageId) {
+        return;
+    }
+    const addReaction = params.api.addReaction;
+    if (typeof addReaction !== 'function') {
+        return;
+    }
+    let shouldResetTyping = false;
+    try {
+        await addReaction.call(params.api, params.webhookUrl, params.bot, messageId, NATIVE_FORWARD_SUCCESS_REACTION);
+        shouldResetTyping = true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes('REACTION_ALREADY_SET')) {
+            defaultLogger.debug('Native forward success reaction already set', { messageId });
+            shouldResetTyping = true;
+        }
+        else {
+            defaultLogger.warn('Failed to add native forward success reaction', {
+                messageId,
+                error: errorMessage,
+            });
+        }
+    }
+    if (shouldResetTyping) {
+        await maybeSendReactionTypingReset({
+            sendService: params.sendService,
+            webhookUrl: params.webhookUrl,
+            bot: params.bot,
+            dialogId: params.dialogId,
+        });
+    }
+}
+function buildPendingNativeReactionAckKey(currentMessageId, accountId) {
+    return buildAccountMessageScopeKey(accountId, currentMessageId);
+}
+function pruneRecentSuccessfulActions(now = Date.now()) {
+    for (const [key, expiresAt] of recentSuccessfulActionsByMessage.entries()) {
+        if (!Number.isFinite(expiresAt) || expiresAt <= now) {
+            recentSuccessfulActionsByMessage.delete(key);
+        }
+    }
+}
+function markRecentSuccessfulAction(currentMessageId, accountId) {
+    const key = buildAccountMessageScopeKey(accountId, currentMessageId);
+    if (!key) {
+        return;
+    }
+    pruneRecentSuccessfulActions();
+    recentSuccessfulActionsByMessage.set(key, Date.now() + RECENT_SUCCESSFUL_ACTION_TTL_MS);
+}
+function hasRecentSuccessfulAction(currentMessageId, accountId) {
+    const key = buildAccountMessageScopeKey(accountId, currentMessageId);
+    if (!key) {
+        return false;
+    }
+    pruneRecentSuccessfulActions();
+    return recentSuccessfulActionsByMessage.has(key);
+}
+function pruneRecentOutboundMessages(now = Date.now()) {
+    for (const [key, expiresAt] of recentOutboundMessagesById.entries()) {
+        if (!Number.isFinite(expiresAt) || expiresAt <= now) {
+            recentOutboundMessagesById.delete(key);
+        }
+    }
+}
+function markRecentOutboundMessage(messageId, accountId) {
+    const key = buildAccountMessageScopeKey(accountId, messageId);
+    if (!key) {
+        return;
+    }
+    pruneRecentOutboundMessages();
+    recentOutboundMessagesById.set(key, Date.now() + RECENT_OUTBOUND_MESSAGE_TTL_MS);
+}
+function hasRecentOutboundMessage(messageId, accountId) {
+    const key = buildAccountMessageScopeKey(accountId, messageId);
+    if (!key) {
+        return false;
+    }
+    pruneRecentOutboundMessages();
+    return recentOutboundMessagesById.has(key);
+}
+function pruneRecentWatchNotifications(now = Date.now()) {
+    for (const [key, expiresAt] of recentWatchNotificationsByMessage.entries()) {
+        if (!Number.isFinite(expiresAt) || expiresAt <= now) {
+            recentWatchNotificationsByMessage.delete(key);
+        }
+    }
+}
+function markRecentWatchNotification(messageId, accountId) {
+    const key = buildAccountMessageScopeKey(accountId, messageId);
+    if (!key) {
+        return;
+    }
+    pruneRecentWatchNotifications();
+    recentWatchNotificationsByMessage.set(key, Date.now() + RECENT_WATCH_NOTIFICATION_TTL_MS);
+}
+function hasRecentWatchNotification(messageId, accountId) {
+    const key = buildAccountMessageScopeKey(accountId, messageId);
+    if (!key) {
+        return false;
+    }
+    pruneRecentWatchNotifications();
+    return recentWatchNotificationsByMessage.has(key);
+}
+function buildRecentMediaDeliveryKey(dialogId, currentMessageId, accountId) {
+    return buildPendingNativeForwardAckKey(dialogId, currentMessageId, accountId);
+}
+function normalizeMediaDeliveryName(mediaUrl) {
+    return basename(mediaUrl.trim()).toLowerCase();
+}
+function pruneRecentMediaDeliveries(now = Date.now()) {
+    for (const [key, entry] of recentSuccessfulMediaDeliveries.entries()) {
+        if (!entry || !Number.isFinite(entry.expiresAt) || entry.expiresAt <= now) {
+            recentSuccessfulMediaDeliveries.delete(key);
+        }
+    }
+}
+function markRecentMediaDelivery(params) {
+    const key = buildRecentMediaDeliveryKey(params.dialogId, params.currentMessageId, params.accountId);
+    if (!key || params.mediaUrls.length === 0) {
+        return;
+    }
+    pruneRecentMediaDeliveries();
+    const mediaByName = recentSuccessfulMediaDeliveries.get(key)?.mediaByName ?? new Map();
+    const normalizedMessageId = String(params.messageId ?? '').trim();
+    for (const mediaUrl of params.mediaUrls) {
+        const mediaName = normalizeMediaDeliveryName(mediaUrl);
+        if (!mediaName) {
+            continue;
+        }
+        mediaByName.set(mediaName, normalizedMessageId);
+    }
+    recentSuccessfulMediaDeliveries.set(key, {
+        expiresAt: Date.now() + RECENT_MEDIA_DELIVERY_TTL_MS,
+        mediaByName,
+    });
+}
+function findRecentMediaDelivery(params) {
+    const key = buildRecentMediaDeliveryKey(params.dialogId, params.currentMessageId, params.accountId);
+    if (!key || params.mediaUrls.length === 0) {
+        return null;
+    }
+    pruneRecentMediaDeliveries();
+    const entry = recentSuccessfulMediaDeliveries.get(key);
+    if (!entry) {
+        return null;
+    }
+    const normalizedNames = params.mediaUrls
+        .map((mediaUrl) => normalizeMediaDeliveryName(mediaUrl))
+        .filter(Boolean);
+    if (normalizedNames.length === 0) {
+        return null;
+    }
+    for (const mediaName of normalizedNames) {
+        if (!entry.mediaByName.has(mediaName)) {
+            return null;
+        }
+    }
+    const lastMessageId = normalizedNames
+        .map((mediaName) => entry.mediaByName.get(mediaName) ?? '')
+        .find(Boolean);
+    return lastMessageId ? { messageId: lastMessageId } : {};
+}
+function hasRecentMediaDelivery(dialogId, currentMessageId, accountId) {
+    const key = buildRecentMediaDeliveryKey(dialogId, currentMessageId, accountId);
+    if (!key) {
+        return false;
+    }
+    pruneRecentMediaDeliveries();
+    const entry = recentSuccessfulMediaDeliveries.get(key);
+    return Boolean(entry && entry.mediaByName.size > 0);
+}
+function prunePendingNativeReactionAcks(now = Date.now()) {
+    for (const [key, entry] of pendingNativeReactionAcks.entries()) {
+        if (!entry || !Number.isFinite(entry.expiresAt) || entry.expiresAt <= now) {
+            pendingNativeReactionAcks.delete(key);
+        }
+    }
+}
+function markPendingNativeReactionAck(currentMessageId, emoji, accountId) {
+    const key = buildPendingNativeReactionAckKey(currentMessageId, accountId);
+    const normalizedEmoji = emoji.trim();
+    if (!key || !normalizedEmoji) {
+        return;
+    }
+    prunePendingNativeReactionAcks();
+    pendingNativeReactionAcks.set(key, {
+        emoji: normalizedEmoji,
+        expiresAt: Date.now() + NATIVE_REACTION_ACK_TTL_MS,
+    });
+}
+function consumePendingNativeReactionAck(currentMessageId, text, accountId) {
+    const key = buildPendingNativeReactionAckKey(currentMessageId, accountId);
+    if (!key) {
+        return false;
+    }
+    prunePendingNativeReactionAcks();
+    const pendingAck = pendingNativeReactionAcks.get(key);
+    if (!pendingAck) {
+        return false;
+    }
+    if (normalizeComparableMessageText(text) !== pendingAck.emoji) {
+        return false;
+    }
+    pendingNativeReactionAcks.delete(key);
+    return true;
+}
+function pruneRecentInboundMessages(now = Date.now()) {
+    for (const [dialogKey, entries] of recentInboundMessagesByDialog.entries()) {
+        const nextEntries = entries.filter((entry) => Number.isFinite(entry.timestamp) && entry.timestamp > now - RECENT_INBOUND_MESSAGE_TTL_MS);
+        if (nextEntries.length === 0) {
+            recentInboundMessagesByDialog.delete(dialogKey);
+        }
+        else if (nextEntries.length !== entries.length) {
+            recentInboundMessagesByDialog.set(dialogKey, nextEntries);
+        }
+    }
+    for (const [messageId, entry] of inboundMessageContextById.entries()) {
+        if (!Number.isFinite(entry.timestamp) || entry.timestamp <= now - RECENT_INBOUND_MESSAGE_TTL_MS) {
+            inboundMessageContextById.delete(messageId);
+        }
+    }
+}
+function rememberRecentInboundMessage(dialogId, messageId, body, mediaNames = [], timestamp = Date.now(), accountId) {
+    const normalizedMessageId = toMessageId(messageId);
+    const normalizedBody = body.trim();
+    const dialogKey = buildAccountDialogScopeKey(accountId, dialogId);
+    const messageKey = buildAccountMessageScopeKey(accountId, normalizedMessageId);
+    if (!dialogKey || !messageKey || !normalizedBody) {
+        return;
+    }
+    pruneRecentInboundMessages(timestamp);
+    const id = String(normalizedMessageId);
+    const currentEntries = recentInboundMessagesByDialog.get(dialogKey) ?? [];
+    const nextEntries = currentEntries
+        .filter((entry) => entry.messageId !== id)
+        .concat({ messageId: id, body: normalizedBody, timestamp })
+        .slice(-RECENT_INBOUND_MESSAGE_LIMIT);
+    recentInboundMessagesByDialog.set(dialogKey, nextEntries);
+    inboundMessageContextById.set(messageKey, {
+        dialogId,
+        dialogKey,
+        body: normalizedBody,
+        mediaNames: mediaNames
+            .filter((name) => typeof name === 'string')
+            .map((name) => name.trim())
+            .filter(Boolean),
+        timestamp,
+    });
+}
+function findPreviousRecentInboundMessage(currentMessageId, accountId) {
+    const messageKey = buildAccountMessageScopeKey(accountId, currentMessageId);
+    const normalizedMessageId = toMessageId(currentMessageId);
+    if (!messageKey || !normalizedMessageId) {
+        return undefined;
+    }
+    pruneRecentInboundMessages();
+    const currentEntry = inboundMessageContextById.get(messageKey);
+    if (!currentEntry) {
+        return undefined;
+    }
+    const dialogEntries = recentInboundMessagesByDialog.get(currentEntry.dialogKey);
+    if (!dialogEntries || dialogEntries.length === 0) {
+        return undefined;
+    }
+    const currentIndex = dialogEntries.findIndex((entry) => entry.messageId === String(normalizedMessageId));
+    if (currentIndex <= 0) {
+        return undefined;
+    }
+    for (let index = currentIndex - 1; index >= 0; index -= 1) {
+        const entry = dialogEntries[index];
+        if (entry.body.trim()) {
+            return entry;
+        }
+    }
+    return undefined;
+}
+const INLINE_REPLY_DIRECTIVE_RE = /\[\[\s*(reply_to_current|reply_to\s*:\s*([^\]\n]+))\s*\]\]/gi;
+function normalizeComparableMessageText(value) {
+    return value
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function normalizeBitrix24DialogTarget(raw) {
+    const stripped = raw.trim().replace(CHANNEL_PREFIX_RE, '');
+    if (!stripped) {
+        return '';
+    }
+    const bracketedUserMatch = stripped.match(/^\[USER=(\d+)(?:[^\]]*)\][\s\S]*?\[\/USER\]$/iu);
+    if (bracketedUserMatch?.[1]) {
+        return bracketedUserMatch[1];
+    }
+    const bracketedChatMatch = stripped.match(/^\[CHAT=(?:chat)?(\d+)(?:[^\]]*)\][\s\S]*?\[\/CHAT\]$/iu);
+    if (bracketedChatMatch?.[1]) {
+        return `chat${bracketedChatMatch[1]}`;
+    }
+    const plainUserMatch = stripped.match(/^USER=(\d+)$/iu);
+    if (plainUserMatch?.[1]) {
+        return plainUserMatch[1];
+    }
+    const plainChatMatch = stripped.match(/^CHAT=(?:chat)?(\d+)$/iu);
+    if (plainChatMatch?.[1]) {
+        return `chat${plainChatMatch[1]}`;
+    }
+    const prefixedChatMatch = stripped.match(/^chat(\d+)$/iu);
+    if (prefixedChatMatch?.[1]) {
+        return `chat${prefixedChatMatch[1]}`;
+    }
+    return stripped;
+}
+function looksLikeBitrix24DialogTarget(raw) {
+    const normalized = normalizeBitrix24DialogTarget(raw);
+    return /^\d+$/.test(normalized) || /^chat\d+$/iu.test(normalized);
+}
+function extractBitrix24DialogTargetsFromText(text) {
+    const targets = new Set();
+    for (const match of text.matchAll(/\[CHAT=(?:chat)?(\d+)(?:[^\]]*)\][\s\S]*?\[\/CHAT\]/giu)) {
+        if (match[1]) {
+            targets.add(`chat${match[1]}`);
+        }
+    }
+    for (const match of text.matchAll(/\[USER=(\d+)(?:[^\]]*)\][\s\S]*?\[\/USER\]/giu)) {
+        if (match[1]) {
+            targets.add(match[1]);
+        }
+    }
+    for (const match of text.matchAll(/\bCHAT=(?:chat)?(\d+)\b/giu)) {
+        if (match[1]) {
+            targets.add(`chat${match[1]}`);
+        }
+    }
+    for (const match of text.matchAll(/\bUSER=(\d+)\b/giu)) {
+        if (match[1]) {
+            targets.add(match[1]);
+        }
+    }
+    return [...targets];
+}
+function isLikelyForwardControlMessage(text) {
+    return extractBitrix24DialogTargetsFromText(text).length > 0;
+}
+function extractReplyDirective(params) {
+    let wantsCurrentReply = false;
+    let inlineReplyToId;
+    const cleanText = cleanupTextAfterInlineMediaExtraction(params.text.replace(INLINE_REPLY_DIRECTIVE_RE, (_match, _rawDirective, explicitId) => {
+        if (typeof explicitId === 'string' && explicitId.trim()) {
+            inlineReplyToId = explicitId.trim();
+        }
+        else {
+            wantsCurrentReply = true;
+        }
+        return ' ';
+    }));
+    const explicitReplyToMessageId = parseActionMessageIds(params.explicitReplyToId)[0];
+    if (explicitReplyToMessageId) {
+        return { cleanText, replyToMessageId: explicitReplyToMessageId };
+    }
+    const inlineReplyToMessageId = parseActionMessageIds(inlineReplyToId)[0];
+    if (inlineReplyToMessageId) {
+        return { cleanText, replyToMessageId: inlineReplyToMessageId };
+    }
+    if (wantsCurrentReply) {
+        const currentReplyToMessageId = parseActionMessageIds(params.currentMessageId)[0];
+        if (currentReplyToMessageId) {
+            return { cleanText, replyToMessageId: currentReplyToMessageId };
+        }
+    }
+    return { cleanText };
+}
+function isBitrix24DirectDialogId(dialogId) {
+    const normalizedDialogId = String(dialogId ?? '').trim();
+    return normalizedDialogId.length > 0 && !normalizedDialogId.startsWith('chat');
+}
+function shouldUseBitrix24NativeReply(params) {
+    if (typeof params.isDm === 'boolean') {
+        return !params.isDm;
+    }
+    if (!params.dialogId) {
+        return false;
+    }
+    return !isBitrix24DirectDialogId(params.dialogId);
+}
+function findNativeForwardTarget(params) {
+    const deliveredText = normalizeComparableMessageText(params.deliveredText);
+    if (!deliveredText) {
+        return undefined;
+    }
+    if (deliveredText === normalizeComparableMessageText(params.requestText)) {
+        return undefined;
+    }
+    const currentMessageId = toMessageId(params.currentMessageId);
+    const matchedEntry = [...params.historyEntries]
+        .reverse()
+        .find((entry) => {
+        if (normalizeComparableMessageText(entry.body) !== deliveredText) {
+            return false;
+        }
+        return currentMessageId === undefined || toMessageId(entry.messageId) !== currentMessageId;
+    });
+    if (!matchedEntry) {
+        return undefined;
+    }
+    return toMessageId(matchedEntry.messageId);
+}
+function findImplicitForwardTargetFromRecentInbound(params) {
+    const normalizedDeliveredText = normalizeComparableMessageText(params.deliveredText);
+    const normalizedRequestText = normalizeComparableMessageText(params.requestText);
+    const targetDialogIds = extractBitrix24DialogTargetsFromText(params.requestText);
+    const isForwardMarkerOnly = Boolean(normalizedDeliveredText) && FORWARD_MARKER_RE.test(normalizedDeliveredText);
+    if (!normalizedDeliveredText
+        || (!isForwardMarkerOnly
+            && (targetDialogIds.length === 0
+                || normalizedDeliveredText !== normalizedRequestText))) {
+        return undefined;
+    }
+    const previousInboundMessage = findPreviousRecentInboundMessage(params.currentMessageId, params.accountId);
+    if (previousInboundMessage) {
+        return Number(previousInboundMessage.messageId);
+    }
+    const previousHistoryEntry = [...(params.historyEntries ?? [])]
+        .reverse()
+        .find((entry) => toMessageId(entry.messageId));
+    return toMessageId(previousHistoryEntry?.messageId);
+}
+function findPreviousForwardableMessageId(params) {
+    // If the user replied to a specific message, that's the source to forward
+    const replyToId = toMessageId(params.replyToMessageId);
+    if (replyToId) {
+        return replyToId;
+    }
+    const normalizedCurrentBody = normalizeComparableMessageText(params.currentBody);
+    const previousHistoryEntry = [...(params.historyEntries ?? [])]
+        .reverse()
+        .find((entry) => {
+        const messageId = toMessageId(entry.messageId);
+        const normalizedBody = normalizeComparableMessageText(entry.body);
+        if (!messageId || !normalizedBody) {
+            return false;
+        }
+        if (normalizedCurrentBody && normalizedBody === normalizedCurrentBody) {
+            return false;
+        }
+        return !isLikelyForwardControlMessage(entry.body);
+    });
+    if (previousHistoryEntry) {
+        return toMessageId(previousHistoryEntry.messageId);
+    }
+    const previousInboundMessage = findPreviousRecentInboundMessage(params.currentMessageId, params.accountId);
+    if (previousInboundMessage) {
+        if (normalizeComparableMessageText(previousInboundMessage.body) !== normalizedCurrentBody
+            && !isLikelyForwardControlMessage(previousInboundMessage.body)) {
+            return Number(previousInboundMessage.messageId);
+        }
+    }
+    return undefined;
+}
+function buildBitrix24NativeForwardAgentHint(params) {
+    const targetDialogIds = extractBitrix24DialogTargetsFromText(params.currentBody);
+    const sourceMessageId = findPreviousForwardableMessageId(params);
+    if (!sourceMessageId) {
+        return undefined;
+    }
+    const formattedTargets = targetDialogIds
+        .map((dialogId) => (dialogId.startsWith('chat') ? `${dialogId} (chat)` : `${dialogId} (user)`))
+        .join(', ');
+    const lines = [
+        '[Bitrix24 native forward instruction]',
+        'Use this only if you intentionally want a native Bitrix24 forward instead of repeating visible text.',
+        `Previous Bitrix24 message id available for forwarding: ${sourceMessageId}.`,
+        'Use action "send" with "forwardMessageIds" set to that source message id.',
+        'If the tool requires a non-empty message field for a pure forward, use "↩️".',
+        'Do not repeat the source message text or the user instruction text when doing a native forward.',
+    ];
+    if (formattedTargets) {
+        lines.push(`Explicit target dialog ids mentioned in the current message: ${formattedTargets}.`);
+        lines.push('If you forward to those explicit targets, send one message-tool call per target dialog id and set "to" to the exact dialog id shown above.');
+        lines.push('Do not use CHAT=xxx or USER=xxx format for "to" — use "chat520" or "77" directly.');
+    }
+    else {
+        lines.push('If you forward in the current dialog, do not set "to" to another dialog id.');
+    }
+    lines.push('[/Bitrix24 native forward instruction]');
+    return lines.join('\n');
+}
+function buildBitrix24NativeReplyAgentHint(currentMessageId) {
+    const normalizedMessageId = toMessageId(currentMessageId);
+    if (!normalizedMessageId) {
+        return undefined;
+    }
+    return [
+        '[Bitrix24 native reply instruction]',
+        `Current Bitrix24 message id: ${normalizedMessageId}.`,
+        'Only in group chats, if you intentionally want a native Bitrix24 reply to the current inbound message, set "replyToMessageId" to that id.',
+        'For text-only payloads in group chats, you can also prepend [[reply_to_current]] to the reply text.',
+        'Do not use a native reply unless you actually want reply threading.',
+        '[/Bitrix24 native reply instruction]',
+    ].join('\n');
+}
+function buildBitrix24FileDeliveryAgentHint() {
+    return [
+        '[Bitrix24 file delivery instruction]',
+        'When you need to deliver a real file or document to the user, prefer a structured reply payload with field "mediaUrl" or "mediaUrls".',
+        'Set "mediaUrl" to the local path of the generated file in the OpenClaw workspace or managed media directory.',
+        'If the current prompt already includes a <file ...>...</file> block with the file contents, use that inline content directly and do not call read on the attached Bitrix24 media path unless you truly need to.',
+        'If read on an attached Bitrix24 media path fails, fall back to the inline <file> content from the current prompt instead of giving up.',
+        'If you use the generic message tool instead of a structured reply payload, attach the local file with "media", "filePath", or "path". Do not use "mediaUrl" with the message tool.',
+        'Use "text" only for an optional short caption.',
+        'For file requests, follow this order exactly: read/prepare content, write the output file, send that file once, then stop.',
+        'Never call the file-delivery tool before the write tool has succeeded for that file path.',
+        'If the upload tool says the media upload failed, fix the file path or create the file first. Do not blindly retry the same send.',
+        'After one successful file upload in a turn, do not send the same file again and do not send an extra text-only confirmation.',
+        'Do not output "NO_REPLY" unless you already called the message tool or emitted a structured reply payload with mediaUrl/mediaUrls in this same turn.',
+        'Do not output "NO_REPLY" after only read/write tools. NO_REPLY is allowed only after the actual file-delivery tool result succeeded in this same turn.',
+        'If the user asked for a file and you have not emitted the actual file delivery payload yet, do not answer with "NO_REPLY".',
+        'Do not place local file paths inside markdown links or plain text, because that only sends text to the user and does not upload the file.',
+        '[/Bitrix24 file delivery instruction]',
+    ].join('\n');
+}
+export function buildBitrix24InlineButtonsAgentHint() {
+    return [
+        '[Bitrix24 buttons instruction]',
+        'For an ordinary reply in the current Bitrix24 dialog that needs buttons or multiple choices, prefer normal assistant text with inline button markup instead of calling the message tool.',
+        'Append the buttons to the end of the visible reply text using the exact format [[{"text":"Option 1","callback_data":"one"},{"text":"Option 2","callback_data":"two"}]].',
+        'The channel will strip that markup from the visible text and render native Bitrix24 buttons automatically.',
+        'Use the message tool for Bitrix24 only when you truly need an explicit action such as send to another dialog, native forward/reply, reaction, edit, delete, or file upload.',
+        '[/Bitrix24 buttons instruction]',
+    ].join('\n');
+}
+function getDispatchCount(counts, key) {
+    const value = counts?.[key];
+    return Number.isFinite(value) ? Number(value) : 0;
+}
+function isEmptyDispatchResult(dispatchResult) {
+    if (!dispatchResult || dispatchResult.queuedFinal !== false) {
+        return false;
+    }
+    const toolCount = getDispatchCount(dispatchResult.counts, 'tool');
+    const blockCount = getDispatchCount(dispatchResult.counts, 'block');
+    const finalCount = getDispatchCount(dispatchResult.counts, 'final');
+    return toolCount + blockCount + finalCount === 0;
+}
+function readExplicitForwardMessageIds(rawParams) {
+    return parseActionMessageIds(rawParams.forwardMessageIds
+        ?? rawParams.forwardIds);
+}
+function resolveActionForwardMessageIds(params) {
+    const explicitForwardMessages = readExplicitForwardMessageIds(params.rawParams);
+    if (explicitForwardMessages.length > 0) {
+        return explicitForwardMessages;
+    }
+    const aliasedForwardMessages = parseActionMessageIds(params.rawParams.messageIds
+        ?? params.rawParams.message_ids
+        ?? params.rawParams.messageId
+        ?? params.rawParams.message_id
+        ?? params.rawParams.replyToMessageId
+        ?? params.rawParams.replyToId);
+    if (aliasedForwardMessages.length > 0) {
+        return aliasedForwardMessages;
+    }
+    const previousInboundMessage = findPreviousRecentInboundMessage(params.toolContext?.currentMessageId, params.accountId);
+    return previousInboundMessage ? [Number(previousInboundMessage.messageId)] : [];
+}
+const FORWARD_MARKER_RE = /^[\s↩️➡️→⤵️🔄📨]+$/u;
+function normalizeForwardActionText(text) {
+    const normalizedText = typeof text === 'string' ? text.trim() : '';
+    if (!normalizedText || FORWARD_MARKER_RE.test(normalizedText)) {
+        return '';
+    }
+    return normalizedText;
+}
 function escapeBbCodeText(value) {
     return value
         .replace(/\[/g, '(')
@@ -262,6 +1067,9 @@ function createReplyStatusHeartbeat(params) {
 async function waitReplyFallbackGraceWindow() {
     await new Promise((resolve) => setTimeout(resolve, REPLY_FALLBACK_GRACE_MS));
 }
+async function waitEmptyReplyFallbackGraceWindow() {
+    await new Promise((resolve) => setTimeout(resolve, EMPTY_REPLY_FALLBACK_GRACE_MS));
+}
 export function canCoalesceDirectMessage(msgCtx, config) {
     return msgCtx.isDm
         && config.dmPolicy !== 'pairing'
@@ -741,6 +1549,19 @@ class BufferedDirectMessageCoalescer {
 let gatewayState = null;
 export function __setGatewayStateForTests(state) {
     gatewayState = state;
+    if (state === null) {
+        pendingNativeForwardAcks.clear();
+        pendingNativeReactionAcks.clear();
+        recentSuccessfulMediaDeliveries.clear();
+        recentSuccessfulActionsByMessage.clear();
+        recentOutboundMessagesById.clear();
+        recentWatchNotificationsByMessage.clear();
+        recentInboundMessagesByDialog.clear();
+        inboundMessageContextById.clear();
+    }
+}
+export function __rememberRecentInboundMessageForTests(params) {
+    rememberRecentInboundMessage(params.dialogId, params.messageId, params.body, params.mediaNames, params.timestamp, params.accountId);
 }
 // ─── Keyboard layouts ────────────────────────────────────────────────────────
 export function buildWelcomeKeyboard(language) {
@@ -768,6 +1589,638 @@ export function buildDefaultCommandKeyboard(language) {
 }
 export const DEFAULT_COMMAND_KEYBOARD = buildDefaultCommandKeyboard();
 export const DEFAULT_WELCOME_KEYBOARD = buildWelcomeKeyboard();
+const BITRIX24_ACTION_NAMES = ['send', 'reply', 'react', 'edit', 'delete'];
+const BITRIX24_DISCOVERY_ACTION_NAMES = ['send', 'reply', 'react', 'edit', 'delete'];
+function buildMessageToolButtonsSchema() {
+    return {
+        type: 'array',
+        description: 'Optional Bitrix24 message buttons as rows of button objects. Each button object can include text, optional callback_data and optional style.',
+        items: {
+            type: 'array',
+            items: {
+                type: 'object',
+                description: 'Single button object. Use text, optional callback_data, and optional style=primary|attention|danger.',
+            },
+        },
+    };
+}
+function buildMessageToolAttachSchema() {
+    return {
+        description: 'Bitrix24 ATTACH rich layout blocks. Use this for rich cards, not for binary file uploads. Accepts either an array of block objects or an object with BLOCKS array. Prefer direct Bitrix block keys such as [{USER:{USER_ID:1,NAME:"Eugene"}},{GRID:[{DISPLAY:"LINE",NAME:"Status",VALUE:"In progress"},{DISPLAY:"LINE",NAME:"Owner",VALUE:"Eugene"}]},{LINK:{NAME:"Open",LINK:"https://example.com"}}]. Supported top-level block keys include MESSAGE, LINK, IMAGE, FILE, DELIMITER, GRID and USER. For actual file uploads, use the generic message tool fields media/filePath/path or a structured reply payload with mediaUrl/mediaUrls.',
+    };
+}
+function buildMessageToolIdListSchema(description) {
+    return {
+        description: `${description} Can be an integer, a string, or an array of integers.`,
+    };
+}
+function resolveConfiguredBitrix24ActionAccounts(cfg, accountId) {
+    if (accountId) {
+        const account = resolveAccount(cfg, accountId);
+        return account.enabled && account.configured ? [account.accountId] : [];
+    }
+    return listAccountIds(cfg).filter((candidateId) => {
+        const account = resolveAccount(cfg, candidateId);
+        return account.enabled && account.configured;
+    });
+}
+function describeBitrix24MessageTool(params) {
+    const configuredAccounts = resolveConfiguredBitrix24ActionAccounts(params.cfg, params.accountId);
+    if (configuredAccounts.length === 0) {
+        return {
+            actions: [],
+            capabilities: [],
+            schema: null,
+        };
+    }
+    return {
+        actions: [...BITRIX24_DISCOVERY_ACTION_NAMES],
+        capabilities: ['interactive', 'buttons', 'cards'],
+        schema: {
+            properties: {
+                buttons: buildMessageToolButtonsSchema(),
+                attach: buildMessageToolAttachSchema(),
+                forwardMessageIds: buildMessageToolIdListSchema('Bitrix24 source message id(s) to forward natively. Use with action="send" plus to/target. Prefer the referenced message id, not the current instruction message id. The message field must be non-empty — use "↩️" (emoji) for a pure forward without extra text.'),
+                forwardIds: buildMessageToolIdListSchema('Alias for forwardMessageIds. Use with action="send".'),
+                replyToId: buildMessageToolIdListSchema('Bitrix24 message id to reply to natively inside the current dialog.'),
+                replyToMessageId: buildMessageToolIdListSchema('Alias for replyToId.'),
+            },
+        },
+    };
+}
+function extractBitrix24ToolSend(args) {
+    if ((typeof args.action === 'string' ? args.action.trim() : '') !== 'sendMessage') {
+        return null;
+    }
+    const to = typeof args.to === 'string' ? normalizeBitrix24DialogTarget(args.to) : '';
+    if (!to) {
+        return null;
+    }
+    const accountId = typeof args.accountId === 'string'
+        ? args.accountId.trim()
+        : undefined;
+    const threadId = typeof args.threadId === 'number'
+        ? String(args.threadId)
+        : typeof args.threadId === 'string'
+            ? args.threadId.trim()
+            : '';
+    return {
+        to,
+        ...(accountId ? { accountId } : {}),
+        ...(threadId ? { threadId } : {}),
+    };
+}
+function readActionTextParam(params) {
+    const rawText = params.message ?? params.text ?? params.content;
+    return typeof rawText === 'string' ? rawText : null;
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isAttachColorToken(value) {
+    return value === 'primary'
+        || value === 'secondary'
+        || value === 'alert'
+        || value === 'base';
+}
+function isPresent(value) {
+    return value != null;
+}
+function isAttachBlock(value) {
+    return isPlainObject(value) && Object.keys(value).length > 0;
+}
+function isBitrix24Attach(value) {
+    if (Array.isArray(value)) {
+        return value.length > 0 && value.every(isAttachBlock);
+    }
+    if (!isPlainObject(value) || !Array.isArray(value.BLOCKS) || value.BLOCKS.length === 0) {
+        return false;
+    }
+    if (value.COLOR_TOKEN !== undefined && !isAttachColorToken(value.COLOR_TOKEN)) {
+        return false;
+    }
+    return value.BLOCKS.every(isAttachBlock);
+}
+function readAttachString(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function readAttachNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return Math.trunc(value);
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        const normalized = Number(trimmed);
+        if (Number.isFinite(normalized)) {
+            return Math.trunc(normalized);
+        }
+    }
+    return undefined;
+}
+function normalizeAttachColorTokenValue(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    return isAttachColorToken(normalized) ? normalized : undefined;
+}
+function normalizeAttachGridDisplayValue(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toUpperCase();
+    return normalized === 'BLOCK'
+        || normalized === 'LINE'
+        || normalized === 'ROW'
+        || normalized === 'TABLE'
+        ? normalized
+        : undefined;
+}
+function normalizeAttachGridItem(rawValue) {
+    if (!isPlainObject(rawValue)) {
+        return undefined;
+    }
+    const display = normalizeAttachGridDisplayValue(rawValue.DISPLAY) ?? 'LINE';
+    const name = readAttachString(rawValue.NAME);
+    const value = readAttachString(rawValue.VALUE);
+    const width = readAttachNumber(rawValue.WIDTH);
+    const height = readAttachNumber(rawValue.HEIGHT);
+    const colorToken = normalizeAttachColorTokenValue(rawValue.COLOR_TOKEN);
+    const color = readAttachString(rawValue.COLOR);
+    const link = readAttachString(rawValue.LINK);
+    const userId = readAttachNumber(rawValue.USER_ID);
+    const chatId = readAttachNumber(rawValue.CHAT_ID);
+    if (!name && !value && !link && userId === undefined && chatId === undefined) {
+        return undefined;
+    }
+    return {
+        DISPLAY: display,
+        ...(name ? { NAME: name } : {}),
+        ...(value ? { VALUE: value } : {}),
+        ...(width !== undefined ? { WIDTH: width } : {}),
+        ...(height !== undefined ? { HEIGHT: height } : {}),
+        ...(colorToken ? { COLOR_TOKEN: colorToken } : {}),
+        ...(color ? { COLOR: color } : {}),
+        ...(link ? { LINK: link } : {}),
+        ...(userId !== undefined ? { USER_ID: userId } : {}),
+        ...(chatId !== undefined ? { CHAT_ID: chatId } : {}),
+    };
+}
+function normalizeAttachLinkValue(rawValue, aliasSource) {
+    if (typeof rawValue === 'string') {
+        const link = readAttachString(rawValue);
+        if (!link) {
+            return undefined;
+        }
+        const aliasName = aliasSource
+            ? readAttachString(aliasSource.NAME) ?? readAttachString(aliasSource.TITLE)
+            : undefined;
+        const aliasDesc = aliasSource ? readAttachString(aliasSource.DESC) : undefined;
+        const aliasHtml = aliasSource ? readAttachString(aliasSource.HTML) : undefined;
+        const aliasPreview = aliasSource ? readAttachString(aliasSource.PREVIEW) : undefined;
+        const aliasWidth = aliasSource ? readAttachNumber(aliasSource.WIDTH) : undefined;
+        const aliasHeight = aliasSource ? readAttachNumber(aliasSource.HEIGHT) : undefined;
+        const aliasUserId = aliasSource ? readAttachNumber(aliasSource.USER_ID) : undefined;
+        const aliasChatId = aliasSource ? readAttachNumber(aliasSource.CHAT_ID) : undefined;
+        const aliasNetworkId = aliasSource ? readAttachString(aliasSource.NETWORK_ID) : undefined;
+        return {
+            LINK: link,
+            ...(aliasName ? { NAME: aliasName } : {}),
+            ...(aliasDesc ? { DESC: aliasDesc } : {}),
+            ...(aliasHtml ? { HTML: aliasHtml } : {}),
+            ...(aliasPreview ? { PREVIEW: aliasPreview } : {}),
+            ...(aliasWidth !== undefined ? { WIDTH: aliasWidth } : {}),
+            ...(aliasHeight !== undefined ? { HEIGHT: aliasHeight } : {}),
+            ...(aliasUserId !== undefined ? { USER_ID: aliasUserId } : {}),
+            ...(aliasChatId !== undefined ? { CHAT_ID: aliasChatId } : {}),
+            ...(aliasNetworkId ? { NETWORK_ID: aliasNetworkId } : {}),
+        };
+    }
+    if (!isPlainObject(rawValue)) {
+        return undefined;
+    }
+    const link = readAttachString(rawValue.LINK);
+    if (!link) {
+        return undefined;
+    }
+    const name = readAttachString(rawValue.NAME) ?? readAttachString(rawValue.TITLE);
+    const desc = readAttachString(rawValue.DESC);
+    const html = readAttachString(rawValue.HTML);
+    const preview = readAttachString(rawValue.PREVIEW);
+    const width = readAttachNumber(rawValue.WIDTH);
+    const height = readAttachNumber(rawValue.HEIGHT);
+    const userId = readAttachNumber(rawValue.USER_ID);
+    const chatId = readAttachNumber(rawValue.CHAT_ID);
+    const networkId = readAttachString(rawValue.NETWORK_ID);
+    return {
+        LINK: link,
+        ...(name ? { NAME: name } : {}),
+        ...(desc ? { DESC: desc } : {}),
+        ...(html ? { HTML: html } : {}),
+        ...(preview ? { PREVIEW: preview } : {}),
+        ...(width !== undefined ? { WIDTH: width } : {}),
+        ...(height !== undefined ? { HEIGHT: height } : {}),
+        ...(userId !== undefined ? { USER_ID: userId } : {}),
+        ...(chatId !== undefined ? { CHAT_ID: chatId } : {}),
+        ...(networkId ? { NETWORK_ID: networkId } : {}),
+    };
+}
+function normalizeAttachImageItem(rawValue) {
+    const normalized = normalizeAttachLinkValue(rawValue);
+    if (!normalized) {
+        return undefined;
+    }
+    return {
+        LINK: normalized.LINK,
+        ...(normalized.NAME ? { NAME: normalized.NAME } : {}),
+        ...(normalized.PREVIEW ? { PREVIEW: normalized.PREVIEW } : {}),
+        ...(normalized.WIDTH !== undefined ? { WIDTH: normalized.WIDTH } : {}),
+        ...(normalized.HEIGHT !== undefined ? { HEIGHT: normalized.HEIGHT } : {}),
+    };
+}
+function normalizeAttachFileItem(rawValue) {
+    if (typeof rawValue === 'string') {
+        const link = readAttachString(rawValue);
+        return link ? { LINK: link } : undefined;
+    }
+    if (!isPlainObject(rawValue)) {
+        return undefined;
+    }
+    const link = readAttachString(rawValue.LINK);
+    if (!link) {
+        return undefined;
+    }
+    const name = readAttachString(rawValue.NAME);
+    const size = readAttachNumber(rawValue.SIZE);
+    return {
+        LINK: link,
+        ...(name ? { NAME: name } : {}),
+        ...(size !== undefined ? { SIZE: size } : {}),
+    };
+}
+function normalizeAttachUserValue(rawValue, aliasSource) {
+    if (typeof rawValue === 'number' || typeof rawValue === 'string') {
+        const userId = readAttachNumber(rawValue);
+        if (userId === undefined) {
+            return undefined;
+        }
+        const aliasName = aliasSource
+            ? readAttachString(aliasSource.NAME) ?? readAttachString(aliasSource.USER_NAME)
+            : undefined;
+        const aliasAvatar = aliasSource ? readAttachString(aliasSource.AVATAR) : undefined;
+        const aliasLink = aliasSource ? readAttachString(aliasSource.LINK) : undefined;
+        const aliasNetworkId = aliasSource ? readAttachString(aliasSource.NETWORK_ID) : undefined;
+        return {
+            USER_ID: userId,
+            ...(aliasName ? { NAME: aliasName } : {}),
+            ...(aliasAvatar ? { AVATAR: aliasAvatar } : {}),
+            ...(aliasLink ? { LINK: aliasLink } : {}),
+            ...(aliasNetworkId ? { NETWORK_ID: aliasNetworkId } : {}),
+        };
+    }
+    if (!isPlainObject(rawValue)) {
+        return undefined;
+    }
+    const userId = readAttachNumber(rawValue.USER_ID);
+    const name = readAttachString(rawValue.NAME) ?? readAttachString(rawValue.USER_NAME);
+    const avatar = readAttachString(rawValue.AVATAR);
+    const link = readAttachString(rawValue.LINK);
+    const networkId = readAttachString(rawValue.NETWORK_ID);
+    if (userId === undefined && !name && !avatar && !link && !networkId) {
+        return undefined;
+    }
+    return {
+        ...(name ? { NAME: name } : {}),
+        ...(avatar ? { AVATAR: avatar } : {}),
+        ...(link ? { LINK: link } : {}),
+        ...(userId !== undefined ? { USER_ID: userId } : {}),
+        ...(networkId ? { NETWORK_ID: networkId } : {}),
+    };
+}
+function normalizeAttachBlock(rawValue) {
+    if (!isPlainObject(rawValue)) {
+        return undefined;
+    }
+    const message = readAttachString(rawValue.MESSAGE);
+    if (message && Object.keys(rawValue).every((key) => key === 'MESSAGE' || key === 'TYPE')) {
+        return { MESSAGE: message };
+    }
+    if ('LINK' in rawValue && rawValue.LINK !== undefined) {
+        const linkValue = normalizeAttachLinkValue(rawValue.LINK, rawValue);
+        if (linkValue) {
+            return { LINK: linkValue };
+        }
+    }
+    if ('IMAGE' in rawValue && rawValue.IMAGE !== undefined) {
+        const rawImage = rawValue.IMAGE;
+        const imageItems = Array.isArray(rawImage)
+            ? rawImage.map(normalizeAttachImageItem).filter(isPresent)
+            : [normalizeAttachImageItem(rawImage)].filter(isPresent);
+        if (imageItems.length > 0) {
+            return { IMAGE: imageItems.length === 1 ? imageItems[0] : imageItems };
+        }
+    }
+    if ('FILE' in rawValue && rawValue.FILE !== undefined) {
+        const rawFile = rawValue.FILE;
+        const fileItems = Array.isArray(rawFile)
+            ? rawFile.map(normalizeAttachFileItem).filter(isPresent)
+            : [normalizeAttachFileItem(rawFile)].filter(isPresent);
+        if (fileItems.length > 0) {
+            return { FILE: fileItems.length === 1 ? fileItems[0] : fileItems };
+        }
+    }
+    if ('DELIMITER' in rawValue && isPlainObject(rawValue.DELIMITER)) {
+        const delimiter = rawValue.DELIMITER;
+        const size = readAttachNumber(delimiter.SIZE);
+        const color = readAttachString(delimiter.COLOR);
+        if (size !== undefined || color) {
+            return {
+                DELIMITER: {
+                    ...(size !== undefined ? { SIZE: size } : {}),
+                    ...(color ? { COLOR: color } : {}),
+                },
+            };
+        }
+    }
+    if ('GRID' in rawValue && Array.isArray(rawValue.GRID)) {
+        const gridItems = rawValue.GRID.map(normalizeAttachGridItem).filter(isPresent);
+        if (gridItems.length > 0) {
+            return { GRID: gridItems };
+        }
+    }
+    if ('USER' in rawValue && rawValue.USER !== undefined) {
+        const userValue = normalizeAttachUserValue(rawValue.USER, rawValue);
+        if (userValue) {
+            return { USER: userValue };
+        }
+    }
+    const rawType = readAttachString(rawValue.TYPE)?.toUpperCase();
+    if (!rawType) {
+        return undefined;
+    }
+    if (rawType === 'MESSAGE') {
+        const title = readAttachString(rawValue.TITLE);
+        return message
+            ? { MESSAGE: message }
+            : title
+                ? { MESSAGE: `[B]${title}[/B]` }
+                : undefined;
+    }
+    if (rawType === 'TITLE') {
+        const title = readAttachString(rawValue.TITLE) ?? message;
+        return title ? { MESSAGE: `[B]${title}[/B]` } : undefined;
+    }
+    if (rawType === 'LINK') {
+        const linkValue = normalizeAttachLinkValue(rawValue.LINK ?? rawValue, rawValue);
+        return linkValue ? { LINK: linkValue } : undefined;
+    }
+    if (rawType === 'USER') {
+        const userValue = normalizeAttachUserValue(rawValue.USER ?? rawValue.USER_ID ?? rawValue, rawValue);
+        return userValue ? { USER: userValue } : undefined;
+    }
+    if (rawType === 'GRID') {
+        const rawGridItems = Array.isArray(rawValue.GRID)
+            ? rawValue.GRID
+            : Array.isArray(rawValue.ITEMS)
+                ? rawValue.ITEMS
+                : Array.isArray(rawValue.ROWS)
+                    ? rawValue.ROWS
+                    : [];
+        const gridItems = rawGridItems.map(normalizeAttachGridItem).filter(isPresent);
+        return gridItems.length > 0 ? { GRID: gridItems } : undefined;
+    }
+    if (rawType === 'DELIMITER') {
+        const size = readAttachNumber(rawValue.SIZE);
+        const color = readAttachString(rawValue.COLOR);
+        return size !== undefined || color
+            ? {
+                DELIMITER: {
+                    ...(size !== undefined ? { SIZE: size } : {}),
+                    ...(color ? { COLOR: color } : {}),
+                },
+            }
+            : undefined;
+    }
+    if (rawType === 'IMAGE') {
+        const rawImage = rawValue.IMAGE ?? rawValue.LINK ?? rawValue;
+        const imageItems = Array.isArray(rawImage)
+            ? rawImage.map(normalizeAttachImageItem).filter(isPresent)
+            : [normalizeAttachImageItem(rawImage)].filter(isPresent);
+        return imageItems.length > 0
+            ? { IMAGE: imageItems.length === 1 ? imageItems[0] : imageItems }
+            : undefined;
+    }
+    if (rawType === 'FILE') {
+        const rawFile = rawValue.FILE ?? rawValue.LINK ?? rawValue;
+        const fileItems = Array.isArray(rawFile)
+            ? rawFile.map(normalizeAttachFileItem).filter(isPresent)
+            : [normalizeAttachFileItem(rawFile)].filter(isPresent);
+        return fileItems.length > 0
+            ? { FILE: fileItems.length === 1 ? fileItems[0] : fileItems }
+            : undefined;
+    }
+    return undefined;
+}
+function normalizeBitrix24Attach(rawValue) {
+    if (Array.isArray(rawValue)) {
+        const blocks = rawValue.map(normalizeAttachBlock).filter(isPresent);
+        return blocks.length > 0 ? blocks : undefined;
+    }
+    if (!isPlainObject(rawValue)) {
+        return undefined;
+    }
+    if (Array.isArray(rawValue.BLOCKS)) {
+        const blocks = rawValue.BLOCKS.map(normalizeAttachBlock).filter(isPresent);
+        if (blocks.length === 0) {
+            return undefined;
+        }
+        const id = readAttachNumber(rawValue.ID);
+        const colorToken = normalizeAttachColorTokenValue(rawValue.COLOR_TOKEN);
+        const color = readAttachString(rawValue.COLOR);
+        return {
+            ...(id !== undefined ? { ID: id } : {}),
+            ...(colorToken ? { COLOR_TOKEN: colorToken } : {}),
+            ...(color ? { COLOR: color } : {}),
+            BLOCKS: blocks,
+        };
+    }
+    const block = normalizeAttachBlock(rawValue);
+    return block ? [block] : undefined;
+}
+function parseActionAttach(rawValue) {
+    if (rawValue == null) {
+        return undefined;
+    }
+    let parsed = rawValue;
+    if (typeof rawValue === 'string') {
+        const trimmed = rawValue.trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return normalizeBitrix24Attach(parsed);
+}
+function hasMeaningfulAttachInput(rawValue) {
+    if (rawValue == null) {
+        return false;
+    }
+    if (typeof rawValue === 'string') {
+        const trimmed = rawValue.trim();
+        if (!trimmed) {
+            return false;
+        }
+        try {
+            return hasMeaningfulAttachInput(JSON.parse(trimmed));
+        }
+        catch {
+            return true;
+        }
+    }
+    if (Array.isArray(rawValue)) {
+        return rawValue.length > 0;
+    }
+    if (isPlainObject(rawValue)) {
+        if (Array.isArray(rawValue.BLOCKS)) {
+            return rawValue.BLOCKS.length > 0;
+        }
+        return Object.keys(rawValue).length > 0;
+    }
+    return true;
+}
+function readActionTargetParam(params, fallbackTarget) {
+    const rawTarget = params.to ?? params.target ?? fallbackTarget;
+    return typeof rawTarget === 'string' ? normalizeBitrix24DialogTarget(rawTarget) : '';
+}
+function parseActionMessageIds(rawValue) {
+    const ids = [];
+    const seen = new Set();
+    const append = (value) => {
+        if (Array.isArray(value)) {
+            value.forEach(append);
+            return;
+        }
+        if (typeof value === 'number') {
+            const normalizedId = Math.trunc(value);
+            if (Number.isFinite(normalizedId) && normalizedId > 0 && !seen.has(normalizedId)) {
+                seen.add(normalizedId);
+                ids.push(normalizedId);
+            }
+            return;
+        }
+        if (typeof value !== 'string') {
+            return;
+        }
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return;
+        }
+        if (trimmed.startsWith('[')) {
+            try {
+                append(JSON.parse(trimmed));
+                return;
+            }
+            catch {
+                // Fall through to scalar / CSV parsing.
+            }
+        }
+        trimmed
+            .split(/[,\s]+/)
+            .forEach((part) => {
+            if (!part) {
+                return;
+            }
+            const normalizedId = Number(part);
+            if (Number.isFinite(normalizedId) && normalizedId > 0 && !seen.has(normalizedId)) {
+                seen.add(normalizedId);
+                ids.push(normalizedId);
+            }
+        });
+    };
+    append(rawValue);
+    return ids;
+}
+function parseActionKeyboard(rawButtons) {
+    if (rawButtons == null) {
+        return undefined;
+    }
+    try {
+        const parsed = typeof rawButtons === 'string' ? JSON.parse(rawButtons) : rawButtons;
+        if (Array.isArray(parsed)) {
+            const keyboard = convertButtonsToKeyboard(parsed);
+            return keyboard.length > 0 ? keyboard : undefined;
+        }
+    }
+    catch {
+        // Ignore invalid buttons payload and send without keyboard.
+    }
+    return undefined;
+}
+function collectActionMediaUrls(params) {
+    const mediaUrls = [];
+    const seen = new Set();
+    const append = (value) => {
+        if (Array.isArray(value)) {
+            value.forEach(append);
+            return;
+        }
+        if (typeof value !== 'string') {
+            return;
+        }
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return;
+        }
+        if (trimmed.startsWith('[')) {
+            try {
+                append(JSON.parse(trimmed));
+                return;
+            }
+            catch {
+                // Fall through to scalar handling.
+            }
+        }
+        if (!seen.has(trimmed)) {
+            seen.add(trimmed);
+            mediaUrls.push(trimmed);
+        }
+    };
+    append(params.mediaUrl);
+    append(params.mediaUrls);
+    append(params.media);
+    append(params.filePath);
+    append(params.filePaths);
+    append(params.path);
+    append(params.paths);
+    return mediaUrls;
+}
+function buildActionMessageText(params) {
+    const normalizedText = typeof params.text === 'string'
+        ? markdownToBbCode(params.text.trim())
+        : '';
+    if (normalizedText) {
+        return normalizedText;
+    }
+    if (params.attach) {
+        return null;
+    }
+    return params.keyboard ? ' ' : null;
+}
 function parseRegisteredCommandTrigger(callbackData) {
     const trimmed = callbackData.trim();
     const isSlashCommand = trimmed.startsWith('/');
@@ -844,6 +2297,13 @@ export function extractKeyboardFromPayload(payload) {
     }
     return undefined;
 }
+export function extractAttachFromPayload(payload) {
+    const cd = payload.channelData;
+    if (!cd)
+        return undefined;
+    const b24Data = cd.bitrix24;
+    return parseActionAttach(b24Data?.attach ?? b24Data?.attachments);
+}
 /**
  * Extract inline button JSON embedded in message text by the agent.
  *
@@ -874,6 +2334,13 @@ export function extractInlineButtonsFromText(text) {
         return undefined;
     }
 }
+function cleanupTextAfterInlineMediaExtraction(text) {
+    return text
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .replace(/[ \t]{2,}/g, ' ')
+        .trim();
+}
 function normalizeCommandReplyPayload(params) {
     const { commandName, commandParams, text, language } = params;
     if (commandName === 'models' && commandParams.trim() === '') {
@@ -1130,12 +2597,13 @@ export async function handleWebhookRequest(req, res) {
 // ─── Outbound adapter helpers ────────────────────────────────────────────────
 function resolveOutboundSendCtx(params) {
     const { config } = resolveAccount(params.cfg, params.accountId);
-    if (!config.webhookUrl || !gatewayState)
+    const dialogId = normalizeBitrix24DialogTarget(params.to);
+    if (!config.webhookUrl || !gatewayState || !dialogId)
         return null;
     return {
         webhookUrl: config.webhookUrl,
         bot: gatewayState.bot,
-        dialogId: params.to,
+        dialogId,
     };
 }
 function collectOutboundMediaUrls(input) {
@@ -1155,16 +2623,22 @@ async function uploadOutboundMedia(params) {
     let lastMessageId = '';
     let message = params.initialMessage;
     for (const mediaUrl of params.mediaUrls) {
+        const outboundFileName = resolveSemanticOutboundFileName({
+            requestedFileName: basename(mediaUrl),
+            dialogId: params.sendCtx.dialogId,
+            currentMessageId: params.currentMessageId,
+            accountId: params.accountId,
+        });
         const result = await params.mediaService.uploadMediaToChat({
             localPath: mediaUrl,
-            fileName: basename(mediaUrl),
+            fileName: outboundFileName,
             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)}`);
+            throw new Error(`Failed to upload media: ${outboundFileName}`);
         }
         if (result.messageId) {
             lastMessageId = String(result.messageId);
@@ -1196,13 +2670,10 @@ export const bitrix24Plugin = {
         inlineButtons: 'all',
     },
     messaging: {
-        normalizeTarget: (raw) => raw.trim().replace(CHANNEL_PREFIX_RE, ''),
+        normalizeTarget: (raw) => normalizeBitrix24DialogTarget(raw),
         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);
-            },
+            hint: 'Use a numeric dialog ID like "1", a group dialog like "chat42", or Bitrix mentions like "[USER=1]John[/USER]" / "[CHAT=42]Team[/CHAT]".',
+            looksLikeId: (raw, _normalized) => looksLikeBitrix24DialogTarget(raw),
         },
     },
     config: {
@@ -1272,6 +2743,8 @@ export const bitrix24Plugin = {
                     mediaService: gatewayState.mediaService,
                     sendCtx,
                     mediaUrls,
+                    currentMessageId: ctx.currentMessageId,
+                    accountId: ctx.accountId,
                     initialMessage: ctx.text,
                 });
                 return { messageId };
@@ -1286,27 +2759,49 @@ export const bitrix24Plugin = {
             const sendCtx = resolveOutboundSendCtx(ctx);
             if (!sendCtx || !gatewayState)
                 throw new Error('Bitrix24 gateway not started');
+            const text = ctx.text;
             const keyboard = ctx.payload?.channelData
                 ? extractKeyboardFromPayload({ channelData: ctx.payload.channelData })
                 : undefined;
+            const attach = ctx.payload?.channelData
+                ? extractAttachFromPayload({ channelData: ctx.payload.channelData })
+                : undefined;
             const mediaUrls = collectOutboundMediaUrls({
                 mediaUrl: ctx.mediaUrl,
                 payload: ctx.payload,
             });
             if (mediaUrls.length > 0) {
+                const initialMessage = !keyboard && !attach ? text || undefined : undefined;
                 const uploadedMessageId = await uploadOutboundMedia({
                     mediaService: gatewayState.mediaService,
                     sendCtx,
                     mediaUrls,
+                    currentMessageId: ctx.currentMessageId,
+                    accountId: ctx.accountId,
+                    initialMessage,
                 });
-                if (ctx.text) {
-                    const result = await gatewayState.sendService.sendText(sendCtx, ctx.text, keyboard ? { keyboard } : undefined);
+                if ((text && !initialMessage) || keyboard || attach) {
+                    if (attach) {
+                        const messageId = await gatewayState.api.sendMessage(sendCtx.webhookUrl, sendCtx.bot, sendCtx.dialogId, buildActionMessageText({ text, keyboard, attach }), {
+                            ...(keyboard ? { keyboard } : {}),
+                            attach,
+                        });
+                        return { messageId: String(messageId || uploadedMessageId) };
+                    }
+                    const result = await gatewayState.sendService.sendText(sendCtx, 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);
+            if (text || keyboard || attach) {
+                if (attach) {
+                    const messageId = await gatewayState.api.sendMessage(sendCtx.webhookUrl, sendCtx.bot, sendCtx.dialogId, buildActionMessageText({ text, keyboard, attach }), {
+                        ...(keyboard ? { keyboard } : {}),
+                        attach,
+                    });
+                    return { messageId: String(messageId ?? '') };
+                }
+                const result = await gatewayState.sendService.sendText(sendCtx, text || '', keyboard ? { keyboard } : undefined);
                 return { messageId: String(result.messageId ?? '') };
             }
             return { messageId: '' };
@@ -1314,11 +2809,13 @@ export const bitrix24Plugin = {
     },
     // ─── Actions (agent-driven: reactions, etc.) ────────────────────────────
     actions: {
+        describeMessageTool: (params) => describeBitrix24MessageTool(params),
+        extractToolSend: (params) => extractBitrix24ToolSend(params.args),
         listActions: (_params) => {
-            return ['react', 'send'];
+            return [...BITRIX24_DISCOVERY_ACTION_NAMES];
         },
         supportsAction: (params) => {
-            return params.action === 'react' || params.action === 'send';
+            return BITRIX24_ACTION_NAMES.includes(params.action);
         },
         handleAction: async (ctx) => {
             // Helper: wrap payload as gateway-compatible tool result
@@ -1326,36 +2823,276 @@ export const bitrix24Plugin = {
                 content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
                 details: payload,
             });
+            const markSuccessfulAction = (currentMessageId) => {
+                markRecentSuccessfulAction(currentMessageId, ctx.accountId);
+            };
             // ─── 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 rawAttach = ctx.params.attach ?? ctx.params.attachments;
                 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();
+                const to = readActionTargetParam(ctx.params, ctx.to);
                 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;
+                const canUseNativeReply = shouldUseBitrix24NativeReply({ dialogId: to });
+                const messageText = readActionTextParam(ctx.params);
+                const message = typeof messageText === 'string' ? messageText.trim() : '';
+                const keyboard = parseActionKeyboard(rawButtons);
+                const attach = parseActionAttach(rawAttach);
+                const mediaUrls = collectActionMediaUrls(ctx.params);
+                const toolContext = ctx.toolContext;
+                const currentToolMessageId = toolContext?.currentMessageId;
+                const currentInboundContextKey = buildAccountMessageScopeKey(ctx.accountId, currentToolMessageId);
+                const currentInboundContext = currentInboundContextKey
+                    ? inboundMessageContextById.get(currentInboundContextKey)
+                    : undefined;
+                const forwardAckDialogId = resolvePendingNativeForwardAckDialogId(currentToolMessageId, to, ctx.accountId);
+                const explicitForwardMessages = readExplicitForwardMessageIds(ctx.params);
+                const referencedReplyMessageId = parseActionMessageIds(ctx.params.replyToMessageId ?? ctx.params.replyToId)[0];
+                if (hasMeaningfulAttachInput(rawAttach) && !attach) {
+                    return toolResult({ ok: false, reason: 'invalid_attach', hint: 'Bitrix24 attach must use ATTACH rich blocks. Do not pass uploaded files here; use mediaUrl/mediaUrls for file uploads.' });
+                }
+                if (explicitForwardMessages.length > 0 && mediaUrls.length > 0) {
+                    return toolResult({
+                        ok: false,
+                        reason: 'unsupported_payload_combo',
+                        hint: 'Bitrix24 native forward cannot be combined with mediaUrl/mediaUrls uploads in one send action. Send the forward separately.',
+                    });
+                }
+                if (!message && !keyboard && !attach && mediaUrls.length === 0 && explicitForwardMessages.length === 0) {
+                    return toolResult({
+                        ok: false,
+                        reason: 'missing_payload',
+                        hint: 'Provide message text, buttons, rich attach blocks or mediaUrl/mediaUrls for Bitrix24 send.',
+                    });
                 }
-                catch {
-                    // invalid buttons JSON — send without keyboard
+                const duplicateMediaDelivery = mediaUrls.length > 0
+                    ? findRecentMediaDelivery({
+                        dialogId: to,
+                        currentMessageId: currentToolMessageId,
+                        mediaUrls,
+                        accountId: ctx.accountId,
+                    })
+                    : null;
+                if (duplicateMediaDelivery) {
+                    markSuccessfulAction(currentToolMessageId);
+                    return toolResult({
+                        channel: 'bitrix24',
+                        to,
+                        via: 'direct',
+                        mediaUrl: mediaUrls[0] ?? null,
+                        duplicateSuppressed: true,
+                        result: { messageId: duplicateMediaDelivery.messageId ?? '' },
+                    });
                 }
-                const keyboard = buttons?.length ? convertButtonsToKeyboard(buttons) : undefined;
                 try {
+                    if (explicitForwardMessages.length > 0) {
+                        const normalizedForwardText = normalizeForwardActionText(messageText);
+                        if (attach) {
+                            const messageId = await gatewayState.api.sendMessage(config.webhookUrl, bot, to, buildActionMessageText({ text: normalizedForwardText, keyboard, attach }), {
+                                ...(keyboard ? { keyboard } : {}),
+                                attach,
+                                forwardMessages: explicitForwardMessages,
+                            });
+                            await maybeAddNativeForwardSuccessReaction({
+                                api: gatewayState.api,
+                                sendService: gatewayState.sendService,
+                                webhookUrl: config.webhookUrl,
+                                bot,
+                                dialogId: forwardAckDialogId,
+                                currentMessageId: currentToolMessageId,
+                            });
+                            markPendingNativeForwardAck(forwardAckDialogId, currentToolMessageId, ctx.accountId);
+                            markSuccessfulAction(currentToolMessageId);
+                            return toolResult({
+                                channel: 'bitrix24',
+                                to,
+                                via: 'direct',
+                                mediaUrl: null,
+                                forwarded: true,
+                                forwardMessages: explicitForwardMessages,
+                                result: { messageId: String(messageId ?? '') },
+                            });
+                        }
+                        const result = await gatewayState.sendService.sendText(sendCtx, normalizedForwardText || (keyboard ? ' ' : ''), {
+                            ...(keyboard ? { keyboard } : {}),
+                            forwardMessages: explicitForwardMessages,
+                        });
+                        await maybeAddNativeForwardSuccessReaction({
+                            api: gatewayState.api,
+                            sendService: gatewayState.sendService,
+                            webhookUrl: config.webhookUrl,
+                            bot,
+                            dialogId: forwardAckDialogId,
+                            currentMessageId: currentToolMessageId,
+                        });
+                        markPendingNativeForwardAck(forwardAckDialogId, currentToolMessageId, ctx.accountId);
+                        markSuccessfulAction(currentToolMessageId);
+                        return toolResult({
+                            channel: 'bitrix24',
+                            to,
+                            via: 'direct',
+                            mediaUrl: null,
+                            forwarded: true,
+                            forwardMessages: explicitForwardMessages,
+                            result: { messageId: String(result.messageId ?? '') },
+                        });
+                    }
+                    if (canUseNativeReply && referencedReplyMessageId && !attach && mediaUrls.length === 0) {
+                        let referencedMessageText = '';
+                        try {
+                            const referencedMessage = await gatewayState.api.getMessage(config.webhookUrl, bot, referencedReplyMessageId);
+                            referencedMessageText = resolveFetchedMessageBody(referencedMessage.message?.text ?? '');
+                        }
+                        catch (err) {
+                            defaultLogger.debug('Failed to hydrate referenced Bitrix24 message for send action', err);
+                        }
+                        const normalizedReferencedMessage = normalizeComparableMessageText(referencedMessageText);
+                        const normalizedMessage = normalizeComparableMessageText(message);
+                        if (normalizedReferencedMessage && normalizedReferencedMessage === normalizedMessage) {
+                            const result = await gatewayState.sendService.sendText(sendCtx, '', { forwardMessages: [referencedReplyMessageId] });
+                            await maybeAddNativeForwardSuccessReaction({
+                                api: gatewayState.api,
+                                sendService: gatewayState.sendService,
+                                webhookUrl: config.webhookUrl,
+                                bot,
+                                dialogId: forwardAckDialogId,
+                                currentMessageId: currentToolMessageId,
+                            });
+                            markPendingNativeForwardAck(forwardAckDialogId, currentToolMessageId, ctx.accountId);
+                            markSuccessfulAction(currentToolMessageId);
+                            return toolResult({
+                                channel: 'bitrix24',
+                                to,
+                                via: 'direct',
+                                mediaUrl: null,
+                                forwarded: true,
+                                forwardMessages: [referencedReplyMessageId],
+                                result: { messageId: String(result.messageId ?? '') },
+                            });
+                        }
+                        const sendOptions = {
+                            ...(keyboard ? { keyboard } : {}),
+                            ...(canUseNativeReply ? { replyToMessageId: referencedReplyMessageId } : {}),
+                        };
+                        const result = await gatewayState.sendService.sendText(sendCtx, message || ' ', Object.keys(sendOptions).length > 0 ? sendOptions : undefined);
+                        markSuccessfulAction(currentToolMessageId);
+                        return toolResult({
+                            channel: 'bitrix24',
+                            to,
+                            via: 'direct',
+                            mediaUrl: null,
+                            ...(canUseNativeReply ? {
+                                replied: true,
+                                replyToMessageId: referencedReplyMessageId,
+                            } : {}),
+                            result: { messageId: String(result.messageId ?? '') },
+                        });
+                    }
+                    const previousInboundMessage = findPreviousRecentInboundMessage(currentToolMessageId, ctx.accountId);
+                    if (!referencedReplyMessageId
+                        && !attach
+                        && mediaUrls.length === 0
+                        && !keyboard
+                        && previousInboundMessage
+                        && currentInboundContext
+                        && normalizeComparableMessageText(message)
+                        && normalizeComparableMessageText(message) === normalizeComparableMessageText(previousInboundMessage.body)
+                        && normalizeComparableMessageText(currentInboundContext.body) !== normalizeComparableMessageText(message)) {
+                        const result = await gatewayState.sendService.sendText(sendCtx, '', { forwardMessages: [Number(previousInboundMessage.messageId)] });
+                        await maybeAddNativeForwardSuccessReaction({
+                            api: gatewayState.api,
+                            sendService: gatewayState.sendService,
+                            webhookUrl: config.webhookUrl,
+                            bot,
+                            dialogId: forwardAckDialogId,
+                            currentMessageId: currentToolMessageId,
+                        });
+                        markPendingNativeForwardAck(forwardAckDialogId, currentToolMessageId, ctx.accountId);
+                        markSuccessfulAction(currentToolMessageId);
+                        return toolResult({
+                            channel: 'bitrix24',
+                            to,
+                            via: 'direct',
+                            mediaUrl: null,
+                            forwarded: true,
+                            forwardMessages: [Number(previousInboundMessage.messageId)],
+                            result: { messageId: String(result.messageId ?? '') },
+                        });
+                    }
+                    if (mediaUrls.length > 0) {
+                        const initialMessage = !keyboard && !attach ? message || undefined : undefined;
+                        const uploadedMessageId = await uploadOutboundMedia({
+                            mediaService: gatewayState.mediaService,
+                            sendCtx,
+                            mediaUrls,
+                            currentMessageId: currentToolMessageId,
+                            accountId: ctx.accountId,
+                            initialMessage,
+                        });
+                        markRecentMediaDelivery({
+                            dialogId: to,
+                            currentMessageId: currentToolMessageId,
+                            mediaUrls,
+                            accountId: ctx.accountId,
+                            messageId: uploadedMessageId,
+                        });
+                        if ((message && !initialMessage) || keyboard || attach) {
+                            if (attach) {
+                                const messageId = await gatewayState.api.sendMessage(config.webhookUrl, bot, to, buildActionMessageText({ text: message, keyboard, attach }), {
+                                    ...(keyboard ? { keyboard } : {}),
+                                    attach,
+                                });
+                                markSuccessfulAction(currentToolMessageId);
+                                return toolResult({
+                                    channel: 'bitrix24',
+                                    to,
+                                    via: 'direct',
+                                    mediaUrl: mediaUrls[0] ?? null,
+                                    result: { messageId: String(messageId ?? uploadedMessageId) },
+                                });
+                            }
+                            const result = await gatewayState.sendService.sendText(sendCtx, message || '', keyboard ? { keyboard } : undefined);
+                            markSuccessfulAction(currentToolMessageId);
+                            return toolResult({
+                                channel: 'bitrix24',
+                                to,
+                                via: 'direct',
+                                mediaUrl: mediaUrls[0] ?? null,
+                                result: { messageId: String(result.messageId ?? uploadedMessageId) },
+                            });
+                        }
+                        markSuccessfulAction(currentToolMessageId);
+                        return toolResult({
+                            channel: 'bitrix24',
+                            to,
+                            via: 'direct',
+                            mediaUrl: mediaUrls[0] ?? null,
+                            result: { messageId: uploadedMessageId },
+                        });
+                    }
+                    if (attach) {
+                        const messageId = await gatewayState.api.sendMessage(config.webhookUrl, bot, to, buildActionMessageText({ text: message, keyboard, attach }), {
+                            ...(keyboard ? { keyboard } : {}),
+                            attach,
+                        });
+                        markSuccessfulAction(currentToolMessageId);
+                        return toolResult({
+                            channel: 'bitrix24',
+                            to,
+                            via: 'direct',
+                            mediaUrl: null,
+                            result: { messageId: String(messageId ?? '') },
+                        });
+                    }
                     const result = await gatewayState.sendService.sendText(sendCtx, message || ' ', keyboard ? { keyboard } : undefined);
+                    markSuccessfulAction(currentToolMessageId);
                     return toolResult({
                         channel: 'bitrix24',
                         to,
@@ -1366,9 +3103,174 @@ export const bitrix24Plugin = {
                 }
                 catch (err) {
                     const errMsg = err instanceof Error ? err.message : String(err);
+                    if (errMsg.startsWith('Failed to upload media: ')) {
+                        return toolResult({
+                            ok: false,
+                            reason: 'media_upload_failed',
+                            error: errMsg,
+                            hint: 'The local file could not be uploaded. First create/write the file in the OpenClaw workspace or managed media directory, then send it once with media/filePath/path. Do not retry the same send blindly, and do not send an extra confirmation after a successful file upload.',
+                        });
+                    }
                     return toolResult({ ok: false, error: errMsg });
                 }
             }
+            if (ctx.action === 'reply') {
+                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 params = ctx.params;
+                const bot = gatewayState.bot;
+                const to = readActionTargetParam(params, ctx.to);
+                if (!to) {
+                    return toolResult({ ok: false, reason: 'missing_target', hint: 'Bitrix24 reply requires a target dialog id in "to" or "target". Do not retry.' });
+                }
+                const toolContext = ctx.toolContext;
+                const canUseNativeReply = shouldUseBitrix24NativeReply({ dialogId: to });
+                const replyToMessageId = parseActionMessageIds(params.replyToMessageId
+                    ?? params.replyToId
+                    ?? params.messageId
+                    ?? params.message_id
+                    ?? toolContext?.currentMessageId)[0];
+                if (!replyToMessageId) {
+                    return toolResult({ ok: false, reason: 'missing_message_id', hint: 'Bitrix24 reply requires a valid target messageId. Do not retry.' });
+                }
+                const text = readActionTextParam(params);
+                const normalizedText = typeof text === 'string' ? text.trim() : '';
+                const keyboard = parseActionKeyboard(params.buttons);
+                const rawAttach = params.attach ?? params.attachments;
+                const attach = parseActionAttach(rawAttach);
+                if (hasMeaningfulAttachInput(rawAttach) && !attach) {
+                    return toolResult({ ok: false, reason: 'invalid_attach', hint: 'Bitrix24 attach must use ATTACH rich blocks. Do not pass uploaded files here; use mediaUrl/mediaUrls for file uploads.' });
+                }
+                if (!normalizedText && !keyboard && !attach) {
+                    return toolResult({ ok: false, reason: 'missing_payload', hint: 'Provide reply text, buttons or rich attach blocks for Bitrix24 reply.' });
+                }
+                try {
+                    if (attach) {
+                        const messageId = await gatewayState.api.sendMessage(config.webhookUrl, bot, to, buildActionMessageText({ text: normalizedText, keyboard, attach }), {
+                            ...(keyboard ? { keyboard } : {}),
+                            attach,
+                            ...(canUseNativeReply ? { replyToMessageId } : {}),
+                        });
+                        markSuccessfulAction(toolContext?.currentMessageId);
+                        return toolResult({
+                            ok: true,
+                            to,
+                            ...(canUseNativeReply ? {
+                                replied: true,
+                                replyToMessageId,
+                            } : {}),
+                            messageId: String(messageId ?? ''),
+                        });
+                    }
+                    const sendOptions = {
+                        ...(keyboard ? { keyboard } : {}),
+                        ...(canUseNativeReply ? { replyToMessageId } : {}),
+                    };
+                    const result = await gatewayState.sendService.sendText({ webhookUrl: config.webhookUrl, bot, dialogId: to }, normalizedText || ' ', Object.keys(sendOptions).length > 0 ? sendOptions : undefined);
+                    markSuccessfulAction(toolContext?.currentMessageId);
+                    return toolResult({
+                        ok: true,
+                        to,
+                        ...(canUseNativeReply ? {
+                            replied: true,
+                            replyToMessageId,
+                        } : {}),
+                        messageId: String(result.messageId ?? ''),
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    return toolResult({ ok: false, reason: 'error', hint: `Failed to send Bitrix24 reply: ${errMsg}. Do not retry.` });
+                }
+            }
+            // Note: "forward" action is not supported by OpenClaw runtime (not in
+            // MESSAGE_ACTION_TARGET_MODE), so the runtime blocks target before it
+            // reaches handleAction.  All forwarding goes through action "send" with
+            // forwardMessageIds parameter instead.
+            if (ctx.action === 'edit') {
+                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;
+                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 edits. Do not retry.' });
+                }
+                let keyboard;
+                if (params.buttons === 'N') {
+                    keyboard = 'N';
+                }
+                else if (params.buttons != null) {
+                    try {
+                        const parsed = typeof params.buttons === 'string'
+                            ? JSON.parse(params.buttons)
+                            : params.buttons;
+                        if (Array.isArray(parsed)) {
+                            keyboard = convertButtonsToKeyboard(parsed);
+                        }
+                    }
+                    catch {
+                        // Ignore invalid buttons payload and update text only.
+                    }
+                }
+                const message = readActionTextParam(params);
+                const rawAttach = params.attach ?? params.attachments;
+                const attach = parseActionAttach(rawAttach);
+                if (hasMeaningfulAttachInput(rawAttach) && !attach) {
+                    return toolResult({ ok: false, reason: 'invalid_attach', hint: 'Bitrix24 attach must use ATTACH rich blocks. Do not pass uploaded files here; use mediaUrl/mediaUrls for file uploads.' });
+                }
+                if (message == null && !keyboard && !attach) {
+                    return toolResult({ ok: false, reason: 'missing_payload', hint: 'Provide message text, buttons or rich attach blocks for Bitrix24 edits.' });
+                }
+                try {
+                    await api.updateMessage(config.webhookUrl, bot, messageId, message, {
+                        ...(keyboard ? { keyboard } : {}),
+                        ...(attach ? { attach } : {}),
+                    });
+                    markSuccessfulAction(toolContext?.currentMessageId);
+                    return toolResult({ ok: true, edited: true, messageId });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    return toolResult({ ok: false, reason: 'error', hint: `Failed to edit message: ${errMsg}. Do not retry.` });
+                }
+            }
+            if (ctx.action === 'delete') {
+                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;
+                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 deletes. Do not retry.' });
+                }
+                const complete = params.complete == null
+                    ? undefined
+                    : (params.complete === true
+                        || params.complete === 'true'
+                        || params.complete === 'Y');
+                try {
+                    await api.deleteMessage(config.webhookUrl, bot, messageId, complete);
+                    markSuccessfulAction(toolContext?.currentMessageId);
+                    return toolResult({ ok: true, deleted: true, messageId });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    return toolResult({ ok: false, reason: 'error', hint: `Failed to delete message: ${errMsg}. Do not retry.` });
+                }
+            }
             // ─── React ────────────────────────────────────────────────────────────
             if (ctx.action !== 'react')
                 return null;
@@ -1383,6 +3285,10 @@ export const bitrix24Plugin = {
             const toolContext = ctx.toolContext;
             const rawMessageId = params.messageId ?? params.message_id ?? toolContext?.currentMessageId;
             const messageId = Number(rawMessageId);
+            const reactionAckSourceMessageId = typeof rawMessageId === 'string' || typeof rawMessageId === 'number'
+                ? rawMessageId
+                : toolContext?.currentMessageId;
+            const reactionAckDialogId = resolveRecentInboundDialogId(reactionAckSourceMessageId, ctx.accountId);
             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.' });
             }
@@ -1396,6 +3302,7 @@ export const bitrix24Plugin = {
                 }
                 try {
                     await api.deleteReaction(config.webhookUrl, bot, messageId, reactionCode);
+                    markSuccessfulAction(toolContext?.currentMessageId);
                     return toolResult({ ok: true, removed: true });
                 }
                 catch (err) {
@@ -1418,12 +3325,28 @@ export const bitrix24Plugin = {
             }
             try {
                 await api.addReaction(config.webhookUrl, bot, messageId, reactionCode);
+                await maybeSendReactionTypingReset({
+                    sendService: gatewayState.sendService,
+                    webhookUrl: config.webhookUrl,
+                    bot,
+                    dialogId: reactionAckDialogId,
+                });
+                markPendingNativeReactionAck(toolContext?.currentMessageId, emoji, ctx.accountId);
+                markSuccessfulAction(toolContext?.currentMessageId);
                 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) {
+                    await maybeSendReactionTypingReset({
+                        sendService: gatewayState.sendService,
+                        webhookUrl: config.webhookUrl,
+                        bot,
+                        dialogId: reactionAckDialogId,
+                    });
+                    markPendingNativeReactionAck(toolContext?.currentMessageId, emoji, ctx.accountId);
+                    markSuccessfulAction(toolContext?.currentMessageId);
                     return toolResult({ ok: true, added: emoji, warning: 'Reaction already set.' });
                 }
                 return toolResult({ ok: false, reason: 'error', emoji, hint: `Reaction failed: ${errMsg}. Do not retry.` });
@@ -1561,6 +3484,30 @@ export const bitrix24Plugin = {
             }
             const sendService = new SendService(api, logger);
             const mediaService = new MediaService(api, logger);
+            const originalSendText = sendService.sendText.bind(sendService);
+            sendService.sendText = async (...args) => {
+                const result = await originalSendText(...args);
+                markRecentOutboundMessage(result?.messageId, ctx.accountId);
+                return result;
+            };
+            const originalAnswerCommandText = sendService.answerCommandText.bind(sendService);
+            sendService.answerCommandText = async (...args) => {
+                const result = await originalAnswerCommandText(...args);
+                markRecentOutboundMessage(result?.messageId, ctx.accountId);
+                return result;
+            };
+            const originalApiSendMessage = api.sendMessage.bind(api);
+            api.sendMessage = async (...args) => {
+                const messageId = await originalApiSendMessage(...args);
+                markRecentOutboundMessage(messageId, ctx.accountId);
+                return messageId;
+            };
+            const originalUploadMediaToChat = mediaService.uploadMediaToChat.bind(mediaService);
+            mediaService.uploadMediaToChat = async (...args) => {
+                const result = await originalUploadMediaToChat(...args);
+                markRecentOutboundMessage(result?.messageId, ctx.accountId);
+                return result;
+            };
             const hydrateReplyEntry = async (replyToMessageId) => {
                 const bitrixMessageId = toMessageId(replyToMessageId);
                 if (!bitrixMessageId) {
@@ -1723,9 +3670,27 @@ export const bitrix24Plugin = {
                         query: bodyWithReply,
                         historyCache,
                     });
-                    const bodyForAgent = crossChatContext
-                        ? [crossChatContext, bodyWithReply].filter(Boolean).join('\n\n')
-                        : bodyWithReply;
+                    const inlineButtonsAgentHint = buildBitrix24InlineButtonsAgentHint();
+                    const fileDeliveryAgentHint = buildBitrix24FileDeliveryAgentHint();
+                    const canUseNativeReply = shouldUseBitrix24NativeReply({ isDm: msgCtx.isDm });
+                    const nativeReplyAgentHint = canUseNativeReply
+                        ? buildBitrix24NativeReplyAgentHint(msgCtx.messageId)
+                        : undefined;
+                    const nativeForwardAgentHint = buildBitrix24NativeForwardAgentHint({
+                        accountId: ctx.accountId,
+                        currentBody: body,
+                        currentMessageId: msgCtx.messageId,
+                        replyToMessageId: msgCtx.replyToMessageId,
+                        historyEntries: previousEntries,
+                    });
+                    const bodyForAgent = [
+                        inlineButtonsAgentHint,
+                        fileDeliveryAgentHint,
+                        nativeReplyAgentHint,
+                        nativeForwardAgentHint,
+                        crossChatContext,
+                        bodyWithReply,
+                    ].filter(Boolean).join('\n\n');
                     const combinedBody = msgCtx.isGroup
                         ? buildHistoryContext({
                             entries: previousEntries,
@@ -1733,6 +3698,7 @@ export const bitrix24Plugin = {
                         })
                         : bodyForAgent;
                     recordHistory(body);
+                    rememberRecentInboundMessage(conversation.dialogId, msgCtx.messageId, body, msgCtx.media.map((mediaItem) => mediaItem.name), msgCtx.timestamp ?? Date.now(), ctx.accountId);
                     // Resolve which agent handles this conversation
                     const route = runtime.channel.routing.resolveAgentRoute({
                         cfg,
@@ -1785,15 +3751,56 @@ export const bitrix24Plugin = {
                                 deliver: async (payload) => {
                                     await replyStatusHeartbeat.stopAndWait();
                                     const mediaUrls = payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
+                                    const hadRecentMediaDelivery = mediaUrls.length === 0
+                                        && hasRecentMediaDelivery(sendCtx.dialogId, msgCtx.messageId, ctx.accountId);
                                     if (mediaUrls.length > 0) {
-                                        await uploadOutboundMedia({
+                                        const uploadedMessageId = await uploadOutboundMedia({
                                             mediaService,
                                             sendCtx,
                                             mediaUrls,
                                         });
+                                        markRecentMediaDelivery({
+                                            dialogId: sendCtx.dialogId,
+                                            currentMessageId: msgCtx.messageId,
+                                            mediaUrls,
+                                            accountId: ctx.accountId,
+                                            messageId: uploadedMessageId,
+                                        });
                                     }
                                     if (payload.text) {
-                                        let text = payload.text;
+                                        if (hadRecentMediaDelivery) {
+                                            replyDelivered = true;
+                                            logger.debug('Suppressing trailing text after successful Bitrix24 file upload', {
+                                                senderId: msgCtx.senderId,
+                                                chatId: msgCtx.chatId,
+                                                messageId: msgCtx.messageId,
+                                            });
+                                            return;
+                                        }
+                                        if (consumePendingNativeForwardAck(sendCtx.dialogId, msgCtx.messageId, ctx.accountId)) {
+                                            replyDelivered = true;
+                                            logger.debug('Suppressing trailing acknowledgement after native Bitrix24 forward', {
+                                                senderId: msgCtx.senderId,
+                                                chatId: msgCtx.chatId,
+                                                messageId: msgCtx.messageId,
+                                            });
+                                            return;
+                                        }
+                                        const replyDirective = extractReplyDirective({
+                                            text: payload.text,
+                                            currentMessageId: msgCtx.messageId,
+                                            explicitReplyToId: payload.replyToId,
+                                        });
+                                        let text = replyDirective.cleanText;
+                                        if (consumePendingNativeReactionAck(msgCtx.messageId, text, ctx.accountId)) {
+                                            replyDelivered = true;
+                                            logger.debug('Suppressing trailing acknowledgement after native Bitrix24 reaction', {
+                                                senderId: msgCtx.senderId,
+                                                chatId: msgCtx.chatId,
+                                                messageId: msgCtx.messageId,
+                                            });
+                                            return;
+                                        }
                                         let keyboard = extractKeyboardFromPayload(payload);
                                         // Fallback: agent may embed button JSON in text as [[{...}]]
                                         if (!keyboard) {
@@ -1803,8 +3810,52 @@ export const bitrix24Plugin = {
                                                 keyboard = extracted.keyboard;
                                             }
                                         }
+                                        const nativeForwardMessageId = findNativeForwardTarget({
+                                            accountId: ctx.accountId,
+                                            requestText: body,
+                                            deliveredText: text,
+                                            historyEntries: previousEntries,
+                                            currentMessageId: msgCtx.messageId,
+                                        }) ?? findImplicitForwardTargetFromRecentInbound({
+                                            accountId: ctx.accountId,
+                                            requestText: body,
+                                            deliveredText: text,
+                                            currentMessageId: msgCtx.messageId,
+                                            historyEntries: previousEntries,
+                                        });
+                                        const nativeForwardTargets = nativeForwardMessageId
+                                            ? extractBitrix24DialogTargetsFromText(body)
+                                            : [];
+                                        const nativeReplyToMessageId = nativeForwardMessageId
+                                            ? undefined
+                                            : (canUseNativeReply ? replyDirective.replyToMessageId : undefined);
+                                        const sendOptions = {
+                                            ...(keyboard ? { keyboard } : {}),
+                                            ...(nativeReplyToMessageId ? { replyToMessageId: nativeReplyToMessageId } : {}),
+                                            ...(nativeForwardMessageId ? { forwardMessages: [nativeForwardMessageId] } : {}),
+                                        };
                                         replyDelivered = true;
-                                        await sendService.sendText(sendCtx, text, keyboard ? { keyboard } : undefined);
+                                        if (nativeForwardMessageId && nativeForwardTargets.length > 0) {
+                                            const forwardResults = await Promise.allSettled(nativeForwardTargets.map((dialogId) => sendService.sendText({ ...sendCtx, dialogId }, '', { forwardMessages: [nativeForwardMessageId] })));
+                                            const firstFailure = forwardResults.find((result) => result.status === 'rejected');
+                                            const hasSuccess = forwardResults.some((result) => result.status === 'fulfilled');
+                                            if (firstFailure && !hasSuccess) {
+                                                throw firstFailure.reason;
+                                            }
+                                            if (firstFailure) {
+                                                logger.warn('Failed to deliver Bitrix24 native forward to one or more explicit targets', {
+                                                    senderId: msgCtx.senderId,
+                                                    chatId: msgCtx.chatId,
+                                                    messageId: msgCtx.messageId,
+                                                    targets: nativeForwardTargets,
+                                                    error: firstFailure.reason instanceof Error
+                                                        ? firstFailure.reason.message
+                                                        : String(firstFailure.reason),
+                                                });
+                                            }
+                                            return;
+                                        }
+                                        await sendService.sendText(sendCtx, nativeForwardMessageId ? '' : text, Object.keys(sendOptions).length > 0 ? sendOptions : undefined);
                                     }
                                 },
                                 onReplyStart: async () => {
@@ -1815,18 +3866,55 @@ export const bitrix24Plugin = {
                                 },
                             },
                         });
+                        if (!replyDelivered && hasRecentMediaDelivery(sendCtx.dialogId, msgCtx.messageId, ctx.accountId)) {
+                            replyDelivered = true;
+                            logger.debug('Suppressing fallback after successful Bitrix24 file upload in the same turn', {
+                                senderId: msgCtx.senderId,
+                                chatId: msgCtx.chatId,
+                                messageId: msgCtx.messageId,
+                            });
+                        }
+                        if (!replyDelivered && hasRecentSuccessfulAction(msgCtx.messageId, ctx.accountId)) {
+                            replyDelivered = true;
+                            logger.debug('Suppressing fallback after successful Bitrix24 action in the same turn', {
+                                senderId: msgCtx.senderId,
+                                chatId: msgCtx.chatId,
+                                messageId: msgCtx.messageId,
+                            });
+                        }
+                        const shouldWaitForEmptyReplyFallback = !replyDelivered
+                            && isEmptyDispatchResult(dispatchResult);
                         if (!replyDelivered && dispatchResult?.queuedFinal === false) {
                             logger.debug('Reply completed without queued final block, waiting before fallback', {
                                 senderId: msgCtx.senderId,
                                 chatId: msgCtx.chatId,
                                 counts: dispatchResult.counts,
+                                fallbackDelayMs: shouldWaitForEmptyReplyFallback
+                                    ? EMPTY_REPLY_FALLBACK_GRACE_MS
+                                    : REPLY_FALLBACK_GRACE_MS,
+                            });
+                            if (shouldWaitForEmptyReplyFallback) {
+                                await waitEmptyReplyFallbackGraceWindow();
+                            }
+                            else {
+                                await waitReplyFallbackGraceWindow();
+                            }
+                        }
+                        if (!replyDelivered && isEmptyDispatchResult(dispatchResult)) {
+                            replyDelivered = true;
+                            logger.warn('Reply completed without any user-visible payload or tool activity; sending fallback notice', {
+                                senderId: msgCtx.senderId,
+                                chatId: msgCtx.chatId,
+                                messageId: msgCtx.messageId,
+                                counts: dispatchResult.counts,
                             });
-                            await waitReplyFallbackGraceWindow();
+                            await sendService.sendText(sendCtx, emptyReplyFallback(msgCtx.language));
                         }
-                        if (!replyDelivered && dispatchResult?.queuedFinal === false) {
+                        else if (!replyDelivered && dispatchResult?.queuedFinal === false) {
                             logger.warn('Reply completed without a final user-visible message; fallback notice suppressed', {
                                 senderId: msgCtx.senderId,
                                 chatId: msgCtx.chatId,
+                                messageId: msgCtx.messageId,
                                 counts: dispatchResult.counts,
                             });
                         }
@@ -1834,6 +3922,7 @@ export const bitrix24Plugin = {
                             logger.debug('Late reply arrived during fallback grace window, skipping fallback', {
                                 senderId: msgCtx.senderId,
                                 chatId: msgCtx.chatId,
+                                messageId: msgCtx.messageId,
                             });
                         }
                     }
@@ -1852,7 +3941,7 @@ export const bitrix24Plugin = {
                     }
                 }
                 finally {
-                    await mediaService.cleanupDownloadedMedia(downloadedMedia.map((mediaItem) => mediaItem.path));
+                    mediaService.scheduleDownloadedMediaCleanup(downloadedMedia.map((mediaItem) => mediaItem.path));
                 }
             };
             const directTextCoalescer = new BufferedDirectMessageCoalescer({
@@ -2005,6 +4094,15 @@ export const bitrix24Plugin = {
                         messageId: msgCtx.messageId,
                         textLen: msgCtx.text.length,
                     });
+                    if (hasRecentOutboundMessage(msgCtx.messageId, ctx.accountId)) {
+                        logger.debug('Skipping recent outbound Bitrix24 message echo', {
+                            senderId: msgCtx.senderId,
+                            chatId: msgCtx.chatId,
+                            messageId: msgCtx.messageId,
+                            eventScope: msgCtx.eventScope,
+                        });
+                        return;
+                    }
                     const pendingForwardContext = msgCtx.isForwarded
                         ? directTextCoalescer.take(ctx.accountId, msgCtx.chatId)
                         : null;
@@ -2029,7 +4127,7 @@ export const bitrix24Plugin = {
                             chatId: msgCtx.chatInternalId,
                         })
                         : null;
-                    const agentWatchRules = config.agentMode && msgCtx.eventScope === 'user'
+                    const agentWatchRules = config.agentMode
                         ? resolveAgentWatchRules({
                             config,
                             dialogId: msgCtx.chatId,
@@ -2039,37 +4137,61 @@ export const bitrix24Plugin = {
                     const watchRule = msgCtx.isGroup && groupAccess?.groupAllowed
                         ? findMatchingWatchRule(msgCtx, groupAccess?.watch)
                         : undefined;
-                    const activeWatchRule = watchRule?.mode === 'notifyOwnerDm'
+                    const botId = String(bot.botId);
+                    const ownerBotDmParticipantIds = new Set([msgCtx.senderId, msgCtx.chatId, msgCtx.chatInternalId]
+                        .map((value) => String(value ?? '').trim())
+                        .filter(Boolean));
+                    const isOwnerBotUserDmMirror = Boolean(config.agentMode
+                        && msgCtx.eventScope === 'user'
+                        && msgCtx.isDm
                         && webhookOwnerId
-                        && msgCtx.senderId === webhookOwnerId
+                        && ownerBotDmParticipantIds.has(webhookOwnerId)
+                        && ownerBotDmParticipantIds.has(botId));
+                    const isOwnerAuthoredMessage = Boolean(webhookOwnerId && msgCtx.senderId === webhookOwnerId);
+                    const isCurrentBotAuthoredMessage = msgCtx.senderId === botId;
+                    const activeWatchRule = watchRule?.mode === 'notifyOwnerDm'
+                        && (isOwnerAuthoredMessage || isCurrentBotAuthoredMessage)
                         ? undefined
                         : watchRule;
-                    const agentWatchRule = msgCtx.eventScope === 'user'
-                        ? findMatchingWatchRule(msgCtx, agentWatchRules)
+                    const agentWatchRule = findMatchingWatchRule(msgCtx, agentWatchRules);
+                    const activeAgentWatchRule = agentWatchRule?.mode === 'notifyOwnerDm'
+                        && !isOwnerBotUserDmMirror
+                        && !isOwnerAuthoredMessage
+                        && !isCurrentBotAuthoredMessage
+                        ? agentWatchRule
                         : undefined;
                     /** Shorthand: record message in RAM history for this dialog. */
                     const recordHistory = (body) => appendMessageToHistory({ historyCache, historyKey, historyLimit, msgCtx, body });
+                    if (isOwnerBotUserDmMirror) {
+                        logger.debug('Skipping mirrored agent-mode owner DM user event; bot channel will handle it', {
+                            senderId: msgCtx.senderId,
+                            chatId: msgCtx.chatId,
+                            messageId: msgCtx.messageId,
+                            eventScope: msgCtx.eventScope,
+                            webhookOwnerId,
+                            botId,
+                        });
+                        return;
+                    }
                     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,
-                            });
+                        if (activeAgentWatchRule) {
+                            if (hasRecentWatchNotification(msgCtx.messageId, ctx.accountId)) {
+                                logger.debug('Skipping duplicate agent watch notification for recent message', {
+                                    senderId: msgCtx.senderId,
+                                    chatId: msgCtx.chatId,
+                                    messageId: msgCtx.messageId,
+                                    eventScope: msgCtx.eventScope,
+                                });
+                            }
+                            else if (await notifyWebhookOwnerAboutWatchMatch(msgCtx, activeAgentWatchRule)) {
+                                markRecentWatchNotification(msgCtx.messageId, ctx.accountId);
+                                logger.debug('User-event watch matched and notified webhook owner in DM', {
+                                    senderId: msgCtx.senderId,
+                                    chatId: msgCtx.chatId,
+                                    messageId: msgCtx.messageId,
+                                });
+                            }
                         }
                         return;
                     }
@@ -2090,6 +4212,7 @@ export const bitrix24Plugin = {
                     await sendService.markRead(sendCtx, toMessageId(msgCtx.messageId));
                     if (msgCtx.isGroup
                         && !activeWatchRule
+                        && !activeAgentWatchRule
                         && groupAccess?.requireMention
                         && !msgCtx.wasMentioned) {
                         recordHistory();
@@ -2102,12 +4225,42 @@ export const bitrix24Plugin = {
                     }
                     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,
-                        });
+                        if (hasRecentWatchNotification(msgCtx.messageId, ctx.accountId)) {
+                            logger.debug('Skipping duplicate group watch notification for recent message', {
+                                senderId: msgCtx.senderId,
+                                chatId: msgCtx.chatId,
+                                messageId: msgCtx.messageId,
+                                eventScope: msgCtx.eventScope,
+                            });
+                        }
+                        else if (await notifyWebhookOwnerAboutWatchMatch(msgCtx, activeWatchRule)) {
+                            markRecentWatchNotification(msgCtx.messageId, ctx.accountId);
+                            logger.debug('Group watch matched and notified webhook owner in DM', {
+                                senderId: msgCtx.senderId,
+                                chatId: msgCtx.chatId,
+                                messageId: msgCtx.messageId,
+                            });
+                        }
+                        return;
+                    }
+                    if (activeAgentWatchRule) {
+                        recordHistory();
+                        if (hasRecentWatchNotification(msgCtx.messageId, ctx.accountId)) {
+                            logger.debug('Skipping duplicate bot-scope agent watch notification for recent message', {
+                                senderId: msgCtx.senderId,
+                                chatId: msgCtx.chatId,
+                                messageId: msgCtx.messageId,
+                                eventScope: msgCtx.eventScope,
+                            });
+                        }
+                        else if (await notifyWebhookOwnerAboutWatchMatch(msgCtx, activeAgentWatchRule)) {
+                            markRecentWatchNotification(msgCtx.messageId, ctx.accountId);
+                            logger.debug('Bot-scope agent watch matched and notified webhook owner in DM', {
+                                senderId: msgCtx.senderId,
+                                chatId: msgCtx.chatId,
+                                messageId: msgCtx.messageId,
+                            });
+                        }
                         return;
                     }
                     const accessResult = activeWatchRule
@@ -2339,10 +4492,22 @@ export const bitrix24Plugin = {
                         accountId: ctx.accountId,
                         peer: conversation.peer,
                     });
+                    const inlineButtonsAgentHint = buildBitrix24InlineButtonsAgentHint();
+                    const fileDeliveryAgentHint = buildBitrix24FileDeliveryAgentHint();
+                    const canUseNativeReply = shouldUseBitrix24NativeReply({ isDm });
+                    const nativeReplyAgentHint = canUseNativeReply
+                        ? buildBitrix24NativeReplyAgentHint(commandMessageId)
+                        : undefined;
+                    const commandBodyForAgent = [
+                        inlineButtonsAgentHint,
+                        fileDeliveryAgentHint,
+                        nativeReplyAgentHint,
+                        commandText,
+                    ].filter(Boolean).join('\n\n');
                     const slashSessionKey = `bitrix24:slash:${senderId}:${Date.now()}`;
                     const inboundCtx = runtime.channel.reply.finalizeInboundContext({
                         Body: commandText,
-                        BodyForAgent: commandText,
+                        BodyForAgent: commandBodyForAgent,
                         RawBody: commandText,
                         CommandBody: commandText,
                         CommandAuthorized: true,
@@ -2380,20 +4545,31 @@ export const bitrix24Plugin = {
                                 deliver: async (payload) => {
                                     await replyStatusHeartbeat.stopAndWait();
                                     if (payload.text) {
+                                        const replyDirective = extractReplyDirective({
+                                            text: payload.text,
+                                            currentMessageId: commandMessageId,
+                                            explicitReplyToId: payload.replyToId,
+                                        });
                                         const keyboard = extractKeyboardFromPayload(payload)
                                             ?? defaultSessionKeyboard;
                                         const formattedPayload = normalizeCommandReplyPayload({
                                             commandName,
                                             commandParams,
-                                            text: payload.text,
+                                            text: replyDirective.cleanText,
                                             language: cmdCtx.language,
                                         });
+                                        const sendOptions = {
+                                            keyboard,
+                                            convertMarkdown: formattedPayload.convertMarkdown,
+                                            ...(canUseNativeReply && replyDirective.replyToMessageId
+                                                ? { replyToMessageId: replyDirective.replyToMessageId }
+                                                : {}),
+                                        };
                                         if (!commandReplyDelivered) {
-                                            if (isDm) {
+                                            if (isDm || (canUseNativeReply && replyDirective.replyToMessageId)) {
                                                 commandReplyDelivered = true;
                                                 await sendService.sendText(sendCtx, formattedPayload.text, {
-                                                    keyboard,
-                                                    convertMarkdown: formattedPayload.convertMarkdown,
+                                                    ...sendOptions,
                                                 });
                                             }
                                             else {
@@ -2406,10 +4582,7 @@ export const bitrix24Plugin = {
                                             return;
                                         }
                                         commandReplyDelivered = true;
-                                        await sendService.sendText(sendCtx, formattedPayload.text, {
-                                            keyboard,
-                                            convertMarkdown: formattedPayload.convertMarkdown,
-                                        });
+                                        await sendService.sendText(sendCtx, formattedPayload.text, sendOptions);
                                     }
                                 },
                                 onReplyStart: async () => {
@@ -2420,20 +4593,68 @@ export const bitrix24Plugin = {
                                 },
                             },
                         });
+                        if (!commandReplyDelivered && hasRecentMediaDelivery(sendCtx.dialogId, commandMessageId, ctx.accountId)) {
+                            commandReplyDelivered = true;
+                            logger.debug('Suppressing command fallback after successful Bitrix24 file upload in the same turn', {
+                                commandName,
+                                senderId,
+                                dialogId,
+                                messageId: commandMessageId,
+                            });
+                        }
+                        if (!commandReplyDelivered && hasRecentSuccessfulAction(commandMessageId, ctx.accountId)) {
+                            commandReplyDelivered = true;
+                            logger.debug('Suppressing command fallback after successful Bitrix24 action in the same turn', {
+                                commandName,
+                                senderId,
+                                dialogId,
+                                messageId: commandMessageId,
+                            });
+                        }
+                        const shouldWaitForEmptyCommandReplyFallback = !commandReplyDelivered
+                            && isEmptyDispatchResult(dispatchResult);
                         if (!commandReplyDelivered && dispatchResult?.queuedFinal === false) {
                             logger.debug('Command reply completed without queued final block, waiting before fallback', {
                                 commandName,
                                 senderId,
                                 dialogId,
                                 counts: dispatchResult.counts,
+                                fallbackDelayMs: shouldWaitForEmptyCommandReplyFallback
+                                    ? EMPTY_REPLY_FALLBACK_GRACE_MS
+                                    : REPLY_FALLBACK_GRACE_MS,
                             });
-                            await waitReplyFallbackGraceWindow();
+                            if (shouldWaitForEmptyCommandReplyFallback) {
+                                await waitEmptyReplyFallbackGraceWindow();
+                            }
+                            else {
+                                await waitReplyFallbackGraceWindow();
+                            }
                         }
-                        if (!commandReplyDelivered && dispatchResult?.queuedFinal === false) {
+                        if (!commandReplyDelivered && isEmptyDispatchResult(dispatchResult)) {
+                            commandReplyDelivered = true;
+                            logger.warn('Command reply completed without any user-visible payload or tool activity; sending fallback notice', {
+                                commandName,
+                                senderId,
+                                dialogId,
+                                messageId: commandMessageId,
+                                counts: dispatchResult.counts,
+                            });
+                            const fallbackText = emptyReplyFallback(cmdCtx.language);
+                            if (isDm) {
+                                await sendService.sendText(sendCtx, fallbackText);
+                            }
+                            else {
+                                await sendService.answerCommandText(commandSendCtx, fallbackText, {
+                                    keyboard: defaultCommandKeyboard,
+                                });
+                            }
+                        }
+                        else if (!commandReplyDelivered && dispatchResult?.queuedFinal === false) {
                             logger.warn('Command reply completed without a final user-visible message; fallback notice suppressed', {
                                 commandName,
                                 senderId,
                                 dialogId,
+                                messageId: commandMessageId,
                                 counts: dispatchResult.counts,
                             });
                         }
@@ -2442,6 +4663,7 @@ export const bitrix24Plugin = {
                                 commandName,
                                 senderId,
                                 dialogId,
+                                messageId: commandMessageId,
                             });
                         }
                     }