Add owner ban commands, dependabot PR cap, seed docs

.github/dependabot.yml

@@ -7,14 +7,18 @@ updates:
     directory: "/"
     schedule:
       interval: "weekly"
+    open-pull-requests-limit: 3
     groups:
       actions:
         patterns:
           - "*"
+  # pip смотрит все requirements*.txt в каталоге: requirements.txt и
+  # requirements-dev.txt оба покрыты, отдельных записей не нужно.
   - package-ecosystem: "pip"
     directory: "/"
     schedule:
       interval: "weekly"
+    open-pull-requests-limit: 3
     groups:
       pip-minor:
         patterns:

README.md

@@ -115,13 +115,15 @@ All three endpoints below require `Authorization: Bearer <ADMIN_PANEL_KEY>` (`/a
 | `/tts [text]` | anyone | Reads text out loud. |
 | `/lang` | anyone in DMs; group admins/owner in groups | Bot language menu (system messages; AI answers always follow your language). |
 
-Three more owner-only commands stay out of the menu on purpose, since they surface internal details that shouldn't be visible in a group chat:
+More owner-only commands stay out of the menu on purpose, since they surface internal details that shouldn't be visible in a group chat:
 
 | Command | Access | Purpose |
 |---|---|---|
 | `/stats` | bot owner, DMs only | Active chat count, process uptime, per-model quota usage. |
 | `/logs` | bot owner, DMs only | Sends `bot.log` with secrets redacted. |
 | `/selftest [gemini]` | bot owner, DMs only, max once a minute | Live probe of route heads (Groq, light OpenRouter, Telegram proxy, TikWM; Gemini only with the `gemini` argument). Successful probes count against quota. |
+| `/ban <ID>` / `/unban <ID>` (or as a reply) | bot owner, DMs only | Block/unblock a user by Telegram ID. Banned users are fully ignored: no answers, no group context, no limit counters. Survives restarts. |
+| `/banlist` | bot owner, DMs only | Shows banned user IDs. |
 
 In groups the bot keeps recent messages (up to 100) as context and sends them to the model providers together with the question; `/reset` (group admins/owner) clears them.
 

bot.py

@@ -481,6 +481,11 @@ from lumen_chat_state import (
     _evict_orphan_chat_locks,
     _is_owner,
     _notify_owner,
+    BANNED_KEY,
+    _is_banned,
+    _ban_user,
+    _unban_user,
+    _banned_list,
     _is_privileged_in_chat,
     _quota_entry,
     _mark_quota_exhausted,
@@ -888,6 +893,11 @@ __all__ = [
     "GLOBAL_QUOTA",
     "_is_owner",
     "_is_privileged_in_chat",
+    "BANNED_KEY",
+    "_is_banned",
+    "_ban_user",
+    "_unban_user",
+    "_banned_list",
     "_mark_quota_exhausted",
     "_mark_rate_limited",
     "_record_quota_usage",
@@ -1201,6 +1211,9 @@ from lumen_commands import (
     cmd_logs,
     cmd_stats,
     cmd_selftest,
+    cmd_ban,
+    cmd_unban,
+    cmd_banlist,
     _build_version,
     _webhook_info_text,
     _process_memory_text,
@@ -1217,6 +1230,9 @@ dp.callback_query.register(handle_lang_callback, F.data.startswith("lang:"))
 dp.message.register(cmd_logs, Command("logs"))
 dp.message.register(cmd_stats, Command("stats"))
 dp.message.register(cmd_selftest, Command("selftest"))
+dp.message.register(cmd_ban, Command("ban"))
+dp.message.register(cmd_unban, Command("unban"))
+dp.message.register(cmd_banlist, Command("banlist"))
 dp.callback_query.register(handle_pick_callback, F.data.startswith("pick:"))
 
 
@@ -1248,6 +1264,11 @@ async def global_error_handler(event: Any) -> bool:
 
 @dp.message()
 async def handle_message(message: Message) -> None:
+    # Владельческая блокировка: ни ответа, ни контекста группы, ни счётчиков —
+    # отсекаем раньше всего, включая медиагруппы и пассивный фон.
+    if message.from_user is not None and _is_banned(message.from_user.id):
+        return
+
     if message.media_group_id:
         mgid = message.media_group_id
         _mg_buffers.setdefault(mgid, []).append(message)

docs/ENVIRONMENT.md

@@ -132,7 +132,7 @@ These ceilings are fixed in code; change them only with a code edit:
 | `BOT_LOG_PATH` | `/app/bot.log` | Log file path. Mainly relevant for tests; leave it alone in production. |
 | `LOG_LEVEL` | `INFO` | Standard logging level (`DEBUG`/`INFO`/`WARNING`/...). |
 | `DIAG_TOTAL_BUDGET_SEC` | `25s` | Total budget for the `/diag` network check across all probed hosts, so a hanging host cannot hang the diagnostic. |
-| `ADMIN_SECRET_SEED` | — | Secret seed for deriving `WEBHOOK_SECRET` and `ADMIN_PANEL_KEY`. **Set it.** Without it both keys are derived from `BOT_TOKEN`, so a leaked token also exposes `/export_state` and `/webhook` (the bot logs a warning at startup). Any change here rotates both keys; `WEBHOOK_SECRET` re-registers itself, `ADMIN_PANEL_KEY` is retrieved with `GET /admin_keys` (Bearer `BOT_TOKEN`). |
+| `ADMIN_SECRET_SEED` | — | Secret seed for deriving `WEBHOOK_SECRET` and `ADMIN_PANEL_KEY`. **Set it to its own random value, separate from `BOT_TOKEN`.** Without it both keys are derived from `BOT_TOKEN`, so a leaked token also exposes `/export_state` and `/webhook` (the bot logs a warning at startup). Changing the seed (or setting it for the first time) rotates both keys at once: on restart the bot re-registers the Telegram webhook with the new `WEBHOOK_SECRET` by itself, but anything using the old `ADMIN_PANEL_KEY` (browser bookmarks, cron export scripts) gets `401` until updated — fetch the new key via `GET /admin_keys` with Bearer `BOT_TOKEN`. |
 
 Sentry setup: create a free Python project at [sentry.io](https://sentry.io) (Developer tier: 5,000 events/month), copy the DSN from the project settings, and add it as a Space secret.
 

lumen_chat_state.py

@@ -294,6 +294,16 @@ def load_global_quota() -> None:
                     except (TypeError, ValueError):
                         clean_stats[field] = 0
                 GLOBAL_QUOTA[STATS_KEY] = clean_stats
+            # Владельческая блокировка переживает рестарт тем же файлом/ключом.
+            raw_banned = loaded.get(BANNED_KEY)
+            if isinstance(raw_banned, dict):
+                clean_banned: dict[str, Any] = {}
+                for uid, ts in raw_banned.items():
+                    try:
+                        clean_banned[str(int(uid))] = max(0, int(ts or 0))
+                    except (TypeError, ValueError):
+                        continue
+                GLOBAL_QUOTA[BANNED_KEY] = clean_banned
             raw_ts = loaded.get("last_storage_write_ts")
             if isinstance(raw_ts, (int, float)) and not isinstance(raw_ts, bool) and raw_ts > 0:
                 GLOBAL_QUOTA["last_storage_write_ts"] = float(raw_ts)
@@ -835,6 +845,55 @@ def _is_owner(user_id: int | None) -> bool:
     import bot
     return bot.OWNER_ID is not None and user_id is not None and user_id == bot.OWNER_ID
 
+# ── Владельческая блокировка (/ban): тот же персистентный файл/ключ, что квота.
+BANNED_KEY = "banned_users"
+
+def _banned_map() -> dict[str, Any]:
+    import bot
+    raw = bot.GLOBAL_QUOTA.get(BANNED_KEY)
+    if not isinstance(raw, dict):
+        raw = {}
+        bot.GLOBAL_QUOTA[BANNED_KEY] = raw
+    return raw
+
+def _is_banned(user_id: int | None) -> bool:
+    """Заблокирован ли пользователь. Владельца забанить нельзя — всегда False."""
+    import bot
+    if user_id is None or bot._is_owner(user_id):
+        return False
+    return str(user_id) in _banned_map()
+
+def _ban_user(user_id: int) -> bool:
+    """True если добавился сейчас, False если уже был (или это владелец)."""
+    import bot
+    if bot._is_owner(user_id):
+        return False
+    entry = _banned_map()
+    if str(user_id) in entry:
+        return False
+    entry[str(user_id)] = int(time.time())
+    bot.mark_quota_dirty()
+    return True
+
+def _unban_user(user_id: int) -> bool:
+    """True если был в списке и убран."""
+    import bot
+    if str(user_id) not in _banned_map():
+        return False
+    del _banned_map()[str(user_id)]
+    bot.mark_quota_dirty()
+    return True
+
+def _banned_list() -> list[int]:
+    """ID по возрастанию — для /banlist."""
+    ids = []
+    for key in _banned_map():
+        try:
+            ids.append(int(key))
+        except (TypeError, ValueError):
+            continue
+    return sorted(ids)
+
 async def _notify_owner(text: str) -> None:
     """ЛС владельцу о редких важных событиях; с троттлингом у вызывателя, никогда не кидает."""
     import bot

lumen_commands.py

@@ -720,6 +720,76 @@ async def cmd_selftest(message: Message) -> None:
     log.info("[selftest] chat=%s gemini_arg=%s %s", message.chat.id, want_gemini, " ".join(summary))
 
 
+def _ban_target_id(message: Message) -> int | None:
+    """ID цели /ban//unban: ответ на сообщение или числовой аргумент."""
+    replied = getattr(message, "reply_to_message", None)
+    replied_user = getattr(replied, "from_user", None) if replied is not None else None
+    replied_id = getattr(replied_user, "id", None)
+    if isinstance(replied_id, int) and not isinstance(replied_id, bool):
+        return replied_id
+    args = (getattr(message, "text", "") or "").split()[1:]
+    if args:
+        raw = args[0].split("@")[0].lstrip("+")
+        if raw.isdigit():
+            return int(raw)
+    return None
+
+async def cmd_ban(message: Message) -> None:
+    """Владельческая блокировка (только владелец, только личка)."""
+    import bot
+    if not bot._is_owner(message.from_user.id if message.from_user else None):
+        await bot._tg_call(message.reply, bot._t(message.chat.id, "stats_deny"))
+        return
+    if message.chat.type != ChatType.PRIVATE:
+        await bot._tg_call(message.reply, bot._t(message.chat.id, "ban_group_only"))
+        return
+    target = _ban_target_id(message)
+    if target is None:
+        await bot._tg_call(message.reply, bot._t(message.chat.id, "ban_usage"))
+        return
+    if bot._is_owner(target):
+        await bot._tg_call(message.reply, bot._t(message.chat.id, "ban_owner_refuse"))
+        return
+    bot._ban_user(target)
+    await bot._tg_call(message.reply, bot._t(message.chat.id, "ban_done", user_id=target))
+    log.info("[ban] Owner banned user %s", target)
+
+async def cmd_unban(message: Message) -> None:
+    """Снятие владельческой блокировки (только владелец, только личка)."""
+    import bot
+    if not bot._is_owner(message.from_user.id if message.from_user else None):
+        await bot._tg_call(message.reply, bot._t(message.chat.id, "stats_deny"))
+        return
+    if message.chat.type != ChatType.PRIVATE:
+        await bot._tg_call(message.reply, bot._t(message.chat.id, "ban_group_only"))
+        return
+    target = _ban_target_id(message)
+    if target is None:
+        await bot._tg_call(message.reply, bot._t(message.chat.id, "ban_usage"))
+        return
+    if bot._unban_user(target):
+        await bot._tg_call(message.reply, bot._t(message.chat.id, "unban_done", user_id=target))
+        log.info("[ban] Owner unbanned user %s", target)
+    else:
+        await bot._tg_call(message.reply, bot._t(message.chat.id, "unban_missing", user_id=target))
+
+async def cmd_banlist(message: Message) -> None:
+    """Список заблокированных (только владелец, только личка)."""
+    import bot
+    if not bot._is_owner(message.from_user.id if message.from_user else None):
+        await bot._tg_call(message.reply, bot._t(message.chat.id, "stats_deny"))
+        return
+    if message.chat.type != ChatType.PRIVATE:
+        await bot._tg_call(message.reply, bot._t(message.chat.id, "ban_group_only"))
+        return
+    ids = bot._banned_list()
+    if not ids:
+        await bot._tg_call(message.reply, bot._t(message.chat.id, "banlist_empty"))
+        return
+    text = bot._t(message.chat.id, "banlist_header") + "\n" + "\n".join(f"• {uid}" for uid in ids)
+    await bot._tg_call(message.reply, text)
+
+
 _BUILD_VERSION_CACHED: str | None = None
 
 

lumen_lang.py

@@ -569,6 +569,70 @@ STRINGS: dict[str, dict[str, str]] = {
         "ru": "(Gemini пропущен — допиши gemini, квота дефицитная)",
         "uk": "(Gemini пропущено — допиши gemini, квота дефіцитна)",
     },
+    "ban_group_only": {
+        "be": "Гэтая каманда кіруе блакіроўкай — даступна толькі ў асабістых паведамленнях з ботам, не ў групах.",
+        "en": "This command manages the blocklist — available only in direct messages with the bot, not in groups.",
+        "es": "Este comando gestiona la lista de bloqueados — disponible solo en mensajes directos con el bot, no en grupos.",
+        "kk": "Бұл команда бұғаттау тізімін басқарады — тек ботпен жеке хабарламаларда қолжетімді, топтарда емес.",
+        "ru": "Эта команда управляет блокировкой — доступна только в личных сообщениях с ботом, не в группах.",
+        "uk": "Ця команда керує блокуванням — доступна лише в особистих повідомленнях з ботом, не в групах.",
+    },
+    "ban_usage": {
+        "be": "Выкарыстанне: /ban <ID> або адказам на паведамленне; /unban <ID> або адказам.",
+        "en": "Usage: /ban <ID> or as a reply; /unban <ID> or as a reply.",
+        "es": "Uso: /ban <ID> o como respuesta; /unban <ID> o como respuesta.",
+        "kk": "Қолдану: /ban <ID> немесе хабарламаға жауап ретінде; /unban <ID> немесе жауап ретінде.",
+        "ru": "Использование: /ban <ID> или ответом на сообщение; /unban <ID> или ответом.",
+        "uk": "Використання: /ban <ID> або відповіддю на повідомлення; /unban <ID> або відповіддю.",
+    },
+    "ban_owner_refuse": {
+        "be": "Уладальніка заблакаваць нельга.",
+        "en": "The owner cannot be banned.",
+        "es": "No se puede bloquear al dueño.",
+        "kk": "Иесін бұғаттау мүмкін емес.",
+        "ru": "Владельца заблокировать нельзя.",
+        "uk": "Власника заблокувати не можна.",
+    },
+    "ban_done": {
+        "be": "Карыстальнік {user_id} заблакаваны.",
+        "en": "User {user_id} banned.",
+        "es": "Usuario {user_id} bloqueado.",
+        "kk": "Пайдаланушы {user_id} бұғатталды.",
+        "ru": "Пользователь {user_id} заблокирован.",
+        "uk": "Користувача {user_id} заблоковано.",
+    },
+    "unban_done": {
+        "be": "Карыстальнік {user_id} разблакаваны.",
+        "en": "User {user_id} unbanned.",
+        "es": "Usuario {user_id} desbloqueado.",
+        "kk": "Пайдаланушы {user_id} бұғаттан шығарылды.",
+        "ru": "Пользователь {user_id} разблокирован.",
+        "uk": "Користувача {user_id} розблоковано.",
+    },
+    "unban_missing": {
+        "be": "Карыстальніка {user_id} няма ў спісе.",
+        "en": "User {user_id} is not on the list.",
+        "es": "El usuario {user_id} no está en la lista.",
+        "kk": "Пайдаланушы {user_id} тізімде жоқ.",
+        "ru": "Пользователя {user_id} нет в списке.",
+        "uk": "Користувача {user_id} немає у списку.",
+    },
+    "banlist_empty": {
+        "be": "Спіс пусты — нікога не заблакавана.",
+        "en": "The list is empty — nobody is banned.",
+        "es": "La lista está vacía — nadie bloqueado.",
+        "kk": "Тізім бос — ешкім бұғатталмаған.",
+        "ru": "Список пуст — никто не заблокирован.",
+        "uk": "Список порожній — нікого не заблоковано.",
+    },
+    "banlist_header": {
+        "be": "Заблакаваныя:",
+        "en": "Banned:",
+        "es": "Bloqueados:",
+        "kk": "Бұғатталғандар:",
+        "ru": "Заблокированные:",
+        "uk": "Заблоковані:",
+    },
     "stats_no_data": {
         "be": "  няма даных",
         "en": "  no data",
@@ -837,6 +901,14 @@ PACK_PT: dict[str, str] = {
     "selftest_cooldown": "Espera {sec}s antes da próxima execução.",
     "selftest_header": "Autoteste:",
     "selftest_gemini_skipped": "(Gemini ignorado — adiciona o argumento gemini, a quota dele é escassa)",
+    "ban_group_only": "Este comando gere a lista de bloqueados — disponível apenas em mensagens diretas com o bot, não em grupos.",
+    "ban_usage": "Uso: /ban <ID> ou como resposta; /unban <ID> ou como resposta.",
+    "ban_owner_refuse": "O dono não pode ser bloqueado.",
+    "ban_done": "Utilizador {user_id} bloqueado.",
+    "unban_done": "Utilizador {user_id} desbloqueado.",
+    "unban_missing": "O utilizador {user_id} não está na lista.",
+    "banlist_empty": "A lista está vazia — ninguém bloqueado.",
+    "banlist_header": "Bloqueados:",
     "stats_no_data": "  sem dados",
     "stats_limit_used": " (limite esgotado)",
     "tiktok_sound_recognized": "Link de som do TikTok reconhecido.",
@@ -930,6 +1002,14 @@ PACK_AR: dict[str, str] = {
     "selftest_cooldown": "انتظر {sec} ث قبل التشغيل التالي.",
     "selftest_header": "فحص ذاتي:",
     "selftest_gemini_skipped": "(تم تخطي Gemini — أضف الوسيط gemini، حصته شحيحة)",
+    "ban_group_only": "هذا الأمر يدير قائمة الحظر — متاح فقط في الرسائل الخاصة مع البوت وليس في المجموعات.",
+    "ban_usage": "الاستخدام: /ban <ID> أو بالرد؛ /unban <ID> أو بالرد.",
+    "ban_owner_refuse": "لا يمكن حظر المالك.",
+    "ban_done": "تم حظر المستخدم {user_id}.",
+    "unban_done": "تم إلغاء حظر المستخدم {user_id}.",
+    "unban_missing": "المستخدم {user_id} ليس في القائمة.",
+    "banlist_empty": "القائمة فارغة — لا أحد محظور.",
+    "banlist_header": "محظورون:",
     "stats_no_data": "  لا بيانات",
     "stats_limit_used": " (الحد مستنفد)",
     "tiktok_sound_recognized": "تم التعرف على رابط صوت TikTok.",
@@ -1023,6 +1103,14 @@ PACK_TR: dict[str, str] = {
     "selftest_cooldown": "Sonraki çalıştırmadan önce {sec} sn bekle.",
     "selftest_header": "Öz test:",
     "selftest_gemini_skipped": "(Gemini atlandı — gemini argümanını ekle, kotası kıt)",
+    "ban_group_only": "Bu komut engel listesini yönetir — yalnızca botla direkt mesajlarda kullanılabilir, gruplarda değil.",
+    "ban_usage": "Kullanım: /ban <ID> veya yanıt olarak; /unban <ID> veya yanıt olarak.",
+    "ban_owner_refuse": "Sahip engellenemez.",
+    "ban_done": "Kullanıcı {user_id} engellendi.",
+    "unban_done": "Kullanıcı {user_id} engeli kaldırıldı.",
+    "unban_missing": "Kullanıcı {user_id} listede yok.",
+    "banlist_empty": "Liste boş — kimse engelli değil.",
+    "banlist_header": "Engellenenler:",
     "stats_no_data": "  veri yok",
     "stats_limit_used": " (limit doldu)",
     "tiktok_sound_recognized": "TikTok ses bağlantısı tanındı.",
@@ -1116,6 +1204,14 @@ PACK_DE: dict[str, str] = {
     "selftest_cooldown": "Warte {sec} s vor dem nächsten Start.",
     "selftest_header": "Selbsttest:",
     "selftest_gemini_skipped": "(Gemini übersprungen — füge das Argument gemini hinzu, sein Kontingent ist knapp)",
+    "ban_group_only": "Dieser Befehl verwaltet die Sperrliste — nur in Direktnachrichten mit dem Bot verfügbar, nicht in Gruppen.",
+    "ban_usage": "Verwendung: /ban <ID> oder als Antwort; /unban <ID> oder als Antwort.",
+    "ban_owner_refuse": "Der Besitzer kann nicht gesperrt werden.",
+    "ban_done": "Benutzer {user_id} gesperrt.",
+    "unban_done": "Benutzer {user_id} entsperrt.",
+    "unban_missing": "Benutzer {user_id} steht nicht auf der Liste.",
+    "banlist_empty": "Die Liste ist leer — niemand gesperrt.",
+    "banlist_header": "Gesperrt:",
     "stats_no_data": "  keine Daten",
     "stats_limit_used": " (Limit erschöpft)",
     "tiktok_sound_recognized": "TikTok-Soundlink erkannt.",
@@ -1209,6 +1305,14 @@ PACK_FR: dict[str, str] = {
     "selftest_cooldown": "Attends {sec} s avant le prochain lancement.",
     "selftest_header": "Auto-test :",
     "selftest_gemini_skipped": "(Gemini ignoré — ajoute l'argument gemini, son quota est limité)",
+    "ban_group_only": "Cette commande gère la liste des bloqués — disponible uniquement en messages privés avec le bot, pas en groupes.",
+    "ban_usage": "Usage : /ban <ID> ou en réponse ; /unban <ID> ou en réponse.",
+    "ban_owner_refuse": "Le propriétaire ne peut pas être bloqué.",
+    "ban_done": "Utilisateur {user_id} bloqué.",
+    "unban_done": "Utilisateur {user_id} débloqué.",
+    "unban_missing": "L'utilisateur {user_id} n'est pas dans la liste.",
+    "banlist_empty": "La liste est vide — personne n'est bloqué.",
+    "banlist_header": "Bloqués :",
     "stats_no_data": "  pas de données",
     "stats_limit_used": " (limite épuisée)",
     "tiktok_sound_recognized": "Lien de son TikTok reconnu.",
@@ -1302,6 +1406,14 @@ PACK_IT: dict[str, str] = {
     "selftest_cooldown": "Attendi {sec} s prima del prossimo avvio.",
     "selftest_header": "Autotest:",
     "selftest_gemini_skipped": "(Gemini saltato — aggiungi l'argomento gemini, la sua quota è scarsa)",
+    "ban_group_only": "Questo comando gestisce la lista dei bloccati — disponibile solo nei messaggi diretti con il bot, non nei gruppi.",
+    "ban_usage": "Uso: /ban <ID> o come risposta; /unban <ID> o come risposta.",
+    "ban_owner_refuse": "Il proprietario non può essere bloccato.",
+    "ban_done": "Utente {user_id} bloccato.",
+    "unban_done": "Utente {user_id} sbloccato.",
+    "unban_missing": "L'utente {user_id} non è nella lista.",
+    "banlist_empty": "La lista è vuota — nessuno bloccato.",
+    "banlist_header": "Bloccati:",
     "stats_no_data": "  nessun dato",
     "stats_limit_used": " (limite esaurito)",
     "tiktok_sound_recognized": "Link audio di TikTok riconosciuto.",
@@ -1395,6 +1507,14 @@ PACK_HI: dict[str, str] = {
     "selftest_cooldown": "अगली बार चलाने से पहले {sec} सेकंड रुको।",
     "selftest_header": "स्व-जांच:",
     "selftest_gemini_skipped": "(Gemini छोड़ा गया — gemini आर्गुमेंट जोड़ो, उसका कोटा सीमित है)",
+    "ban_group_only": "यह कमांड ब्लॉक सूची संभालता है — केवल बॉट के साथ सीधे संदेशों में, समूहों में नहीं।",
+    "ban_usage": "उपयोग: /ban <ID> या जवाब में; /unban <ID> या जवाब में।",
+    "ban_owner_refuse": "मालिक को बैन नहीं किया जा सकता।",
+    "ban_done": "उपयोगकर्ता {user_id} बैन हुआ।",
+    "unban_done": "उपयोगकर्ता {user_id} अनबैन हुआ।",
+    "unban_missing": "उपयोगकर्ता {user_id} सूची में नहीं है।",
+    "banlist_empty": "सूची खाली है — कोई बैन नहीं है।",
+    "banlist_header": "बैन किए गए:",
     "stats_no_data": "  कोई डेटा नहीं",
     "stats_limit_used": " (सीमा समाप्त)",
     "tiktok_sound_recognized": "TikTok ध्वनि लिंक पहचानी गई।",
@@ -1488,6 +1608,14 @@ PACK_ID: dict[str, str] = {
     "selftest_cooldown": "Tunggu {sec} dtk sebelum menjalankan lagi.",
     "selftest_header": "Uji mandiri:",
     "selftest_gemini_skipped": "(Gemini dilewati — tambahkan argumen gemini, kuotanya terbatas)",
+    "ban_group_only": "Perintah ini mengelola daftar blokir — hanya tersedia di pesan langsung dengan bot, bukan di grup.",
+    "ban_usage": "Penggunaan: /ban <ID> atau sebagai balasan; /unban <ID> atau sebagai balasan.",
+    "ban_owner_refuse": "Pemilik tidak bisa diblokir.",
+    "ban_done": "Pengguna {user_id} diblokir.",
+    "unban_done": "Pengguna {user_id} dibuka blokirnya.",
+    "unban_missing": "Pengguna {user_id} tidak ada dalam daftar.",
+    "banlist_empty": "Daftarnya kosong — tidak ada yang diblokir.",
+    "banlist_header": "Diblokir:",
     "stats_no_data": "  tidak ada data",
     "stats_limit_used": " (batas habis)",
     "tiktok_sound_recognized": "Tautan suara TikTok dikenali.",
@@ -1581,6 +1709,14 @@ PACK_MS: dict[str, str] = {
     "selftest_cooldown": "Tunggu {sec}s sebelum larian seterusnya.",
     "selftest_header": "Ujian kendiri:",
     "selftest_gemini_skipped": "(Gemini dilangkau — tambah argumen gemini, kuotanya terhad)",
+    "ban_group_only": "Perintah ini mengurus senarai sekat — hanya tersedia dalam mesej langsung dengan bot, bukan dalam kumpulan.",
+    "ban_usage": "Penggunaan: /ban <ID> atau sebagai balasan; /unban <ID> atau sebagai balasan.",
+    "ban_owner_refuse": "Pemilik tidak boleh disekat.",
+    "ban_done": "Pengguna {user_id} disekat.",
+    "unban_done": "Pengguna {user_id} dinyahsekat.",
+    "unban_missing": "Pengguna {user_id} tiada dalam senarai.",
+    "banlist_empty": "Senarai kosong — tiada siapa disekat.",
+    "banlist_header": "Disekat:",
     "stats_no_data": "  tiada data",
     "stats_limit_used": " (had habis)",
     "tiktok_sound_recognized": "Pautan bunyi TikTok dikenal pasti.",
@@ -1674,6 +1810,14 @@ PACK_VI: dict[str, str] = {
     "selftest_cooldown": "Đợi {sec} giây trước lần chạy tiếp theo.",
     "selftest_header": "Tự kiểm tra:",
     "selftest_gemini_skipped": "(Bỏ qua Gemini — thêm đối số gemini, hạn ngạch của nó khan hiếm)",
+    "ban_group_only": "Lệnh này quản lý danh sách chặn — chỉ dùng được trong tin nhắn riêng với bot, không dùng trong nhóm.",
+    "ban_usage": "Cách dùng: /ban <ID> hoặc trả lời tin nhắn; /unban <ID> hoặc trả lời tin nhắn.",
+    "ban_owner_refuse": "Không thể chặn chủ sở hữu.",
+    "ban_done": "Đã chặn người dùng {user_id}.",
+    "unban_done": "Đã bỏ chặn người dùng {user_id}.",
+    "unban_missing": "Người dùng {user_id} không có trong danh sách.",
+    "banlist_empty": "Danh sách trống — không ai bị chặn.",
+    "banlist_header": "Đã chặn:",
     "stats_no_data": "  không có dữ liệu",
     "stats_limit_used": " (hết hạn mức)",
     "tiktok_sound_recognized": "Đã nhận ra liên kết âm thanh TikTok.",
@@ -1767,6 +1911,14 @@ PACK_TH: dict[str, str] = {
     "selftest_cooldown": "รอ {sec} วินาทีก่อนรันครั้งถัดไป",
     "selftest_header": "ทดสอบตัวเอง:",
     "selftest_gemini_skipped": "(ข้าม Gemini — เติมอาร์กิวเมนต์ gemini โควต้าของมันมีจำกัด)",
+    "ban_group_only": "คำสั่งนี้จัดการรายชื่อที่ถูกบล็อก — ใช้ได้เฉพาะในข้อความส่วนตัวกับบอท ไม่ใช่ในกลุ่ม",
+    "ban_usage": "วิธีใช้: /ban <ID> หรือตอบกลับ; /unban <ID> หรือตอบกลับ",
+    "ban_owner_refuse": "บล็อกเจ้าของไม่ได้",
+    "ban_done": "แบนผู้ใช้ {user_id} แล้ว",
+    "unban_done": "ปลดบล็อกผู้ใช้ {user_id} แล้ว",
+    "unban_missing": "ผู้ใช้ {user_id} ไม่ได้อยู่ในรายชื่อ",
+    "banlist_empty": "รายชื่อว่าง — ไม่มีใครถูกบล็อก",
+    "banlist_header": "ถูกบล็อก:",
     "stats_no_data": "  ไม่มีข้อมูล",
     "stats_limit_used": " (โควต้าหมด)",
     "tiktok_sound_recognized": "รู้จักลิงก์เสียง TikTok แล้ว",
@@ -1860,6 +2012,14 @@ PACK_FA: dict[str, str] = {
     "selftest_cooldown": "{sec} ثانیه تا اجرای بعدی صبر کن.",
     "selftest_header": "خودآزمایی:",
     "selftest_gemini_skipped": "(Gemini رد شد — آرگومان gemini را اضافه کن، سهمیه‌اش کم است)",
+    "ban_group_only": "این دستور فهرست مسدودی‌ها را مدیریت می‌کند — فقط در پیام‌های خصوصی با ربات، نه در گروه‌ها.",
+    "ban_usage": "کاربرد: /ban <ID> یا با پاسخ؛ /unban <ID> یا با پاسخ.",
+    "ban_owner_refuse": "مالک را نمی‌توان مسدود کرد.",
+    "ban_done": "کاربر {user_id} مسدود شد.",
+    "unban_done": "کاربر {user_id} رفع مسدودیت شد.",
+    "unban_missing": "کاربر {user_id} در فهرست نیست.",
+    "banlist_empty": "فهرست خالی است — هیچ‌کس مسدود نیست.",
+    "banlist_header": "مسدودشده‌ها:",
     "stats_no_data": "  داده‌ای نیست",
     "stats_limit_used": " (سقف تمام شد)",
     "tiktok_sound_recognized": "لینک صدای TikTok شناخته شد.",
@@ -1953,6 +2113,14 @@ PACK_UR: dict[str, str] = {
     "selftest_cooldown": "اگلی بار چلانے سے پہلے {sec} سیکنڈ انتظار کرو۔",
     "selftest_header": "خود جانچ:",
     "selftest_gemini_skipped": "(Gemini چھوڑ دیا گیا — gemini دلیل شامل کرو، اس کا کوٹہ محدود ہے)",
+    "ban_group_only": "یہ کمانڈ بلاک لسٹ کا نظم کرتی ہے — صرف بوٹ کے ساتھ براہ راست پیغامات میں، گروپس میں نہیں۔",
+    "ban_usage": "استعمال: /ban <ID> یا جواب میں؛ /unban <ID> یا جواب میں۔",
+    "ban_owner_refuse": "مالک کو بین نہیں کیا جا سکتا۔",
+    "ban_done": "صارف {user_id} بین ہو گیا۔",
+    "unban_done": "صارف {user_id} ان بین ہو گیا۔",
+    "unban_missing": "صارف {user_id} فہرست میں نہیں ہے۔",
+    "banlist_empty": "فہرست خالی ہے — کوئی بین نہیں ہے۔",
+    "banlist_header": "بین شدہ:",
     "stats_no_data": "  کوئی ڈیٹا نہیں",
     "stats_limit_used": " (حد ختم)",
     "tiktok_sound_recognized": "TikTok آواز کا لنک پہچانا گیا۔",
@@ -2046,6 +2214,14 @@ PACK_UZ: dict[str, str] = {
     "selftest_cooldown": "Keyingi ishga tushirishdan oldin {sec} s kuting.",
     "selftest_header": "O‘z-o‘zini tekshirish:",
     "selftest_gemini_skipped": "(Gemini o‘tkazib yuborildi — gemini argumentini qo‘shing, kvotasi tanqis)",
+    "ban_group_only": "Bu buyruq bloklanganlar ro‘yxatini boshqaradi — faqat bot bilan shaxsiy xabarlarda, guruhlarda emas.",
+    "ban_usage": "Foydalanish: /ban <ID> yoki javob tariqasida; /unban <ID> yoki javob tariqasida.",
+    "ban_owner_refuse": "Egani bloklab bo‘lmaydi.",
+    "ban_done": "Foydalanuvchi {user_id} bloklandi.",
+    "unban_done": "Foydalanuvchi {user_id} blokdan chiqarildi.",
+    "unban_missing": "Foydalanuvchi {user_id} ro‘yxatda yo‘q.",
+    "banlist_empty": "Ro‘yxat bo‘sh — hech kim bloklanmagan.",
+    "banlist_header": "Bloklanganlar:",
     "stats_no_data": "  ma'lumot yo'q",
     "stats_limit_used": " (limit tugadi)",
     "tiktok_sound_recognized": "TikTok tovush havolasi tanildi.",
@@ -2139,6 +2315,14 @@ PACK_BN: dict[str, str] = {
     "selftest_cooldown": "পরের বার চালানোর আগে {sec} সেকেন্ড অপেক্ষা করো।",
     "selftest_header": "স্ব-পরীক্ষা:",
     "selftest_gemini_skipped": "(Gemini বাদ দেওয়া হয়েছে — gemini আর্গুমেন্ট যোগ করো, কোটা সীমিত)",
+    "ban_group_only": "এই কমান্ড ব্লকলিস্ট পরিচালনা করে — শুধু বটের সাথে ব্যক্তিগত বার্তায়, গ্রুপে নয়।",
+    "ban_usage": "ব্যবহার: /ban <ID> বা উত্তরে; /unban <ID> বা উত্তরে।",
+    "ban_owner_refuse": "মালিককে ব্যান করা যাবে না।",
+    "ban_done": "ব্যবহারকারী {user_id} ব্যান হয়েছে।",
+    "unban_done": "ব্যবহারকারী {user_id} আনব্যান হয়েছে।",
+    "unban_missing": "ব্যবহারকারী {user_id} তালিকায় নেই।",
+    "banlist_empty": "তালিকা খালি — কেউ ব্যান নয়।",
+    "banlist_header": "ব্যানড:",
     "stats_no_data": "  কোনো তথ্য নেই",
     "stats_limit_used": " (সীমা শেষ)",
     "tiktok_sound_recognized": "TikTok সাউন্ড লিংক চেনা গেছে।",
@@ -2232,6 +2416,14 @@ PACK_FIL: dict[str, str] = {
     "selftest_cooldown": "Maghintay ng {sec}s bago sa susunod na pag-run.",
     "selftest_header": "Self-test:",
     "selftest_gemini_skipped": "(Nilaktawan ang Gemini — idagdag ang argument na gemini, kakaunti ang quota nito)",
+    "ban_group_only": "Pinamamahalaan ng command na ito ang blocklist — sa direktang mensahe lang sa bot, hindi sa mga grupo.",
+    "ban_usage": "Paggamit: /ban <ID> o bilang reply; /unban <ID> o bilang reply.",
+    "ban_owner_refuse": "Hindi puwedeng i-ban ang may-ari.",
+    "ban_done": "Na-ban ang user na {user_id}.",
+    "unban_done": "Na-unban ang user na {user_id}.",
+    "unban_missing": "Wala sa listahan ang user na {user_id}.",
+    "banlist_empty": "Walang laman ang listahan — walang naka-ban.",
+    "banlist_header": "Naka-ban:",
     "stats_no_data": "  walang data",
     "stats_limit_used": " (ubos ang limit)",
     "tiktok_sound_recognized": "Nakilala ang TikTok sound link.",
@@ -2325,6 +2517,14 @@ PACK_PL: dict[str, str] = {
     "selftest_cooldown": "Poczekaj {sec} s przed kolejnym uruchomieniem.",
     "selftest_header": "Autotest:",
     "selftest_gemini_skipped": "(Gemini pominięte — dopisz argument gemini, limit jest niski)",
+    "ban_group_only": "Ta komenda zarządza listą zablokowanych — dostępna tylko w wiadomościach prywatnych z botem, nie w grupach.",
+    "ban_usage": "Użycie: /ban <ID> lub w odpowiedzi; /unban <ID> lub w odpowiedzi.",
+    "ban_owner_refuse": "Właściciela nie można zablokować.",
+    "ban_done": "Użytkownik {user_id} zablokowany.",
+    "unban_done": "Użytkownik {user_id} odblokowany.",
+    "unban_missing": "Użytkownika {user_id} nie ma na liście.",
+    "banlist_empty": "Lista jest pusta — nikt nie jest zablokowany.",
+    "banlist_header": "Zablokowani:",
     "stats_no_data": "  brak danych",
     "stats_limit_used": " (limit wyczerpany)",
     "tiktok_sound_recognized": "Rozpoznano link do dźwięku TikToka.",
@@ -2418,6 +2618,14 @@ PACK_NL: dict[str, str] = {
     "selftest_cooldown": "Wacht {sec} s voor de volgende run.",
     "selftest_header": "Zelftest:",
     "selftest_gemini_skipped": "(Gemini overgeslagen — voeg het argument gemini toe, zijn quotum is schaars)",
+    "ban_group_only": "Deze opdracht beheert de blokkeerlijst — alleen beschikbaar in directe berichten met de bot, niet in groepen.",
+    "ban_usage": "Gebruik: /ban <ID> of als antwoord; /unban <ID> of als antwoord.",
+    "ban_owner_refuse": "De eigenaar kan niet worden geblokkeerd.",
+    "ban_done": "Gebruiker {user_id} geblokkeerd.",
+    "unban_done": "Gebruiker {user_id} gedeblokkeerd.",
+    "unban_missing": "Gebruiker {user_id} staat niet op de lijst.",
+    "banlist_empty": "De lijst is leeg — niemand geblokkeerd.",
+    "banlist_header": "Geblokkeerd:",
     "stats_no_data": "  geen data",
     "stats_limit_used": " (limiet op)",
     "tiktok_sound_recognized": "TikTok-geluidslink herkend.",
@@ -2511,6 +2719,14 @@ PACK_ZU: dict[str, str] = {
     "selftest_cooldown": "Linda u-{sec}s ngaphambi kokusebenza okulandelayo.",
     "selftest_header": "Ukuzihlola:",
     "selftest_gemini_skipped": "(I-Gemini yeqiwe — engeza i-agumenti ethi gemini, i-quota yayo yincane)",
+    "ban_group_only": "Lo myalo uphatha uhlu lwavinjiwe — utholakala kuphela emilayezweni eqondile ne-bot, hhayi emaqenjini.",
+    "ban_usage": "Ukusebenzisa: /ban <ID> noma ngempendulo; /unban <ID> noma ngempendulo.",
+    "ban_owner_refuse": "Umnikazi akakwazi ukuvinjwa.",
+    "ban_done": "Umsebenzisi {user_id} uvinjiwe.",
+    "unban_done": "Umsebenzisi {user_id} ukhTshirwe.",
+    "unban_missing": "Umsebenzisi {user_id} akekho ohlwini.",
+    "banlist_empty": "Uhlu alunamuntu — akekho ovinjiwe.",
+    "banlist_header": "Abavinjiwe:",
     "stats_no_data": "  ayikho idatha",
     "stats_limit_used": " (umkhawulo uphelile)",
     "tiktok_sound_recognized": "Isixhumanisi somsindo se-TikTok saziwe.",

tests/test_bot_commands.py

@@ -1445,3 +1445,105 @@ def test_cmd_stats_shows_quarantine(monkeypatch):
     asyncio.run(bot.cmd_stats(incoming))
     assert "Карантин моделей" in sent["text"]
     assert "qs-model:free" in sent["text"]
+
+
+def _make_ban_message(chat_id, user_id, text, group=False, reply_to=None):
+    incoming = _FakeIncomingMessage(chat_id)
+    if group:
+        incoming.chat.type = bot.ChatType.GROUP
+    incoming.from_user = SimpleNamespace(id=user_id)
+    incoming.text = text
+    incoming.reply_to_message = reply_to
+    return incoming
+
+
+def _capture_replies(monkeypatch):
+    sent = {}
+
+    async def fake_tg_call(method, *args, **kwargs):
+        sent["text"] = args[0] if args else kwargs.get("text", "")
+        return SimpleNamespace()
+
+    monkeypatch.setattr(bot, "_tg_call", fake_tg_call)
+    return sent
+
+
+def test_ban_flow_by_id_unban_and_list(monkeypatch):
+    # Полный цикл: бан по ID, список, разбан, повторный разбан — мимо.
+    monkeypatch.setattr(bot, "OWNER_ID", 101001)
+    sent = _capture_replies(monkeypatch)
+    assert bot._is_banned(777002) is False
+    asyncio.run(bot.cmd_ban(_make_ban_message(999801, 101001, "/ban 777002")))
+    assert sent["text"] == bot._t(999801, "ban_done", user_id=777002)
+    assert bot._is_banned(777002) is True
+    asyncio.run(bot.cmd_banlist(_make_ban_message(999801, 101001, "/banlist")))
+    assert "777002" in sent["text"]
+    asyncio.run(bot.cmd_unban(_make_ban_message(999801, 101001, "/unban 777002")))
+    assert sent["text"] == bot._t(999801, "unban_done", user_id=777002)
+    assert bot._is_banned(777002) is False
+    asyncio.run(bot.cmd_unban(_make_ban_message(999801, 101001, "/unban 777002")))
+    assert sent["text"] == bot._t(999801, "unban_missing", user_id=777002)
+    asyncio.run(bot.cmd_banlist(_make_ban_message(999801, 101001, "/banlist")))
+    assert sent["text"] == bot._t(999801, "banlist_empty")
+
+
+def test_ban_by_reply_and_usage_and_owner_refuse(monkeypatch):
+    # Цель ответом на сообщение; мусор вместо ID — подсказка; владельца — отказ.
+    monkeypatch.setattr(bot, "OWNER_ID", 102001)
+    sent = _capture_replies(monkeypatch)
+    replied = SimpleNamespace(from_user=SimpleNamespace(id=555003))
+    asyncio.run(bot.cmd_ban(_make_ban_message(999802, 102001, "/ban", reply_to=replied)))
+    assert bot._is_banned(555003) is True
+    asyncio.run(bot.cmd_ban(_make_ban_message(999802, 102001, "/ban вообще")))
+    assert sent["text"] == bot._t(999802, "ban_usage")
+    asyncio.run(bot.cmd_ban(_make_ban_message(999802, 102001, "/ban 102001")))
+    assert sent["text"] == bot._t(999802, "ban_owner_refuse")
+    assert bot._is_banned(102001) is False
+
+
+def test_ban_denies_non_owner_and_group(monkeypatch):
+    # Чужой и группа: только отказ, список не меняется.
+    monkeypatch.setattr(bot, "OWNER_ID", 103001)
+    sent = _capture_replies(monkeypatch)
+    asyncio.run(bot.cmd_ban(_make_ban_message(999803, 999999, "/ban 123")))
+    assert sent["text"] == bot._t(999803, "stats_deny")
+    asyncio.run(bot.cmd_ban(_make_ban_message(999803, 103001, "/ban 123", group=True)))
+    assert sent["text"] == bot._t(999803, "ban_group_only")
+    assert bot._is_banned(123) is False
+
+
+def test_handle_message_ignores_banned_user(monkeypatch):
+    # Заблокированный: ни ответа, ни ядра (там контекст группы и счётчики лимитов).
+    from unittest.mock import AsyncMock
+    monkeypatch.setattr(bot, "OWNER_ID", 104001)
+    bot._ban_user(605001)
+    fake_core = AsyncMock()
+    monkeypatch.setattr(bot, "_handle_message_core", fake_core)
+
+    def _msg(chat_type, text="привет"):
+        return SimpleNamespace(
+            media_group_id=None,
+            chat=SimpleNamespace(id=999804, type=chat_type),
+            from_user=SimpleNamespace(id=605001),
+            text=text, caption=None, reply_to_message=None,
+        )
+
+    asyncio.run(bot.handle_message(_msg(bot.ChatType.PRIVATE)))
+    asyncio.run(bot.handle_message(_msg(bot.ChatType.GROUP)))
+    assert fake_core.await_count == 0
+    bot._unban_user(605001)
+    asyncio.run(bot.handle_message(_msg(bot.ChatType.GROUP)))
+    assert fake_core.await_count == 1
+
+
+def test_banned_list_survives_quota_reload(monkeypatch):
+    # Список живёт в том же файле, что квота: рестарт его не сбрасывает.
+    import json
+    monkeypatch.setattr(bot, "OWNER_ID", 105001)
+    bot._ban_user(606001)
+    snapshot = json.dumps(dict(bot.GLOBAL_QUOTA), ensure_ascii=False)
+    monkeypatch.setattr(bot, "_storage_read_text", lambda *args, **kwargs: snapshot)
+    bot.GLOBAL_QUOTA.pop(bot.BANNED_KEY, None)
+    assert bot._is_banned(606001) is False
+    bot.load_global_quota()
+    assert bot._is_banned(606001) is True