@ihazz/bitrix24 1.0.3 → 1.1.0

package/tests/channel-flow.test.ts

@@ -0,0 +1,1692 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const mockState = vi.hoisted(() => {
+  return {
+    rootCfg: {} as Record<string, unknown>,
+    inboundHandlerOptions: null as Record<string, unknown> | null,
+    api: {
+      listBots: vi.fn(),
+      updateBot: vi.fn(),
+      registerBot: vi.fn(),
+      registerCommand: vi.fn(),
+      getMessage: vi.fn(),
+      getMessageContext: vi.fn(),
+      sendMessage: vi.fn(),
+      addReaction: vi.fn(),
+      leaveChat: vi.fn(),
+      unsubscribeUserEvents: vi.fn(),
+      subscribeUserEvents: vi.fn(),
+      destroy: vi.fn(),
+    },
+    sendService: {
+      sendText: vi.fn(),
+      sendTyping: vi.fn(),
+      sendStatus: vi.fn(),
+      markRead: vi.fn(),
+      answerCommandText: vi.fn(),
+    },
+    mediaService: {
+      downloadMedia: vi.fn(),
+      uploadMediaToChat: vi.fn(),
+      cleanupDownloadedMedia: vi.fn(),
+    },
+    inboundHandler: {
+      handleWebhook: vi.fn(),
+      handleFetchEvent: vi.fn(),
+      destroy: vi.fn(),
+    },
+    pollingService: {
+      options: null as Record<string, unknown> | null,
+      start: vi.fn(),
+      stop: vi.fn(),
+    },
+    runtime: {
+      config: {
+        loadConfig: vi.fn(),
+      },
+      channel: {
+        routing: {
+          resolveAgentRoute: vi.fn(),
+        },
+        reply: {
+          finalizeInboundContext: vi.fn(),
+          dispatchReplyWithBufferedBlockDispatcher: vi.fn(),
+        },
+        session: {
+          recordInboundSession: vi.fn(),
+        },
+        pairing: {
+          readAllowFromStore: vi.fn(),
+          upsertPairingRequest: vi.fn(),
+          buildPairingReply: vi.fn(),
+        },
+      },
+      logging: {
+        getChildLogger: vi.fn(),
+      },
+    },
+  };
+});
+
+vi.mock('../src/api.js', () => {
+  class MockBitrix24Api {
+    listBots = mockState.api.listBots;
+    updateBot = mockState.api.updateBot;
+    registerBot = mockState.api.registerBot;
+    registerCommand = mockState.api.registerCommand;
+    getMessage = mockState.api.getMessage;
+    getMessageContext = mockState.api.getMessageContext;
+    sendMessage = mockState.api.sendMessage;
+    addReaction = mockState.api.addReaction;
+    leaveChat = mockState.api.leaveChat;
+    unsubscribeUserEvents = mockState.api.unsubscribeUserEvents;
+    subscribeUserEvents = mockState.api.subscribeUserEvents;
+    destroy = mockState.api.destroy;
+  }
+
+  return {
+    Bitrix24Api: MockBitrix24Api,
+  };
+});
+
+vi.mock('../src/send-service.js', () => {
+  class MockSendService {
+    sendText = mockState.sendService.sendText;
+    sendTyping = mockState.sendService.sendTyping;
+    sendStatus = mockState.sendService.sendStatus;
+    markRead = mockState.sendService.markRead;
+    answerCommandText = mockState.sendService.answerCommandText;
+  }
+
+  return {
+    SendService: MockSendService,
+  };
+});
+
+vi.mock('../src/media-service.js', () => {
+  class MockMediaService {
+    downloadMedia = mockState.mediaService.downloadMedia;
+    uploadMediaToChat = mockState.mediaService.uploadMediaToChat;
+    cleanupDownloadedMedia = mockState.mediaService.cleanupDownloadedMedia;
+  }
+
+  return {
+    MediaService: MockMediaService,
+  };
+});
+
+vi.mock('../src/inbound-handler.js', () => {
+  class MockInboundHandler {
+    constructor(opts: Record<string, unknown>) {
+      mockState.inboundHandlerOptions = opts;
+    }
+
+    handleWebhook = mockState.inboundHandler.handleWebhook;
+    handleFetchEvent = mockState.inboundHandler.handleFetchEvent;
+    destroy = mockState.inboundHandler.destroy;
+  }
+
+  return {
+    InboundHandler: MockInboundHandler,
+  };
+});
+
+vi.mock('../src/polling-service.js', () => {
+  class MockPollingService {
+    constructor(opts: Record<string, unknown>) {
+      mockState.pollingService.options = opts;
+    }
+
+    start = mockState.pollingService.start;
+    stop = mockState.pollingService.stop;
+  }
+
+  return {
+    PollingService: MockPollingService,
+  };
+});
+
+vi.mock('../src/runtime.js', () => {
+  return {
+    getBitrix24Runtime: () => mockState.runtime,
+  };
+});
+
+import { __setGatewayStateForTests, bitrix24Plugin } from '../src/channel.js';
+import type { B24MsgContext } from '../src/types.js';
+
+const silentLogger = {
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+  debug: vi.fn(),
+};
+
+function createRootConfig(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    channels: {
+      bitrix24: {
+        webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+        callbackUrl: 'https://example.com/hooks/bitrix24',
+        eventMode: 'webhook',
+        botName: 'OpenClaw',
+        showTyping: false,
+        ...overrides,
+      },
+    },
+  };
+}
+
+function createGroupMessage(overrides: Partial<B24MsgContext> = {}): B24MsgContext {
+  return {
+    channel: 'bitrix24',
+    senderId: '42',
+    senderName: 'Alice',
+    senderFirstName: 'Alice',
+    chatId: 'chat520',
+    chatInternalId: '520',
+    chatName: 'Чат зеленый 17',
+    chatType: 'chat',
+    messageId: '100',
+    text: 'hello',
+    isDm: false,
+    isGroup: true,
+    media: [],
+    language: 'ru',
+    timestamp: Date.parse('2026-03-19T14:36:03+02:00'),
+    raw: { type: 'ONIMBOTV2MESSAGEADD' } as never,
+    botId: 6809,
+    memberId: '',
+    ...overrides,
+  };
+}
+
+function createDirectMessage(overrides: Partial<B24MsgContext> = {}): B24MsgContext {
+  return {
+    channel: 'bitrix24',
+    senderId: '1',
+    senderName: 'Евгений Шеленков',
+    senderFirstName: 'Евгений',
+    chatId: '1',
+    chatInternalId: '40985',
+    chatName: 'Евгений Шеленков',
+    chatType: 'private',
+    messageId: '500',
+    text: 'какие чаты ты видишь?',
+    isDm: true,
+    isGroup: false,
+    media: [],
+    language: 'ru',
+    timestamp: Date.parse('2026-03-19T15:10:00+02:00'),
+    raw: { type: 'ONIMBOTV2MESSAGEADD' } as never,
+    botId: 6809,
+    memberId: '',
+    ...overrides,
+  };
+}
+
+describe('channel group flow', () => {
+  let controller: AbortController | null = null;
+  let startPromise: Promise<void> | undefined;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockState.inboundHandlerOptions = null;
+    mockState.rootCfg = {};
+
+    mockState.api.listBots.mockResolvedValue({
+      bots: [{
+        id: 6809,
+        code: 'openclaw_1',
+        language: 'ru',
+      }],
+      users: [],
+      hasNextPage: false,
+    });
+    mockState.api.updateBot.mockResolvedValue({});
+    mockState.api.registerBot.mockResolvedValue({
+      bot: { id: 6809, language: 'ru' },
+    });
+    mockState.api.registerCommand.mockResolvedValue({});
+    mockState.api.getMessage.mockResolvedValue({
+      message: {
+        id: 201,
+        chatId: 520,
+        authorId: 42,
+        date: '2026-03-19T15:00:00+02:00',
+        text: 'исходное сообщение из API',
+        isSystem: false,
+        uuid: '',
+        forward: null,
+        params: {},
+        viewedByOthers: true,
+      },
+      user: {
+        id: 42,
+        active: true,
+        name: 'Alice',
+        firstName: 'Alice',
+        lastName: '',
+        workPosition: '',
+        color: '#ffffff',
+        avatar: '',
+        gender: 'F',
+        birthday: '',
+        extranet: false,
+        bot: false,
+        connector: false,
+        externalAuthId: '',
+        status: 'online',
+        idle: false,
+        lastActivityDate: false,
+        absent: false,
+        departments: [],
+        phones: false,
+        type: 'employee',
+      },
+    });
+    mockState.api.getMessageContext.mockResolvedValue({
+      messages: [],
+      users: [],
+      hasPrevPage: false,
+      hasNextPage: false,
+    });
+    mockState.api.sendMessage.mockResolvedValue(9001);
+    mockState.api.addReaction.mockResolvedValue(true);
+    mockState.api.leaveChat.mockResolvedValue({});
+    mockState.api.unsubscribeUserEvents.mockResolvedValue({});
+    mockState.api.subscribeUserEvents.mockResolvedValue({});
+    mockState.api.destroy.mockResolvedValue(undefined);
+
+    mockState.sendService.sendText.mockResolvedValue({ ok: true, messageId: 5001 });
+    mockState.sendService.sendTyping.mockResolvedValue(undefined);
+    mockState.sendService.sendStatus.mockResolvedValue(undefined);
+    mockState.sendService.markRead.mockResolvedValue(undefined);
+    mockState.sendService.answerCommandText.mockResolvedValue(undefined);
+
+    mockState.mediaService.downloadMedia.mockResolvedValue(null);
+    mockState.mediaService.uploadMediaToChat.mockResolvedValue({ ok: true, messageId: 6001 });
+    mockState.mediaService.cleanupDownloadedMedia.mockResolvedValue(undefined);
+
+    mockState.inboundHandler.handleWebhook.mockResolvedValue(true);
+    mockState.inboundHandler.handleFetchEvent.mockResolvedValue(true);
+    mockState.inboundHandler.destroy.mockResolvedValue(undefined);
+
+    mockState.pollingService.options = null;
+    mockState.pollingService.start.mockResolvedValue(undefined);
+    mockState.pollingService.stop.mockResolvedValue(undefined);
+
+    mockState.runtime.config.loadConfig.mockImplementation(() => mockState.rootCfg);
+    mockState.runtime.channel.routing.resolveAgentRoute.mockReturnValue({
+      sessionKey: 'route:session',
+      agentId: 'agent:test',
+      matchedBy: 'default',
+      accountId: 'default',
+    });
+    mockState.runtime.channel.reply.finalizeInboundContext.mockImplementation((ctx) => ctx);
+    mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher.mockResolvedValue(undefined);
+    mockState.runtime.channel.session.recordInboundSession.mockResolvedValue(undefined);
+    mockState.runtime.channel.pairing.readAllowFromStore.mockResolvedValue([]);
+    mockState.runtime.channel.pairing.upsertPairingRequest.mockResolvedValue({ code: 'ABCD1234', created: true });
+    mockState.runtime.channel.pairing.buildPairingReply.mockReturnValue('ABCD1234');
+    mockState.runtime.logging.getChildLogger.mockReturnValue(silentLogger);
+  });
+
+  afterEach(async () => {
+    if (controller && startPromise) {
+      controller.abort();
+      await startPromise;
+    }
+    controller = null;
+    startPromise = undefined;
+    __setGatewayStateForTests(null);
+  });
+
+  async function startWebhookAccount(overrides: Record<string, unknown> = {}): Promise<Record<string, unknown>> {
+    controller = new AbortController();
+    mockState.rootCfg = createRootConfig(overrides);
+
+    startPromise = bitrix24Plugin.gateway.startAccount({
+      cfg: mockState.rootCfg,
+      accountId: 'default',
+      account: {
+        config: (mockState.rootCfg.channels as { bitrix24: Record<string, unknown> }).bitrix24,
+      },
+      runtime: mockState.runtime,
+      abortSignal: controller.signal,
+      log: silentLogger,
+    });
+
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+      if (mockState.inboundHandlerOptions) {
+        break;
+      }
+      await Promise.resolve();
+    }
+
+    expect(mockState.inboundHandlerOptions).not.toBeNull();
+
+    return mockState.inboundHandlerOptions as Record<string, unknown>;
+  }
+
+  it('stores unmentioned group messages in history and injects them after a later mention', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'open',
+      requireMention: true,
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '101',
+      text: 'обсуждаем план',
+      wasMentioned: false,
+    }));
+
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).not.toHaveBeenCalled();
+    expect(mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher).not.toHaveBeenCalled();
+    expect(mockState.sendService.sendText).not.toHaveBeenCalled();
+    expect(mockState.sendService.markRead).toHaveBeenCalledTimes(1);
+
+    await onMessage(createGroupMessage({
+      messageId: '102',
+      text: '[USER=6809]OpenClaw[/USER] подведи итог',
+      wasMentioned: true,
+    }));
+
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).toHaveBeenCalledTimes(1);
+    const inboundCtx = mockState.runtime.channel.reply.finalizeInboundContext.mock.calls[0][0] as Record<string, unknown>;
+
+    expect(String(inboundCtx.Body)).toContain('[Chat messages since your last reply - for context]');
+    expect(String(inboundCtx.Body)).toContain('обсуждаем план');
+    expect(String(inboundCtx.BodyForAgent)).toContain('[USER=6809]OpenClaw[/USER] подведи итог');
+    expect(inboundCtx.InboundHistory).toEqual([
+      {
+        sender: 'Alice',
+        body: 'обсуждаем план',
+        timestamp: Date.parse('2026-03-19T14:36:03+02:00'),
+      },
+    ]);
+    expect(inboundCtx.WasMentioned).toBe(true);
+    expect(mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher).toHaveBeenCalledTimes(1);
+  });
+
+  it('subscribes to user events and enables combined polling in fetch mode when agent mode is on', async () => {
+    await startWebhookAccount({
+      callbackUrl: undefined,
+      eventMode: 'fetch',
+      agentMode: true,
+    });
+
+    expect(mockState.api.subscribeUserEvents).toHaveBeenCalledTimes(1);
+    expect(mockState.api.subscribeUserEvents).toHaveBeenCalledWith(
+      'https://test.bitrix24.com/rest/1/token/',
+    );
+    expect(mockState.api.unsubscribeUserEvents).not.toHaveBeenCalled();
+    expect(mockState.pollingService.options).toEqual(expect.objectContaining({
+      withUserEvents: true,
+    }));
+  });
+
+  it('answers direct native help commands via command answer transport', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'webhookUser',
+      requireMention: true,
+    });
+
+    const onCommand = inbound.onCommand as (ctx: Record<string, unknown>) => Promise<void>;
+
+    await onCommand({
+      commandId: 54,
+      commandName: 'help',
+      commandParams: '',
+      commandText: '/help',
+      senderId: '1',
+      dialogId: '1',
+      chatId: '40985',
+      chatType: 'P',
+      messageId: '490667',
+      language: 'ru',
+      fetchCtx: {
+        webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+        botId: 6809,
+        botToken: 'token',
+      },
+    });
+
+    expect(mockState.sendService.answerCommandText).toHaveBeenCalledTimes(1);
+    expect(mockState.sendService.sendText).not.toHaveBeenCalled();
+  });
+
+  it('unsubscribes from user events in fetch mode when agent mode is off', async () => {
+    await startWebhookAccount({
+      callbackUrl: undefined,
+      eventMode: 'fetch',
+      agentMode: false,
+    });
+
+    expect(mockState.api.unsubscribeUserEvents).toHaveBeenCalledTimes(1);
+    expect(mockState.api.unsubscribeUserEvents).toHaveBeenCalledWith(
+      'https://test.bitrix24.com/rest/1/token/',
+    );
+    expect(mockState.api.subscribeUserEvents).not.toHaveBeenCalled();
+    expect(mockState.pollingService.options).toEqual(expect.objectContaining({
+      withUserEvents: false,
+    }));
+  });
+
+  it('responds to any group messages from any participants in open mode without mention', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'open',
+      requireMention: false,
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '120',
+      text: 'первое сообщение от Алисы',
+      senderId: '42',
+      senderName: 'Alice',
+      wasMentioned: false,
+    }));
+
+    await onMessage(createGroupMessage({
+      messageId: '121',
+      text: 'второе сообщение от Боба',
+      senderId: '77',
+      senderName: 'Bob',
+      wasMentioned: false,
+      timestamp: Date.parse('2026-03-19T14:36:33+02:00'),
+    }));
+
+    expect(mockState.sendService.sendText).not.toHaveBeenCalled();
+    expect(mockState.api.addReaction).not.toHaveBeenCalled();
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).toHaveBeenCalledTimes(2);
+    expect(mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher).toHaveBeenCalledTimes(2);
+
+    const secondInboundCtx = mockState.runtime.channel.reply.finalizeInboundContext.mock.calls[1][0] as Record<string, unknown>;
+    expect(secondInboundCtx.ChatType).toBe('group');
+    expect(secondInboundCtx.WasMentioned).toBe(false);
+    expect(secondInboundCtx.InboundHistory).toEqual([
+      {
+        sender: 'Alice',
+        body: 'первое сообщение от Алисы',
+        timestamp: Date.parse('2026-03-19T14:36:03+02:00'),
+      },
+    ]);
+    expect(String(secondInboundCtx.Body)).toContain('первое сообщение от Алисы');
+    expect(String(secondInboundCtx.Body)).toContain('второе сообщение от Боба');
+  });
+
+  it('captures all group messages and answers only mentioned messages in open mode', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'open',
+      requireMention: true,
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '130',
+      text: 'обычное сообщение без упоминания',
+      senderId: '42',
+      senderName: 'Alice',
+      wasMentioned: false,
+    }));
+
+    expect(mockState.sendService.markRead).toHaveBeenCalledTimes(1);
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).not.toHaveBeenCalled();
+
+    await onMessage(createGroupMessage({
+      messageId: '131',
+      text: '[USER=6809]OpenClaw[/USER] ответь мне',
+      senderId: '77',
+      senderName: 'Bob',
+      wasMentioned: true,
+    }));
+
+    expect(mockState.sendService.markRead).toHaveBeenCalledTimes(2);
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).toHaveBeenCalledTimes(1);
+    const inboundCtx = mockState.runtime.channel.reply.finalizeInboundContext.mock.calls[0][0] as Record<string, unknown>;
+    expect(inboundCtx.InboundHistory).toEqual([
+      {
+        sender: 'Alice',
+        body: 'обычное сообщение без упоминания',
+        timestamp: Date.parse('2026-03-19T14:36:03+02:00'),
+      },
+    ]);
+    expect(String(inboundCtx.BodyForAgent)).toContain('ответь мне');
+  });
+
+  it('sends an owner-only notice when a non-owner is denied in webhookUser group mode', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'webhookUser',
+      requireMention: true,
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '150',
+      text: '[USER=6809]OpenClaw[/USER] а мне поможешь?',
+      senderId: '77',
+      senderName: 'Colleague',
+      wasMentioned: true,
+    }));
+
+    expect(mockState.sendService.markRead).toHaveBeenCalledTimes(1);
+    expect(mockState.api.addReaction).toHaveBeenCalledTimes(1);
+    expect(mockState.api.addReaction).toHaveBeenCalledWith(
+      'https://test.bitrix24.com/rest/1/token/',
+      { botId: 6809, botToken: expect.any(String) },
+      150,
+      'crossMark',
+    );
+    expect(mockState.sendService.sendText).toHaveBeenCalledTimes(1);
+    expect(mockState.sendService.sendText).toHaveBeenCalledWith(
+      expect.objectContaining({
+        dialogId: 'chat520',
+      }),
+      'Это персональный бот. Писать ему может только владелец.',
+      { convertMarkdown: false },
+    );
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).not.toHaveBeenCalled();
+    expect(mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher).not.toHaveBeenCalled();
+  });
+
+  it('keeps unmentioned denied group messages in RAM history without sending a notice', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'webhookUser',
+      requireMention: true,
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '155',
+      text: 'секретный секрет',
+      senderId: '77',
+      senderName: 'Сергей Рыжиков',
+      wasMentioned: false,
+    }));
+
+    expect(mockState.sendService.markRead).toHaveBeenCalledTimes(1);
+    expect(mockState.api.addReaction).not.toHaveBeenCalled();
+    expect(mockState.sendService.sendText).not.toHaveBeenCalled();
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).not.toHaveBeenCalled();
+    expect(mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher).not.toHaveBeenCalled();
+
+    await onMessage(createGroupMessage({
+      messageId: '156',
+      text: '[USER=6809]OpenClaw[/USER] что написал Сергей Рыжиков в этом чате?',
+      senderId: '1',
+      senderName: 'Евгений Шеленков',
+      wasMentioned: true,
+      timestamp: Date.parse('2026-03-19T14:37:03+02:00'),
+    }));
+
+    const inboundCtx = mockState.runtime.channel.reply.finalizeInboundContext.mock.calls[0][0] as Record<string, unknown>;
+    expect(inboundCtx.InboundHistory).toEqual([
+      {
+        sender: 'Сергей Рыжиков',
+        body: 'секретный секрет',
+        timestamp: Date.parse('2026-03-19T14:36:03+02:00'),
+      },
+    ]);
+    expect(String(inboundCtx.Body)).toContain('секретный секрет');
+    expect(mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher).toHaveBeenCalledTimes(1);
+  });
+
+  it('responds to all owner group messages without mention in webhookUser mode', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'webhookUser',
+      requireMention: false,
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '157',
+      text: 'мой вопрос без упоминания',
+      senderId: '1',
+      senderName: 'Евгений Шеленков',
+      wasMentioned: false,
+    }));
+
+    expect(mockState.sendService.sendText).not.toHaveBeenCalled();
+    expect(mockState.api.addReaction).not.toHaveBeenCalled();
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).toHaveBeenCalledTimes(1);
+    expect(mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher).toHaveBeenCalledTimes(1);
+
+    const inboundCtx = mockState.runtime.channel.reply.finalizeInboundContext.mock.calls[0][0] as Record<string, unknown>;
+    expect(inboundCtx.ChatType).toBe('group');
+    expect(inboundCtx.WasMentioned).toBe(false);
+    expect(String(inboundCtx.BodyForAgent)).toContain('мой вопрос без упоминания');
+    expect(String(inboundCtx.From)).toBe('bitrix24:chat520');
+  });
+
+  it('captures all group messages and silently ignores non-owner messages without mention in webhookUser mode', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'webhookUser',
+      requireMention: false,
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '158',
+      text: 'чужое сообщение',
+      senderId: '77',
+      senderName: 'Сергей Рыжиков',
+      wasMentioned: false,
+    }));
+
+    expect(mockState.sendService.markRead).toHaveBeenCalledTimes(1);
+    expect(mockState.sendService.sendText).not.toHaveBeenCalled();
+    expect(mockState.api.addReaction).not.toHaveBeenCalled();
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).not.toHaveBeenCalled();
+
+    await onMessage(createGroupMessage({
+      messageId: '159',
+      text: 'мой вопрос в группе',
+      senderId: '1',
+      senderName: 'Евгений Шеленков',
+      wasMentioned: false,
+    }));
+
+    expect(mockState.sendService.markRead).toHaveBeenCalledTimes(2);
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).toHaveBeenCalledTimes(1);
+    const inboundCtx = mockState.runtime.channel.reply.finalizeInboundContext.mock.calls[0][0] as Record<string, unknown>;
+    expect(inboundCtx.InboundHistory).toEqual([
+      {
+        sender: 'Сергей Рыжиков',
+        body: 'чужое сообщение',
+        timestamp: Date.parse('2026-03-19T14:36:03+02:00'),
+      },
+    ]);
+    expect(String(inboundCtx.BodyForAgent)).toContain('мой вопрос в группе');
+    expect(inboundCtx.WasMentioned).toBe(false);
+  });
+
+  it('keeps denied group messages in RAM history for the owner context', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'webhookUser',
+      requireMention: true,
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '160',
+      text: '[USER=6809]OpenClaw[/USER] а мне поможешь?',
+      senderId: '77',
+      senderName: 'Сергей Рыжиков',
+      wasMentioned: true,
+    }));
+
+    mockState.runtime.channel.reply.finalizeInboundContext.mockClear();
+    mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher.mockClear();
+    mockState.sendService.sendText.mockClear();
+
+    await onMessage(createGroupMessage({
+      messageId: '161',
+      text: '[USER=6809]OpenClaw[/USER] что написал Сергей Рыжиков?',
+      senderId: '1',
+      senderName: 'Евгений Шеленков',
+      wasMentioned: true,
+    }));
+
+    const inboundCtx = mockState.runtime.channel.reply.finalizeInboundContext.mock.calls[0][0] as Record<string, unknown>;
+    expect(inboundCtx.InboundHistory).toEqual([
+      {
+        sender: 'Сергей Рыжиков',
+        body: '[USER=6809]OpenClaw[/USER] а мне поможешь?',
+        timestamp: Date.parse('2026-03-19T14:36:03+02:00'),
+      },
+    ]);
+    expect(String(inboundCtx.Body)).toContain('Сергей Рыжиков');
+    expect(String(inboundCtx.Body)).toContain('а мне поможешь?');
+    expect(mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher).toHaveBeenCalledTimes(1);
+  });
+
+  it('captures all group messages and answers only owner mentions in webhookUser mode', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'webhookUser',
+      requireMention: true,
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '162',
+      text: 'мой текст без упоминания',
+      senderId: '1',
+      senderName: 'Евгений Шеленков',
+      wasMentioned: false,
+    }));
+    await onMessage(createGroupMessage({
+      messageId: '163',
+      text: '[USER=6809]OpenClaw[/USER] а мне можно?',
+      senderId: '77',
+      senderName: 'Сергей Рыжиков',
+      wasMentioned: true,
+    }));
+
+    expect(mockState.sendService.markRead).toHaveBeenCalledTimes(2);
+    expect(mockState.sendService.sendText).toHaveBeenCalledTimes(1);
+    expect(mockState.api.addReaction).toHaveBeenCalledTimes(1);
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).not.toHaveBeenCalled();
+
+    await onMessage(createGroupMessage({
+      messageId: '164',
+      text: '[USER=6809]OpenClaw[/USER] только мне ответь',
+      senderId: '1',
+      senderName: 'Евгений Шеленков',
+      wasMentioned: true,
+    }));
+
+    expect(mockState.sendService.markRead).toHaveBeenCalledTimes(3);
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).toHaveBeenCalledTimes(1);
+    const inboundCtx = mockState.runtime.channel.reply.finalizeInboundContext.mock.calls[0][0] as Record<string, unknown>;
+    expect(inboundCtx.InboundHistory).toEqual([
+      {
+        sender: 'Евгений Шеленков',
+        body: 'мой текст без упоминания',
+        timestamp: Date.parse('2026-03-19T14:36:03+02:00'),
+      },
+      {
+        sender: 'Сергей Рыжиков',
+        body: '[USER=6809]OpenClaw[/USER] а мне можно?',
+        timestamp: Date.parse('2026-03-19T14:36:03+02:00'),
+      },
+    ]);
+    expect(String(inboundCtx.BodyForAgent)).toContain('только мне ответь');
+    expect(inboundCtx.WasMentioned).toBe(true);
+  });
+
+  it('uses allowlist-specific notice when denied user is outside approved access', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'allowlist',
+      allowFrom: ['1'],
+      requireMention: true,
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '170',
+      text: '[USER=6809]OpenClaw[/USER] а мне можно?',
+      senderId: '77',
+      senderName: 'Сергей Рыжиков',
+      wasMentioned: true,
+    }));
+
+    expect(mockState.sendService.sendText).toHaveBeenCalledTimes(1);
+    expect(mockState.sendService.sendText).toHaveBeenCalledWith(
+      expect.objectContaining({
+        dialogId: 'chat520',
+      }),
+      'Этот бот доступен только владельцу и пользователям с подтвержденным доступом.',
+      { convertMarkdown: false },
+    );
+  });
+
+  it('captures all group messages and answers only allowlisted mentions in allowlist mode', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'allowlist',
+      allowFrom: ['77'],
+      requireMention: true,
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '171',
+      text: 'сообщение без mention от allowlist',
+      senderId: '77',
+      senderName: 'Сергей Рыжиков',
+      wasMentioned: false,
+    }));
+    await onMessage(createGroupMessage({
+      messageId: '172',
+      text: '[USER=6809]OpenClaw[/USER] чужой mention',
+      senderId: '42',
+      senderName: 'Alice',
+      wasMentioned: true,
+    }));
+
+    expect(mockState.sendService.markRead).toHaveBeenCalledTimes(2);
+    expect(mockState.sendService.sendText).toHaveBeenCalledTimes(1);
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).not.toHaveBeenCalled();
+
+    await onMessage(createGroupMessage({
+      messageId: '173',
+      text: '[USER=6809]OpenClaw[/USER] allowlist mention',
+      senderId: '77',
+      senderName: 'Сергей Рыжиков',
+      wasMentioned: true,
+    }));
+
+    expect(mockState.sendService.markRead).toHaveBeenCalledTimes(3);
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).toHaveBeenCalledTimes(1);
+    const inboundCtx = mockState.runtime.channel.reply.finalizeInboundContext.mock.calls[0][0] as Record<string, unknown>;
+    expect(inboundCtx.InboundHistory).toEqual([
+      {
+        sender: 'Сергей Рыжиков',
+        body: 'сообщение без mention от allowlist',
+        timestamp: Date.parse('2026-03-19T14:36:03+02:00'),
+      },
+      {
+        sender: 'Alice',
+        body: '[USER=6809]OpenClaw[/USER] чужой mention',
+        timestamp: Date.parse('2026-03-19T14:36:03+02:00'),
+      },
+    ]);
+    expect(String(inboundCtx.BodyForAgent)).toContain('allowlist mention');
+  });
+
+  it('hydrates reply context from RAM cache for group replies', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'open',
+      requireMention: false,
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '201',
+      text: 'исходное сообщение',
+      wasMentioned: false,
+    }));
+
+    mockState.runtime.channel.reply.finalizeInboundContext.mockClear();
+    mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher.mockClear();
+
+    await onMessage(createGroupMessage({
+      messageId: '202',
+      text: 'ответ на сообщение',
+      replyToMessageId: '201',
+      senderName: 'Bob',
+      senderId: '77',
+      wasMentioned: false,
+    }));
+
+    const inboundCtx = mockState.runtime.channel.reply.finalizeInboundContext.mock.calls[0][0] as Record<string, unknown>;
+    expect(inboundCtx.ReplyToId).toBe('201');
+    expect(inboundCtx.ReplyToBody).toBe('исходное сообщение');
+    expect(inboundCtx.ReplyToSender).toBe('Alice');
+    expect(String(inboundCtx.Body)).toContain('[Replying to Alice id:201]');
+    expect(mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher).toHaveBeenCalledTimes(1);
+  });
+
+  it('hydrates reply context from Bitrix24 API when RAM cache misses', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'open',
+      requireMention: false,
+    });
+
+    mockState.api.getMessage.mockResolvedValueOnce({
+      message: {
+        id: 999,
+        chatId: 520,
+        authorId: 55,
+        date: '2026-03-19T15:00:00+02:00',
+        text: 'сообщение из API',
+        isSystem: false,
+        uuid: '',
+        forward: null,
+        params: {},
+        viewedByOthers: true,
+      },
+      user: {
+        id: 55,
+        active: true,
+        name: 'Carol',
+        firstName: 'Carol',
+        lastName: '',
+        workPosition: '',
+        color: '#ffffff',
+        avatar: '',
+        gender: 'F',
+        birthday: '',
+        extranet: false,
+        bot: false,
+        connector: false,
+        externalAuthId: '',
+        status: 'online',
+        idle: false,
+        lastActivityDate: false,
+        absent: false,
+        departments: [],
+        phones: false,
+        type: 'employee',
+      },
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '203',
+      text: 'ответ на сообщение из API',
+      replyToMessageId: '999',
+      senderName: 'Bob',
+      senderId: '77',
+      wasMentioned: false,
+    }));
+
+    const inboundCtx = mockState.runtime.channel.reply.finalizeInboundContext.mock.calls[0][0] as Record<string, unknown>;
+    expect(inboundCtx.ReplyToId).toBe('999');
+    expect(inboundCtx.ReplyToBody).toBe('сообщение из API');
+    expect(inboundCtx.ReplyToSender).toBe('Carol');
+    expect(String(inboundCtx.Body)).toContain('[Replying to Carol id:999]');
+    expect(mockState.api.getMessage).toHaveBeenCalledWith(
+      'https://test.bitrix24.com/rest/1/token/',
+      expect.objectContaining({ botId: 6809 }),
+      999,
+    );
+  });
+
+  it('loads referenced group history in DM by Bitrix chat mention', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'open',
+      requireMention: false,
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '401',
+      text: 'первое сообщение в группе',
+      senderName: 'Алиса',
+      senderId: '42',
+      wasMentioned: false,
+    }));
+    await onMessage(createGroupMessage({
+      messageId: '402',
+      text: 'второе сообщение в группе',
+      senderName: 'Боб',
+      senderId: '77',
+      wasMentioned: false,
+      timestamp: Date.parse('2026-03-19T15:10:10+02:00'),
+    }));
+
+    mockState.runtime.channel.reply.finalizeInboundContext.mockClear();
+    mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher.mockClear();
+
+    await onMessage(createDirectMessage({
+      messageId: '403',
+      text: 'что было в [CHAT=520]Чат зеленый 17[/CHAT]?',
+      replyToMessageId: 'dm-chat-mention',
+      timestamp: Date.parse('2026-03-19T15:10:20+02:00'),
+    }));
+
+    const inboundCtx = mockState.runtime.channel.reply.finalizeInboundContext.mock.calls[0][0] as Record<string, unknown>;
+    expect(String(inboundCtx.Body)).toContain('[Visible group chat history: [CHAT=520]Чат зеленый 17[/CHAT]]');
+    expect(String(inboundCtx.Body)).toContain('[Алиса] первое сообщение в группе');
+    expect(String(inboundCtx.Body)).toContain('[Боб] второе сообщение в группе');
+    expect(String(inboundCtx.BodyForAgent)).toContain('[CHAT=520]Чат зеленый 17[/CHAT]');
+  });
+
+  it('hydrates standalone forwarded messages from Bitrix24 context instead of sending a stub notice', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'open',
+      requireMention: false,
+    });
+
+    mockState.api.getMessageContext.mockResolvedValueOnce({
+      messages: [
+        {
+          id: 299,
+          chatId: 520,
+          authorId: 42,
+          date: '2026-03-19T15:01:00+02:00',
+          text: 'что там в пересланном сообщении?',
+          isSystem: false,
+          uuid: '',
+          forward: null,
+          params: {},
+          viewedByOthers: true,
+        },
+        {
+          id: 300,
+          chatId: 520,
+          authorId: 77,
+          date: '2026-03-19T15:01:03+02:00',
+          text: 'пересланный текст',
+          isSystem: false,
+          uuid: '',
+          forward: { id: 1, userId: 77, chatId: 520, date: '2026-03-19T15:01:03+02:00' },
+          params: {},
+          viewedByOthers: true,
+        },
+      ],
+      users: [
+        {
+          id: 42,
+          active: true,
+          name: 'Alice',
+          firstName: 'Alice',
+          lastName: '',
+          workPosition: '',
+          color: '#ffffff',
+          avatar: '',
+          gender: 'F',
+          birthday: '',
+          extranet: false,
+          bot: false,
+          connector: false,
+          externalAuthId: '',
+          status: 'online',
+          idle: false,
+          lastActivityDate: false,
+          absent: false,
+          departments: [],
+          phones: false,
+          type: 'employee',
+        },
+        {
+          id: 77,
+          active: true,
+          name: 'Bob',
+          firstName: 'Bob',
+          lastName: '',
+          workPosition: '',
+          color: '#ffffff',
+          avatar: '',
+          gender: 'M',
+          birthday: '',
+          extranet: false,
+          bot: false,
+          connector: false,
+          externalAuthId: '',
+          status: 'online',
+          idle: false,
+          lastActivityDate: false,
+          absent: false,
+          departments: [],
+          phones: false,
+          type: 'employee',
+        },
+      ],
+      hasPrevPage: false,
+      hasNextPage: false,
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '300',
+      text: 'пересланный текст',
+      senderName: 'Bob',
+      senderId: '77',
+      isForwarded: true,
+      wasMentioned: false,
+    }));
+
+    const inboundCtx = mockState.runtime.channel.reply.finalizeInboundContext.mock.calls[0][0] as Record<string, unknown>;
+    expect(String(inboundCtx.Body)).toContain('пересланный текст');
+    expect(String(inboundCtx.Body)).toContain('[Forwarded message body]');
+    expect(String(inboundCtx.Body)).toContain('[/Forwarded message body]');
+    expect(String(inboundCtx.Body)).toContain('[Bitrix24 surrounding context around this forwarded message - not the forwarded message body]');
+    expect(String(inboundCtx.Body)).toContain('[Alice id:299] что там в пересланном сообщении?');
+    expect(mockState.api.getMessageContext).toHaveBeenCalledWith(
+      'https://test.bitrix24.com/rest/1/token/',
+      expect.objectContaining({ botId: 6809 }),
+      300,
+      5,
+    );
+    expect(mockState.sendService.sendText).not.toHaveBeenCalled();
+    expect(mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher).toHaveBeenCalledTimes(1);
+  });
+
+  it('hydrates and prioritizes the forwarded message when it follows a buffered direct question', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'open',
+      requireMention: false,
+    });
+
+    mockState.api.getMessageContext.mockResolvedValueOnce({
+      messages: [
+        {
+          id: 500,
+          chatId: 1,
+          authorId: 1,
+          date: '2026-03-19T23:46:00+02:00',
+          text: 'Message for all',
+          isSystem: false,
+          uuid: '',
+          forward: { id: 1, userId: 1, chatId: 520, date: '2026-03-19T23:46:00+02:00' },
+          params: {},
+          viewedByOthers: true,
+        },
+        {
+          id: 499,
+          chatId: 1,
+          authorId: 77,
+          date: '2026-03-19T23:45:58+02:00',
+          text: 'context before forwarded message',
+          isSystem: false,
+          uuid: '',
+          forward: null,
+          params: {},
+          viewedByOthers: true,
+        },
+      ],
+      users: [
+        {
+          id: 1,
+          active: true,
+          name: 'Евгений Шеленков',
+          firstName: 'Евгений',
+          lastName: 'Шеленков',
+          workPosition: '',
+          color: '#ffffff',
+          avatar: '',
+          gender: 'M',
+          birthday: '',
+          extranet: false,
+          bot: false,
+          connector: false,
+          externalAuthId: '',
+          status: 'online',
+          idle: false,
+          lastActivityDate: false,
+          absent: false,
+          departments: [],
+          phones: false,
+          type: 'employee',
+        },
+        {
+          id: 77,
+          active: true,
+          name: 'Bob',
+          firstName: 'Bob',
+          lastName: '',
+          workPosition: '',
+          color: '#ffffff',
+          avatar: '',
+          gender: 'M',
+          birthday: '',
+          extranet: false,
+          bot: false,
+          connector: false,
+          externalAuthId: '',
+          status: 'online',
+          idle: false,
+          lastActivityDate: false,
+          absent: false,
+          departments: [],
+          phones: false,
+          type: 'employee',
+        },
+      ],
+      hasPrevPage: false,
+      hasNextPage: false,
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createDirectMessage({
+      messageId: '499',
+      text: 'что в пересланном сообщении - можешь сказать слово в слово',
+      replyToMessageId: undefined,
+      timestamp: Date.parse('2026-03-19T23:45:59+02:00'),
+    }));
+
+    await onMessage(createDirectMessage({
+      messageId: '500',
+      text: '',
+      isForwarded: true,
+      replyToMessageId: '201',
+      timestamp: Date.parse('2026-03-19T23:46:00+02:00'),
+    }));
+
+    const inboundCtx = mockState.runtime.channel.reply.finalizeInboundContext.mock.calls[0][0] as Record<string, unknown>;
+    expect(String(inboundCtx.Body)).toContain('[User question about the forwarded message]');
+    expect(String(inboundCtx.Body)).toContain('[/User question]');
+    expect(String(inboundCtx.Body)).toContain('[Forwarded message body]');
+    expect(String(inboundCtx.Body)).toContain('[/Forwarded message body]');
+    expect(String(inboundCtx.Body)).toContain('Message for all');
+    expect(String(inboundCtx.Body)).toContain('[Bitrix24 surrounding context around this forwarded message - not the forwarded message body]');
+    expect(inboundCtx.ReplyToBody).toBeUndefined();
+    expect(inboundCtx.ReplyToId).toBeUndefined();
+    expect(mockState.api.getMessageContext).toHaveBeenCalledWith(
+      'https://test.bitrix24.com/rest/1/token/',
+      expect.objectContaining({ botId: 6809 }),
+      500,
+      5,
+    );
+  });
+
+  it('loads referenced group history in group messages by explicit Bitrix chat mention', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'open',
+      requireMention: false,
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '501',
+      chatId: 'chat615',
+      chatInternalId: '615',
+      chatName: 'Синий чат 15',
+      text: 'секретная заметка из синего чата',
+      senderName: 'Алиса',
+      senderId: '42',
+      wasMentioned: false,
+    }));
+
+    mockState.runtime.channel.reply.finalizeInboundContext.mockClear();
+    mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher.mockClear();
+
+    await onMessage(createGroupMessage({
+      messageId: '502',
+      chatId: 'chat520',
+      chatInternalId: '520',
+      chatName: 'Чат зеленый 17',
+      text: 'что было в [CHAT=615]Синий чат 15[/CHAT]?',
+      senderName: 'Евгений Шеленков',
+      senderId: '1',
+      wasMentioned: false,
+    }));
+
+    const inboundCtx = mockState.runtime.channel.reply.finalizeInboundContext.mock.calls[0][0] as Record<string, unknown>;
+    expect(String(inboundCtx.Body)).toContain('[Visible group chat history: [CHAT=615]Синий чат 15[/CHAT]]');
+    expect(String(inboundCtx.Body)).toContain('секретная заметка из синего чата');
+  });
+
+  it('does not load cross-chat history in DM without explicit Bitrix chat mention', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'open',
+      requireMention: false,
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '411',
+      text: 'секреты зеленого чата',
+      senderName: 'Алиса',
+      wasMentioned: false,
+    }));
+
+    mockState.runtime.channel.reply.finalizeInboundContext.mockClear();
+    mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher.mockClear();
+
+    await onMessage(createDirectMessage({
+      messageId: '412',
+      text: 'что было в чате зеленый 17?',
+      replyToMessageId: 'dm-chat-name',
+      timestamp: Date.parse('2026-03-19T15:10:30+02:00'),
+    }));
+
+    const inboundCtx = mockState.runtime.channel.reply.finalizeInboundContext.mock.calls[0][0] as Record<string, unknown>;
+    expect(String(inboundCtx.Body)).not.toContain('[Visible group chat history:');
+    expect(String(inboundCtx.Body)).not.toContain('секреты зеленого чата');
+    expect(String(inboundCtx.BodyForAgent)).toBe('что было в чате зеленый 17?');
+  });
+
+  it('answers watched user messages on matching topics in group chat', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'webhookUser',
+      requireMention: true,
+      groups: {
+        chat520: {
+          watch: [
+            { userId: '77', topics: ['секрет'] },
+          ],
+        },
+      },
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '701',
+      text: 'другая тема',
+      senderId: '77',
+      senderName: 'Сергей Рыжиков',
+      wasMentioned: false,
+    }));
+
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).not.toHaveBeenCalled();
+
+    await onMessage(createGroupMessage({
+      messageId: '702',
+      text: 'секретный секрет',
+      senderId: '77',
+      senderName: 'Сергей Рыжиков',
+      wasMentioned: false,
+      timestamp: Date.parse('2026-03-19T15:12:00+02:00'),
+    }));
+
+    expect(mockState.sendService.markRead).toHaveBeenCalledTimes(2);
+    expect(mockState.sendService.sendText).not.toHaveBeenCalled();
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).toHaveBeenCalledTimes(1);
+    const inboundCtx = mockState.runtime.channel.reply.finalizeInboundContext.mock.calls[0][0] as Record<string, unknown>;
+    expect(inboundCtx.InboundHistory).toEqual([
+      {
+        sender: 'Сергей Рыжиков',
+        body: 'другая тема',
+        timestamp: Date.parse('2026-03-19T14:36:03+02:00'),
+      },
+    ]);
+    expect(inboundCtx.WasMentioned).toBe(false);
+    expect(String(inboundCtx.BodyForAgent)).toContain('секретный секрет');
+  });
+
+  it('notifies the webhook owner in DM with a native forward when watch mode is notifyOwnerDm', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'webhookUser',
+      requireMention: true,
+      groups: {
+        chat520: {
+          watch: [
+            { userId: '10', topics: ['секрет'], mode: 'notifyOwnerDm' },
+          ],
+        },
+      },
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '710',
+      text: 'секретный комментарий',
+      senderId: '10',
+      senderName: 'Watched User',
+      wasMentioned: false,
+    }));
+
+    expect(mockState.sendService.markRead).toHaveBeenCalledTimes(1);
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).not.toHaveBeenCalled();
+    expect(mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher).not.toHaveBeenCalled();
+    expect(mockState.api.addReaction).not.toHaveBeenCalled();
+    expect(mockState.sendService.sendText).toHaveBeenCalledTimes(1);
+    expect(mockState.sendService.sendText).toHaveBeenCalledWith(
+      expect.objectContaining({
+        dialogId: '1',
+      }),
+      expect.stringContaining('Сработало правило отслеживания в чате'),
+      {
+        convertMarkdown: false,
+      },
+    );
+    expect(mockState.sendService.sendText.mock.calls[0][1]).toContain('[URL=/online/?IM_DIALOG=chat520&IM_MESSAGE=710]');
+    expect(mockState.sendService.sendText.mock.calls[0][1]).toContain('Совпавшие темы: [b]секрет[/b]');
+    expect(mockState.api.sendMessage).toHaveBeenCalledWith(
+      'https://test.bitrix24.com/rest/1/token/',
+      expect.objectContaining({
+        botId: 6809,
+      }),
+      '1',
+      null,
+      { forwardMessages: [710] },
+    );
+  });
+
+  it('matches any sender when watch userId is wildcard', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'webhookUser',
+      requireMention: true,
+      groups: {
+        chat520: {
+          watch: [
+            { userId: '*', topics: ['авария'], mode: 'notifyOwnerDm' },
+          ],
+        },
+      },
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '711',
+      text: 'авария на линии',
+      senderId: '99',
+      senderName: 'Any User',
+      wasMentioned: false,
+    }));
+
+    expect(mockState.sendService.sendText).toHaveBeenCalledTimes(1);
+    expect(mockState.sendService.sendText).toHaveBeenCalledWith(
+      expect.objectContaining({
+        dialogId: '1',
+      }),
+      expect.stringContaining('Сработало правило отслеживания в чате'),
+      {
+        convertMarkdown: false,
+      },
+    );
+    expect(mockState.sendService.sendText.mock.calls[0][1]).toContain('Совпавшие темы: [b]авария[/b]');
+    expect(mockState.api.sendMessage).toHaveBeenCalledWith(
+      'https://test.bitrix24.com/rest/1/token/',
+      expect.objectContaining({
+        botId: 6809,
+      }),
+      '1',
+      null,
+      { forwardMessages: [711] },
+    );
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).not.toHaveBeenCalled();
+  });
+
+  it('does not notify the webhook owner about their own notifyOwnerDm watch match', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'webhookUser',
+      requireMention: true,
+      groups: {
+        chat520: {
+          watch: [
+            { userId: '*', topics: ['авария'], mode: 'notifyOwnerDm' },
+          ],
+        },
+      },
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '711-own',
+      text: 'авария у нас снова',
+      senderId: '1',
+      senderName: 'Евгений Шеленков',
+      wasMentioned: false,
+    }));
+
+    expect(mockState.sendService.markRead).toHaveBeenCalledTimes(1);
+    expect(mockState.sendService.sendText).not.toHaveBeenCalled();
+    expect(mockState.api.sendMessage).not.toHaveBeenCalled();
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).not.toHaveBeenCalled();
+    expect(mockState.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher).not.toHaveBeenCalled();
+  });
+
+  it('applies wildcard group watch rules even when the group has its own override config', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'webhookUser',
+      requireMention: true,
+      groups: {
+        '*': {
+          watch: [
+            { userId: '*', topics: ['авария'], mode: 'notifyOwnerDm' },
+          ],
+        },
+        chat520: {
+          requireMention: false,
+        },
+      },
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createGroupMessage({
+      messageId: '712',
+      text: 'авария на линии',
+      senderId: '55',
+      senderName: 'Wildcard User',
+      wasMentioned: false,
+    }));
+
+    expect(mockState.sendService.sendText).toHaveBeenCalledTimes(1);
+    expect(mockState.sendService.sendText).toHaveBeenCalledWith(
+      expect.objectContaining({
+        dialogId: '1',
+      }),
+      expect.stringContaining('Сработало правило отслеживания в чате'),
+      {
+        convertMarkdown: false,
+      },
+    );
+    expect(mockState.api.sendMessage).toHaveBeenCalledWith(
+      'https://test.bitrix24.com/rest/1/token/',
+      expect.objectContaining({
+        botId: 6809,
+      }),
+      '1',
+      null,
+      { forwardMessages: [712] },
+    );
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).not.toHaveBeenCalled();
+  });
+
+  it('captures user events in agent mode and notifies owner DM when agentWatch matches', async () => {
+    const inbound = await startWebhookAccount({
+      agentMode: true,
+      agentWatch: {
+        '*': [
+          { userId: '*', topics: ['авария'], mode: 'notifyOwnerDm' },
+        ],
+      },
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createDirectMessage({
+      eventScope: 'user',
+      messageId: '9001',
+      chatId: '77',
+      chatInternalId: '99001',
+      chatName: 'Сергей Рыжиков',
+      text: 'авария в личке',
+      senderId: '77',
+      senderName: 'Сергей Рыжиков',
+      isDm: true,
+      isGroup: false,
+      wasMentioned: false,
+    }));
+
+    expect(mockState.sendService.markRead).not.toHaveBeenCalled();
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).not.toHaveBeenCalled();
+    expect(mockState.sendService.sendText).toHaveBeenCalledTimes(2);
+    expect(mockState.sendService.sendText).toHaveBeenCalledWith(
+      expect.objectContaining({ dialogId: '1' }),
+      expect.stringContaining('Сработало правило отслеживания в личном чате с'),
+      { convertMarkdown: false },
+    );
+    expect(mockState.sendService.sendText.mock.calls[0][1]).toContain('[URL=/online/?IM_DIALOG=77&IM_MESSAGE=9001]Сергей Рыжиков[/URL]');
+    expect(String(mockState.sendService.sendText.mock.calls[1][1])).toContain('Сергей Рыжиков');
+    expect(String(mockState.sendService.sendText.mock.calls[1][1])).toContain('#77:1/9001');
+    expect(String(mockState.sendService.sendText.mock.calls[1][1])).toContain('авария в личке');
+    expect(mockState.api.sendMessage).not.toHaveBeenCalled();
+  });
+
+  it('ignores agent-mode user events from the direct chat with the bot', async () => {
+    const inbound = await startWebhookAccount({
+      agentMode: true,
+      agentWatch: {
+        '*': [
+          { userId: '*', topics: ['авария'], mode: 'notifyOwnerDm' },
+        ],
+      },
+    });
+
+    const onMessage = inbound.onMessage as (ctx: B24MsgContext) => Promise<void>;
+
+    await onMessage(createDirectMessage({
+      eventScope: 'user',
+      messageId: '9002',
+      chatId: '6809',
+      chatInternalId: '6809',
+      chatName: 'OpenClaw',
+      text: 'авария в личке с ботом',
+      senderId: '6809',
+      senderName: 'OpenClaw',
+      isDm: true,
+      isGroup: false,
+      wasMentioned: false,
+    }));
+
+    expect(mockState.sendService.markRead).not.toHaveBeenCalled();
+    expect(mockState.sendService.sendText).not.toHaveBeenCalled();
+    expect(mockState.api.sendMessage).not.toHaveBeenCalled();
+    expect(mockState.runtime.channel.reply.finalizeInboundContext).not.toHaveBeenCalled();
+  });
+
+  it('sends a notice and leaves disabled group chats on join', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'disabled',
+    });
+
+    const onJoinChat = inbound.onJoinChat as (ctx: Record<string, unknown>) => Promise<void>;
+
+    await onJoinChat({
+      senderId: '1',
+      dialogId: 'chat520',
+      chatId: '520',
+      chatType: 'chat',
+      language: 'ru',
+      fetchCtx: {
+        webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+        botId: 6809,
+        botToken: 'token',
+      },
+    });
+
+    expect(mockState.sendService.sendText).toHaveBeenCalledTimes(1);
+    expect(mockState.api.leaveChat).toHaveBeenCalledTimes(1);
+    expect(mockState.api.leaveChat).toHaveBeenCalledWith(
+      'https://test.bitrix24.com/rest/1/token/',
+      { botId: 6809, botToken: expect.any(String) },
+      'chat520',
+    );
+  });
+
+  it('sends an access notice and leaves when invited by a user without group access', async () => {
+    const inbound = await startWebhookAccount({
+      groupPolicy: 'webhookUser',
+      requireMention: false,
+    });
+
+    const onJoinChat = inbound.onJoinChat as (ctx: Record<string, unknown>) => Promise<void>;
+
+    await onJoinChat({
+      senderId: '77',
+      dialogId: 'chat520',
+      chatId: '520',
+      chatType: 'chat',
+      language: 'ru',
+      fetchCtx: {
+        webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+        botId: 6809,
+        botToken: 'token',
+      },
+    });
+
+    expect(mockState.sendService.sendText).toHaveBeenCalledTimes(1);
+    expect(mockState.sendService.sendText).toHaveBeenCalledWith(
+      expect.objectContaining({
+        dialogId: 'chat520',
+      }),
+      'Это персональный бот. Писать ему может только владелец.',
+      { convertMarkdown: false },
+    );
+    expect(mockState.api.leaveChat).toHaveBeenCalledTimes(1);
+    expect(mockState.api.leaveChat).toHaveBeenCalledWith(
+      'https://test.bitrix24.com/rest/1/token/',
+      { botId: 6809, botToken: expect.any(String) },
+      'chat520',
+    );
+  });
+});