@ihazz/bitrix24 1.1.6 → 1.1.8

package/src/channel.ts

@@ -1,5 +1,6 @@
-import { createHash } from 'node:crypto';
-import { basename } from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { listAccountIds, resolveAccount, getConfig } from './config.js';
 import { Bitrix24Api } from './api.js';
@@ -11,6 +12,7 @@ import type { DownloadedMedia } from './media-service.js';
 import { InboundHandler } from './inbound-handler.js';
 import type { FetchCommandContext, FetchJoinChatContext, FetchReactionContext } from './inbound-handler.js';
 import { PollingService } from './polling-service.js';
+import { resolvePollingStateDir } from './state-paths.js';
 import {
   normalizeAllowEntry,
   normalizeAllowList,
@@ -27,7 +29,12 @@ import { DEFAULT_AVATAR_BASE64 } from './bot-avatar.js';
 import { Bitrix24ApiError, createVerboseLogger, defaultLogger, CHANNEL_PREFIX_RE } from './utils.js';
 import { getBitrix24Runtime } from './runtime.js';
 import type { ChannelPairingAdapter } from './runtime.js';
-import { OPENCLAW_COMMANDS, buildCommandsHelpText, formatModelsCommandReply } from './commands.js';
+import {
+  OPENCLAW_COMMANDS,
+  buildCommandsHelpText,
+  formatModelsCommandReply,
+  getCommandRegistrationPayload,
+} from './commands.js';
 import {
   accessApproved,
   accessDenied,
@@ -35,9 +42,13 @@ import {
   groupPairingPending,
   mediaDownloadFailed,
   groupChatUnsupported,
+  newSessionReplyTexts,
   onboardingMessage,
+  normalizeNewSessionReply,
   ownerAndAllowedUsersOnly,
   personalBotOwnerOnly,
+  replyGenerationFailed,
+  welcomeKeyboardLabels,
   watchOwnerDmNotice,
 } from './i18n.js';
 import { HistoryCache } from './history-cache.js';
@@ -78,6 +89,9 @@ const CROSS_CHAT_HISTORY_LIMIT = 20;
 const ACCESS_DENIED_REACTION = 'crossMark';
 const BOT_MESSAGE_WATCH_REACTION = 'eyes';
 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 REGISTERED_COMMANDS = new Set(OPENCLAW_COMMANDS.map((command) => command.command));
 
 // ─── Emoji → B24 reaction code mapping ──────────────────────────────────
@@ -180,7 +194,7 @@ function buildTopicsBbCode(topics: string[] | undefined): string | undefined {
 }
 
 function formatQuoteTimestamp(timestamp: number | undefined, language: string | undefined): string {
-  const locale = (language ?? 'ru').toLowerCase().slice(0, 2);
+  const locale = (language ?? 'en').toLowerCase().slice(0, 2);
   const value = timestamp ?? Date.now();
 
   try {
@@ -192,7 +206,7 @@ function formatQuoteTimestamp(timestamp: number | undefined, language: string |
       minute: '2-digit',
     }).format(new Date(value)).replace(',', '');
   } catch {
-    return new Intl.DateTimeFormat('ru', {
+    return new Intl.DateTimeFormat('en', {
       year: 'numeric',
       month: '2-digit',
       day: '2-digit',
@@ -202,6 +216,14 @@ function formatQuoteTimestamp(timestamp: number | undefined, language: string |
   }
 }
 
+function buildWatchQuoteAnchor(msgCtx: B24MsgContext, ownerId: string): string {
+  if (msgCtx.isGroup) {
+    return `#${msgCtx.chatId}/${msgCtx.messageId}`;
+  }
+
+  return `#${msgCtx.chatId}:${ownerId}/${msgCtx.messageId}`;
+}
+
 function buildWatchQuoteText(params: {
   senderName: string;
   language?: string;
@@ -504,8 +526,116 @@ export function resolveConversationRef(params: {
 export function buildConversationSessionKey(
   routeSessionKey: string,
   conversation: Pick<Bitrix24ConversationRef, 'address'>,
+  sessionNamespace?: string,
 ): string {
-  return `${routeSessionKey}:${conversation.address}`;
+  const baseKey = `${routeSessionKey}:${conversation.address}`;
+  return sessionNamespace
+    ? `${baseKey}:${sessionNamespace}`
+    : baseKey;
+}
+
+type ActiveSessionNamespaceEntry = {
+  namespace: string;
+  updatedAt: number;
+};
+
+function normalizeSessionNamespaceTimestamp(value: unknown, now: number, fallback: number): number {
+  let parsed: number | undefined;
+
+  if (typeof value === 'number') {
+    parsed = value;
+  } else if (typeof value === 'string') {
+    const asNumber = Number(value);
+    parsed = Number.isFinite(asNumber) ? asNumber : Date.parse(value);
+  }
+
+  if (!Number.isFinite(parsed) || parsed == null || parsed <= 0) {
+    return fallback;
+  }
+
+  return Math.min(parsed, now);
+}
+
+function isValidActiveSessionNamespace(value: unknown): value is string {
+  return typeof value === 'string' && ACTIVE_SESSION_NAMESPACE_RE.test(value);
+}
+
+export function normalizeActiveSessionNamespaceState(
+  state: unknown,
+  accountId: string,
+  now = Date.now(),
+): Record<string, ActiveSessionNamespaceEntry> {
+  if (!state || typeof state !== 'object') {
+    return {};
+  }
+
+  const rawState = state as {
+    updatedAt?: unknown;
+    sessions?: Record<string, unknown>;
+  };
+  const fallbackUpdatedAt = normalizeSessionNamespaceTimestamp(rawState.updatedAt, now, now);
+  const accountKeyPrefix = `${accountId}:`;
+  const entries: Array<[string, ActiveSessionNamespaceEntry]> = [];
+
+  for (const [key, value] of Object.entries(rawState.sessions ?? {})) {
+    if (!key.startsWith(accountKeyPrefix)) {
+      continue;
+    }
+
+    let namespace: unknown;
+    let updatedAt = fallbackUpdatedAt;
+
+    if (typeof value === 'string') {
+      namespace = value;
+    } else if (value && typeof value === 'object') {
+      const rawEntry = value as {
+        namespace?: unknown;
+        updatedAt?: unknown;
+      };
+      namespace = rawEntry.namespace;
+      updatedAt = normalizeSessionNamespaceTimestamp(rawEntry.updatedAt, now, fallbackUpdatedAt);
+    }
+
+    if (!isValidActiveSessionNamespace(namespace)) {
+      continue;
+    }
+
+    if (now - updatedAt > ACTIVE_SESSION_NAMESPACE_TTL_MS) {
+      continue;
+    }
+
+    entries.push([key, { namespace, updatedAt }]);
+  }
+
+  entries.sort((left, right) => left[1].updatedAt - right[1].updatedAt);
+  return Object.fromEntries(entries.slice(-ACTIVE_SESSION_NAMESPACE_MAX_KEYS));
+}
+
+function pruneActiveSessionNamespaceEntries(
+  entries: Map<string, ActiveSessionNamespaceEntry>,
+  now = Date.now(),
+): void {
+  for (const [key, value] of entries) {
+    if (!isValidActiveSessionNamespace(value?.namespace)
+      || !Number.isFinite(value?.updatedAt)
+      || value.updatedAt <= 0
+      || now - value.updatedAt > ACTIVE_SESSION_NAMESPACE_TTL_MS) {
+      entries.delete(key);
+    }
+  }
+
+  if (entries.size <= ACTIVE_SESSION_NAMESPACE_MAX_KEYS) {
+    return;
+  }
+
+  const overflow = entries.size - ACTIVE_SESSION_NAMESPACE_MAX_KEYS;
+  const staleFirst = [...entries.entries()]
+    .sort((left, right) => left[1].updatedAt - right[1].updatedAt)
+    .slice(0, overflow);
+
+  for (const [key] of staleFirst) {
+    entries.delete(key);
+  }
 }
 
 function buildHistoryBody(msgCtx: B24MsgContext): string {
@@ -736,7 +866,7 @@ function normalizeTopicText(text: string): string {
 
 function tokenizeTopicText(text: string): string[] {
   return normalizeTopicText(text)
-    .split(/[^a-zа-яё0-9]+/i)
+    .split(/[^\p{L}\p{N}]+/u)
     .filter(Boolean);
 }
 
@@ -921,7 +1051,20 @@ export function __setGatewayStateForTests(state: GatewayState | null): void {
   gatewayState = state;
 }
 
-// ─── Default command keyboard ────────────────────────────────────────────────
+// ─── Keyboard layouts ────────────────────────────────────────────────────────
+
+export function buildWelcomeKeyboard(language?: string): B24Keyboard {
+  const labels = welcomeKeyboardLabels(language);
+
+  return [
+    { TEXT: labels.todayTasks, ACTION: 'SEND', ACTION_VALUE: labels.todayTasks, DISPLAY: 'LINE' },
+    { TEXT: labels.stalledDeals, ACTION: 'SEND', ACTION_VALUE: labels.stalledDeals, DISPLAY: 'LINE' },
+    { TYPE: 'NEWLINE' },
+    { TEXT: labels.newSession, COMMAND: 'new', DISPLAY: 'LINE' },
+    { TEXT: labels.commands, COMMAND: 'commands', DISPLAY: 'LINE' },
+    { TEXT: labels.help, COMMAND: 'help', BG_COLOR_TOKEN: 'primary', DISPLAY: 'LINE' },
+  ];
+}
 
 /** Default keyboard shown with command responses and welcome messages. */
 export function buildDefaultCommandKeyboard(language?: string): B24Keyboard {
@@ -938,6 +1081,7 @@ export function buildDefaultCommandKeyboard(language?: string): B24Keyboard {
 }
 
 export const DEFAULT_COMMAND_KEYBOARD: B24Keyboard = buildDefaultCommandKeyboard();
+export const DEFAULT_WELCOME_KEYBOARD: B24Keyboard = buildWelcomeKeyboard();
 
 // ─── Keyboard / Button conversion ────────────────────────────────────────────
 
@@ -1031,7 +1175,8 @@ export function extractKeyboardFromPayload(
 
   const tgData = cd.telegram as { buttons?: ChannelButton[][] } | undefined;
   if (tgData?.buttons?.length) {
-    return convertButtonsToKeyboard(tgData.buttons);
+    const keyboard = convertButtonsToKeyboard(tgData.buttons);
+    return keyboard.length > 0 ? keyboard : undefined;
   }
 
   return undefined;
@@ -1085,6 +1230,13 @@ function normalizeCommandReplyPayload(params: {
     }
   }
 
+  if (commandName === 'new' && commandParams.trim() === '') {
+    const normalizedText = normalizeNewSessionReply(language, text);
+    if (normalizedText) {
+      return { text: normalizedText, convertMarkdown: false };
+    }
+  }
+
   return { text };
 }
 
@@ -1169,7 +1321,7 @@ async function sendInitialWelcomeToWebhookOwner(params: {
   const text = onboardingMessage(language, config.botName ?? 'OpenClaw', config.dmPolicy);
   const options = isPairing
     ? undefined
-    : { keyboard: buildDefaultCommandKeyboard(language) };
+    : { keyboard: buildWelcomeKeyboard(language) };
 
   try {
     await sendService.sendText(sendCtx, text, options);
@@ -1306,8 +1458,7 @@ async function ensureCommandsRegistered(
     try {
       await api.registerCommand(webhookUrl, bot, {
         command: cmd.command,
-        title: { en: cmd.en, ru: cmd.ru },
-        ...(cmd.params ? { params: { en: cmd.params, ru: cmd.params } } : {}),
+        ...getCommandRegistrationPayload(cmd),
       });
       registered++;
     } catch (err: unknown) {
@@ -1816,6 +1967,90 @@ export const bitrix24Plugin = {
       const welcomedDialogs = new Set<string>();
       const dialogNoticeTimestamps = new Map<string, number>();
       const historyCache = new HistoryCache({ maxKeys: HISTORY_CACHE_MAX_KEYS });
+      const activeSessionNamespaces = new Map<string, ActiveSessionNamespaceEntry>();
+      const sessionNamespaceStatePath = join(resolvePollingStateDir(), `session-namespaces-${ctx.accountId}.json`);
+      let persistActiveSessionNamespacesTail: Promise<void> = Promise.resolve();
+
+      const buildActiveSessionNamespaceKey = (conversation: Pick<Bitrix24ConversationRef, 'address'>): string => {
+        return `${ctx.accountId}:${conversation.address}`;
+      };
+
+      const loadActiveSessionNamespaces = async (): Promise<void> => {
+        try {
+          const raw = await readFile(sessionNamespaceStatePath, 'utf-8');
+          const state = JSON.parse(raw) as {
+            sessions?: Record<string, unknown>;
+          };
+          const entries = normalizeActiveSessionNamespaceState(state, ctx.accountId);
+          const persistedSessions = state.sessions ?? {};
+          const needsCompaction = Object.keys(entries).length !== Object.keys(persistedSessions).length
+            || Object.values(persistedSessions).some((value) => typeof value === 'string');
+
+          activeSessionNamespaces.clear();
+          for (const [key, value] of Object.entries(entries)) {
+            activeSessionNamespaces.set(key, value);
+          }
+
+          if (needsCompaction) {
+            void persistActiveSessionNamespaces();
+          }
+        } catch (err) {
+          logger.debug('Failed to load active session namespaces, starting fresh', err);
+        }
+      };
+
+      const persistActiveSessionNamespaces = (): Promise<void> => {
+        persistActiveSessionNamespacesTail = persistActiveSessionNamespacesTail
+          .catch(() => undefined)
+          .then(async () => {
+            try {
+              pruneActiveSessionNamespaceEntries(activeSessionNamespaces);
+              await mkdir(dirname(sessionNamespaceStatePath), { recursive: true });
+              const data = JSON.stringify({
+                updatedAt: new Date().toISOString(),
+                sessions: Object.fromEntries(activeSessionNamespaces),
+              }, null, 2);
+              const tmpPath = `${sessionNamespaceStatePath}.${randomUUID()}.tmp`;
+              await writeFile(tmpPath, data, 'utf-8');
+              await rename(tmpPath, sessionNamespaceStatePath);
+            } catch (err) {
+              logger.warn('Failed to persist active session namespaces', err);
+            }
+          });
+
+        return persistActiveSessionNamespacesTail;
+      };
+
+      const resolveActiveConversationSessionKey = (
+        routeSessionKey: string,
+        conversation: Pick<Bitrix24ConversationRef, 'address'>,
+      ): string => {
+        return buildConversationSessionKey(
+          routeSessionKey,
+          conversation,
+          activeSessionNamespaces.get(buildActiveSessionNamespaceKey(conversation))?.namespace,
+        );
+      };
+
+      const startNewConversationSession = async (
+        conversation: Pick<Bitrix24ConversationRef, 'address' | 'historyKey' | 'dialogId'>,
+      ): Promise<string> => {
+        const sessionNamespace = randomUUID();
+        pruneActiveSessionNamespaceEntries(activeSessionNamespaces);
+        historyCache.clear(conversation.historyKey);
+        activeSessionNamespaces.set(buildActiveSessionNamespaceKey(conversation), {
+          namespace: sessionNamespace,
+          updatedAt: Date.now(),
+        });
+        await persistActiveSessionNamespaces();
+        logger.info('Started new local conversation session', {
+          dialogId: conversation.dialogId,
+          sessionNamespace,
+        });
+        return sessionNamespace;
+      };
+
+      await loadActiveSessionNamespaces();
 
       // Cleanup stale denied dialog entries once per day
       const DENIED_CLEANUP_INTERVAL_MS = 24 * 60 * 60 * 1000;
@@ -1987,6 +2222,8 @@ export const bitrix24Plugin = {
             sendCtx,
             config,
           });
+          let replyDelivered = false;
+          let dispatchFailed = false;
 
           // Download media files if present
           let mediaFields: Record<string, unknown> = {};
@@ -2089,7 +2326,7 @@ export const bitrix24Plugin = {
             RawBody: body,
             From: conversation.address,
             To: conversation.address,
-            SessionKey: buildConversationSessionKey(route.sessionKey, conversation),
+            SessionKey: resolveActiveConversationSessionKey(route.sessionKey, conversation),
             AccountId: route.accountId,
             ChatType: msgCtx.isDm ? 'direct' : 'group',
             ConversationLabel: msgCtx.senderName,
@@ -2110,7 +2347,7 @@ export const bitrix24Plugin = {
           });
 
           try {
-            await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            const dispatchResult = await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
               ctx: inboundCtx,
               cfg,
               dispatcherOptions: {
@@ -2137,6 +2374,7 @@ export const bitrix24Plugin = {
                       }
                     }
 
+                    replyDelivered = true;
                     await sendService.sendText(sendCtx, text, keyboard ? { keyboard } : undefined);
                   }
                 },
@@ -2148,11 +2386,28 @@ export const bitrix24Plugin = {
                 },
               },
             });
+
+            if (!replyDelivered && dispatchResult?.queuedFinal === false) {
+              await sendService.sendText(
+                sendCtx,
+                replyGenerationFailed(msgCtx.language),
+                { convertMarkdown: false },
+              );
+            }
           } catch (err) {
+            dispatchFailed = true;
             logger.error('Error dispatching message to agent', { senderId: msgCtx.senderId, chatId: msgCtx.chatId, error: err });
           } finally {
             replyStatusHeartbeat.stop();
           }
+
+          if (!replyDelivered && dispatchFailed) {
+            await sendService.sendText(
+              sendCtx,
+              replyGenerationFailed(msgCtx.language),
+              { convertMarkdown: false },
+            );
+          }
         } finally {
           await mediaService.cleanupDownloadedMedia(downloadedMedia.map((mediaItem) => mediaItem.path));
         }
@@ -2265,6 +2520,19 @@ export const bitrix24Plugin = {
           bot,
           dialogId: ownerId,
         };
+        const sendQuotedWatchMessage = async (): Promise<void> => {
+          const quoteText = buildWatchQuoteText({
+            senderName: msgCtx.senderName || msgCtx.chatName || msgCtx.chatId,
+            language: msgCtx.language,
+            timestamp: msgCtx.timestamp,
+            anchor: buildWatchQuoteAnchor(msgCtx, ownerId),
+            body: msgCtx.text.trim(),
+          });
+
+          await sendService.sendText(ownerSendCtx, quoteText, {
+            convertMarkdown: false,
+          });
+        };
 
         const noticeText = watchOwnerDmNotice(msgCtx.language, {
           chatRef: buildChatContextUrl(
@@ -2283,31 +2551,21 @@ export const bitrix24Plugin = {
             convertMarkdown: false,
           });
 
-          if (msgCtx.eventScope === 'user' && msgCtx.isDm) {
-            const quoteText = buildWatchQuoteText({
-              senderName: msgCtx.senderName || msgCtx.chatName || msgCtx.chatId,
-              language: msgCtx.language,
-              timestamp: msgCtx.timestamp,
-              anchor: `#${msgCtx.chatId}:${ownerId}/${msgCtx.messageId}`,
-              body: msgCtx.text.trim(),
-            });
-
-            await sendService.sendText(ownerSendCtx, quoteText, {
-              convertMarkdown: false,
-            });
-            return true;
+          try {
+            await api.sendMessage(
+              webhookUrl,
+              bot,
+              ownerId,
+              null,
+              { forwardMessages: [forwardedMessageId] },
+            );
+          } catch (err) {
+            logger.warn('Failed to send owner watch notification with native forward, falling back to quote', err);
+            await sendQuotedWatchMessage();
           }
-
-          await api.sendMessage(
-            webhookUrl,
-            bot,
-            ownerId,
-            null,
-            { forwardMessages: [forwardedMessageId] },
-          );
           return true;
         } catch (err) {
-          logger.warn('Failed to send owner watch notification with native forward', err);
+          logger.warn('Failed to send owner watch notification', err);
           return false;
         }
       };
@@ -2586,9 +2844,10 @@ export const bitrix24Plugin = {
             messageId,
           } = cmdCtx;
           const isDm = chatType === 'P';
+          const replyDialogId = isDm ? senderId : dialogId;
           const conversation = resolveConversationRef({
             accountId: ctx.accountId,
-            dialogId,
+            dialogId: replyDialogId,
             isDirect: isDm,
           });
 
@@ -2606,7 +2865,7 @@ export const bitrix24Plugin = {
           const sendCtx: SendContext = {
             webhookUrl,
             bot,
-            dialogId: conversation.dialogId,
+            dialogId: replyDialogId,
           };
 
           let runtime;
@@ -2686,8 +2945,6 @@ export const bitrix24Plugin = {
             return;
           }
 
-          await sendService.sendStatus(sendCtx, 'IMBOT_AGENT_ACTION_THINKING', 8);
-
           if (accessResult === 'deny') {
             await sendService.markRead(sendCtx, commandMessageId);
             await sendService.answerCommandText(
@@ -2724,6 +2981,9 @@ export const bitrix24Plugin = {
           await directTextCoalescer.flush(ctx.accountId, conversation.dialogId);
 
           const defaultCommandKeyboard = buildDefaultCommandKeyboard(cmdCtx.language);
+          const defaultSessionKeyboard = commandName === 'new' && commandParams.trim() === ''
+            ? buildWelcomeKeyboard(cmdCtx.language)
+            : defaultCommandKeyboard;
 
           if (commandName === 'help' || commandName === 'commands') {
             const helpText = buildCommandsHelpText(cmdCtx.language, { concise: commandName === 'help' });
@@ -2744,6 +3004,28 @@ export const bitrix24Plugin = {
             return;
           }
 
+          if (commandName === 'new' && commandParams.trim() === '') {
+            await startNewConversationSession(conversation);
+            const startedText = newSessionReplyTexts(cmdCtx.language).started;
+
+            if (isDm) {
+              await sendService.sendText(
+                sendCtx,
+                startedText,
+                { keyboard: defaultSessionKeyboard, convertMarkdown: false },
+              );
+            } else {
+              await sendService.answerCommandText(
+                commandSendCtx,
+                startedText,
+                { keyboard: defaultSessionKeyboard, convertMarkdown: false },
+              );
+            }
+            return;
+          }
+
+          await sendService.sendStatus(sendCtx, 'IMBOT_AGENT_ACTION_THINKING', 8);
+
           const route = runtime.channel.routing.resolveAgentRoute({
             cfg,
             channel: 'bitrix24',
@@ -2760,7 +3042,7 @@ export const bitrix24Plugin = {
             CommandBody: commandText,
             CommandAuthorized: true,
             CommandSource: 'native',
-            CommandTargetSessionKey: buildConversationSessionKey(route.sessionKey, conversation),
+            CommandTargetSessionKey: resolveActiveConversationSessionKey(route.sessionKey, conversation),
             From: conversation.address,
             To: `slash:${senderId}`,
             SessionKey: slashSessionKey,
@@ -2784,10 +3066,11 @@ export const bitrix24Plugin = {
             config,
           });
           let commandReplyDelivered = false;
+          let commandDispatchFailed = false;
 
           try {
             await replyStatusHeartbeat.start();
-            await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            const dispatchResult = await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
               ctx: inboundCtx,
               cfg,
               dispatcherOptions: {
@@ -2795,7 +3078,7 @@ export const bitrix24Plugin = {
                   await replyStatusHeartbeat.stopAndWait();
                   if (payload.text) {
                     const keyboard = extractKeyboardFromPayload(payload)
-                      ?? defaultCommandKeyboard;
+                      ?? defaultSessionKeyboard;
                     const formattedPayload = normalizeCommandReplyPayload({
                       commandName,
                       commandParams,
@@ -2803,13 +3086,14 @@ export const bitrix24Plugin = {
                       language: cmdCtx.language,
                     });
                     if (!commandReplyDelivered) {
-                      commandReplyDelivered = true;
                       if (isDm) {
+                        commandReplyDelivered = true;
                         await sendService.sendText(sendCtx, formattedPayload.text, {
                           keyboard,
                           convertMarkdown: formattedPayload.convertMarkdown,
                         });
                       } else {
+                        commandReplyDelivered = true;
                         await sendService.answerCommandText(commandSendCtx, formattedPayload.text, {
                           keyboard,
                           convertMarkdown: formattedPayload.convertMarkdown,
@@ -2818,6 +3102,7 @@ export const bitrix24Plugin = {
                       return;
                     }
 
+                    commandReplyDelivered = true;
                     await sendService.sendText(sendCtx, formattedPayload.text, {
                       keyboard,
                       convertMarkdown: formattedPayload.convertMarkdown,
@@ -2832,11 +3117,42 @@ export const bitrix24Plugin = {
                 },
               },
             });
+
+            if (!commandReplyDelivered && dispatchResult?.queuedFinal === false) {
+              const fallbackText = replyGenerationFailed(cmdCtx.language);
+              if (isDm) {
+                await sendService.sendText(sendCtx, fallbackText, {
+                  keyboard: defaultSessionKeyboard,
+                  convertMarkdown: false,
+                });
+              } else {
+                await sendService.answerCommandText(commandSendCtx, fallbackText, {
+                  keyboard: defaultSessionKeyboard,
+                  convertMarkdown: false,
+                });
+              }
+            }
           } catch (err) {
+            commandDispatchFailed = true;
             logger.error('Error dispatching command to agent', { commandName, senderId, dialogId, error: err });
           } finally {
             replyStatusHeartbeat.stop();
           }
+
+          if (!commandReplyDelivered && commandDispatchFailed) {
+            const fallbackText = replyGenerationFailed(cmdCtx.language);
+            if (isDm) {
+              await sendService.sendText(sendCtx, fallbackText, {
+                keyboard: defaultSessionKeyboard,
+                convertMarkdown: false,
+              });
+            } else {
+              await sendService.answerCommandText(commandSendCtx, fallbackText, {
+                keyboard: defaultSessionKeyboard,
+                convertMarkdown: false,
+              });
+            }
+          }
         },
 
         onJoinChat: async (joinCtx: FetchJoinChatContext) => {
@@ -2927,7 +3243,7 @@ export const bitrix24Plugin = {
             await sendService.sendText(
               sendCtx,
               text,
-              isPairing ? undefined : { keyboard: buildDefaultCommandKeyboard(language) },
+              isPairing ? undefined : { keyboard: buildWelcomeKeyboard(language) },
             );
             welcomedDialogs.add(dialogId);
             logger.info('Welcome message sent', { dialogId });