@ihazz/bitrix24 1.1.13 → 1.1.14

package/src/channel.ts

@@ -39,6 +39,7 @@ import {
   accessApproved,
   accessDenied,
   commandKeyboardLabels,
+  emptyReplyFallback,
   groupPairingPending,
   mediaDownloadFailed,
   groupChatUnsupported,
@@ -57,6 +58,12 @@ import type {
   B24Attach,
   B24AttachBlock,
   B24AttachColorToken,
+  B24AttachFileItem,
+  B24AttachGridDisplay,
+  B24AttachGridItem,
+  B24AttachImageItem,
+  B24AttachLinkValue,
+  B24AttachUserValue,
   B24MsgContext,
   B24InputActionStatusCode,
   B24V2FetchEventItem,
@@ -85,6 +92,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;
@@ -101,11 +109,26 @@ 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<string, number>();
 const pendingNativeReactionAcks = new Map<string, { emoji: string; expiresAt: number }>();
+const recentSuccessfulMediaDeliveries = new Map<string, {
+  expiresAt: number;
+  mediaByName: Map<string, string>;
+}>();
+const recentSuccessfulActionsByMessage = new Map<string, number>();
+const recentOutboundMessagesById = new Map<string, number>();
+const recentWatchNotificationsByMessage = new Map<string, number>();
 const recentInboundMessagesByDialog = new Map<string, Array<{
   messageId: string;
   body: string;
@@ -115,6 +138,7 @@ const inboundMessageContextById = new Map<string, {
   dialogId: string;
   dialogKey: string;
   body: string;
+  mediaNames: string[];
   timestamp: number;
 }>();
 
@@ -294,6 +318,245 @@ function resolvePendingNativeForwardAckDialogId(
   return inboundMessageContextById.get(messageKey)?.dialogId ?? fallbackDialogId;
 }
 
+function resolveRecentInboundDialogId(
+  currentMessageId: string | number | undefined,
+  accountId?: string,
+): string | undefined {
+  const messageKey = buildAccountMessageScopeKey(accountId, currentMessageId);
+  if (!messageKey) {
+    return undefined;
+  }
+
+  pruneRecentInboundMessages();
+  return inboundMessageContextById.get(messageKey)?.dialogId;
+}
+
+function splitFileNameParts(fileName: string): { stem: string; extension: string } {
+  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: string): string {
+  return stem
+    .trim()
+    .replace(/\s+\(\d+\)$/u, '')
+    .trim();
+}
+
+function isGenericOutboundFileName(fileName: string): boolean {
+  const { stem } = splitFileNameParts(fileName);
+  return GENERIC_OUTBOUND_FILE_NAME_RE.test(stem);
+}
+
+function isSemanticInboundFileName(fileName: string): boolean {
+  const { stem } = splitFileNameParts(fileName);
+  return Boolean(stem) && !GENERIC_INBOUND_FILE_NAME_RE.test(stem);
+}
+
+function inferTranslationSuffixFromBody(body: string): string | undefined {
+  const normalizedBody = body.toLowerCase();
+  if (!/translate|translation|перевед|перевод/u.test(normalizedBody)) {
+    return undefined;
+  }
+
+  const languagePatterns: Array<[string, RegExp]> = [
+    ['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: string, body: string): string | undefined {
+  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: {
+  dialogId: string;
+  currentMessageId?: string | number;
+  accountId?: string;
+}): {
+  body: string;
+  mediaNames: string[];
+} | undefined {
+  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: {
+  requestedFileName: string;
+  dialogId: string;
+  currentMessageId?: string | number;
+  accountId?: string;
+}): string {
+  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: {
+  sendService: unknown;
+  webhookUrl: string;
+  bot: BotContext;
+  dialogId: string | undefined;
+}): Promise<void> {
+  const dialogId = typeof params.dialogId === 'string' ? params.dialogId.trim() : '';
+  if (!dialogId) {
+    return;
+  }
+
+  const sendTyping = (params.sendService as { sendTyping?: unknown }).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: {
+  api: unknown;
+  sendService: unknown;
+  webhookUrl: string;
+  bot: BotContext;
+  dialogId: string | undefined;
+  currentMessageId: string | number | undefined;
+}): Promise<void> {
+  const messageId = toMessageId(params.currentMessageId);
+  if (!messageId) {
+    return;
+  }
+
+  const addReaction = (params.api as { addReaction?: unknown }).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: string | number | undefined,
   accountId?: string,
@@ -301,6 +564,211 @@ function buildPendingNativeReactionAckKey(
   return buildAccountMessageScopeKey(accountId, currentMessageId);
 }
 
+function pruneRecentSuccessfulActions(now = Date.now()): void {
+  for (const [key, expiresAt] of recentSuccessfulActionsByMessage.entries()) {
+    if (!Number.isFinite(expiresAt) || expiresAt <= now) {
+      recentSuccessfulActionsByMessage.delete(key);
+    }
+  }
+}
+
+function markRecentSuccessfulAction(
+  currentMessageId: string | number | undefined,
+  accountId?: string,
+): void {
+  const key = buildAccountMessageScopeKey(accountId, currentMessageId);
+  if (!key) {
+    return;
+  }
+
+  pruneRecentSuccessfulActions();
+  recentSuccessfulActionsByMessage.set(key, Date.now() + RECENT_SUCCESSFUL_ACTION_TTL_MS);
+}
+
+function hasRecentSuccessfulAction(
+  currentMessageId: string | number | undefined,
+  accountId?: string,
+): boolean {
+  const key = buildAccountMessageScopeKey(accountId, currentMessageId);
+  if (!key) {
+    return false;
+  }
+
+  pruneRecentSuccessfulActions();
+  return recentSuccessfulActionsByMessage.has(key);
+}
+
+function pruneRecentOutboundMessages(now = Date.now()): void {
+  for (const [key, expiresAt] of recentOutboundMessagesById.entries()) {
+    if (!Number.isFinite(expiresAt) || expiresAt <= now) {
+      recentOutboundMessagesById.delete(key);
+    }
+  }
+}
+
+function markRecentOutboundMessage(
+  messageId: string | number | undefined,
+  accountId?: string,
+): void {
+  const key = buildAccountMessageScopeKey(accountId, messageId);
+  if (!key) {
+    return;
+  }
+
+  pruneRecentOutboundMessages();
+  recentOutboundMessagesById.set(key, Date.now() + RECENT_OUTBOUND_MESSAGE_TTL_MS);
+}
+
+function hasRecentOutboundMessage(
+  messageId: string | number | undefined,
+  accountId?: string,
+): boolean {
+  const key = buildAccountMessageScopeKey(accountId, messageId);
+  if (!key) {
+    return false;
+  }
+
+  pruneRecentOutboundMessages();
+  return recentOutboundMessagesById.has(key);
+}
+
+function pruneRecentWatchNotifications(now = Date.now()): void {
+  for (const [key, expiresAt] of recentWatchNotificationsByMessage.entries()) {
+    if (!Number.isFinite(expiresAt) || expiresAt <= now) {
+      recentWatchNotificationsByMessage.delete(key);
+    }
+  }
+}
+
+function markRecentWatchNotification(
+  messageId: string | number | undefined,
+  accountId?: string,
+): void {
+  const key = buildAccountMessageScopeKey(accountId, messageId);
+  if (!key) {
+    return;
+  }
+
+  pruneRecentWatchNotifications();
+  recentWatchNotificationsByMessage.set(key, Date.now() + RECENT_WATCH_NOTIFICATION_TTL_MS);
+}
+
+function hasRecentWatchNotification(
+  messageId: string | number | undefined,
+  accountId?: string,
+): boolean {
+  const key = buildAccountMessageScopeKey(accountId, messageId);
+  if (!key) {
+    return false;
+  }
+
+  pruneRecentWatchNotifications();
+  return recentWatchNotificationsByMessage.has(key);
+}
+
+function buildRecentMediaDeliveryKey(
+  dialogId: string,
+  currentMessageId: string | number | undefined,
+  accountId?: string,
+): string | undefined {
+  return buildPendingNativeForwardAckKey(dialogId, currentMessageId, accountId);
+}
+
+function normalizeMediaDeliveryName(mediaUrl: string): string {
+  return basename(mediaUrl.trim()).toLowerCase();
+}
+
+function pruneRecentMediaDeliveries(now = Date.now()): void {
+  for (const [key, entry] of recentSuccessfulMediaDeliveries.entries()) {
+    if (!entry || !Number.isFinite(entry.expiresAt) || entry.expiresAt <= now) {
+      recentSuccessfulMediaDeliveries.delete(key);
+    }
+  }
+}
+
+function markRecentMediaDelivery(params: {
+  dialogId: string;
+  currentMessageId: string | number | undefined;
+  mediaUrls: string[];
+  accountId?: string;
+  messageId?: string;
+}): void {
+  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<string, string>();
+  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: {
+  dialogId: string;
+  currentMessageId: string | number | undefined;
+  mediaUrls: string[];
+  accountId?: string;
+}): { messageId?: string } | null {
+  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: string,
+  currentMessageId: string | number | undefined,
+  accountId?: string,
+): boolean {
+  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()): void {
   for (const [key, entry] of pendingNativeReactionAcks.entries()) {
     if (!entry || !Number.isFinite(entry.expiresAt) || entry.expiresAt <= now) {
@@ -372,6 +840,7 @@ function rememberRecentInboundMessage(
   dialogId: string,
   messageId: string | number | undefined,
   body: string,
+  mediaNames: string[] = [],
   timestamp = Date.now(),
   accountId?: string,
 ): void {
@@ -397,6 +866,10 @@ function rememberRecentInboundMessage(
     dialogId,
     dialogKey,
     body: normalizedBody,
+    mediaNames: mediaNames
+      .filter((name) => typeof name === 'string')
+      .map((name) => name.trim())
+      .filter(Boolean),
     timestamp,
   });
 }
@@ -558,6 +1031,26 @@ function extractReplyDirective(params: {
   return { cleanText };
 }
 
+function isBitrix24DirectDialogId(dialogId: string | undefined): boolean {
+  const normalizedDialogId = String(dialogId ?? '').trim();
+  return normalizedDialogId.length > 0 && !normalizedDialogId.startsWith('chat');
+}
+
+function shouldUseBitrix24NativeReply(params: {
+  isDm?: boolean;
+  dialogId?: string;
+}): boolean {
+  if (typeof params.isDm === 'boolean') {
+    return !params.isDm;
+  }
+
+  if (!params.dialogId) {
+    return false;
+  }
+
+  return !isBitrix24DirectDialogId(params.dialogId);
+}
+
 function findNativeForwardTarget(params: {
   accountId?: string;
   requestText: string;
@@ -728,8 +1221,8 @@ function buildBitrix24NativeReplyAgentHint(currentMessageId: string | number | u
   return [
     '[Bitrix24 native reply instruction]',
     `Current Bitrix24 message id: ${normalizedMessageId}.`,
-    'If you intentionally want a native Bitrix24 reply to the current inbound message, set "replyToMessageId" to that id.',
-    'For text-only payloads you can also prepend [[reply_to_current]] to the reply text.',
+    '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');
@@ -738,14 +1231,54 @@ function buildBitrix24NativeReplyAgentHint(currentMessageId: string | number | u
 function buildBitrix24FileDeliveryAgentHint(): string {
   return [
     '[Bitrix24 file delivery instruction]',
-    'When you need to deliver a real file or document to the user, use structured reply payload field "mediaUrl" or "mediaUrls".',
+    '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(): string {
+  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: Record<string, number> | undefined, key: 'tool' | 'block' | 'final'): number {
+  const value = counts?.[key];
+  return Number.isFinite(value) ? Number(value) : 0;
+}
+
+function isEmptyDispatchResult(
+  dispatchResult: { queuedFinal: boolean; counts: Record<string, number> } | undefined,
+): boolean {
+  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: Record<string, unknown>): number[] {
   return parseActionMessageIds(
     rawParams.forwardMessageIds
@@ -991,6 +1524,10 @@ async function waitReplyFallbackGraceWindow(): Promise<void> {
   await new Promise((resolve) => setTimeout(resolve, REPLY_FALLBACK_GRACE_MS));
 }
 
+async function waitEmptyReplyFallbackGraceWindow(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, EMPTY_REPLY_FALLBACK_GRACE_MS));
+}
+
 export function canCoalesceDirectMessage(
   msgCtx: B24MsgContext,
   config: Bitrix24AccountConfig,
@@ -1680,6 +2217,10 @@ export function __setGatewayStateForTests(state: GatewayState | null): void {
   if (state === null) {
     pendingNativeForwardAcks.clear();
     pendingNativeReactionAcks.clear();
+    recentSuccessfulMediaDeliveries.clear();
+    recentSuccessfulActionsByMessage.clear();
+    recentOutboundMessagesById.clear();
+    recentWatchNotificationsByMessage.clear();
     recentInboundMessagesByDialog.clear();
     inboundMessageContextById.clear();
   }
@@ -1690,12 +2231,14 @@ export function __rememberRecentInboundMessageForTests(params: {
   dialogId: string;
   messageId: string | number;
   body: string;
+  mediaNames?: string[];
   timestamp?: number;
 }): void {
   rememberRecentInboundMessage(
     params.dialogId,
     params.messageId,
     params.body,
+    params.mediaNames,
     params.timestamp,
     params.accountId,
   );
@@ -1748,86 +2291,26 @@ const BITRIX24_DISCOVERY_ACTION_NAMES = ['send', 'reply', 'react', 'edit', 'dele
 function buildMessageToolButtonsSchema(): Record<string, unknown> {
   return {
     type: 'array',
-    description: 'Optional Bitrix24 message buttons as rows of button objects.',
+    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',
-        additionalProperties: false,
-        properties: {
-          text: {
-            type: 'string',
-            description: 'Visible button label.',
-          },
-          callback_data: {
-            type: 'string',
-            description: 'Registered command like /help, or any plain text payload to send when tapped.',
-          },
-          style: {
-            type: 'string',
-            enum: ['primary', 'attention', 'danger'],
-            description: 'Optional Bitrix24 button accent.',
-          },
-        },
-        required: ['text'],
+        description: 'Single button object. Use text, optional callback_data, and optional style=primary|attention|danger.',
       },
     },
   };
 }
 
 function buildMessageToolAttachSchema(): Record<string, unknown> {
-  const blockSchema = {
-    type: 'object',
-    description: 'Single Bitrix24 ATTACH rich block. Supported top-level keys are MESSAGE, LINK, IMAGE, FILE, DELIMITER, GRID or USER.',
-  };
-
   return {
-    description: 'Bitrix24 ATTACH rich layout blocks. Use this for rich cards, not for binary file uploads. For a status-owner-link card, prefer blocks like USER, LINK and GRID. Example: [{"USER":{"NAME":"Alice"}},{"LINK":{"NAME":"Open","LINK":"https://example.com"}},{"GRID":[{"NAME":"Status","VALUE":"In progress","DISPLAY":"LINE"},{"NAME":"Owner","VALUE":"Alice","DISPLAY":"LINE"}]}]. Use mediaUrl/mediaUrls for actual files and media.',
-    anyOf: [
-      {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-          ID: { type: 'integer' },
-          COLOR_TOKEN: {
-            type: 'string',
-            enum: ['primary', 'secondary', 'alert', 'base'],
-          },
-          COLOR: { type: 'string' },
-          BLOCKS: {
-            type: 'array',
-            items: blockSchema,
-          },
-        },
-        required: ['BLOCKS'],
-      },
-      {
-        type: 'array',
-        items: blockSchema,
-      },
-    ],
+    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: string): Record<string, unknown> {
   return {
-    anyOf: [
-      {
-        type: 'integer',
-        description,
-      },
-      {
-        type: 'string',
-        description: `${description} Can also be a comma-separated list or JSON array string.`,
-      },
-      {
-        type: 'array',
-        description,
-        items: {
-          type: 'integer',
-        },
-      },
-    ],
+    description: `${description} Can be an integer, a string, or an array of integers.`,
   };
 }
 
@@ -1866,93 +2349,507 @@ function describeBitrix24MessageTool(params: {
   return {
     actions: [...BITRIX24_DISCOVERY_ACTION_NAMES],
     capabilities: ['interactive', 'buttons', 'cards'],
-    schema: [
-      {
-        properties: {
-          buttons: buildMessageToolButtonsSchema(),
-        },
+    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.',
+        ),
       },
-      {
-        properties: {
-          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: Record<string, unknown>): ExtractedToolSendTarget | null {
+  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: Record<string, unknown>): string | null {
+  const rawText = params.message ?? params.text ?? params.content;
+  return typeof rawText === 'string' ? rawText : null;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isAttachColorToken(value: unknown): value is B24AttachColorToken {
+  return value === 'primary'
+    || value === 'secondary'
+    || value === 'alert'
+    || value === 'base';
+}
+
+function isPresent<T>(value: T | undefined | null): value is T {
+  return value != null;
+}
+
+function isAttachBlock(value: unknown): value is B24AttachBlock {
+  return isPlainObject(value) && Object.keys(value).length > 0;
+}
+
+function isBitrix24Attach(value: unknown): value is B24Attach {
+  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: unknown): string | undefined {
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+
+  const trimmed = value.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+function readAttachNumber(value: unknown): number | undefined {
+  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: unknown): B24AttachColorToken | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+
+  const normalized = value.trim().toLowerCase();
+  return isAttachColorToken(normalized) ? normalized : undefined;
+}
+
+function normalizeAttachGridDisplayValue(value: unknown): B24AttachGridDisplay | undefined {
+  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: unknown): B24AttachGridItem | undefined {
+  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: unknown, aliasSource?: Record<string, unknown>): B24AttachLinkValue | undefined {
+  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: unknown): B24AttachImageItem | undefined {
+  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: unknown): B24AttachFileItem | undefined {
+  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: unknown, aliasSource?: Record<string, unknown>): B24AttachUserValue | undefined {
+  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 extractBitrix24ToolSend(args: Record<string, unknown>): ExtractedToolSendTarget | null {
-  if ((typeof args.action === 'string' ? args.action.trim() : '') !== 'sendMessage') {
-    return null;
+function normalizeAttachBlock(rawValue: unknown): B24AttachBlock | undefined {
+  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 as Record<string, unknown>;
+    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;
   }
 
-  const to = typeof args.to === 'string' ? normalizeBitrix24DialogTarget(args.to) : '';
-  if (!to) {
-    return null;
+  if (rawType === 'LINK') {
+    const linkValue = normalizeAttachLinkValue(rawValue.LINK ?? rawValue, rawValue);
+    return linkValue ? { LINK: linkValue } : undefined;
   }
 
-  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()
-      : '';
+  if (rawType === 'USER') {
+    const userValue = normalizeAttachUserValue(rawValue.USER ?? rawValue.USER_ID ?? rawValue, rawValue);
+    return userValue ? { USER: userValue } : undefined;
+  }
 
-  return {
-    to,
-    ...(accountId ? { accountId } : {}),
-    ...(threadId ? { threadId } : {}),
-  };
-}
+  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;
+  }
 
-function readActionTextParam(params: Record<string, unknown>): string | null {
-  const rawText = params.message ?? params.text ?? params.content;
-  return typeof rawText === 'string' ? rawText : null;
-}
+  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;
+  }
 
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
+  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;
+  }
 
-function isAttachColorToken(value: unknown): value is B24AttachColorToken {
-  return value === 'primary'
-    || value === 'secondary'
-    || value === 'alert'
-    || value === 'base';
-}
+  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;
+  }
 
-function isAttachBlock(value: unknown): value is B24AttachBlock {
-  return isPlainObject(value) && Object.keys(value).length > 0;
+  return undefined;
 }
 
-function isBitrix24Attach(value: unknown): value is B24Attach {
-  if (Array.isArray(value)) {
-    return value.length > 0 && value.every(isAttachBlock);
+function normalizeBitrix24Attach(rawValue: unknown): B24Attach | undefined {
+  if (Array.isArray(rawValue)) {
+    const blocks = rawValue.map(normalizeAttachBlock).filter(isPresent);
+    return blocks.length > 0 ? blocks : undefined;
   }
 
-  if (!isPlainObject(value) || !Array.isArray(value.BLOCKS) || value.BLOCKS.length === 0) {
-    return false;
+  if (!isPlainObject(rawValue)) {
+    return undefined;
   }
 
-  if (value.COLOR_TOKEN !== undefined && !isAttachColorToken(value.COLOR_TOKEN)) {
-    return false;
+  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,
+    };
   }
 
-  return value.BLOCKS.every(isAttachBlock);
+  const block = normalizeAttachBlock(rawValue);
+  return block ? [block] : undefined;
 }
 
 function parseActionAttach(rawValue: unknown): B24Attach | undefined {
@@ -1974,7 +2871,7 @@ function parseActionAttach(rawValue: unknown): B24Attach | undefined {
     }
   }
 
-  return isBitrix24Attach(parsed) ? parsed : undefined;
+  return normalizeBitrix24Attach(parsed);
 }
 
 function hasMeaningfulAttachInput(rawValue: unknown): boolean {
@@ -2127,8 +3024,11 @@ function collectActionMediaUrls(params: Record<string, unknown>): string[] {
 
   append(params.mediaUrl);
   append(params.mediaUrls);
+  append(params.media);
   append(params.filePath);
   append(params.filePaths);
+  append(params.path);
+  append(params.paths);
 
   return mediaUrls;
 }
@@ -2685,15 +3585,23 @@ async function uploadOutboundMedia(params: {
   mediaService: MediaService;
   mediaUrls: string[];
   sendCtx: SendContext;
+  currentMessageId?: string | number;
+  accountId?: string;
   initialMessage?: string;
 }): Promise<string> {
   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,
@@ -2701,7 +3609,7 @@ async function uploadOutboundMedia(params: {
     });
 
     if (!result.ok) {
-      throw new Error(`Failed to upload media: ${basename(mediaUrl)}`);
+      throw new Error(`Failed to upload media: ${outboundFileName}`);
     }
 
     if (result.messageId) {
@@ -2834,6 +3742,8 @@ export const bitrix24Plugin = {
           mediaService: gatewayState.mediaService,
           sendCtx,
           mediaUrls,
+          currentMessageId: ctx.currentMessageId as string | number | undefined,
+          accountId: ctx.accountId,
           initialMessage: ctx.text,
         });
         return { messageId };
@@ -2877,6 +3787,8 @@ export const bitrix24Plugin = {
           mediaService: gatewayState.mediaService,
           sendCtx,
           mediaUrls,
+          currentMessageId: ctx.currentMessageId as string | number | undefined,
+          accountId: ctx.accountId,
           initialMessage,
         });
 
@@ -2967,6 +3879,9 @@ export const bitrix24Plugin = {
         content: [{ type: 'text' as const, text: JSON.stringify(payload, null, 2) }],
         details: payload,
       });
+      const markSuccessfulAction = (currentMessageId: string | number | undefined): void => {
+        markRecentSuccessfulAction(currentMessageId, ctx.accountId);
+      };
 
       // ─── Send with buttons ──────────────────────────────────────────────
       if (ctx.action === 'send') {
@@ -2984,6 +3899,7 @@ export const bitrix24Plugin = {
         }
 
         const sendCtx: SendContext = { webhookUrl: config.webhookUrl, bot, dialogId: to };
+        const canUseNativeReply = shouldUseBitrix24NativeReply({ dialogId: to });
         const messageText = readActionTextParam(ctx.params);
         const message = typeof messageText === 'string' ? messageText.trim() : '';
         const keyboard = parseActionKeyboard(rawButtons);
@@ -3026,6 +3942,26 @@ export const bitrix24Plugin = {
           });
         }
 
+        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 ?? '' },
+          });
+        }
+
         try {
           if (explicitForwardMessages.length > 0) {
             const normalizedForwardText = normalizeForwardActionText(messageText);
@@ -3042,7 +3978,16 @@ export const bitrix24Plugin = {
                   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,
@@ -3062,7 +4007,16 @@ export const bitrix24Plugin = {
                 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,
@@ -3074,7 +4028,7 @@ export const bitrix24Plugin = {
             });
           }
 
-          if (referencedReplyMessageId && !attach && mediaUrls.length === 0) {
+          if (canUseNativeReply && referencedReplyMessageId && !attach && mediaUrls.length === 0) {
             let referencedMessageText = '';
 
             try {
@@ -3092,13 +4046,22 @@ export const bitrix24Plugin = {
             const normalizedMessage = normalizeComparableMessageText(message);
 
             if (normalizedReferencedMessage && normalizedReferencedMessage === normalizedMessage) {
-              const result = await gatewayState.sendService.sendText(
-                sendCtx,
-                '',
-                { forwardMessages: [referencedReplyMessageId] },
-              );
-              markPendingNativeForwardAck(forwardAckDialogId, currentToolMessageId, ctx.accountId);
-              return toolResult({
+            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',
@@ -3109,21 +4072,25 @@ export const bitrix24Plugin = {
               });
             }
 
+            const sendOptions = {
+              ...(keyboard ? { keyboard } : {}),
+              ...(canUseNativeReply ? { replyToMessageId: referencedReplyMessageId } : {}),
+            };
             const result = await gatewayState.sendService.sendText(
               sendCtx,
               message || ' ',
-              {
-                ...(keyboard ? { keyboard } : {}),
-                replyToMessageId: referencedReplyMessageId,
-              },
+              Object.keys(sendOptions).length > 0 ? sendOptions : undefined,
             );
+            markSuccessfulAction(currentToolMessageId);
             return toolResult({
               channel: 'bitrix24',
               to,
               via: 'direct',
               mediaUrl: null,
-              replied: true,
-              replyToMessageId: referencedReplyMessageId,
+              ...(canUseNativeReply ? {
+                replied: true,
+                replyToMessageId: referencedReplyMessageId,
+              } : {}),
               result: { messageId: String(result.messageId ?? '') },
             });
           }
@@ -3149,7 +4116,16 @@ export const bitrix24Plugin = {
               '',
               { 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,
@@ -3167,8 +4143,17 @@ export const bitrix24Plugin = {
               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) {
@@ -3182,6 +4167,7 @@ export const bitrix24Plugin = {
                     attach,
                   },
                 );
+                markSuccessfulAction(currentToolMessageId);
                 return toolResult({
                   channel: 'bitrix24',
                   to,
@@ -3196,6 +4182,7 @@ export const bitrix24Plugin = {
                 message || '',
                 keyboard ? { keyboard } : undefined,
               );
+              markSuccessfulAction(currentToolMessageId);
               return toolResult({
                 channel: 'bitrix24',
                 to,
@@ -3205,6 +4192,7 @@ export const bitrix24Plugin = {
               });
             }
 
+            markSuccessfulAction(currentToolMessageId);
             return toolResult({
               channel: 'bitrix24',
               to,
@@ -3225,6 +4213,7 @@ export const bitrix24Plugin = {
                 attach,
               },
             );
+            markSuccessfulAction(currentToolMessageId);
             return toolResult({
               channel: 'bitrix24',
               to,
@@ -3237,6 +4226,7 @@ export const bitrix24Plugin = {
           const result = await gatewayState.sendService.sendText(
             sendCtx, message || ' ', keyboard ? { keyboard } : undefined,
           );
+          markSuccessfulAction(currentToolMessageId);
           return toolResult({
             channel: 'bitrix24',
             to,
@@ -3246,6 +4236,14 @@ 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 });
         }
       }
@@ -3265,6 +4263,7 @@ export const bitrix24Plugin = {
 
         const toolContext = (ctx as Record<string, unknown>).toolContext as
           | { currentMessageId?: string | number } | undefined;
+        const canUseNativeReply = shouldUseBitrix24NativeReply({ dialogId: to });
         const replyToMessageId = parseActionMessageIds(
           params.replyToMessageId
           ?? params.replyToId
@@ -3300,31 +4299,38 @@ export const bitrix24Plugin = {
               {
                 ...(keyboard ? { keyboard } : {}),
                 attach,
-                replyToMessageId,
+                ...(canUseNativeReply ? { replyToMessageId } : {}),
               },
             );
+            markSuccessfulAction(toolContext?.currentMessageId);
             return toolResult({
               ok: true,
-              replied: true,
               to,
-              replyToMessageId,
+              ...(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 || ' ',
-            {
-              ...(keyboard ? { keyboard } : {}),
-              replyToMessageId,
-            },
+            Object.keys(sendOptions).length > 0 ? sendOptions : undefined,
           );
+          markSuccessfulAction(toolContext?.currentMessageId);
           return toolResult({
             ok: true,
-            replied: true,
             to,
-            replyToMessageId,
+            ...(canUseNativeReply ? {
+              replied: true,
+              replyToMessageId,
+            } : {}),
             messageId: String(result.messageId ?? ''),
           });
         } catch (err) {
@@ -3394,6 +4400,7 @@ export const bitrix24Plugin = {
               ...(attach ? { attach } : {}),
             },
           );
+          markSuccessfulAction(toolContext?.currentMessageId);
           return toolResult({ ok: true, edited: true, messageId });
         } catch (err) {
           const errMsg = err instanceof Error ? err.message : String(err);
@@ -3429,6 +4436,7 @@ export const bitrix24Plugin = {
 
         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);
@@ -3453,6 +4461,13 @@ export const bitrix24Plugin = {
         | { currentMessageId?: string | number } | undefined;
       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.' });
@@ -3469,6 +4484,7 @@ export const bitrix24Plugin = {
         }
         try {
           await api.deleteReaction(config.webhookUrl, bot, messageId, reactionCode);
+          markSuccessfulAction(toolContext?.currentMessageId);
           return toolResult({ ok: true, removed: true });
         } catch (err) {
           const errMsg = err instanceof Error ? err.message : String(err);
@@ -3493,13 +4509,27 @@ 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.` });
@@ -3675,6 +4705,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: string | undefined,
       ): Promise<{ sender: string; body: string; messageId: string } | undefined> => {
@@ -3867,8 +4921,12 @@ export const bitrix24Plugin = {
             query: bodyWithReply,
             historyCache,
           });
+          const inlineButtonsAgentHint = buildBitrix24InlineButtonsAgentHint();
           const fileDeliveryAgentHint = buildBitrix24FileDeliveryAgentHint();
-          const nativeReplyAgentHint = buildBitrix24NativeReplyAgentHint(msgCtx.messageId);
+          const canUseNativeReply = shouldUseBitrix24NativeReply({ isDm: msgCtx.isDm });
+          const nativeReplyAgentHint = canUseNativeReply
+            ? buildBitrix24NativeReplyAgentHint(msgCtx.messageId)
+            : undefined;
           const nativeForwardAgentHint = buildBitrix24NativeForwardAgentHint({
             accountId: ctx.accountId,
             currentBody: body,
@@ -3877,6 +4935,7 @@ export const bitrix24Plugin = {
             historyEntries: previousEntries,
           });
           const bodyForAgent = [
+            inlineButtonsAgentHint,
             fileDeliveryAgentHint,
             nativeReplyAgentHint,
             nativeForwardAgentHint,
@@ -3895,6 +4954,7 @@ export const bitrix24Plugin = {
             conversation.dialogId,
             msgCtx.messageId,
             body,
+            msgCtx.media.map((mediaItem) => mediaItem.name),
             msgCtx.timestamp ?? Date.now(),
             ctx.accountId,
           );
@@ -3954,14 +5014,33 @@ 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) {
+                    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', {
@@ -4016,7 +5095,7 @@ export const bitrix24Plugin = {
                       : [];
                     const nativeReplyToMessageId = nativeForwardMessageId
                       ? undefined
-                      : replyDirective.replyToMessageId;
+                      : (canUseNativeReply ? replyDirective.replyToMessageId : undefined);
                     const sendOptions = {
                       ...(keyboard ? { keyboard } : {}),
                       ...(nativeReplyToMessageId ? { replyToMessageId: nativeReplyToMessageId } : {}),
@@ -4071,25 +5150,64 @@ 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,
               });
-              await waitReplyFallbackGraceWindow();
+              if (shouldWaitForEmptyReplyFallback) {
+                await waitEmptyReplyFallbackGraceWindow();
+              } else {
+                await waitReplyFallbackGraceWindow();
+              }
             }
 
-            if (!replyDelivered && dispatchResult?.queuedFinal === false) {
+            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 sendService.sendText(sendCtx, emptyReplyFallback(msgCtx.language));
+            } 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,
               });
             } else if (replyDelivered && dispatchResult?.queuedFinal === false) {
               logger.debug('Late reply arrived during fallback grace window, skipping fallback', {
                 senderId: msgCtx.senderId,
                 chatId: msgCtx.chatId,
+                messageId: msgCtx.messageId,
               });
             }
           } catch (err) {
@@ -4106,7 +5224,9 @@ export const bitrix24Plugin = {
             });
           }
         } finally {
-          await mediaService.cleanupDownloadedMedia(downloadedMedia.map((mediaItem) => mediaItem.path));
+          mediaService.scheduleDownloadedMediaCleanup(
+            downloadedMedia.map((mediaItem) => mediaItem.path),
+          );
         }
       };
       const directTextCoalescer = new BufferedDirectMessageCoalescer({
@@ -4298,6 +5418,16 @@ export const bitrix24Plugin = {
             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;
@@ -4324,7 +5454,7 @@ export const bitrix24Plugin = {
               chatId: msgCtx.chatInternalId,
             })
             : null;
-          const agentWatchRules = config.agentMode && msgCtx.eventScope === 'user'
+          const agentWatchRules = config.agentMode
             ? resolveAgentWatchRules({
               config,
               dialogId: msgCtx.chatId,
@@ -4334,43 +5464,71 @@ 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?: string) =>
             appendMessageToHistory({ historyCache, historyKey, historyLimit, msgCtx, body });
 
-          if (msgCtx.eventScope === 'user') {
-            const isBotDialogUserEvent = msgCtx.isDm && msgCtx.chatId === String(bot.botId);
-            const isBotAuthoredUserEvent = msgCtx.senderId === String(bot.botId);
-
-            if (isBotDialogUserEvent || isBotAuthoredUserEvent) {
-              logger.debug('Skipping agent-mode user event for bot-owned conversation', {
-                senderId: msgCtx.senderId,
-                chatId: msgCtx.chatId,
-                messageId: msgCtx.messageId,
-                isBotDialogUserEvent,
-                isBotAuthoredUserEvent,
-              });
-              return;
-            }
+          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') {
             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;
           }
@@ -4395,6 +5553,7 @@ export const bitrix24Plugin = {
           if (
             msgCtx.isGroup
             && !activeWatchRule
+            && !activeAgentWatchRule
             && groupAccess?.requireMention
             && !msgCtx.wasMentioned
           ) {
@@ -4411,12 +5570,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;
           }
 
@@ -4729,9 +5918,14 @@ export const bitrix24Plugin = {
             accountId: ctx.accountId,
             peer: conversation.peer,
           });
+          const inlineButtonsAgentHint = buildBitrix24InlineButtonsAgentHint();
           const fileDeliveryAgentHint = buildBitrix24FileDeliveryAgentHint();
-          const nativeReplyAgentHint = buildBitrix24NativeReplyAgentHint(commandMessageId);
+          const canUseNativeReply = shouldUseBitrix24NativeReply({ isDm });
+          const nativeReplyAgentHint = canUseNativeReply
+            ? buildBitrix24NativeReplyAgentHint(commandMessageId)
+            : undefined;
           const commandBodyForAgent = [
+            inlineButtonsAgentHint,
             fileDeliveryAgentHint,
             nativeReplyAgentHint,
             commandText,
@@ -4797,10 +5991,12 @@ export const bitrix24Plugin = {
                     const sendOptions = {
                       keyboard,
                       convertMarkdown: formattedPayload.convertMarkdown,
-                      ...(replyDirective.replyToMessageId ? { replyToMessageId: replyDirective.replyToMessageId } : {}),
+                      ...(canUseNativeReply && replyDirective.replyToMessageId
+                        ? { replyToMessageId: replyDirective.replyToMessageId }
+                        : {}),
                     };
                     if (!commandReplyDelivered) {
-                      if (isDm || replyDirective.replyToMessageId) {
+                      if (isDm || (canUseNativeReply && replyDirective.replyToMessageId)) {
                         commandReplyDelivered = true;
                         await sendService.sendText(sendCtx, formattedPayload.text, {
                           ...sendOptions,
@@ -4828,21 +6024,69 @@ 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,
               });
             } else if (commandReplyDelivered && dispatchResult?.queuedFinal === false) {
@@ -4850,6 +6094,7 @@ export const bitrix24Plugin = {
                 commandName,
                 senderId,
                 dialogId,
+                messageId: commandMessageId,
               });
             }
           } catch (err) {