@emaxe/tuigram 1.5.0 → 1.6.0

package/CHANGELOG.md

@@ -13,6 +13,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 - English localization of the TUI and CLI interface strings.
 
+## [1.6.0] — 2026-09-05
+
+### Added
+
+- Message loading preloader: switching to a dialog now displays an animated loading indicator until message history is fetched, preventing premature "No messages yet" placeholder.
+- Scroll-to-bottom button ("↓ Вниз") and `End` / `G` keyboard shortcuts to quickly jump to the latest messages in the active chat; button appears when scrolling up and hides automatically at the bottom.
+- Automatic selection and opening of the first dialog upon application startup.
+- Message input field locking for channels and groups where the user lacks posting permissions (showing lock icon 🔒 and restriction reason).
+
+## [1.5.1] — 2026-09-03
+
+### Fixed
+
+- Message sender attribution across TUI and CLI: channel posts now display the channel title (along with author signature if present) instead of generic "Собеседник" or marking owner posts as "Вы ✓✓".
+- Sender names in direct 1-on-1 chats and groups are now properly resolved and cached from Telegram entities instead of falling back to "Собеседник".
+- Live typing indicator in the active chat now displays the typing user's display name instead of generic "Собеседник".
+- Contextual reply preview bar in the input box displays the channel name when replying to channel posts.
+- Resolution of Telegram Peer objects and channel IDs in `entityCache` and `parsePeer`.
+
 ## [1.5.0] — 2026-09-02
 
 ### Added
@@ -195,7 +214,9 @@ First public release.
 - A WCAG contrast test (3:1 threshold) applied to every theme **after** conversion
   to xterm-256 — the colors are checked exactly as the user sees them.
 
-[Unreleased]: https://github.com/emaxe/tuigram/compare/v1.5.0...HEAD
+[Unreleased]: https://github.com/emaxe/tuigram/compare/v1.6.0...HEAD
+[1.6.0]: https://github.com/emaxe/tuigram/compare/v1.5.1...v1.6.0
+[1.5.1]: https://github.com/emaxe/tuigram/compare/v1.5.0...v1.5.1
 [1.5.0]: https://github.com/emaxe/tuigram/compare/v1.4.0...v1.5.0
 [1.4.0]: https://github.com/emaxe/tuigram/compare/v1.3.0...v1.4.0
 [1.3.0]: https://github.com/emaxe/tuigram/compare/v1.2.0...v1.3.0

package/CHANGELOG.ru.md

@@ -13,6 +13,25 @@
 
 - Английская локализация строк интерфейса TUI и CLI.
 
+## [1.6.0] — 2026-09-05
+
+### Добавлено
+
+- Прелоадер при переходе в диалог: во время сетевой подгрузки сообщений вместо текста «Сообщений пока нет..» отображается анимированный индикатор загрузки сообщений.
+- Плавающая кнопка «↓ Вниз» и горячие клавиши `End` / `G` для быстрой прокрутки к последним сообщениям диалога; кнопка появляется при скролле вверх и автоматически скрывается внизу ленты.
+- Автоматический выбор и открытие первого диалога в списке при запуске приложения.
+- Автоматическая блокировка поля ввода сообщений в каналах и группах, где у пользователя нет прав на отправку сообщений (с отображением причины и иконки 🔒).
+
+## [1.5.1] — 2026-09-03
+
+### Исправлено
+
+- Отображение авторов сообщений в TUI и CLI: посты в каналах теперь выводятся от имени канала (с подписью автора, если она включена в канале) вместо подстановки «Собеседник» или ошибочной отметки «Вы ✓✓» для постов владельца канала.
+- Определение и кэширование имён отправителей в личных диалогах и группах: при входящих сообщениях и загрузке истории имена резолвятся из сущностей Telegram, предотвращая фоллбэк на «Собеседник».
+- Индикатор набора текста в активном чате теперь отображает имя конкретного пользователя (например, «Sam печатает...») вместо обобщённого «Собеседник».
+- В строке контекста ответа (Reply) в поле ввода для сообщений каналов отображается название канала вместо «Собеседник».
+- Улучшена работа кэша сущностей (`entityCache`) с поддержкой маркированных и числовых ID, юзернеймов с префиксом `@` и без него, а также объектов Peer в `parsePeer`.
+
 ## [1.5.0] — 2026-09-02
 
 ### Добавлено
@@ -201,7 +220,9 @@
 - Тест контраста по WCAG (порог 3:1) для каждой темы — **после** конверсии в xterm-256,
   то есть ровно в том виде, в каком цвет увидит пользователь.
 
-[Unreleased]: https://github.com/emaxe/tuigram/compare/v1.5.0...HEAD
+[Unreleased]: https://github.com/emaxe/tuigram/compare/v1.6.0...HEAD
+[1.6.0]: https://github.com/emaxe/tuigram/compare/v1.5.1...v1.6.0
+[1.5.1]: https://github.com/emaxe/tuigram/compare/v1.5.0...v1.5.1
 [1.5.0]: https://github.com/emaxe/tuigram/compare/v1.4.0...v1.5.0
 [1.4.0]: https://github.com/emaxe/tuigram/compare/v1.3.0...v1.4.0
 [1.3.0]: https://github.com/emaxe/tuigram/compare/v1.2.0...v1.3.0

package/README.md

@@ -72,11 +72,15 @@ TuiGram lets you use Telegram entirely from the terminal: browse your dialog lis
 
 - **A complete interactive TUI**:
   - Two-pane adaptive layout (dialog list on the left, history and input box on the right);
+  - Automatic selection and opening of the first dialog upon application startup;
   - Keyboard and mouse control (left click selects a message, right click opens the action
     menu, clicking an image opens it full screen, clicking a video plays it, wheel scrolling);
+  - Fast scroll-to-bottom ("↓ Вниз" button and `End` / `G` shortcuts);
+  - Animated preloader when switching dialogs until message history is loaded;
+  - Message input field locking for channels and groups without posting permissions (showing 🔒 and reason);
   - Chat categories: All, Direct messages, Groups, Channels, Bots, Unread;
   - Instant search and filtering of chats by title and `@username` (`/`);
-  - Live typing indicator ("… is typing");
+  - Live typing indicator with sender display name in real time;
   - Colored rendering of Telegram entities (bold, italic, monospace code, URLs, mentions, spoilers);
   - High-resolution inline image previews (Unicode Half-Block `▀` pixel art);
   - Terminal video and video note playback (Unicode Half-Block + synchronized audio);
@@ -475,6 +479,7 @@ TuiGram fully supports mouse interaction in terminals that support mouse reporti
 | **Right click** | **Message in the feed** | **Open the action menu (reactions, reply, edit, download, delete)** |
 | **Left click** | **Image preview inside a message** | **Open the image full screen** |
 | **Left click** | **Video preview inside a message** | **Play video in modal player** |
+| **Left click** | **"↓ Вниз" button in feed** | **Scroll down to latest messages (visible when scrolled up)** |
 | Left click | Empty area of the feed | Focus the message feed |
 | Left click | Header logo 🚀 | Open Help window |
 | Left click | Header active chat title | Open Chat Info window |

package/README.ru.md

@@ -68,11 +68,15 @@
 
 - **Полноценный интерактивный TUI**:
   - Двухпанельный адаптивный интерфейс (список чатов слева + история и поле ввода справа);
+  - Автоматический выбор и открытие первого диалога при запуске;
   - Поддержка управления клавиатурой и мышью (левый клик — выделение сообщения,
     правый — меню действий, клик по картинке — просмотр на весь экран, клик по видео — воспроизведение, колесо — прокрутка);
+  - Быстрая прокрутка к последним сообщениям диалога (кнопка «↓ Вниз» и клавиши `End` / `G`);
+  - Анимированный прелоадер при переходе в диалог до загрузки истории сообщений;
+  - Блокировка поля ввода для каналов и чатов без прав на отправку сообщений (с иконкой 🔒 и причиной);
   - Категории чатов: Все, Личные (ЛС), Группы, Каналы, Боты, Непрочитанные;
   - Мгновенный поиск и фильтрация чатов по названию и `@username` (`/`);
-  - Отображение статуса набора текста («Собеседник печатает...») в реальном времени;
+  - Отображение статуса набора текста с именем собеседника в реальном времени;
   - Цветовое форматирование Telegram Entities (Bold, Italic, Monospace Code, URLs, Mentions, Spoilers);
   - Цветные превью изображений высокого разрешения прямо в чате (Unicode Half-Block `▀` pixel art);
   - Воспроизведение видео и видеозаметок в псевдографике (Unicode Half-Block + синхронный звук);
@@ -467,6 +471,7 @@ TuiGram полноценно поддерживает управление мы
 | **Правый клик** | **Сообщение в ленте** | **Меню действий (реакции, ответ, редактирование, скачивание, удаление)** |
 | **Левый клик** | **Превью изображения в сообщении** | **Открытие картинки на весь экран** |
 | **Левый клик** | **Превью видео в сообщении** | **Воспроизведение видео в модальном плеере** |
+| **Левый клик** | **Кнопка «↓ Вниз» в ленте** | **Прокрутка к последним сообщениям диалога (видна при прокрутке вверх)** |
 | Левый клик | Пустое место в ленте | Переключение фокуса на ленту сообщений |
 | Левый клик | Логотип 🚀 в шапке | Открытие окна справки |
 | Левый клик | Название активного чата в шапке | Открытие информации о текущем чате |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emaxe/tuigram",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Полнофункциональный TUI & CLI клиент Telegram на Node.js на базе MTProto (teleproto)",
   "type": "module",
   "exports": {

package/src/cli/formatters.js

@@ -30,7 +30,7 @@ export function formatDialogRow(d) {
 export function formatHistoryMessage(m) {
     const time = gray(`[${formatFullDateTime(m.date)}]`);
     const id = gray(`#${m.id}`);
-    const author = m.out ? green(bold("Вы:")) : cyan(bold(`${m.senderName || "Собеседник"}:`));
+    const author = (m.out && !m.post) ? green(bold("Вы:")) : cyan(bold(`${m.senderName || (m.post ? "Канал" : "Собеседник")}:`));
     const text = m.text || (m.mediaDescription ? m.mediaDescription.replace(/\{[a-z0-9\-]+\}/gi, "") : "");
     const reply = m.replyToMsgId ? gray(` (в ответ на #${m.replyToMsgId})`) : "";
     const edited = m.editDate ? gray(" (изменено)") : "";
@@ -50,7 +50,7 @@ export function formatStreamEvent(kind, data) {
         case "new_message": {
             const m = data.message;
             const peer = yellow(`[${data.peerId}]`);
-            const author = m.out ? green("Вы") : cyan(m.senderName || "Собеседник");
+            const author = (m.out && !m.post) ? green("Вы") : cyan(m.senderName || (m.post ? "Канал" : "Собеседник"));
             const text = m.text || "[медиа]";
             return `${time} ${green("+ НОВОЕ")} ${peer} ${author}: ${text}`;
         }

package/src/telegram/entities.js

@@ -49,6 +49,12 @@ export function toMarkedId(peer) {
  * @returns {string|bigint}
  */
 export function parsePeer(raw) {
+    if (raw && typeof raw === "object") {
+        const marked = toMarkedId(raw);
+        if (marked && marked !== "[object Object]") {
+            return parsePeer(marked);
+        }
+    }
     const value = String(raw || "").trim();
     if (!value) throw new Error("Не указан идентификатор чата (peer)");
     if (value === "me" || value === "self") return "me";
@@ -106,18 +112,67 @@ class EntityCache {
     }
 
     set(id, entity) {
-        if (!id || !entity) return;
-        const key = idToString(id);
-        this.cache.set(key, entity);
+        if (!entity) return;
+        if (id !== null && id !== undefined) {
+            const key = idToString(id).trim().toLowerCase();
+            if (key) this.cache.set(key, entity);
+        }
+        if (entity.id !== null && entity.id !== undefined) {
+            const rawId = idToString(entity.id).trim().toLowerCase();
+            if (rawId) {
+                this.cache.set(rawId, entity);
+                if (entity.className === "Channel" || entity.broadcast || entity.megagroup) {
+                    this.cache.set(`-100${rawId}`, entity);
+                } else if (entity.className === "Chat") {
+                    this.cache.set(`-${rawId}`, entity);
+                }
+            }
+        }
+        const marked = toMarkedId(entity);
+        if (marked && marked !== "[object Object]") {
+            this.cache.set(marked.toLowerCase(), entity);
+        }
         if (entity.username) {
-            this.cache.set(`@${entity.username.toLowerCase()}`, entity);
+            const u = entity.username.toLowerCase();
+            this.cache.set(`@${u}`, entity);
+            this.cache.set(u, entity);
         }
     }
 
     get(idOrUsername) {
-        if (!idOrUsername) return null;
-        const key = String(idOrUsername).toLowerCase();
-        return this.cache.get(key) || this.cache.get(idToString(idOrUsername)) || null;
+        if (idOrUsername === null || idOrUsername === undefined) return null;
+        let key = "";
+        if (typeof idOrUsername === "object") {
+            const marked = toMarkedId(idOrUsername);
+            key = (marked && marked !== "[object Object]" ? marked : idToString(idOrUsername)).trim().toLowerCase();
+        } else {
+            key = String(idOrUsername).trim().toLowerCase();
+        }
+        if (!key) return null;
+
+        let found = this.cache.get(key);
+        if (found) return found;
+
+        if (key.startsWith("-100")) {
+            found = this.cache.get(key.slice(4));
+            if (found) return found;
+        } else if (key.startsWith("-")) {
+            found = this.cache.get(key.slice(1));
+            if (found) return found;
+        } else if (/^\d+$/.test(key)) {
+            found = this.cache.get(`-100${key}`) || this.cache.get(`-${key}`);
+            if (found) return found;
+        }
+
+        if (key.startsWith("@")) {
+            found = this.cache.get(key.slice(1));
+            if (found) return found;
+        } else {
+            found = this.cache.get(`@${key}`);
+            if (found) return found;
+        }
+
+        return null;
     }
 
     has(idOrUsername) {
@@ -156,3 +211,83 @@ export async function resolveEntity(client, rawPeer) {
         throw err;
     }
 }
+
+/**
+ * Проверяет, разрешена ли отправка сообщений в указанный диалог.
+ * Учитывает тип чата, удалённые аккаунты, права администратора в каналах,
+ * общие и персональные ограничения (defaultBannedRights / bannedRights).
+ * @param {object} dialog нормализованный объект диалога
+ * @returns {{ canSend: boolean, reason?: string }}
+ */
+export function canSendMessages(dialog) {
+    if (!dialog) {
+        return { canSend: false, reason: "Чат не выбран" };
+    }
+
+    const entity = dialog.entity || dialog.rawDialog?.entity || {};
+    const className = entity.className || "";
+
+    // 1. Запрещённые или недоступные чаты
+    if (className === "ChatForbidden" || className === "ChannelForbidden") {
+        return { canSend: false, reason: "Доступ к чату запрещён" };
+    }
+
+    // 2. Личные чаты и пользователи
+    if (dialog.type === "saved" || entity.isSelf) {
+        return { canSend: true };
+    }
+
+    if (dialog.type === "user" || className === "User") {
+        if (entity.deleted) {
+            return { canSend: false, reason: "Этот аккаунт удалён" };
+        }
+        return { canSend: true };
+    }
+
+    if (dialog.type === "bot") {
+        return { canSend: true };
+    }
+
+    // 3. Каналы (Broadcast)
+    const isBroadcast = dialog.type === "channel" || Boolean(entity.broadcast);
+    if (isBroadcast) {
+        const isCreator = Boolean(entity.creator);
+        const hasPostRights = Boolean(entity.adminRights?.postMessages);
+        if (!isCreator && !hasPostRights) {
+            return { canSend: false, reason: "Отправка сообщений в этот канал недоступна" };
+        }
+        return { canSend: true };
+    }
+
+    // 4. Группы и супергруппы
+    if (entity.left) {
+        return { canSend: false, reason: "Вы покинули эту группу" };
+    }
+    if (entity.kicked) {
+        return { canSend: false, reason: "Вы исключены из этой группы" };
+    }
+    if (entity.deactivated) {
+        return { canSend: false, reason: "Эта группа деактивирована" };
+    }
+
+    // Создатель или админ всегда может писать в группе
+    if (entity.creator || entity.adminRights) {
+        return { canSend: true };
+    }
+
+    // Персональные ограничения пользователя (bannedRights)
+    if (entity.bannedRights?.sendMessages) {
+        const until = entity.bannedRights.untilDate;
+        const isExpired = typeof until === "number" && until > 0 && until * 1000 <= Date.now();
+        if (!isExpired) {
+            return { canSend: false, reason: "Вам запрещено отправлять сообщения в этой группе" };
+        }
+    }
+
+    // Общие ограничения группы для участников (defaultBannedRights)
+    if (entity.defaultBannedRights?.sendMessages) {
+        return { canSend: false, reason: "Отправка сообщений в этой группе ограничена" };
+    }
+
+    return { canSend: true };
+}

package/src/telegram/listener.js

@@ -2,7 +2,7 @@ import { EventEmitter } from "node:events";
 import { Api } from "teleproto";
 import { NewMessage, EditedMessage, DeletedMessage, Raw } from "teleproto/events/index.js";
 import { normalizeMessage } from "./messages.js";
-import { idToString, toMarkedId, entityCache } from "./entities.js";
+import { idToString, toMarkedId, entityCache, getEntityDisplayName } from "./entities.js";
 
 /**
  * Приводит идентификатор чата из сырого апдейта к маркированному виду (как dialog.id).
@@ -36,21 +36,39 @@ export function startTelegramListener(client) {
         try {
             const msg = event.message;
             if (!msg) return;
-            const normalized = normalizeMessage(msg);
-            const peerId = normalized.peerId;
-            const fromId = normalized.fromId;
 
-            // Кэшируем информацию об авторе сообщения, если доступна
-            try {
-                const sender = await event.getSender?.();
-                if (sender) {
-                    entityCache.set(sender.id, sender);
-                    normalized.senderName = sender.title || [sender.firstName, sender.lastName].filter(Boolean).join(" ") || normalized.senderName;
+            // Кэшируем сущности события, если они пришли в апдейте
+            if (event.originalUpdate?._entities && typeof event.originalUpdate._entities.values === "function") {
+                for (const ent of event.originalUpdate._entities.values()) {
+                    if (ent?.id) entityCache.set(ent.id, ent);
                 }
+            }
+
+            let sender = null;
+            try {
+                sender = await event.getSender?.();
+                if (sender) entityCache.set(sender.id, sender);
+            } catch {
+                // Игнорируем
+            }
+
+            let chat = null;
+            try {
+                chat = await event.getChat?.();
+                if (chat) entityCache.set(chat.id, chat);
             } catch {
                 // Игнорируем
             }
 
+            const normalized = normalizeMessage(msg, chat || sender);
+            if (sender && (!normalized.senderName || normalized.senderName === "Собеседник")) {
+                const baseName = getEntityDisplayName(sender);
+                normalized.senderName = msg.postAuthor ? `${baseName} (${msg.postAuthor})` : baseName;
+            }
+
+            const peerId = normalized.peerId;
+            const fromId = normalized.fromId;
+
             bus.emit("new_message", {
                 peerId,
                 fromId,
@@ -67,7 +85,35 @@ export function startTelegramListener(client) {
         try {
             const msg = event.message;
             if (!msg) return;
-            const normalized = normalizeMessage(msg);
+
+            if (event.originalUpdate?._entities && typeof event.originalUpdate._entities.values === "function") {
+                for (const ent of event.originalUpdate._entities.values()) {
+                    if (ent?.id) entityCache.set(ent.id, ent);
+                }
+            }
+
+            let sender = null;
+            try {
+                sender = await event.getSender?.();
+                if (sender) entityCache.set(sender.id, sender);
+            } catch {
+                // Игнорируем
+            }
+
+            let chat = null;
+            try {
+                chat = await event.getChat?.();
+                if (chat) entityCache.set(chat.id, chat);
+            } catch {
+                // Игнорируем
+            }
+
+            const normalized = normalizeMessage(msg, chat || sender);
+            if (sender && (!normalized.senderName || normalized.senderName === "Собеседник")) {
+                const baseName = getEntityDisplayName(sender);
+                normalized.senderName = msg.postAuthor ? `${baseName} (${msg.postAuthor})` : baseName;
+            }
+
             bus.emit("edited_message", {
                 peerId: normalized.peerId,
                 message: normalized,

package/src/telegram/messages.js

@@ -1,5 +1,5 @@
 import { Api, errors } from "teleproto";
-import { idToString, toMarkedId, getEntityDisplayName, entityCache, resolveEntity } from "./entities.js";
+import { idToString, toMarkedId, detectChatType, getEntityDisplayName, entityCache, resolveEntity } from "./entities.js";
 import { describeMedia } from "./formatter.js";
 import { config } from "../config.js";
 import { renderStrippedThumbnail, renderImageBuffer, renderMediaPreloader, getCachedImagePreview, isPreviewableMedia } from "../utils/image.js";
@@ -33,31 +33,77 @@ export function renderMessageThumbnail(rawMessage, {
 
     // Полноэкранные рендеры не кэшируем: одна такая строка весит сотни килобайт
     const cacheKey = useCache
-        ? (photo?.id ? `photo_${photo.id}` : (doc?.id ? `doc_${doc.id}` : `msg_${rawMessage.id}`))
-        : undefined;
+        ? (rawMessage.id ? `thumb_${rawMessage.id}@${maxWidth}x${maxHeight}` : null)
+        : null;
 
-    return renderStrippedThumbnail(stripped.bytes, { maxWidth, maxHeight, cacheKey }) || "";
+    return renderStrippedThumbnail(stripped.bytes, { maxWidth, maxHeight, cacheKey });
 }
 
 /**
  * Преобразует объект Message из MTProto в нормализованный объект для TUI.
  * @param {object} message
+ * @param {object|null} [chatEntity=null] сущность чата (канал, пользователь, группа)
  * @returns {object}
  */
-export function normalizeMessage(message) {
+export function normalizeMessage(message, chatEntity = null) {
     if (!message) return null;
 
     // fromId остаётся немаркированным: по нему ищется сущность в entityCache,
     // куда объекты кладутся по entity.id (тоже без маркера).
-    const fromId = idToString(message.fromId?.userId || message.fromId?.channelId || message.fromId?.chatId);
+    const fromId = idToString(message.fromId?.userId || message.fromId?.channelId || message.fromId?.chatId || message.senderId);
     // peerId маркируется, чтобы совпадать с dialog.id (см. toMarkedId).
     const peerId = toMarkedId(message.peerId);
 
-    // Извлекаем имя отправителя из кэша сущностей, если доступно
-    let senderName = message.out ? "Вы" : "Собеседник";
-    const cachedSender = entityCache.get(fromId);
-    if (cachedSender) {
-        senderName = getEntityDisplayName(cachedSender);
+    const postAuthor = message.postAuthor ? String(message.postAuthor).trim() : null;
+    const isPost = Boolean(
+        message.post ||
+        chatEntity?.broadcast ||
+        (chatEntity && detectChatType({ entity: chatEntity }) === "channel")
+    );
+
+    // Ищем сущность отправителя:
+    // 1. Уже прикреплённый teleproto sender
+    // 2. Вложенный кэш сущностей сообщения message._entities
+    // 3. Глобальный entityCache
+    let senderEntity = message.sender || null;
+    if (!senderEntity && message._entities && typeof message._entities.get === "function") {
+        senderEntity = (fromId && message._entities.get(fromId)) ||
+            (message.senderId && message._entities.get(idToString(message.senderId))) ||
+            (message.fromId && message._entities.get(toMarkedId(message.fromId))) ||
+            null;
+    }
+    if (!senderEntity) {
+        senderEntity = (fromId && entityCache.get(fromId)) ||
+            (message.senderId && entityCache.get(message.senderId)) ||
+            (message.fromId && entityCache.get(message.fromId)) ||
+            null;
+    }
+    if (senderEntity && senderEntity.id) {
+        entityCache.set(senderEntity.id, senderEntity);
+    }
+
+    let senderName = "";
+    if (isPost) {
+        // В вещательных каналах автор — сам канал (или подпись автора)
+        const channelEntity = senderEntity || chatEntity || message.chat || entityCache.get(peerId) || null;
+        const channelTitle = channelEntity ? getEntityDisplayName(channelEntity) : (chatEntity?.title || "");
+        if (postAuthor) {
+            senderName = channelTitle ? `${channelTitle} (${postAuthor})` : postAuthor;
+        } else {
+            senderName = channelTitle || "Канал";
+        }
+    } else if (message.out) {
+        senderName = "Вы";
+    } else if (senderEntity) {
+        const baseName = getEntityDisplayName(senderEntity);
+        senderName = postAuthor ? `${baseName} (${postAuthor})` : baseName;
+    } else if (chatEntity && (chatEntity.className === "User" || detectChatType({ entity: chatEntity }) === "user")) {
+        // В личном диалоге (1-на-1) входящее сообщение всегда от собеседника чата
+        senderName = getEntityDisplayName(chatEntity);
+    } else if (postAuthor) {
+        senderName = postAuthor;
+    } else {
+        senderName = "Собеседник";
     }
 
     // Реакции
@@ -105,6 +151,8 @@ export function normalizeMessage(message) {
         date: message.date ? message.date * 1000 : Date.now(),
         editDate: message.editDate ? message.editDate * 1000 : null,
         out: Boolean(message.out),
+        post: isPost,
+        postAuthor,
         text: message.message || "",
         fromId,
         senderName,
@@ -140,7 +188,15 @@ export async function fetchHistory(client, rawPeer, { limit = 40, offsetId = 0,
     const load = async () => {
         for await (const msg of client.iterMessages(entity, { limit, offsetId, reverse })) {
             if (msg && msg.className !== "MessageEmpty") {
-                messages.push(normalizeMessage(msg));
+                // Сохраняем сущности, которые Telegram прислал вместе с сообщениями
+                if (msg._entities && typeof msg._entities.values === "function") {
+                    for (const ent of msg._entities.values()) {
+                        if (ent?.id) {
+                            entityCache.set(ent.id, ent);
+                        }
+                    }
+                }
+                messages.push(normalizeMessage(msg, entity));
             }
         }
         if (!reverse) {
@@ -161,6 +217,41 @@ export async function fetchHistory(client, rawPeer, { limit = 40, offsetId = 0,
         }
     }
 
+    // Резолвим отправителей, которых ещё нет в кэше сущностей,
+    // чтобы в диалоге отображались реальные имена, а не «Собеседник».
+    for (const msg of messages) {
+        if (!msg.out && (!msg.senderName || msg.senderName === "Собеседник")) {
+            // 1. Попытка через rawMessage.getSender()
+            if (msg.rawMessage?.getSender) {
+                try {
+                    const sender = await msg.rawMessage.getSender();
+                    if (sender) {
+                        entityCache.set(sender.id, sender);
+                        const baseName = getEntityDisplayName(sender);
+                        msg.senderName = msg.postAuthor ? `${baseName} (${msg.postAuthor})` : baseName;
+                        continue;
+                    }
+                } catch {
+                    // Игнорируем
+                }
+            }
+
+            // 2. Попытка через resolveEntity по targetPeer
+            const targetPeer = msg.rawMessage?.fromId || msg.fromId || msg.rawMessage?.peerId || msg.peerId;
+            if (targetPeer) {
+                try {
+                    const sender = await resolveEntity(client, targetPeer);
+                    if (sender) {
+                        const baseName = getEntityDisplayName(sender);
+                        msg.senderName = msg.postAuthor ? `${baseName} (${msg.postAuthor})` : baseName;
+                    }
+                } catch {
+                    // Имя не резолвится — останется fallback
+                }
+            }
+        }
+    }
+
     return {
         peer: entity,
         messages,

package/src/ui/app.js

@@ -16,6 +16,7 @@ import { createImageViewerModal } from "./components/modals/imageViewerModal.js"
 import { createVideoPlayerModal } from "./components/modals/videoPlayerModal.js";
 import { state } from "../state.js";
 import { config } from "../config.js";
+import { entityCache, getEntityDisplayName, resolveEntity, canSendMessages } from "../telegram/entities.js";
 import { fetchDialogs } from "../telegram/dialogs.js";
 import { setMessagePalette } from "../telegram/formatter.js";
 import { fetchHistory, sendMessage, editMessage, deleteMessages, sendFiles, downloadMedia, sendReaction, markAsRead, loadMessageImagePreview, downloadImageBuffer, renderMessageThumbnail, findFirstUnreadMessage, calculateRemainingUnreadCount } from "../telegram/messages.js";
@@ -205,10 +206,18 @@ export async function startTui(client, me) {
                     videoPlayerModal.play(msg);
                     break;
                 case "reply":
-                    inputBox.setContext("reply", msg);
+                    if (inputBox.isDisabled()) {
+                        statusBar.showMessage(inputBox.getDisabledReason() || "Отправка сообщений в этот чат недоступна", "warning");
+                    } else {
+                        inputBox.setContext("reply", msg);
+                    }
                     break;
                 case "edit":
-                    inputBox.setContext("edit", msg);
+                    if (inputBox.isDisabled()) {
+                        statusBar.showMessage(inputBox.getDisabledReason() || "Редактирование в этом чате недоступно", "warning");
+                    } else {
+                        inputBox.setContext("edit", msg);
+                    }
                     break;
                 case "delete":
                     releaseInputs();
@@ -296,29 +305,43 @@ export async function startTui(client, me) {
         }
     }
 
-    // 2. Список диалогов (левая панель)
-    const chatList = createChatList(screen, theme, {
-        onSelectDialog: async (dialog) => {
-            flushPendingMarkAsRead();
-            state.setActiveChat(dialog);
-            chatView.resetReadState(dialog.readInboxMaxId || 0);
-            statusBar.showMessage(`Загрузка сообщений: ${dialog.title}...`, "info");
+    /**
+     * Открывает диалог, загружает его историю и отображает сообщения.
+     * @param {object} dialog
+     */
+    async function openDialog(dialog) {
+        if (!dialog) return;
+        flushPendingMarkAsRead();
+        state.setActiveChat(dialog);
+        chatView.resetReadState(dialog.readInboxMaxId || 0);
+
+        // Если сообщения диалога ещё не подгружены в память, показываем прелоадер
+        const cached = state.getMessages(dialog.id);
+        if (!cached || cached.length === 0) {
+            chatView.showLoading();
+        }
+        statusBar.showMessage(`Загрузка сообщений: ${dialog.title}...`, "info");
 
-            try {
-                // Загружаем всю пачку непрочитанных сообщений + запас из 20 прочитанных
-                // для контекста и правильного позиционирования разделителя
-                const limit = Math.max(50, Math.min(1000, (dialog.unreadCount || 0) + 20));
-                const history = await fetchHistory(client, dialog.peerId, { limit });
-                if (state.activeChat?.id !== dialog.id) return;
-                const firstUnread = findFirstUnreadMessage(history.messages, dialog);
-                state.setMessages(dialog.id, history.messages, { firstUnreadId: firstUnread?.id || null });
-                statusBar.showMessage(`Чат: ${dialog.title}`, "info");
-            } catch (err) {
-                if (state.activeChat?.id === dialog.id) {
-                    statusBar.showMessage(`Ошибка загрузки: ${err.message}`, "error");
-                }
+        try {
+            // Загружаем всю пачку непрочитанных сообщений + запас из 20 прочитанных
+            // для контекста и правильного позиционирования разделителя
+            const limit = Math.max(50, Math.min(1000, (dialog.unreadCount || 0) + 20));
+            const history = await fetchHistory(client, dialog.peerId, { limit });
+            if (state.activeChat?.id !== dialog.id) return;
+            const firstUnread = findFirstUnreadMessage(history.messages, dialog);
+            state.setMessages(dialog.id, history.messages, { firstUnreadId: firstUnread?.id || null });
+            statusBar.showMessage(`Чат: ${dialog.title}`, "info");
+        } catch (err) {
+            if (state.activeChat?.id === dialog.id) {
+                chatView.setMessages([], false);
+                statusBar.showMessage(`Ошибка загрузки: ${err.message}`, "error");
             }
-        },
+        }
+    }
+
+    // 2. Список диалогов (левая панель)
+    const chatList = createChatList(screen, theme, {
+        onSelectDialog: (dialog) => openDialog(dialog),
         onTabChange: (tab) => {
             state.setFilterTab(tab);
         },
@@ -509,6 +532,10 @@ export async function startTui(client, me) {
 
     inputBox.container.on("click", (data) => {
         if (isRightClick(data)) return;
+        if (inputBox.isDisabled()) {
+            statusBar.showMessage(inputBox.getDisabledReason() || "Отправка сообщений в этот чат недоступна", "warning", 3000);
+            return;
+        }
         if (screen.focused !== inputBox.textarea) {
             inputBox.focus();
             statusBar.showMessage("Фокус: поле ввода", "info", 2000);
@@ -537,6 +564,11 @@ export async function startTui(client, me) {
             activeChat: chat,
             typingUser: state.getTypingUser(chat?.id),
         });
+
+        // Проверяем возможность отправки сообщений в выбранный чат
+        const sendCheck = canSendMessages(chat);
+        inputBox.setDisabled(!sendCheck.canSend, sendCheck.reason);
+
         const msgs = chat ? state.getMessages(chat.id) : [];
         chatView.setSelected(null);
         if (chat && msgs.length > 0) {
@@ -546,6 +578,8 @@ export async function startTui(client, me) {
             } else {
                 chatView.setMessages(msgs, true);
             }
+        } else if (chat) {
+            chatView.showLoading();
         } else {
             chatView.setMessages([], false);
         }
@@ -668,8 +702,16 @@ export async function startTui(client, me) {
         state.removeMessages(peerId, deletedIds);
     });
 
-    listener.on("typing", ({ chatId, userId }) => {
-        state.setTyping(chatId, "Собеседник");
+    listener.on("typing", async ({ chatId, userId }) => {
+        let cached = entityCache.get(userId);
+        if (!cached && userId) {
+            try {
+                cached = await resolveEntity(client, userId);
+            } catch {
+                // Фоллбэк
+            }
+        }
+        state.setTyping(chatId, cached ? getEntityDisplayName(cached) : "Собеседник");
     });
 
     /**
@@ -684,6 +726,10 @@ export async function startTui(client, me) {
             statusBar.showMessage("Сначала выберите чат для отправки файла!", "warning");
             return;
         }
+        if (inputBox.isDisabled()) {
+            statusBar.showMessage(inputBox.getDisabledReason() || "Отправка файлов в этот чат недоступна", "warning");
+            return;
+        }
         if (!files || files.length === 0) return;
 
         const chat = state.activeChat;
@@ -755,6 +801,10 @@ export async function startTui(client, me) {
     /** Включает режим ответа на выделенное сообщение, иначе — на последнее в ленте. */
     function startReply() {
         if (!state.activeChat) return;
+        if (inputBox.isDisabled()) {
+            statusBar.showMessage(inputBox.getDisabledReason() || "Отправка сообщений в этот чат недоступна", "warning");
+            return;
+        }
         const target = chatView.getTargetMessage();
         if (target) {
             inputBox.setContext("reply", target);
@@ -764,6 +814,10 @@ export async function startTui(client, me) {
     /** Включает правку выделенного своего сообщения, иначе — последнего своего. */
     function startEdit() {
         if (!state.activeChat) return;
+        if (inputBox.isDisabled()) {
+            statusBar.showMessage(inputBox.getDisabledReason() || "Редактирование в этом чате недоступно", "warning");
+            return;
+        }
         const selected = chatView.getSelected();
         if (selected?.out) {
             inputBox.setContext("edit", selected);
@@ -800,8 +854,13 @@ export async function startTui(client, me) {
     }
 
     function moveFocus(step) {
-        const current = FOCUS_ORDER.indexOf(detectFocus());
-        const next = FOCUS_ORDER[(current + step + FOCUS_ORDER.length) % FOCUS_ORDER.length];
+        let current = FOCUS_ORDER.indexOf(detectFocus());
+        let nextIndex = (current + step + FOCUS_ORDER.length) % FOCUS_ORDER.length;
+        let next = FOCUS_ORDER[nextIndex];
+        if (next === "input" && inputBox.isDisabled()) {
+            nextIndex = (nextIndex + step + FOCUS_ORDER.length) % FOCUS_ORDER.length;
+            next = FOCUS_ORDER[nextIndex];
+        }
         // Сначала выпускаем клавиатуру из активного поля ввода, иначе оно
         // заберёт фокус обратно своим обработчиком blur.
         releaseInputs();
@@ -835,6 +894,11 @@ export async function startTui(client, me) {
         screen.render();
     });
 
+    screen.key(["end", "C-end"], () => {
+        if (!state.activeChat || screen.focused === inputBox.textarea) return;
+        chatView.scrollToBottom();
+    });
+
     screen.key(["f1", "?"], () => {
         releaseInputs();
         helpModal.show();
@@ -852,6 +916,10 @@ export async function startTui(client, me) {
 
     screen.key(["C-o"], () => {
         if (state.activeChat) {
+            if (inputBox.isDisabled()) {
+                statusBar.showMessage(inputBox.getDisabledReason() || "Отправка файлов в этот чат недоступна", "warning");
+                return;
+            }
             releaseInputs();
             fileModal.show();
         } else {
@@ -909,7 +977,12 @@ export async function startTui(client, me) {
     try {
         const dialogs = await fetchDialogs(client, { limit: 100 });
         state.setDialogs(dialogs);
-        statusBar.showMessage(`Загружено ${dialogs.length} диалогов. Выберите чат и нажмите Enter.`, "success");
+        if (dialogs.length > 0) {
+            chatList.selectIndex(0);
+            await openDialog(dialogs[0]);
+        } else {
+            statusBar.showMessage("Список диалогов пуст", "info");
+        }
     } catch (err) {
         statusBar.showMessage(`Ошибка загрузки диалогов: ${err.message}`, "error");
     }

package/src/ui/components/chatList.js

@@ -404,6 +404,12 @@ export function createChatList(screen, theme, { onSelectDialog, onTabChange, onS
             currentTab = tab;
             renderTabs();
         },
+        selectIndex: (index) => {
+            if (index >= 0 && index < currentDialogs.length) {
+                list.select(index);
+                screen.render();
+            }
+        },
         focus: () => list.focus(),
         /** Завершает режим ввода в строке поиска (см. inputBox.release). */
         release: () => {

package/src/ui/components/chatView.js

@@ -1,7 +1,7 @@
 import blessed from "neo-blessed";
 import { formatMessageTime, formatDateDivider } from "../../utils/time.js";
 import { formatMessageText, escapeBlessed } from "../../telegram/formatter.js";
-import { fg } from "../theme.js";
+import { fg, badge } from "../theme.js";
 
 import { getMessagePartAtPoint, isRightClick, stringCellWidth } from "../../utils/mouse.js";
 import { isMessageVideo } from "../../utils/video.js";
@@ -85,6 +85,23 @@ export function createChatView(screen, theme, {
     scrollBox.removeAllListeners("wheelup");
     scrollBox.removeAllListeners("wheeldown");
 
+    // Кнопка быстрой прокрутки к последним сообщениям
+    const scrollBottomBtn = blessed.box({
+        parent: container,
+        bottom: 0,
+        right: 2,
+        height: 1,
+        width: 10,
+        tags: true,
+        mouse: true,
+        hidden: true,
+        content: badge(theme.accent, theme.onAccent, "{bold}  ↓ Вниз  {/bold}"),
+        style: {
+            bg: theme.accent,
+            fg: theme.onAccent,
+        },
+    });
+
     /** Подсвечивает рамку, когда лента сообщений в фокусе. */
     function setFocusHighlight(active) {
         container.style.border.fg = active ? theme.borders.focusFg : theme.borders.fg;
@@ -100,6 +117,90 @@ export function createChatView(screen, theme, {
     let currentFirstUnreadId = null;
     let lastReportedMaxReadId = 0;
 
+    let isLoading = false;
+    let spinnerTimer = null;
+    let spinnerIndex = 0;
+    const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+    function getLoadingContent() {
+        const frame = SPINNER_FRAMES[spinnerIndex % SPINNER_FRAMES.length];
+        return `\n\n  ${fg(theme.accent, `${frame} Загрузка сообщений...`)}`;
+    }
+
+    function showLoading() {
+        isLoading = true;
+        currentMessages = [];
+        currentRanges = [];
+        selectedId = null;
+        updateScrollBottomBtn();
+        if (spinnerTimer) {
+            clearInterval(spinnerTimer);
+            spinnerTimer = null;
+        }
+        scrollBox.setContent(getLoadingContent());
+        screen.render();
+        spinnerTimer = setInterval(() => {
+            if (!isLoading) {
+                if (spinnerTimer) {
+                    clearInterval(spinnerTimer);
+                    spinnerTimer = null;
+                }
+                return;
+            }
+            spinnerIndex++;
+            scrollBox.setContent(getLoadingContent());
+            screen.render();
+        }, 80);
+    }
+
+    function stopLoading() {
+        isLoading = false;
+        if (spinnerTimer) {
+            clearInterval(spinnerTimer);
+            spinnerTimer = null;
+        }
+    }
+
+    function isAtBottom() {
+        const totalLines = scrollBox._clines?.length || scrollBox.getScrollHeight() || 0;
+        const visible = getVisibleHeight();
+        if (totalLines <= visible) return true;
+        const maxBase = Math.max(0, totalLines - visible);
+        const current = scrollBox.childBase || 0;
+        return current >= maxBase - 1;
+    }
+
+    function updateScrollBottomBtn() {
+        if (isLoading || currentMessages.length === 0 || isAtBottom()) {
+            if (!scrollBottomBtn.hidden) {
+                scrollBottomBtn.hide();
+                screen.render();
+            }
+        } else {
+            if (scrollBottomBtn.hidden) {
+                scrollBottomBtn.show();
+                scrollBottomBtn.setFront();
+                screen.render();
+            }
+        }
+    }
+
+    function handleScrollToBottomAction() {
+        scrollToBottom();
+        screen.render();
+        checkVisibleMessages();
+        updateScrollBottomBtn();
+    }
+
+    scrollBottomBtn.on("click", (data) => {
+        if (isRightClick(data)) return;
+        handleScrollToBottomAction();
+    });
+
+    scrollBottomBtn.on("press", () => {
+        handleScrollToBottomAction();
+    });
+
     // Кэш отформатированных строк сообщений для мгновенной перерисовки и прокрутки ленты
     const messageLinesCache = new Map();
     const MAX_LINES_CACHE = 1000;
@@ -123,11 +224,11 @@ export function createChatView(screen, theme, {
 
         // Отправитель
         let authorTag = "";
-        if (msg.out) {
+        if (msg.out && !msg.post) {
             const readCheck = fg(theme.chatView.outgoingName, "✓✓");
             authorTag = `${fg(theme.chatView.outgoingName, "{bold}Вы{/bold}")} ${timeTag} ${readCheck}`;
         } else {
-            const name = escapeBlessed(msg.senderName || "Собеседник");
+            const name = escapeBlessed(msg.senderName || (msg.post ? "Канал" : "Собеседник"));
             authorTag = `${fg(theme.chatView.incomingName, `{bold}${name}{/bold}`)} ${timeTag}`;
         }
 
@@ -198,6 +299,13 @@ export function createChatView(screen, theme, {
      * @returns {{ text: string, ranges: Array<object> }}
      */
     function renderMessagesWithRanges(messages, firstUnreadId = null) {
+        if (isLoading) {
+            return {
+                text: getLoadingContent(),
+                ranges: [],
+            };
+        }
+
         if (!messages || messages.length === 0) {
             return {
                 text: `\n\n  ${fg(theme.muted, "Сообщений пока нет. Напишите первое сообщение ниже!")}`,
@@ -287,6 +395,7 @@ export function createChatView(screen, theme, {
         const clamped = Math.max(0, Math.min(targetLine, maxBase));
         scrollBox.childBase = clamped;
         scrollBox.childOffset = 0;
+        updateScrollBottomBtn();
     }
 
     /**
@@ -297,6 +406,7 @@ export function createChatView(screen, theme, {
         const visible = getVisibleHeight();
         scrollBox.childBase = Math.max(0, totalLines - visible);
         scrollBox.childOffset = 0;
+        updateScrollBottomBtn();
     }
 
     /** Перерисовывает ленту, сохраняя позицию прокрутки (например, после смены выделения). */
@@ -306,6 +416,7 @@ export function createChatView(screen, theme, {
         currentRanges = rendered.ranges;
         scrollBox.setContent(rendered.text);
         scrollToLine(prevBase);
+        updateScrollBottomBtn();
         screen.render();
     }
 
@@ -360,6 +471,7 @@ export function createChatView(screen, theme, {
      * @param {boolean|object} [scrollOption=true]
      */
     function setMessages(messages, scrollOption = true) {
+        stopLoading();
         currentMessages = messages;
         const prevScroll = scrollBox.childBase || 0;
         const prevHeight = scrollBox.getScrollHeight();
@@ -413,6 +525,7 @@ export function createChatView(screen, theme, {
         }
         screen.render();
         checkVisibleMessages();
+        updateScrollBottomBtn();
     }
 
     /**
@@ -522,6 +635,7 @@ export function createChatView(screen, theme, {
         }
         screen.render();
         checkVisibleMessages();
+        updateScrollBottomBtn();
     }
 
     function handleScrollDown(step = 10) {
@@ -529,6 +643,7 @@ export function createChatView(screen, theme, {
         scrollToLine(current + step);
         screen.render();
         checkVisibleMessages();
+        updateScrollBottomBtn();
     }
 
     scrollBox.key(["pageup", "C-u"], () => handleScrollUp(10));
@@ -540,11 +655,13 @@ export function createChatView(screen, theme, {
         onLoadMoreHistory?.();
         screen.render();
         checkVisibleMessages();
+        updateScrollBottomBtn();
     });
-    scrollBox.key(["end"], () => {
+    scrollBox.key(["end", "G", "C-end"], () => {
         scrollToBottom();
         screen.render();
         checkVisibleMessages();
+        updateScrollBottomBtn();
     });
 
     scrollBox.on("wheelup", () => handleScrollUp(3));
@@ -596,14 +713,20 @@ export function createChatView(screen, theme, {
         }
     });
 
-    // Отслеживание прокрутки для обновления прочитанных сообщений
+    // Отслеживание прокрутки для обновления прочитанных сообщений и видимости кнопки [Вниз]
     scrollBox.on("scroll", () => {
         checkVisibleMessages();
+        updateScrollBottomBtn();
+    });
+
+    screen.on("resize", () => {
+        updateScrollBottomBtn();
     });
 
     return {
         container,
         scrollBox,
+        scrollBottomBtn,
         setMessages,
         setSelected,
         getSelected,
@@ -612,6 +735,7 @@ export function createChatView(screen, theme, {
         resetReadState: (initialReadMaxId = 0) => {
             lastReportedMaxReadId = initialReadMaxId;
             currentFirstUnreadId = null;
+            updateScrollBottomBtn();
         },
         checkVisibleMessages,
         loadMore: () => onLoadMoreHistory?.(),
@@ -619,7 +743,12 @@ export function createChatView(screen, theme, {
             scrollToBottom();
             screen.render();
             checkVisibleMessages();
+            updateScrollBottomBtn();
         },
         focus: () => scrollBox.focus(),
+        showLoading,
+        stopLoading,
+        isLoading: () => isLoading,
+        isScrollBottomVisible: () => !scrollBottomBtn.hidden,
     };
 }

package/src/ui/components/inputBox.js

@@ -91,13 +91,23 @@ export function createInputBox(screen, theme, {
 
     let currentMode = null; // null | "reply" | "edit"
     let currentTarget = null; // object message
+    let isDisabled = false;
+    let disabledReason = "";
 
     const history = [];
     let historyIndex = -1;
 
     function renderContext() {
+        if (isDisabled) {
+            contextBar.setContent(
+                ` ${fg(theme.warning, "🔒")} ${fg(theme.dim, disabledReason || "Отправка сообщений недоступна в этом чате")}`
+            );
+            screen.render();
+            return;
+        }
+
         if (currentMode === "reply" && currentTarget) {
-            const author = escapeBlessed(currentTarget.senderName || "Собеседник");
+            const author = escapeBlessed(currentTarget.senderName || (currentTarget.post ? "Канал" : "Собеседник"));
             const preview = escapeBlessed((currentTarget.text || "").slice(0, 30));
             contextBar.setContent(
                 badge(theme.input.replyBg, theme.input.replyFg,
@@ -124,7 +134,7 @@ export function createInputBox(screen, theme, {
     }
 
     contextBar.on("click", (data) => {
-        if (isRightClick(data)) return;
+        if (isDisabled || isRightClick(data)) return;
         const relX = data.x - (contextBar.aleft || 0);
         const action = getInputContextActionAt(relX, currentMode);
         if (action === "cancel") {
@@ -146,13 +156,31 @@ export function createInputBox(screen, theme, {
     });
 
     textarea.on("click", () => {
+        if (isDisabled) return;
         if (screen.focused !== textarea) {
             textarea.focus();
             screen.render();
         }
     });
 
+    const origReadInput = textarea.readInput.bind(textarea);
+    textarea.readInput = function(callback) {
+        if (isDisabled) {
+            return;
+        }
+        return origReadInput(callback);
+    };
+
+    const origSetValue = textarea.setValue.bind(textarea);
+    textarea.setValue = function(val) {
+        if (isDisabled && val) {
+            return origSetValue("");
+        }
+        return origSetValue(val);
+    };
+
     textarea.key(["enter"], () => {
+        if (isDisabled) return;
         const value = textarea.getValue().trim();
         if (!value) {
             // Textarea уже успел дописать перевод строки в своём обработчике — убираем его.
@@ -251,10 +279,32 @@ export function createInputBox(screen, theme, {
             screen.render();
         },
         focus: () => {
+            if (isDisabled) return;
             if (screen.focused !== textarea) {
                 textarea.focus();
             }
         },
+        /**
+         * Блокирует или разблокирует поле ввода сообщений.
+         * @param {boolean} disabled
+         * @param {string} [reason=""]
+         */
+        setDisabled: (disabled, reason = "") => {
+            isDisabled = Boolean(disabled);
+            disabledReason = reason;
+            if (isDisabled) {
+                currentMode = null;
+                currentTarget = null;
+                textarea.setValue("");
+                if (textarea._reading && typeof textarea._done === "function") {
+                    textarea._done("stop");
+                }
+            }
+            renderContext();
+            screen.render();
+        },
+        isDisabled: () => isDisabled,
+        getDisabledReason: () => disabledReason,
         /**
          * Завершает режим ввода, отдавая фокус предыдущей панели.
          * Нужно вызывать перед открытием модального окна: иначе textarea по blur

package/src/ui/components/modals/helpModal.js

@@ -57,6 +57,7 @@ export function createHelpModal(screen, theme) {
    ${K_CYAN}Правый клик по сообщению${K_END} Меню действий над сообщением
    ${K_CYAN}Клик по превью фото/видео${K_END}Открыть изображение или воспроизвести видео
    ${K_CYAN}  [Space] / [r]${K_END}          — в видеоплеере: пауза / перезапуск
+   ${K_CYAN}Кнопка [↓ Вниз]${K_END}          Прокрутить ленту к последним сообщениям
    ${K_CYAN}Клик по вкладкам/кнопкам${K_END} Переключение фильтров и вызов действий
    ${K_GRAY}macOS Terminal.app перехватывает правый клик — там пользуйтесь [Enter] или [Ctrl+A]${K_END}
    ${K_CYAN}[F12]${K_END}               Отдать мышь терминалу, чтобы выделить и скопировать текст