Merge pull request #11 from S1lverElixir/agent/audit-behavior

bot.py

@@ -303,6 +303,9 @@ for env_name in ("OWNER_ID", "BOT_OWNER_ID", "ADMIN_ID", "TELEGRAM_OWNER_ID"):
 TELEGRAM_REQUEST_TIMEOUT = _env_number("TELEGRAM_REQUEST_TIMEOUT", 45, min_value=1)
 TELEGRAM_AI_TIMEOUT = _env_number("TELEGRAM_AI_TIMEOUT", 45, min_value=1)
 TELEGRAM_MEDIA_TIMEOUT = _env_number("TELEGRAM_MEDIA_TIMEOUT", 25, min_value=1)
+# Потолок скачивания из Telegram: Bot API не отдаёт файлы больше 20МБ через
+# getFile/путь (аудит D1, 30.09.2026) — большее отклоняем до скачивания.
+TELEGRAM_DOWNLOAD_MAX_BYTES = _env_number("TELEGRAM_DOWNLOAD_MAX_BYTES", 20 * 1024 * 1024, cast=int, min_value=1024 * 1024)
 # Раньше было захардкожено как 15.0 прямо внутри _download_telegram_file_bytes —
 # несогласованно с остальными таймаутами, которые все конфигурируются через env.
 TELEGRAM_GET_FILE_TIMEOUT = _env_number("TELEGRAM_GET_FILE_TIMEOUT", 15, min_value=1)
@@ -338,6 +341,10 @@ TTS_MAX_CHARS = _env_number("TTS_MAX_CHARS", 800, cast=int, min_value=1)
 # уходил в поток без таймаута и без http_options у клиента, и зависший Google
 # держал лок чата бесконечно (аудит 26.09.2026).
 TTS_SYNTH_TIMEOUT_SEC = _env_number("TTS_SYNTH_TIMEOUT_SEC", 60, min_value=1)
+# Общий дедлайн на все чанки мультичанкового TTS: зависший синтез иначе держал
+# per-chat lock без края (аудит D2, 30.09.2026). Худший чанк ~100с (60 синтез +
+# 30 ffmpeg + 10 probe), типичные 5 чанков укладываются с запасом.
+TTS_TOTAL_BUDGET_SEC = _env_number("TTS_TOTAL_BUDGET_SEC", 240, min_value=30)
 _PROCESS_START_MONOTONIC = time.monotonic()
 # ── Тайминги автоматического маршрутизатора моделей (см. секцию "автоматический
 # выбор модели" ниже) ──
@@ -378,6 +385,9 @@ _tiktok_probe_semaphore = asyncio.Semaphore(TIKTOK_VIDEO_SLIDE_PROBE_CONCURRENCY
 # Лимит скачивания слайдов 8: 35 слайдов иначе занимают весь пул сессии (limit=40) и стопорят другие чаты (аудит 04.09.2026).
 TIKTOK_SLIDE_DOWNLOAD_CONCURRENCY = _env_number("TIKTOK_SLIDE_DOWNLOAD_CONCURRENCY", 8, cast=int, min_value=1)
 _tiktok_slide_download_semaphore = asyncio.Semaphore(TIKTOK_SLIDE_DOWNLOAD_CONCURRENCY)
+# Общий кап RAM на один пост: 35 слайдов по 75МБ в памяти (до ~2.6ГБ) роняли
+# контейнер для всех чатов (аудит D1, 30.09.2026). Обычный пост весит до 50МБ.
+TIKTOK_SLIDESHOW_MAX_BYTES = _env_number("TIKTOK_SLIDESHOW_MAX_BYTES", 200 * 1024 * 1024, cast=int, min_value=1024 * 1024)
 
 # Состояние/квоты/локи живут в lumen_chat_state.py (P2): здесь только реэкспорт
 # имён (те же объекты — тесты мутируют bot.chat_state/bot.GLOBAL_QUOTA как раньше).
@@ -522,6 +532,7 @@ from lumen_rich import (
     _edit_message_quietly,
 )
 from lumen_media_flow import (
+    _MediaTooLargeError,
     _download_telegram_file_bytes,
     _save_media_to_history,
     _download_message_attachment_to_tmp,
@@ -839,6 +850,7 @@ __all__ = [
     "_delete_message_quietly",
     "_edit_message_quietly",
     "_download_telegram_file_bytes",
+    "_MediaTooLargeError",
     "_save_media_to_history",
     "_download_message_attachment_to_tmp",
     "_fetch_media",
@@ -1207,6 +1219,10 @@ from lumen_message_core import (
     _process_raw_update,
 )
 
+# setWebhook: попыток с экспоненциальным бэкоффом от базы (аудит D4, 30.09.2026).
+SETWEBHOOK_MAX_ATTEMPTS = 5
+SETWEBHOOK_BACKOFF_SEC = 5.0
+
 async def _webhook_startup() -> None:
     # Синхронное дисковое чтение в потоке: иначе старт стопорит приём /webhook.
     await asyncio.to_thread(load_state_from_disk)
@@ -1281,26 +1297,45 @@ async def _webhook_startup() -> None:
         except Exception as exc:
             log.warning("[webhook] deleteWebhook failed (will need manual setup): %s", exc)
 
-        try:
-            await asyncio.wait_for(
-                telegram_api_call("setWebhook", {
-                    "url": webhook_url,
-                    "secret_token": WEBHOOK_SECRET,
-                    # drop_pending_updates=True — решение владельца (27.09.2026): после
-                    # простоя не отвечать пачкой на старые сообщения. Цена — сообщения,
-                    # пришедшие пока бот лежал, теряются.
-                    "drop_pending_updates": True,
-                    "allowed_updates": ALLOWED_UPDATES,
-                }, request_timeout=15.0),
-                timeout=18.0
-            )
+        # setWebhook с ретраями и экспоненциальным бэкоффом: провал без ретрая
+        # оставлял тихий мёртвый бот (аудит D4, 30.09.2026). После исчерпания —
+        # RuntimeError наверх: main останавливает сервер и выходит кодом 1,
+        # чтобы платформа перезапустила контейнер, а не служила пустоту.
+        webhook_ok = False
+        backoff = SETWEBHOOK_BACKOFF_SEC
+        for attempt in range(1, SETWEBHOOK_MAX_ATTEMPTS + 1):
+            try:
+                await asyncio.wait_for(
+                    telegram_api_call("setWebhook", {
+                        "url": webhook_url,
+                        "secret_token": WEBHOOK_SECRET,
+                        # drop_pending_updates=True — решение владельца (27.09.2026): после
+                        # простоя не отвечать пачкой на старые сообщения. Цена — сообщения,
+                        # пришедшие пока бот лежал, теряются.
+                        "drop_pending_updates": True,
+                        "allowed_updates": ALLOWED_UPDATES,
+                    }, request_timeout=15.0),
+                    timeout=18.0
+                )
+                webhook_ok = True
+                break
+            except Exception as exc:
+                log.warning(
+                    "[webhook] setWebhook attempt %d/%d failed: %s",
+                    attempt, SETWEBHOOK_MAX_ATTEMPTS, exc,
+                )
+                if attempt < SETWEBHOOK_MAX_ATTEMPTS:
+                    await asyncio.sleep(backoff)
+                    backoff *= 2
+        if webhook_ok:
             log.info("[webhook] Webhook registered successfully: %s", webhook_url)
-        except Exception as exc:
+        else:
             # Секрет в лог не подставляем — готовая ссылка живёт в /webhook_url (Bearer ADMIN_PANEL_KEY, не query).
-            log.warning(
-                '[webhook] setWebhook failed — register it manually via: curl -H "Authorization: Bearer <ADMIN_PANEL_KEY>" https://.../webhook_url (get ADMIN_PANEL_KEY via curl -H "Authorization: Bearer <BOT_TOKEN>" .../admin_keys if you don\'t have it handy): %s',
-                exc,
+            log.error(
+                '[webhook] setWebhook failed after %d attempts — register it manually via: curl -H "Authorization: Bearer <ADMIN_PANEL_KEY>" https://.../webhook_url (get ADMIN_PANEL_KEY via curl -H "Authorization: Bearer <BOT_TOKEN>" .../admin_keys if you don\'t have it handy)',
+                SETWEBHOOK_MAX_ATTEMPTS,
             )
+            return False
 
         cmd_payloads = [
             {"commands": [{"command": c.command, "description": c.description} for c in commands]}
@@ -1326,8 +1361,11 @@ async def _webhook_startup() -> None:
             log.info("[webhook] Bot commands set successfully.")
         else:
             log.warning("[webhook] Bot commands were not set for any language.")
+        return webhook_ok
 
-    await try_setup()
+    setup_ok = await try_setup()
+    if not setup_ok:
+        raise RuntimeError("setWebhook failed after retries — refusing to serve a dead webhook")
 
     log.info("[webhook] Bot is running in webhook mode. Updates arrive via POST /webhook")
     # Суточные перепроверки моделей в часовом цикле: истёкшее промо иначе видно
@@ -1402,7 +1440,21 @@ async def main() -> None:
     )
     server = uvicorn.Server(srv_config)
     try:
-        await server.serve()
+        serve_task = asyncio.create_task(server.serve(), name="uvicorn_serve")
+        done, _pending = await asyncio.wait(
+            {startup_task, serve_task}, return_when=asyncio.FIRST_COMPLETED,
+        )
+        # Стартап бесконечный (часовой цикл в хвосте): завершился — значит упал.
+        # Раньше падение было тихим (await только в finally) — процесс служил
+        # /webhook, который Telegram не вызывал (аудит D4, 30.09.2026).
+        if startup_task in done and not startup_task.cancelled():
+            exc = startup_task.exception()
+            if exc is not None:
+                log.error("[webhook] Startup failed, stopping the server: %s", exc)
+                server.should_exit = True
+                with contextlib.suppress(Exception, asyncio.CancelledError):
+                    await serve_task
+                raise SystemExit(1) from exc
     finally:
         startup_task.cancel()
         flush_task.cancel()

docs/ARCHITECTURE.md

@@ -16,9 +16,9 @@ Routing is fully automatic: the router builds a fresh candidate list for every m
 
 - **A YouTube or website link** → Gemini only. It's the only provider that can read page content (`url_context`) or analyze a video by URL.
 - **A video or audio attachment** → video goes to Gemini only (OpenRouter's multimodal models only accept images as base64). Voice/audio is first transcribed cheaply (Groq Whisper) and the text joins the normal routing below; if transcription fails or is unavailable, the audio goes to Gemini as before.
-- **An image attachment, no live-info need** → free OpenRouter vision models first, Gemini as a reserve.
+- **An image attachment, no live-info need** → free OpenRouter vision models first, Gemini as a reserve. With a freshness need, Gemini search models go first and OpenRouter vision stays as a fallback.
 - **Needs current information** (a lightweight keyword heuristic: "now," "today," "price," "who is currently...") → Gemini, prioritizing the models with a real search-grounding quota, then OpenRouter as a reserve, Groq last (knowledge-only answer if both are down).
-- **Plain text, no attachments, no freshness need** (the most common case) → Groq first (1000 free requests/day: Qwen, then gpt-oss), then OpenRouter. Heavier requests (code, multi-step reasoning, caught by another lightweight heuristic) skip Groq entirely and start at the stronger free OpenRouter models, Gemini as reserve.
+- **Plain text, no attachments, no freshness need** (the most common case) → Groq first (1000 free requests/day: Qwen, then gpt-oss), then OpenRouter. Heavier requests (code, multi-step reasoning, caught by another lightweight heuristic) also start at Groq to spare the scarcer OpenRouter/Gemini quotas, then go to the stronger free OpenRouter models, Gemini as reserve.
 
 The reasoning: Gemini's free quota (roughly 20 requests per day for the flagship model) is the scarcest resource in the system, so it's only spent where a capability unique to Gemini is actually needed. Everything else, the bulk of ordinary messages, runs on Groq (1000/day) and OpenRouter's free tiers.
 

docs/ENVIRONMENT.md

@@ -61,9 +61,11 @@ Before publishing, configure the same `LUMEN_PROXY_SECRET` on HF and every Deno
 | `TELEGRAM_REQUEST_TIMEOUT` | `45s` | Timeout for HTTP calls to the Telegram API. |
 | `TELEGRAM_AI_TIMEOUT` | `45s` | Budget for the Gemini retry after `MALFORMED_FUNCTION_CALL` inside the main chat route (capped by the remaining `ROUTE_TOTAL_BUDGET_SEC`). Not used by `/tts` — that lives on `TTS_SYNTH_TIMEOUT_SEC`. |
 | `TELEGRAM_MEDIA_TIMEOUT` | `25s` | Timeout for downloading media files from Telegram. |
+| `TELEGRAM_DOWNLOAD_MAX_BYTES` | `20971520` (20 MB) | Cap on a single Telegram download (Bot API doesn't serve bigger files via `getFile`); bigger files are refused before downloading with an honest user-facing message. |
 | `TELEGRAM_GET_FILE_TIMEOUT` | `15s` | Timeout for the `getFile` metadata call before a download. |
 | `TTS_MAX_CHARS` | `800` | Size of one `/tts` synthesis chunk; up to `TTS_MAX_PARTS` (5) chunks are synthesized, so the accepted maximum is `TTS_MAX_CHARS × TTS_MAX_PARTS` (4000 by default). |
 | `TTS_SYNTH_TIMEOUT_SEC` | `60s` | Timeout for a single TTS synthesis call. Also passed into the SDK as `http_options.timeout`, so a hung provider cannot hold the chat lock. |
+| `TTS_TOTAL_BUDGET_SEC` | `240s` | Total deadline for all chunks of one multi-chunk TTS request; past it the text is cut and the user is told only the beginning was voiced. |
 | `RATE_LIMIT_MAX_REQUESTS` | `5` | Max requests per user within `RATE_LIMIT_WINDOW_SEC`. |
 | `RATE_LIMIT_WINDOW_SEC` | `30s` | Sliding window width for rate limiting. |
 | `ROUTE_MODEL_TIMEOUT_SEC` | `22s` | Timeout for a single attempt at a single model. No retries: any failure moves straight to the next model. |
@@ -88,6 +90,7 @@ Before publishing, configure the same `LUMEN_PROXY_SECRET` on HF and every Deno
 | Variable | Default | Purpose |
 |---|---|---|
 | `TIKTOK_DOWNLOAD_MAX_BYTES` | `75 MB` | Hard cap on any single downloaded TikTok file (video, slide, cover or music), aborted mid-stream if exceeded. |
+| `TIKTOK_SLIDESHOW_MAX_BYTES` | `200 MB` | Total RAM cap for one slideshow post; slides past it are skipped (a typical post is under 50 MB). |
 | `TIKTOK_SLIDE_DOWNLOAD_CONCURRENCY` | `8` | Max slideshow slides downloaded in parallel; keeps one large post from hogging the shared HTTP connection pool. |
 | `TIKTOK_VIDEO_SLIDE_PROBE_CONCURRENCY` | `4` | Max concurrent `ffprobe`/`ffmpeg` processes when probing "live" video slides in a slideshow. |
 

lumen_commands.py

@@ -313,9 +313,25 @@ async def inline_tts(message: Message, text: str) -> None:
         )
         return
     status = await bot._tg_call(message.reply, bot._t(message.chat.id, "status_voicing"))
+    # Общий дедлайн на все чанки: зависший синтез иначе держал per-chat lock без края.
+    deadline = time.monotonic() + bot.TTS_TOTAL_BUDGET_SEC
+    shortened = False
     try:
         # Весь синтез ДО отправки: упавший кусок — одна ошибка вместо рваного "пол-ответа + ошибка".
-        voices = [await _synthesize_tts_voice(chunk) for chunk in chunks]
+        voices = []
+        for chunk in chunks:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                shortened = True
+                break
+            try:
+                voices.append(await asyncio.wait_for(_synthesize_tts_voice(chunk), timeout=remaining))
+            except asyncio.TimeoutError:
+                shortened = True
+                break
+        if not voices:
+            # Даже первый кусок не уложился — честная ошибка, а не пустота.
+            raise RuntimeError("TTS total budget exceeded before the first chunk")
     except Exception as exc:
         log.exception("TTS synthesis failed:")
         # Сырой текст ошибки содержит ID моделей — показываем классифицированный текст.
@@ -344,6 +360,9 @@ async def inline_tts(message: Message, text: str) -> None:
         )
         if sent is None:
             raise RuntimeError("Telegram send_voice failed: connection timeout or proxy unavailable")
+    if shortened:
+        # Обрезка по общему дедлайну — говорим прямо, что озвучено начало.
+        await bot._safe_reply(message, bot._t(message.chat.id, "tts_shortened"))
 
 async def cmd_tts(message: Message) -> None:
     import bot

lumen_lang.py

@@ -339,6 +339,22 @@ STRINGS: dict[str, dict[str, str]] = {
         "ru": "Временная ошибка сервиса. Попробуй чуть позже.",
         "uk": "Тимчасова помилка сервісу. Спробуй трохи пізніше.",
     },
+    "tts_shortened": {
+        "be": "Агучыла толькі пачатак — увесь тэкст не ўмясціўся ў ліміт часу, астатняе скарочана.",
+        "en": "Only managed to voice the beginning — the full text didn't fit the time limit, the rest was cut.",
+        "es": "Solo alcancé a ponerle voz al principio — el texto completo no cupo en el límite de tiempo, el resto se ha recortado.",
+        "kk": "Басын ғана дыбыстай алдым — толық мәтін уақыт лимитіне сыймады, қалғаны қысқартылды.",
+        "ru": "Успела озвучить только начало — весь текст не уложился в лимит времени, остальное сокращено.",
+        "uk": "Встигла озвучити лише початок — увесь текст не вмістився в ліміт часу, решту скорочено.",
+    },
+    "media_too_big": {
+        "be": "Гэты файл занадта вялікі для аналізу (ліміт {limit_mb} МБ). Дашлі меншы або апішы словамі — тады змагу дапамагчы.",
+        "en": "This file is too big to analyse (limit {limit_mb} MB). Send a smaller one or describe it in words — then I can help.",
+        "es": "Este archivo es demasiado grande para analizarlo (límite {limit_mb} MB). Envía uno más pequeño o descríbelo con palabras — entonces podré ayudar.",
+        "kk": "Бұл файл талдау үшін тым үлкен (лимит {limit_mb} МБ). Кішірек файл жібер немесе сөзбен сипатта — сонда көмектесемін.",
+        "ru": "Этот файл слишком большой для анализа (лимит {limit_mb} МБ). Пришли файл поменьше или опиши словами — тогда смогу помочь.",
+        "uk": "Цей файл завеликий для аналізу (ліміт {limit_mb} МБ). Надішли менший або опиши словами — тоді зможу допомогти.",
+    },
     "err_quota_exhausted": {
         "be": "Бясплатны ліміт запытаў вычарпаны — гэта рэальны сутачны ліміт сэрвісу, а не памылка. Паспрабуй пазней.",
         "en": "The free request limit is exhausted — that's the service's real daily limit, not an error. Try again later.",
@@ -751,6 +767,8 @@ PACK_PT: dict[str, str] = {
     "tiktok_dl_as_is": "Não encontrei versão sem marcas d'água — baixando como está",
     "tiktok_dl_plain": "Baixando vídeo sem marcas d'água",
     "tiktok_too_big": "Este vídeo do TikTok é grande demais para enviar — a API de bots do Telegram limita o envio de arquivos a 50 MB. Tente baixar este vídeo de outro jeito.",
+    "tts_shortened": "Só consegui dar voz ao começo — o texto completo não coube no limite de tempo, o resto foi cortado.",
+    "media_too_big": "Este arquivo é grande demais para analisar (limite {limit_mb} MB). Envie um menor ou descreva com palavras — então poderei ajudar.",
     "tiktok_no_media": "Link reconhecido, mas o TikTok não devolveu nem vídeo nem fotos — talvez o conteúdo tenha sido excluído ou esteja indisponível.",
     "tiktok_processing": "Processando o link do TikTok",
     "tiktok_fetch_fail": "Não consegui obter o vídeo deste link — talvez seja privado, foi excluído, bloqueado por região ou o link está quebrado.",
@@ -833,6 +851,8 @@ PACK_AR: dict[str, str] = {
     "tiktok_dl_as_is": "لم توجد نسخة دون علامات مائية — جارٍ التنزيل كما هو",
     "tiktok_dl_plain": "جارٍ تنزيل الفيديو دون علامات مائية",
     "tiktok_too_big": "هذا الفيديو من TikTok كبير جدًا للإرسال — واجهة Telegram Bot API تحدّ تحميل الملفات بـ 50 م.ب. حاول تنزيل الفيديو بطريقة أخرى.",
+    "tts_shortened": "تمكنت من التعليق الصوتي على البداية فقط — النص الكامل لم يتسع للمهلة، وتم اختصار الباقي.",
+    "media_too_big": "هذا الملف كبير جدًا للتحليل (الحد {limit_mb} م.ب). أرسل ملفًا أصغر أو صِفه بالكلمات — وسأساعدك.",
     "tiktok_no_media": "تم التعرف على الرابط لكن TikTok لم يعطِ فيديو ولا صور — ربما المحتوى محذوف أو غير متاح.",
     "tiktok_processing": "جارٍ معالجة رابط TikTok",
     "tiktok_fetch_fail": "تعذر جلب الفيديو لهذا الرابط ��� ربما خاص أو محذوف أو محظور إقليميًا أو الرابط تالف.",
@@ -915,6 +935,8 @@ PACK_TR: dict[str, str] = {
     "tiktok_dl_as_is": "Filigransız sürüm bulunamadı — olduğu gibi indiriliyor",
     "tiktok_dl_plain": "Filigransız video indiriliyor",
     "tiktok_too_big": "Bu TikTok videosu göndermek için çok büyük — Telegram Bot API dosya yüklemeyi 50 MB ile sınırlıyor. Videoyu başka yolla indirmeyi dene.",
+    "tts_shortened": "Sadece başlangıcı seslendirebildim — metnin tamamı süre limitine sığmadı, kalanı kısaltıldı.",
+    "media_too_big": "Bu dosya analiz için çok büyük (limit {limit_mb} MB). Daha küçüğünü gönder ya da kelimelerle anlat — o zaman yardım edebilirim.",
     "tiktok_no_media": "Bağlantı tanındı ama TikTok ne video ne fotoğraf verdi — içerik silinmiş veya kullanılamıyor olabilir.",
     "tiktok_processing": "TikTok bağlantısı işleniyor",
     "tiktok_fetch_fail": "Bu bağlantıdan video alınamadı — özel, silinmiş, bölge engelli olabilir veya bağlantı bozuktur.",
@@ -997,6 +1019,8 @@ PACK_DE: dict[str, str] = {
     "tiktok_dl_as_is": "Keine Version ohne Wasserzeichen gefunden — lade wie es ist",
     "tiktok_dl_plain": "Video ohne Wasserzeichen wird geladen",
     "tiktok_too_big": "Dieses TikTok-Video ist zu groß zum Senden — die Telegram Bot API begrenzt Datei-Uploads auf 50 MB. Video auf anderem Weg laden.",
+    "tts_shortened": "Ich habe nur den Anfang vertont — der ganze Text hat das Zeitlimit gesprengt, der Rest wurde gekürzt.",
+    "media_too_big": "Diese Datei ist zu groß für die Analyse (Limit {limit_mb} MB). Schick eine kleinere oder beschreib sie mit Worten — dann kann ich helfen.",
     "tiktok_no_media": "Link erkannt, aber TikTok gab weder Video noch Fotos dazu — Inhalt vielleicht gelöscht oder nicht verfügbar.",
     "tiktok_processing": "TikTok-Link wird verarbeitet",
     "tiktok_fetch_fail": "Video zu diesem Link konnte nicht geholt werden — vielleicht privat, gelöscht, regionsgesperrt oder Link defekt.",
@@ -1079,6 +1103,8 @@ PACK_FR: dict[str, str] = {
     "tiktok_dl_as_is": "Aucune version sans filigrane trouvée — téléchargement tel quel",
     "tiktok_dl_plain": "Téléchargement de la vidéo sans filigrane",
     "tiktok_too_big": "Cette vidéo TikTok est trop grosse pour être envoyée — l'API Bot de Telegram limite l'envoi de fichiers à 50 Mo. Essaie de télécharger cette vidéo autrement.",
+    "tts_shortened": "Je n'ai pu mettre en voix que le début — le texte entier n'a pas tenu dans la limite de temps, la suite a été coupée.",
+    "media_too_big": "Ce fichier est trop gros pour être analysé (limite {limit_mb} Mo). Envoie-en un plus petit ou décris-le avec des mots — je pourrai aider.",
     "tiktok_no_media": "Lien reconnu, mais TikTok n'a donné ni vidéo ni photos — le contenu est peut-être supprimé ou indisponible.",
     "tiktok_processing": "Traitement du lien TikTok",
     "tiktok_fetch_fail": "Impossible de récupérer la vidéo de ce lien — peut-être privée, supprimée, bloquée par région ou lien cassé.",
@@ -1161,6 +1187,8 @@ PACK_IT: dict[str, str] = {
     "tiktok_dl_as_is": "Nessuna versione senza watermark trovata — scarico com'è",
     "tiktok_dl_plain": "Download del video senza watermark",
     "tiktok_too_big": "Questo video TikTok è troppo grande per essere inviato — le Bot API di Telegram limitano l'invio di file a 50 MB. Prova a scaricare questo video in un altro modo.",
+    "tts_shortened": "Sono riuscita a dare voce solo all'inizio — l'intero testo non è entrato nel limite di tempo, il resto è stato tagliato.",
+    "media_too_big": "Questo file è troppo grande per essere analizzato (limite {limit_mb} MB). Inviane uno più piccolo o descrivelo a parole — così potrò aiutare.",
     "tiktok_no_media": "Link riconosciuto, ma TikTok non ha dato né video né foto — forse il contenuto è stato eliminato o non è disponibile.",
     "tiktok_processing": "Elaborazione del link TikTok",
     "tiktok_fetch_fail": "Impossibile ottenere il video da questo link — forse privato, eliminato, bloccato per regione o link rotto.",
@@ -1243,6 +1271,8 @@ PACK_HI: dict[str, str] = {
     "tiktok_dl_as_is": "बिना वॉटरमार्क वाला संस्करण नहीं मिला — जैसा है वैसा डाउनलोड हो रहा है",
     "tiktok_dl_plain": "बिना वॉटरमार्क वीडियो डाउनलोड हो रहा है",
     "tiktok_too_big": "यह TikTok वीडियो भेजने के लिए बहुत बड़ा है — Telegram Bot API फ़ाइल अपलोड को 50 MB तक सीमित करता है। इस वीडियो को किसी और तरीके से डाउनलोड करने की कोशिश करो।",
+    "tts_shortened": "सिर्फ शुरुआत को आवाज़ दे पाई — पूरा पाठ समय सीमा में नहीं समाया, बाकी काट दिया।",
+    "media_too_big": "यह फ़ाइल विश्लेषण के लिए बहुत बड़ी है (सीमा {limit_mb} MB)। छोटी फ़ाइल भेजो या शब्दों में बताओ — तब मदद कर पाऊंगा।",
     "tiktok_no_media": "लिंक पहचाना गया, लेकिन TikTok ने न वीडियो दिया न फ़ोटो — शायद कंटेंट हटाया गया है या उपलब्ध नहीं है।",
     "tiktok_processing": "TikTok लिंक संसाधित हो रहा है",
     "tiktok_fetch_fail": "इस लिंक से वीडियो लाया नहीं जा सका — शायद निजी है, हटाया गया है, क्षेत्र-प्रतिबंधित है या लिंक टूटा है।",
@@ -1325,6 +1355,8 @@ PACK_ID: dict[str, str] = {
     "tiktok_dl_as_is": "Tidak ada versi tanpa watermark — mengunduh apa adanya",
     "tiktok_dl_plain": "Mengunduh video tanpa watermark",
     "tiktok_too_big": "Video TikTok ini terlalu besar untuk dikirim — Bot API Telegram membatasi unggahan file hingga 50 MB. Coba unduh video ini dengan cara lain.",
+    "tts_shortened": "Hanya sempat menyuarakan bagian awal — teks lengkap tidak muat dalam batas waktu, sisanya dipotong.",
+    "media_too_big": "File ini terlalu besar untuk dianalisis (batas {limit_mb} MB). Kirim yang lebih kecil atau jelaskan dengan kata-kata — maka saya bisa membantu.",
     "tiktok_no_media": "Tautan dikenali, tetapi TikTok tidak memberi video maupun foto — kontennya mungkin dihapus atau tidak tersedia.",
     "tiktok_processing": "Memproses tautan TikTok",
     "tiktok_fetch_fail": "Tidak bisa mengambil video dari tautan ini — mungkin privat, dihapus, dibatasi wilayah, atau tautannya rusak.",
@@ -1407,6 +1439,8 @@ PACK_MS: dict[str, str] = {
     "tiktok_dl_as_is": "Tiada versi tanpa tera air — memuat turun seadanya",
     "tiktok_dl_plain": "Memuat turun video tanpa tera air",
     "tiktok_too_big": "Video TikTok ini terlalu besar untuk dihantar — Bot API Telegram mengehadkan muat naik fail hingga 50 MB. Cuba muat turun video ini dengan cara lain.",
+    "tts_shortened": "Hanya sempat menyuarakan bahagian awal — teks penuh tidak muat dalam had masa, selebihnya dipotong.",
+    "media_too_big": "Fail ini terlalu besar untuk dianalisis (had {limit_mb} MB). Hantar yang lebih kecil atau terangkan dengan kata-kata — maka saya boleh membantu.",
     "tiktok_no_media": "Pautan dikenal pasti, tetapi TikTok tidak memberi video mahupun foto — kandungannya mungkin dipadam atau tidak tersedia.",
     "tiktok_processing": "Memproses pautan TikTok",
     "tiktok_fetch_fail": "Tidak dapat mengambil video daripada pautan ini — mungkin peribadi, dipadam, disekat wilayah atau pautannya rosak.",
@@ -1489,6 +1523,8 @@ PACK_VI: dict[str, str] = {
     "tiktok_dl_as_is": "Không thấy bản không watermark — tải nguyên như vậy",
     "tiktok_dl_plain": "Đang tải video không watermark",
     "tiktok_too_big": "Video TikTok này quá lớn để gửi — Bot API Telegram giới hạn tải file lên 50 MB. Thử tải video này bằng cách khác.",
+    "tts_shortened": "Tôi chỉ kịp lồng tiếng phần đầu — toàn văn không vừa giới hạn thời gian, phần còn lại đã bị cắt.",
+    "media_too_big": "Tệp này quá lớn để phân tích (giới hạn {limit_mb} MB). Hãy gửi tệp nhỏ hơn hoặc mô tả bằng lời — tôi sẽ giúp được.",
     "tiktok_no_media": "Đã nhận ra liên kết, nhưng TikTok không đưa video lẫn ảnh — nội dung có thể đã xóa hoặc không khả dụng.",
     "tiktok_processing": "Đang xử lý liên kết TikTok",
     "tiktok_fetch_fail": "Không lấy được video từ liên kết này — có thể riêng tư, đã xóa, chặn vùng hoặc link hỏng.",
@@ -1571,6 +1607,8 @@ PACK_TH: dict[str, str] = {
     "tiktok_dl_as_is": "ไม่พบเวอร์ชันไม่มีลายน้ำ — ดาวน์โหลดตามสภาพ",
     "tiktok_dl_plain": "กำลังดาวน์โหลดวิดีโอแบบไม่มีลายน้ำ",
     "tiktok_too_big": "วิดีโอ TikTok นี้ใหญ่เกินกว่าจะส่ง — Bot API ของ Telegram จำกัดอัปโหลดไฟล์ที่ 50 MB ลองดาวน์โหลดวิดีโอนี้ด้วยวิธีอื่น",
+    "tts_shortened": "พากย์เสียงได้แค่ตอนต้น — ข้อความทั้งหมดเกินขีดจำกัดเวลา ส่วนที่เหลือถูกตัดออก",
+    "media_too_big": "ไฟล์นี้ใหญ่เกินกว่าจะวิเคราะห์ (จำกัด {limit_mb} MB) ส่งไฟล์ที่เล็กกว่ามา หรืออธิบายเป็นคำพูด แล้วจะช่วยได้",
     "tiktok_no_media": "รู้จักลิงก์แล้ว แต่ TikTok ไม่ให้ทั้งวิดีโอและรูปภาพ — เนื้อหาอาจถูกลบหรือใช้ไม่ได้",
     "tiktok_processing": "กำลังประมวลผลลิงก์ TikTok",
     "tiktok_fetch_fail": "ดึงวิดีโอจากลิงก์นี้ไม่ได้ — อาจเป็นส่วนตัว ถูกลบ ถูกบล็อกตามภูมิภาค หรือลิงก์เสีย",
@@ -1653,6 +1691,8 @@ PACK_FA: dict[str, str] = {
     "tiktok_dl_as_is": "نسخه بدون واترمارک پیدا نشد — همان‌طور که هست دانلود می‌شود",
     "tiktok_dl_plain": "در حال دانلود ویدیوی بدون واترمارک",
     "tiktok_too_big": "این ویدیوی TikTok برای ارسال خیلی بزرگ است — Bot API تلگرام آپلود فایل را به ۵۰ مگابایت محدود می‌کند. ویدیو را به روش دیگری دانلود کن.",
+    "tts_shortened": "فقط توانستم ابتدای متن را بخوانم — کل متن در محدودیت زمانی جا نشد، بقیه کوتاه شد.",
+    "media_too_big": "این فایل برای تحلیل خیلی بزرگ است (سقف {limit_mb} مگابایت). فایل کوچک‌تری بفرست یا با کلمات توضیح بده — آن‌وقت کمک می‌کنم.",
     "tiktok_no_media": "لینک شناخته شد، اما TikTok نه ویدیو داد نه عکس — شاید محتوا حذف شده یا در دسترس نیست.",
     "tiktok_processing": "در حال پردازش لینک TikTok",
     "tiktok_fetch_fail": "نتوانستم ویدیوی این لینک را بگیرم — شاید خصوصی، حذف‌شده، محدودشده منطقه‌ای است یا لینک خراب است.",
@@ -1735,6 +1775,8 @@ PACK_UR: dict[str, str] = {
     "tiktok_dl_as_is": "بغیر واٹرمارک والا نسخہ نہیں ملا — جیسی ہے ویسی ڈاؤن لوڈ ہو رہی ہے",
     "tiktok_dl_plain": "بغیر واٹرمارک ویڈیو ڈاؤن لوڈ ہو رہی ہے",
     "tiktok_too_big": "یہ TikTok ویڈیو بھیجنے کے لیے بہت بڑی ہے — Telegram Bot API فائل اپلوڈ کو 50 MB تک محدود کرتا ہے۔ اس ویڈیو کو کسی اور طریقے سے ڈاؤن لوڈ کرنے کی کوشش کرو۔",
+    "tts_shortened": "صرف شروع کو آواز دے سکی — پورا متن وقت کی حد میں نہیں سمایا، باقی مختصر کر دیا۔",
+    "media_too_big": "یہ فائل تجزیے کے لیے بہت بڑی ہے (حد {limit_mb} MB)۔ چھوٹی فائل بھیجو یا لفظوں میں بتاؤ — پھر مدد کر سکوں گا۔",
     "tiktok_no_media": "لنک پہچانا گیا، لیکن TikTok نے نہ ویڈیو دی نہ تصاویر — شاید مواد ہٹایا گیا ہے یا دستیاب نہیں ہے۔",
     "tiktok_processing": "TikTok لنک زیرِ عمل ہے",
     "tiktok_fetch_fail": "اس لنک سے ویڈیو لائی نہ جا سکی — شاید نجی ہے، ہٹائی گئی ہے، علاقائی پابندی ہے یا لنک ٹوٹا ہے۔",
@@ -1817,6 +1859,8 @@ PACK_UZ: dict[str, str] = {
     "tiktok_dl_as_is": "Suv belgisiz nusxa topilmadi — boricha yuklanmoqda",
     "tiktok_dl_plain": "Suv belgisiz video yuklanmoqda",
     "tiktok_too_big": "Bu TikTok videosi yuborish uchun juda katta — Telegram Bot API fayl yuklashni 50 MB bilan cheklaydi. Videoni boshqa yo'l bilan yuklashga urin.",
+    "tts_shortened": "Faqat boshini ovozlay oldim — to'liq matn vaqt limitiga sig'madi, qolgani qisqartirildi.",
+    "media_too_big": "Bu fayl tahlil uchun juda katta (limit {limit_mb} MB). Kichikroq fayl yubor yoki so'z bilan tasvirla — shunda yordam bera olaman.",
     "tiktok_no_media": "Havola tanildi, lekin TikTok na video berdi na foto — kontent o'chirilgan yoki mavjud bo'lmasligi mumkin.",
     "tiktok_processing": "TikTok havolasi qayta ishlanmoqda",
     "tiktok_fetch_fail": "Bu havoladan videoni olib bo'lmadi — shaxsiy, o'chirilgan, hudud cheklovli bo'lishi yoki havola buzilgan bo'lishi mumkin.",
@@ -1899,6 +1943,8 @@ PACK_BN: dict[str, str] = {
     "tiktok_dl_as_is": "ওয়াটারমার্ক ছাড়া সংস্করণ পাওয়া যায়নি — যেমন আছে তেমন ডাউনলোড হচ্ছে",
     "tiktok_dl_plain": "ওয়াটারমার্ক ছাড়া ভিডিও ডাউনলোড হচ্ছে",
     "tiktok_too_big": "এই TikTok ভিডিও প��ঠানোর জন্য অনেক বড় — Telegram Bot API ফাইল আপলোড 50 MB-এ সীমাবদ্ধ। ভিডিওটি অন্য উপায়ে ডাউনলোড করার চেষ্টা করো।",
+    "tts_shortened": "শুধু শুরুটা কণ্ঠ দিতে পেরেছি — পুরো লেখা সময়সীমায় ধরেনি, বাকিটা ছাঁটা হয়েছে।",
+    "media_too_big": "এই ফাইল বিশ্লেষণের জন্য অনেক বড় (সীমা {limit_mb} MB)। ছোট ফাইল পাঠাও বা কথায় বর্ণনা করো — তাহলে সাহায্য করতে পারব।",
     "tiktok_no_media": "লিংক চেনা গেছে, কিন্তু TikTok ভিডিও বা ছবি কিছুই দেয়নি — হয়তো কন্টেন্ট মোছা বা অনুপলব্ধ।",
     "tiktok_processing": "TikTok লিংক প্রক্রিয়াধীন",
     "tiktok_fetch_fail": "এই লিংক থেকে ভিডিও আনা যায়নি — হয়তো ব্যক্তিগত, মোছা, অঞ্চল-নিষিদ্ধ বা লিংক নষ্ট।",
@@ -1981,6 +2027,8 @@ PACK_FIL: dict[str, str] = {
     "tiktok_dl_as_is": "Walang nahanap na bersyong walang watermark — dina-download kung ano",
     "tiktok_dl_plain": "Dina-download ang video nang walang watermark",
     "tiktok_too_big": "Masyadong malaki ang TikTok video na ito para i-send — nililimitahan ng Telegram Bot API ang upload ng file sa 50 MB. Subukang i-download ang video sa ibang paraan.",
+    "tts_shortened": "Nabigyan ko lang ng boses ang simula — hindi kasya ang buong teksto sa limitasyon ng oras, pinutol ang natira.",
+    "media_too_big": "Masyadong malaki ang file na ito para suriin (limit {limit_mb} MB). Magpadala ng mas maliit o ilarawan gamit ang mga salita — makakatulong ako.",
     "tiktok_no_media": "Nakilala ang link, pero walang binigay ang TikTok na video o photo — baka binura o hindi available ang content.",
     "tiktok_processing": "Pinoproseso ang TikTok link",
     "tiktok_fetch_fail": "Hindi makuha ang video mula sa link na ito — baka private, binura, region-blocked, o sira ang link.",
@@ -2063,6 +2111,8 @@ PACK_PL: dict[str, str] = {
     "tiktok_dl_as_is": "Nie znalazłem wersji bez znaków wodnych — pobieram jak jest",
     "tiktok_dl_plain": "Pobieram film bez znaków wodnych",
     "tiktok_too_big": "Ten film z TikToka jest za duży do wysłania — Bot API Telegram ogranicza wysyłanie plików do 50 MB. Spróbuj pobrać ten film inaczej.",
+    "tts_shortened": "Udało mi się udźwiękowić tylko początek — cały tekst nie zmieścił się w limicie czasu, reszta została skrócona.",
+    "media_too_big": "Ten plik jest za duży do analizy (limit {limit_mb} MB). Wyślij mniejszy albo opisz słowami — wtedy będę mógł pomóc.",
     "tiktok_no_media": "Link rozpoznany, ale TikTok nie oddał ani filmu, ani zdjęć — treść może usunięta albo niedostępna.",
     "tiktok_processing": "Przetwarzam link TikToka",
     "tiktok_fetch_fail": "Nie udało się pobrać filmu z tego linku — może prywatny, usunięty, zablokowany regionalnie albo link uszkodzony.",
@@ -2145,6 +2195,8 @@ PACK_NL: dict[str, str] = {
     "tiktok_dl_as_is": "Geen versie zonder watermerk gevonden — downloaden zoals het is",
     "tiktok_dl_plain": "Video zonder watermerk downloaden",
     "tiktok_too_big": "Deze TikTok-video is te groot om te verzenden — de Telegram Bot API limiteert bestandsuploads tot 50 MB. Probeer deze video anders te downloaden.",
+    "tts_shortened": "Ik heb alleen het begin ingesproken — de volledige tekst paste niet in de tijdslimiet, de rest is ingekort.",
+    "media_too_big": "Dit bestand is te groot om te analyseren (limiet {limit_mb} MB). Stuur een kleiner of beschrijf het in woorden — dan kan ik helpen.",
     "tiktok_no_media": "Link herkend, maar TikTok gaf video noch foto's — inhoud misschien verwijderd of niet beschikbaar.",
     "tiktok_processing": "TikTok-link verwerken",
     "tiktok_fetch_fail": "Video van deze link kon niet worden opgehaald — misschien privé, verwijderd, regiogeblokkeerd of link stuk.",
@@ -2227,6 +2279,8 @@ PACK_ZU: dict[str, str] = {
     "tiktok_dl_as_is": "Ayitholakalanga inguqulo engena-watermark — kulanda njengoba injalo",
     "tiktok_dl_plain": "Kulanda ividiyo ngaphandle kwe-watermark",
     "tiktok_too_big": "Le vidiyo ye-TikTok inkulu kakhulu ukuthunyelwa — i-Telegram Bot API ikhawulela ukulayishwa kwefayela ku-50 MB. Zama ukulanda le vidiyo ngenye indlela.",
+    "tts_shortened": "Ngikwazile ukuphimisela isiqalo kuphela — umbiko wonke awungenanga kumkhawulo wesikhathi, okusele kuncishisiwe.",
+    "media_too_big": "Leli fayela likhulu kakhulu ukuhlaziywa (umkhawulo {limit_mb} MB). Thumela elincane noma ulichaze ngamazwi — ngizokwazi ukusiza.",
     "tiktok_no_media": "Isixhumanisi saziwe, kodwa i-TikTok ayinikanga vidiyo noma zithombe — okuqukethwe kungasuswa noma kungatholakali.",
     "tiktok_processing": "Kucutshungulwa isixhumanisi se-TikTok",
     "tiktok_fetch_fail": "Ayikwazanga ukuthathwa ividiyo kulesi sixhumanisi — mhlawumbe eyimfihlo, isusiwe, ivinjelwe isifunda, noma isixhumanisi sonakele.",

lumen_media_flow.py

@@ -21,6 +21,14 @@ from lumen_media import (
 
 log = logging.getLogger("bot")
 
+class _MediaTooLargeError(RuntimeError):
+    """Файл больше капа скачивания: вызывающий код отвечает пользователю
+    понятным текстом вместо слепого анализа (аудит D1, 30.09.2026)."""
+    def __init__(self, size_bytes: int, cap_bytes: int):
+        self.size_bytes = size_bytes
+        self.cap_bytes = cap_bytes
+        super().__init__(f"file size {size_bytes} exceeds the {cap_bytes} byte download cap")
+
 async def _download_telegram_file_bytes(file_id: str, *, timeout: float | None = None, retries: int = 1) -> tuple[bytes, str]:
     # Один ретрай getFile/скачивания: единичный сбой прокси иначе слепил бота ("NOT_FOUND" в логах).
     import bot
@@ -31,14 +39,21 @@ async def _download_telegram_file_bytes(file_id: str, *, timeout: float | None =
             file_path = getattr(file, "file_path", None) or getattr(file, "path", None)
             if not file_path:
                 raise RuntimeError("File path is empty")
+            declared_size = getattr(file, "file_size", None)
+            if isinstance(declared_size, int) and declared_size > bot.TELEGRAM_DOWNLOAD_MAX_BYTES:
+                # Заранее большой размер — без скачивания, с честным отказом выше.
+                raise _MediaTooLargeError(declared_size, bot.TELEGRAM_DOWNLOAD_MAX_BYTES)
             session = await bot._get_telegram_session()
             url = f"{bot.TELEGRAM_API_BASE_URL}/file/bot{bot.BOT_TOKEN}/{file_path}"
             async with session.get(url, timeout=timeout or bot.TELEGRAM_MEDIA_TIMEOUT) as resp:
                 resp.raise_for_status()
-                data = await resp.read()
+                data = await _read_capped_telegram_body(resp, url)
                 mime = resp.headers.get("Content-Type", "application/octet-stream").split(";", 1)[0].strip()
             real_mime = _sanitize_mime_type(file_path, mime)
             return data, real_mime
+        except _MediaTooLargeError:
+            # Кап — не сеть: ретрай бессмыслен, пробрасываем сразу.
+            raise
         except Exception as exc:
             last_exc = exc
             if attempt < retries:
@@ -49,6 +64,26 @@ async def _download_telegram_file_bytes(file_id: str, *, timeout: float | None =
         exc_str = exc_str.replace(bot.BOT_TOKEN, "<TOKEN>")
     raise RuntimeError(f"Network error in download_telegram_file_bytes: {exc_str}") from None
 
+async def _read_capped_telegram_body(resp: Any, url: str) -> bytes:
+    """Тело ответа Telegram с капом: Content-Length врёт/отсутствует —
+    та же проверка потоково по факту (см. кап TikWM-скачиваний)."""
+    import bot
+    content_length = resp.headers.get("Content-Length")
+    if content_length is not None:
+        try:
+            if int(content_length) > bot.TELEGRAM_DOWNLOAD_MAX_BYTES:
+                raise _MediaTooLargeError(int(content_length), bot.TELEGRAM_DOWNLOAD_MAX_BYTES)
+        except ValueError:
+            pass
+    chunks: list[bytes] = []
+    total = 0
+    async for chunk in resp.content.iter_chunked(65536):
+        total += len(chunk)
+        if total > bot.TELEGRAM_DOWNLOAD_MAX_BYTES:
+            raise _MediaTooLargeError(total, bot.TELEGRAM_DOWNLOAD_MAX_BYTES)
+        chunks.append(chunk)
+    return b"".join(chunks)
+
 def _save_media_to_history(source: Any, state: dict[str, Any], user_id: int | None) -> None:
     file_id, mime, _ = _media_file_id_and_mime(source)
     if not file_id or user_id is None:
@@ -103,6 +138,9 @@ async def _fetch_media(file_id: str, mime: str) -> tuple[bytes, str] | None:
         if final_mime == "application/octet-stream":
             final_mime = _sanitize_mime_type(None, real_mime)
         return data, final_mime
+    except _MediaTooLargeError:
+        # Честный отказ выше по стеку, а не тихое None.
+        raise
     except Exception as exc:
         log.warning("[media] Download media failed for file_id %s: %s", file_id, exc)
         return None

lumen_message_core.py

@@ -43,6 +43,12 @@ from lumen_security import _looks_like_injection_probe
 
 log = logging.getLogger("bot")
 
+# Суммарный кап extra-файлов альбома: 9 файлов по 20МБ + base64 давали ~250МБ
+# в RAM (аудит D1, 30.09.2026). Обычный альбом — десятки МБ.
+_ALBUM_EXTRA_MAX_BYTES = 100 * 1024 * 1024
+# Параллельных скачиваний альбома: ограничивает in-flight память (3×20МБ).
+_ALBUM_FETCH_CONCURRENCY = 3
+
 async def _process_media_group_buffers(mgid: str) -> None:
     import bot
     messages: list = []
@@ -116,18 +122,44 @@ async def _process_media_group_buffers_locked(messages: list) -> None:
             continue
         targets.append((fid, mime, src))
     # Качаем параллельно, а не по очереди: альбом из 9 фото иначе ждал бы до ~10-20с последовательных скачиваний.
-    fetched_list = await asyncio.gather(*(bot._fetch_media(fid, mime) for fid, mime, _ in targets))
+    fetched_list: list = [None] * len(targets)
+    # Семафор режет in-flight память, суммарный кап — накопленную (аудит D1, 30.09.2026).
+    _album_fetch_semaphore = asyncio.Semaphore(_ALBUM_FETCH_CONCURRENCY)
+
+    async def _fetch_one_bounded(fid: str, mime: str) -> tuple[bytes, str] | None:
+        async with _album_fetch_semaphore:
+            return await bot._fetch_media(fid, mime)
+
+    try:
+        fetched_list = list(await asyncio.gather(
+            *(_fetch_one_bounded(fid, mime) for fid, mime, _ in targets),
+            return_exceptions=True,
+        ))
+    except Exception:
+        pass
     skipped = 0
+    too_big = 0
+    extra_bytes = 0
     for (fid, mime, src), fetched in zip(targets, fetched_list):
-        if fetched:
-            extra_media.append(fetched)
-            # Регрессия: файлы альбома пишем в recent_media_ids, иначе "что на втором фото" не найдёт их.
-            bot._save_media_to_history(src, album_state, album_user_id)
-        else:
+        if isinstance(fetched, bot._MediaTooLargeError):
+            too_big += 1
+            continue
+        if not fetched or isinstance(fetched, BaseException):
             skipped += 1
+            continue
+        if extra_bytes + len(fetched[0]) > _ALBUM_EXTRA_MAX_BYTES:
+            skipped += 1
+            continue
+        extra_bytes += len(fetched[0])
+        extra_media.append(fetched)
+        # Файлы альбома — в recent_media_ids, иначе последующие вопросы их не найдут.
+        bot._save_media_to_history(src, album_state, album_user_id)
     if skipped:
         # Упавшие слайды молча выпадали и анализ шёл по части файлов.
         log.warning("[album] Skipped %d of %d files: download failed, analysing the rest.", skipped, len(targets))
+    if too_big:
+        # Большие отклонены капом: честный отказ пользователю — из _handle_message_core.
+        log.warning("[album] Skipped %d of %d files: over the download size cap.", too_big, len(targets))
     await bot._handle_message_core(main_msg, extra_media=extra_media or None)
 
 def _record_passive_group_context(message: Message, state: dict[str, Any], t: str) -> None:
@@ -356,9 +388,15 @@ async def _handle_message_core(message: Message, extra_media: list[tuple[bytes,
             await bot._send_pick_question(message, pick_scenario, clean_prompt)
             return
 
-    med_path, med_mime, med_name, media_tuple = await bot._resolve_incoming_media(
-        message, state, clean_prompt, is_private=is_private,
-    )
+    media_too_big_mb = 0
+    try:
+        med_path, med_mime, med_name, media_tuple = await bot._resolve_incoming_media(
+            message, state, clean_prompt, is_private=is_private,
+        )
+    except bot._MediaTooLargeError as exc:
+        # Файл больше капа скачивания: честный отказ ниже вместо слепого ответа.
+        med_path, med_name, media_tuple = None, "", None
+        media_too_big_mb = max(1, round(exc.cap_bytes / (1024 * 1024)))
 
     # Голос/аудио: сначала дешёвая транскрибация — дальше текст идёт общим роутингом по
     # сценарию (тяжесть/свежесть определяются по сказанному). Не вышло — падает в прежний
@@ -386,7 +424,10 @@ async def _handle_message_core(message: Message, extra_media: list[tuple[bytes,
          src = _msg_media_source(message)
          if src is not None and type(src).__name__ != "Sticker":
               # Вложение было, но скачать/распознать не вышло — честно говорим, а не "Слушаю" в пустоту.
-              await bot._safe_reply(message, bot._model_error_text("fallback", bot._chat_lang(message.chat.id)))
+              if media_too_big_mb:
+                   await bot._safe_reply(message, bot._t(message.chat.id, "media_too_big", limit_mb=media_too_big_mb))
+              else:
+                   await bot._safe_reply(message, bot._model_error_text("fallback", bot._chat_lang(message.chat.id)))
               return
          if mentioned:
               await bot._tg_call(message.reply, bot._t(message.chat.id, "status_listening"))

lumen_router_config.py

@@ -441,10 +441,14 @@ def _build_route(
         return _gemini_route(chain)
 
     if media_mime:
-        if needs_freshness or is_video_or_audio_media:
-            # Видео/аудио и медиа+поиск — только Gemini (OpenRouter не примет не-изображение и без поиска).
+        if is_video_or_audio_media:
+            # Видео/аудио — только Gemini (OpenRouter не примет не-изображение).
             chain = GEMINI_SEARCH_CHAIN if needs_freshness else GEMINI_HEAVY_CHAIN
             return _gemini_route(chain)
+        if needs_freshness:
+            # Картинка+свежесть: Gemini с поиском головой, дальше vision
+            # OpenRouter без поиска (аудит D3, 30.09.2026: раньше резерва не было).
+            return _gemini_route(GEMINI_SEARCH_CHAIN) + _or_route(_OR_VISION_ORDER)
         # Картинка без поиска — сначала vision OpenRouter, Gemini резервом.
         return _or_route(_OR_VISION_ORDER) + _gemini_route(GEMINI_HEAVY_CHAIN)
 
@@ -453,6 +457,8 @@ def _build_route(
         return _gemini_route(GEMINI_SEARCH_CHAIN) + _or_route(_OR_HEAVY_ORDER if is_heavy else _OR_LIGHT_ORDER) + _groq_route(_GROQ_LIGHT_ORDER)
 
     # Обычный текст — сначала Groq (1000/день против 50 у OpenRouter), дальше OpenRouter, Gemini резервом.
+    # Тяжёлый — тоже с Groq первой: свободная квота Groq-Tier экономит scarce-квоты
+    # OR/Gemini (аудит D3, 30.09.2026); не потянет — цепочка уйдёт дальше сама.
     if is_heavy:
-        return _or_route(_OR_HEAVY_ORDER) + _gemini_route(GEMINI_HEAVY_CHAIN)
+        return _groq_route(_GROQ_LIGHT_ORDER) + _or_route(_OR_HEAVY_ORDER) + _gemini_route(GEMINI_HEAVY_CHAIN)
     return _groq_route(_GROQ_LIGHT_ORDER) + _or_route(_OR_LIGHT_ORDER) + _gemini_route(GEMINI_SEARCH_CHAIN)

lumen_tiktok.py

@@ -347,9 +347,11 @@ def _checked_redirect_url(current_url: str, location: str | None) -> str | None:
     return next_url
 
 
-async def _download_url_bin(session: aiohttp.ClientSession, url: str, headers: dict | None = None) -> bytes | None:
+async def _download_url_bin(session: aiohttp.ClientSession, url: str, headers: dict | None = None, *, cap_bytes: int | None = None) -> bytes | None:
     # URL — из JSON чужого сервиса (TikWM): качаем только http(s) (AUD-D-003)
-    # и только с публичных адресов (SSRF-гард ниже).
+    # и только с публичных адресов (SSRF-гард ниже). cap_bytes — отдельный кап
+    # вызывающего (видео режем лимитом отправки Telegram, а не общим 75МБ).
+    cap = cap_bytes if cap_bytes is not None else TIKTOK_DOWNLOAD_MAX_BYTES
     scheme = urllib.parse.urlsplit(url).scheme.lower()
     if scheme not in ("http", "https"):
         log.warning("[download] Refusing non-HTTP(S) URL (scheme=%r).", scheme)
@@ -388,8 +390,8 @@ async def _download_url_bin(session: aiohttp.ClientSession, url: str, headers: d
                 content_length = resp.headers.get("Content-Length")
                 if content_length is not None:
                     try:
-                        if int(content_length) > TIKTOK_DOWNLOAD_MAX_BYTES:
-                            log.warning("[download] Refusing to download %s: Content-Length %s exceeds the %d byte cap.", current_url, content_length, TIKTOK_DOWNLOAD_MAX_BYTES)
+                        if int(content_length) > cap:
+                            log.warning("[download] Refusing to download %s: Content-Length %s exceeds the %d byte cap.", current_url, content_length, cap)
                             return None
                     except ValueError:
                         pass
@@ -397,8 +399,8 @@ async def _download_url_bin(session: aiohttp.ClientSession, url: str, headers: d
                 total = 0
                 async for chunk in resp.content.iter_chunked(65536):
                     total += len(chunk)
-                    if total > TIKTOK_DOWNLOAD_MAX_BYTES:
-                        log.warning("[download] Aborting download of %s: exceeded the %d byte cap mid-stream.", current_url, TIKTOK_DOWNLOAD_MAX_BYTES)
+                    if total > cap:
+                        log.warning("[download] Aborting download of %s: exceeded the %d byte cap mid-stream.", current_url, cap)
                         return None
                     chunks.append(chunk)
                 return b"".join(chunks)

lumen_tiktok_flow.py

@@ -223,14 +223,26 @@ async def _try_send_tiktok_slideshow(
          ))
           # Качаем слайды параллельно gather; конкурентность режем семафором, чтобы не занимать весь пул сессии.
          fetch_urls = _slideshow_slide_urls(media_data, images_to_fetch)
+         # Общий кап RAM на пост: больше не качаем и остаток пропускаем.
+         post_budget = [bot.TIKTOK_SLIDESHOW_MAX_BYTES]
 
          async def _download_slide_bounded(slide_url: str) -> bytes | None:
               async with bot._tiktok_slide_download_semaphore:
-                   return await bot._download_url_bin(session, slide_url, headers=headers)
+                   if post_budget[0] <= 0:
+                        return None
+                   data = await bot._download_url_bin(session, slide_url, headers=headers)
+                   if data:
+                        post_budget[0] -= len(data)
+                        if post_budget[0] < 0:
+                             return None
+                   return data
 
          downloaded = list(await asyncio.gather(
               *(_download_slide_bounded(u) for u in fetch_urls)
          ))
+         skipped_slides = sum(1 for b in downloaded if not b)
+         if skipped_slides:
+              log.warning("[tiktok] Slideshow: %d of %d slides skipped (failed or over the post size cap).", skipped_slides, len(downloaded))
          video_indices = [idx for idx, b in enumerate(downloaded) if b and _looks_like_video_bytes(b)]
          if video_indices:
               log.info('[tiktok] In the slideshow, %d of %d slides were recognized as video (live_images/magic bytes).', len(video_indices), len(downloaded))
@@ -322,7 +334,12 @@ async def _send_tiktok_single_video(
                    status_msg = bot._t(message.chat.id, "tiktok_dl_plain")
               await bot._edit_message_quietly(status, status_msg)
 
-              video_bytes = await bot._download_url_bin(session, candidate["url"], headers=headers)
+              video_bytes = await bot._download_url_bin(
+                  session, candidate["url"], headers=headers,
+                  # Видео больше лимита отправки всё равно не уйдёт — режем капом
+                  # отправки, а не общим 75МБ (аудит A7-5: 50-75МБ качались зря).
+                  cap_bytes=bot.TELEGRAM_BOT_API_UPLOAD_LIMIT_BYTES,
+              )
               if not video_bytes:
                    continue
 

tests/test_bot_admin.py

@@ -465,3 +465,52 @@ def test_message_mentions_bot_without_chat_returns_false():
 
     assert bot.message_mentions_bot(_NoChatMessage()) is False
 
+
+def test_webhook_setup_retries_then_raises(monkeypatch):
+    # Аудит D4: провал setWebhook без ретрая давал тихий мёртвый бот — теперь
+    # ретраи с бэкоффом и явный отказ вместо молчания.
+    sleeps = []
+
+    async def fast_sleep(delay):
+        sleeps.append(delay)
+
+    async def always_fail(method, *args, **kwargs):
+        if method == "getMe":
+            return {"username": "testbot"}
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr(bot.asyncio, "sleep", fast_sleep)
+    monkeypatch.setattr(bot, "SETWEBHOOK_MAX_ATTEMPTS", 3)
+    _patch_startup(monkeypatch, always_fail)
+    with pytest.raises(RuntimeError, match="setWebhook"):
+        asyncio.run(bot._webhook_startup())
+    assert sleeps == [1.5, 5.0, 10.0]
+
+
+def test_webhook_setup_succeeds_after_retries(monkeypatch):
+    # Сторож: два провала подряд — третий регистрирует, стартап живёт дальше.
+    calls = {"hook": 0}
+    sleeps = []
+
+    async def fast_sleep(delay):
+        sleeps.append(delay)
+        if len(sleeps) > 3:
+            raise asyncio.CancelledError
+
+    async def flaky(method, *args, **kwargs):
+        if method == "getMe":
+            return {"username": "testbot"}
+        if method == "setWebhook":
+            calls["hook"] += 1
+            if calls["hook"] < 3:
+                raise RuntimeError("boom")
+            return True
+        return {}
+
+    monkeypatch.setattr(bot.asyncio, "sleep", fast_sleep)
+    _patch_startup(monkeypatch, flaky)
+    with pytest.raises(asyncio.CancelledError):
+        asyncio.run(bot._webhook_startup())
+    assert calls["hook"] == 3
+    assert sleeps == [1.5, 5.0, 10.0, 3600]
+

tests/test_bot_state.py

@@ -9,6 +9,7 @@ from unittest.mock import MagicMock
 from unittest.mock import patch
 import asyncio
 import bot
+import pytest
 import contextlib
 import json
 import logging
@@ -1147,8 +1148,8 @@ def test_process_media_group_buffers_cleanup_on_cancel():
 def test_process_media_group_buffers_fetches_extras_in_parallel_keeping_order(monkeypatch):
     # Скачивание осталось параллельным (после проверки лимита, до обработки).
     monkeypatch.setattr(bot, "_reject_rate_limited_message", AsyncMock(return_value=False))
-    # Альбом качается параллельно: медленное первое фото не должно задерживать остальные,
-    # а порядок вложений обязан совпасть с порядком сообщений.
+    # Альбом качается параллельно, но bounded семафором (аудит D1): in-flight
+    # память ограничена, а порядок вложений обязан совпасть с порядком сообщений.
     chat_id = 999961
     user = SimpleNamespace(id=778)
 
@@ -1185,8 +1186,8 @@ def test_process_media_group_buffers_fetches_extras_in_parallel_keeping_order(mo
     bot._mg_buffers["mg2"] = msgs
     try:
         asyncio.run(bot._process_media_group_buffers("mg2"))
-        # Все 4 доп. фото качались одновременно, а не по очереди.
-        assert max_concurrent == 4
+        # Три доп. фото in-flight одновременно (семафор), четвёртое ждёт слота.
+        assert max_concurrent == 3
         assert [b for b, _ in captured["extra"]] == [b"file_1", b"file_2", b"file_3", b"file_4"]
     finally:
         bot._fetch_media = original_fetch
@@ -2442,3 +2443,151 @@ def test_acquire_chat_lock_retakes_after_registry_swap(monkeypatch):
             lock.release()
     finally:
         bot._chat_locks.pop(chat_id, None)
+
+
+# ─────────────── B1: капы размеров (D1) ───────────────
+
+def test_download_refuses_oversize_by_declared_size(monkeypatch):
+    # Аудит D1/A6-1: заявленный размер больше капа — отказ до скачивания.
+    import lumen_media_flow
+
+    async def fake_get_file(file_id):
+        return SimpleNamespace(file_path="photos/x.jpg", file_size=10 ** 12)
+
+    def must_not_run(*args, **kwargs):
+        raise AssertionError("no network for oversize file")
+
+    monkeypatch.setattr(bot, "bot", SimpleNamespace(get_file=fake_get_file))
+    monkeypatch.setattr(bot, "_get_telegram_session", must_not_run)
+    with pytest.raises(lumen_media_flow._MediaTooLargeError):
+        asyncio.run(bot._download_telegram_file_bytes("fid"))
+
+
+def test_download_aborts_mid_stream_over_cap(monkeypatch):
+    # Аудит D1/A6-1: враньё в Content-Length — потоковый кап по факту.
+    import lumen_media_flow
+    from tests.bot_test_helpers import _FakeDownloadContent
+
+    async def fake_get_file(file_id):
+        return SimpleNamespace(file_path="photos/x.jpg", file_size=None)
+
+    class _Resp:
+        status = 200
+        headers = {}
+
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, *args):
+            return False
+
+        def raise_for_status(self):
+            pass
+
+    _Resp.content = _FakeDownloadContent([b"y" * (2 * 1024 * 1024)] * 3)
+
+    class _Session:
+        def get(self, *args, **kwargs):
+            return _Resp()
+
+    async def fake_session():
+        return _Session()
+
+    monkeypatch.setattr(bot, "bot", SimpleNamespace(get_file=fake_get_file))
+    monkeypatch.setattr(bot, "_get_telegram_session", fake_session)
+    monkeypatch.setattr(bot, "TELEGRAM_DOWNLOAD_MAX_BYTES", 1024 * 1024)
+    with pytest.raises(lumen_media_flow._MediaTooLargeError):
+        asyncio.run(bot._download_telegram_file_bytes("fid"))
+
+
+def test_oversize_attachment_gets_honest_refusal(monkeypatch):
+    # Аудит D1: большой файл — понятный текст, а не слепой ответ.
+    chat_id = 999982
+    sent = {}
+
+    async def fake_to_tmp(source):
+        raise bot._MediaTooLargeError(10 ** 12, 20 * 1024 * 1024)
+
+    async def fake_reply(message, text, **kwargs):
+        sent["text"] = text
+
+    monkeypatch.setattr(bot, "_download_message_attachment_to_tmp", fake_to_tmp)
+    monkeypatch.setattr(bot, "_safe_reply", fake_reply)
+    bot.get_state(chat_id)["lang"] = "ru"
+    msg = _FakeIncomingMessage(chat_id)
+    msg.text = None
+    msg.caption = None
+    msg.photo = [SimpleNamespace(file_id="big", mime_type="video/mp4")]
+    msg.from_user = SimpleNamespace(id=555)
+    try:
+        asyncio.run(bot._handle_message_core(msg))
+        assert "20" in sent.get("text", "") and "большой" in sent["text"]
+    finally:
+        bot.chat_state.pop(chat_id, None)
+
+
+def test_album_skips_files_over_running_total(monkeypatch):
+    # Аудит D1/A4-04: суммарный кап extra-файлов альбома.
+    import lumen_message_core
+    monkeypatch.setattr(lumen_message_core, "_ALBUM_EXTRA_MAX_BYTES", 100)
+
+    async def big_fetch(fid, mime):
+        return (b"z" * 60, mime)
+
+    async def allow_all(message):
+        return False
+
+    seen = {}
+
+    async def fake_core(message, extra_media=None):
+        seen["extra"] = extra_media
+
+    monkeypatch.setattr(bot, "_fetch_media", big_fetch)
+    monkeypatch.setattr(bot, "_reject_rate_limited_message", allow_all)
+    monkeypatch.setattr(bot, "_handle_message_core", fake_core)
+    chat_id = 999983
+    try:
+        asyncio.run(lumen_message_core._process_media_group_buffers_locked(
+            [_album_message(chat_id, caption="опиши")] +
+            [_album_message(chat_id, file_id=f"f{i}") for i in range(4)]
+        ))
+        assert seen["extra"] is not None and len(seen["extra"]) == 1
+    finally:
+        bot.chat_state.pop(chat_id, None)
+
+
+def test_album_downloads_bounded_concurrency(monkeypatch):
+    # Аудит D1/A6-2: in-flight скачивания альбома ограничены семафором.
+    import lumen_message_core
+    live = {"cur": 0, "max": 0}
+
+    async def slow_fetch(fid, mime):
+        live["cur"] += 1
+        live["max"] = max(live["max"], live["cur"])
+        try:
+            await asyncio.sleep(0.02)
+            return (b"z", mime)
+        finally:
+            live["cur"] -= 1
+
+    async def allow_all(message):
+        return False
+
+    seen = {}
+
+    async def fake_core(message, extra_media=None):
+        seen["extra"] = extra_media
+
+    monkeypatch.setattr(bot, "_fetch_media", slow_fetch)
+    monkeypatch.setattr(bot, "_reject_rate_limited_message", allow_all)
+    monkeypatch.setattr(bot, "_handle_message_core", fake_core)
+    chat_id = 999984
+    try:
+        asyncio.run(lumen_message_core._process_media_group_buffers_locked(
+            [_album_message(chat_id, caption="опиши")] +
+            [_album_message(chat_id, file_id=f"f{i}") for i in range(9)]
+        ))
+        assert live["max"] <= 3
+        assert seen["extra"] is not None and len(seen["extra"]) == 9
+    finally:
+        bot.chat_state.pop(chat_id, None)

tests/test_bot_tiktok.py

@@ -523,7 +523,7 @@ def test_handle_tiktok_single_video_happy_path():
     async def fake_resolve(session, url):
         return url  # ссылка уже "разрешена", не короткая
 
-    async def fake_download_url_bin(session, url, headers=None):
+    async def fake_download_url_bin(session, url, headers=None, cap_bytes=None):
         return b"\x00" * 100  # не видео-байты (не ftyp) — не важно для этого теста
 
     async def fake_probe_dims(path):
@@ -589,7 +589,7 @@ def test_handle_tiktok_slideshow_video_probing_respects_concurrency_cap():
     async def fake_resolve(session, url):
         return url
 
-    async def fake_download_url_bin(session, url, headers=None):
+    async def fake_download_url_bin(session, url, headers=None, cap_bytes=None):
         return video_bytes
 
     async def fake_probe_and_thumbnail(item_bytes):
@@ -663,7 +663,7 @@ def test_handle_tiktok_slideshow_download_respects_concurrency_cap():
     async def fake_resolve(session, url):
         return url
 
-    async def fake_download_url_bin(session, url, headers=None):
+    async def fake_download_url_bin(session, url, headers=None, cap_bytes=None):
         nonlocal current_concurrent, max_concurrent_seen
         async with lock:
             current_concurrent += 1
@@ -1449,7 +1449,7 @@ def test_single_video_status_deleted_after_music():
     async def fake_resolve(session, url):
         return url
 
-    async def fake_download_url_bin(session, url, headers=None):
+    async def fake_download_url_bin(session, url, headers=None, cap_bytes=None):
         return b"\x00" * 100
 
     async def fake_probe_dims(path):
@@ -1625,3 +1625,51 @@ def test_looks_like_video_bytes_true_for_webm_ebml():
     # A7-9: WebM-слайд раньше принимался за фото.
     assert bot._looks_like_video_bytes(b"\x1a\x45\xdf\xa3" + b"\x00" * 16) is True
 
+
+def test_download_url_bin_honors_caller_cap():
+    # Аудит A7-5: видео режем лимитом отправки (50МБ), а не общим 75МБ.
+    mapping = {"http://8.8.8.8/v.mp4": _FakeDownloadResponse([b"123456789012345"])}
+    session = _RedirectDownloadSession(mapping)
+    result = asyncio.run(lumen_tiktok._download_url_bin(
+        session, "http://8.8.8.8/v.mp4", cap_bytes=10))
+    assert result is None
+
+
+def test_slideshow_stops_at_post_budget(monkeypatch):
+    # Аудит D1/A7-1: общий кап RAM на пост — остаток слайдов пропускается.
+    calls = {}
+
+    async def fake_download(session, url, headers=None):
+        return b"k" * 1024
+
+    class _FakeTgBot:
+        async def send_photo(self, **kwargs):
+            calls["photo"] = calls.get("photo", 0) + 1
+
+        async def send_video(self, **kwargs):
+            calls["video"] = calls.get("video", 0) + 1
+
+        async def send_media_group(self, **kwargs):
+            calls["group"] = calls.get("group", 0) + 1
+
+    async def fake_edit(*args, **kwargs):
+        return True
+
+    monkeypatch.setattr(bot, "TIKTOK_SLIDESHOW_MAX_BYTES", 1500)
+    monkeypatch.setattr(bot, "_download_url_bin", fake_download)
+    monkeypatch.setattr(bot, "_edit_message_quietly", fake_edit)
+    monkeypatch.setattr(bot, "_delete_message_quietly", fake_edit)
+    monkeypatch.setattr(bot, "bot", _FakeTgBot())
+    incoming = _FakeIncomingMessage(999985)
+    incoming.message_id = 7
+    media_data = {"images": ["http://x/1.jpg", "http://x/2.jpg", "http://x/3.jpg"]}
+    try:
+        result = asyncio.run(bot._try_send_tiktok_slideshow(
+            None, media_data, incoming, None, "author", {},
+        ))
+        assert result is True
+        assert calls.get("photo") == 1
+        assert "group" not in calls
+    finally:
+        bot.chat_state.pop(999985, None)
+

tests/test_bot_tts.py

@@ -413,3 +413,67 @@ def test_pcm_to_wav_rejects_non_wav_riff():
     assert out.startswith(b"RIFF") and out[8:12] == b"WAVE"
     assert lumen_tts.pcm_to_wav(b"RIFFxxxxWAVE....") == b"RIFFxxxxWAVE...."
 
+
+def test_inline_tts_zero_budget_never_synthesizes(monkeypatch):
+    # Аудит D2: нулевой общий бюджет — синтез не стартует вообще, сразу честная ошибка.
+    import lumen_commands
+
+    async def must_not_synthesize(text):
+        raise AssertionError("synthesis must not start on zero budget")
+
+    monkeypatch.setattr(bot, "TTS_TOTAL_BUDGET_SEC", 0)
+    monkeypatch.setattr(lumen_commands, "_synthesize_tts_voice", must_not_synthesize)
+    incoming = _FakeIncomingMessage(999986)
+    incoming.message_id = 12350
+    original_bot = bot.bot
+    bot.bot = _FakeVoiceBot()
+    try:
+        asyncio.run(bot.inline_tts(incoming, "Привет, мир"))
+        shown = [text for msg in incoming.sent for text, _ in msg.edits]
+        assert shown, "пользователь должен увидеть ошибку, а не тишину"
+    finally:
+        bot.bot = original_bot
+        bot.chat_state.pop(999986, None)
+
+
+def test_inline_tts_sends_partial_with_shortened_note(monkeypatch):
+    # Аудит D2: второй кусок завис — первый уходит, пользователь узнаёт об обрезке.
+    import lumen_commands
+
+    class _CountingVoiceBot(_FakeVoiceBot):
+        def __init__(self):
+            super().__init__()
+            self.voice_count = 0
+
+        async def send_voice(self, **kwargs):
+            self.voice_count += 1
+            return await super().send_voice(**kwargs)
+
+    calls = {"n": 0}
+
+    async def flaky_synth(text):
+        calls["n"] += 1
+        if calls["n"] > 1:
+            await asyncio.sleep(30)
+        return (b"audio1", "speech.ogg", 5)
+
+    sent = {}
+
+    async def fake_reply(message, text, **kwargs):
+        sent["text"] = text
+
+    monkeypatch.setattr(bot, "TTS_TOTAL_BUDGET_SEC", 0.3)
+    monkeypatch.setattr(lumen_commands, "_synthesize_tts_voice", flaky_synth)
+    monkeypatch.setattr(bot, "_safe_reply", fake_reply)
+    voice_bot = _CountingVoiceBot()
+    monkeypatch.setattr(bot, "bot", voice_bot)
+    incoming = _FakeIncomingMessage(999987)
+    incoming.message_id = 12351
+    bot.get_state(999987)["lang"] = "ru"
+    try:
+        asyncio.run(bot.inline_tts(incoming, "x" * 900))
+        assert voice_bot.voice_count == 1
+        assert "сокращ" in sent.get("text", "")
+    finally:
+        bot.chat_state.pop(999987, None)
+

tests/test_lumen_router_config.py

@@ -161,8 +161,11 @@ def test_build_route_plain_text_prefers_groq_to_save_quotas():
 
 
 def test_build_route_heavy_plain_text_uses_strong_openrouter_models_first():
+    # ОБНОВЛЕНО (аудит D3, 30.09.2026): тяжёлый текст идёт через Groq головой
+    # (свободные 1000/день экономят scarce-квоты OR/Gemini), дальше сильные OR.
     route = lumen_router_config._build_route(needs_youtube=False, needs_website=False, media_mime=None, is_heavy=True, needs_freshness=False)
-    assert route[0] == ("openrouter", "nvidia/nemotron-3-ultra-550b-a55b:free")
+    assert route[0] == ("groq", "qwen/qwen3.8-27b")
+    assert route[2] == ("openrouter", "nvidia/nemotron-3-ultra-550b-a55b:free")
 
 
 def test_build_route_image_without_freshness_prefers_openrouter_vision():
@@ -186,6 +189,9 @@ def test_build_route_image_with_freshness_forces_gemini_search_chain():
     # См. обновлённый GEMINI_SEARCH_CHAIN (24.07.2026) — реальная квота на search
     # grounding подтверждена только у Gemini 2.5, не у 3.x lite-моделей.
     assert route[0][1] == "gemini-2.5-flash"
+    # ОБНОВЛЕНО (аудит D3, 30.09.2026): дальше vision OpenRouter резервом без
+    # поиска — раньше при исчерпании Gemini пользователь получал ошибку квоты.
+    assert any(p == "openrouter" for p, _ in route)
 
 
 def test_or_route_excludes_uncensored_and_dead_models():