Harden identity/output filters, quotas, history and deploy guards after the security audit

.github/workflows/deploy-proxy.yml

@@ -31,9 +31,10 @@ concurrency:
 jobs:
   deploy:
     # Авто: только пуши в ЭТОТ репозиторий с зелёным CI (та же защита от форков, что в sync-to-hf.yml).
-    # Вручную: всегда (для ручного запуска и нужен отдельный пункт).
+    # Вручную: только main — иначе ветка с изменённым proxy.ts получала бы
+    # production OIDC и могла читать токен бота (аудит 28.10.2026).
     if: >-
-      github.event_name == 'workflow_dispatch' ||
+      (github.event_name == 'workflow_dispatch' && github.ref == 'refs/heads/main') ||
       (github.event.workflow_run.conclusion == 'success'
       && github.event.workflow_run.event == 'push'
       && github.event.workflow_run.head_repository.full_name == github.repository)

.github/workflows/persona-eval.yml

@@ -38,6 +38,9 @@ concurrency:
 
 jobs:
   eval:
+    # Секреты провайдеров не должны достаться ветке с чужим eval-скриптом:
+    # ручной запуск разрешён только с main (аудит 28.10.2026).
+    if: github.ref == 'refs/heads/main'
     runs-on: ubuntu-latest
     timeout-minutes: 120
     steps:

.github/workflows/sync-to-hf.yml

@@ -47,7 +47,16 @@ jobs:
         run: |
           set -euo pipefail
           git remote add hf "https://user:${HF_TOKEN}@huggingface.co/spaces/${HF_SPACE_REPO}"
-          # Lease вместо голого force: хотфикс, залитый напрямую на Space,
-          # честно уронит push вместо молчаливого отката.
           git fetch hf main || true
-          git push hf HEAD:main --force-with-lease
+          # Хотфикс, залитый напрямую на Space, нельзя молча перезаписать:
+          # сначала проверяем, что удалённая ветка — предок деплоимого коммита,
+          # и только потом пушим с lease на конкретный SHA (аудит 28.10.2026).
+          if git rev-parse --verify -q hf/main >/dev/null; then
+            if ! git merge-base --is-ancestor hf/main HEAD; then
+              echo "HF Space has commits not in this deploy branch (hotfix?) — refusing to overwrite." >&2
+              exit 1
+            fi
+            git push hf HEAD:main --force-with-lease=main:"$(git rev-parse hf/main)"
+          else
+            git push hf HEAD:main
+          fi

bot.py

@@ -322,6 +322,11 @@ if SENTRY_DSN:
         # Только трекинг ошибок (трейсинг выключен — бережём квоту Sentry 5000 событий/мес).
         traces_sample_rate=0.0,
         send_default_pii=False,
+        # Локальные переменные и тела запросов содержат промпты и историю:
+        # before_send чистит только точные секреты, поэтому не отправляем их вовсе
+        # (аудит 28.10.2026).
+        include_local_variables=False,
+        max_request_body_size="never",
     )
     log.info('[setup] Sentry error tracking enabled.')
 
@@ -441,6 +446,11 @@ DRAW_TOTAL_BUDGET_SEC = _env_number("DRAW_TOTAL_BUDGET_SEC", 120, min_value=1)
 # озвучка — до конца синтеза. Это осознанно (один чат — одно дело за раз), но
 # второй вопрос во время длинной отрисовки честно получит «занято» через 45с.
 CHAT_LOCK_TIMEOUT_SEC = _env_number("CHAT_LOCK_TIMEOUT_SEC", 45, min_value=1)
+# Сколько сообщений одного чата могут ЖДАТЬ лок одновременно. Раньше сотня
+# сообщений занимала все 100 in-flight слотов, и другие чаты получали 503
+# (аудит 28.10.2026). Четвёртый и следующие сразу получают «занято».
+_MAX_CHAT_LOCK_WAITERS = 3
+_chat_lock_waiters: dict[int, int] = {}
 # INFLIGHT_TASKS_SHUTDOWN_TIMEOUT_SEC — сколько main() при остановке ждёт штатного
 # завершения fire-and-forget задач перед отменой остатка (Sentry LUMEN-2: event loop убивал их посреди сетевых вызовов при редеплое).
 INFLIGHT_TASKS_SHUTDOWN_TIMEOUT_SEC = _env_number("INFLIGHT_TASKS_SHUTDOWN_TIMEOUT_SEC", 10, min_value=0)
@@ -544,6 +554,8 @@ from lumen_chat_state import (
     _user_daily_gemini_exhausted,
     _user_daily_tts_exhausted,
     _record_user_daily,
+    _reserve_user_daily,
+    _refund_user_daily,
     _user_key_for_message,
     _user_daily_reset_in,
     _trim_history,
@@ -924,6 +936,8 @@ __all__ = [
     "_user_daily_gemini_exhausted",
     "_user_daily_tts_exhausted",
     "_record_user_daily",
+    "_reserve_user_daily",
+    "_refund_user_daily",
     "_user_key_for_message",
     "_user_daily_reset_in",
     # Имена остальных вынесенных модулей — только для `bot.X` в тестах.
@@ -1364,15 +1378,29 @@ async def _handle_message(message: Message) -> None:
 
     remaining = _msg_remaining_sec()
     lock_timeout = CHAT_LOCK_TIMEOUT_SEC if remaining is None else max(1.0, min(CHAT_LOCK_TIMEOUT_SEC, remaining))
-    try:
-        lock = await acquire_chat_lock(chat_id, lock_timeout)
-    except asyncio.TimeoutError:
-        log.warning("[lock] Timeout waiting for lock on chat %s", chat_id)
+    waiters = _chat_lock_waiters.get(chat_id, 0)
+    if waiters >= _MAX_CHAT_LOCK_WAITERS:
+        log.warning("[lock] Too many waiters for chat %s", chat_id)
         with contextlib.suppress(Exception):
-             # Ответ без создания чата: обычный _t через get_state завёл бы запись
-             # даже тому, кого отшили «занято» (та же причина, что у лимита).
-             await _tg_call(message.reply, _t_no_create(chat_id, "lock_busy"))
+            await _tg_call(message.reply, _t_no_create(chat_id, "lock_busy"))
         return
+    _chat_lock_waiters[chat_id] = waiters + 1
+    try:
+        try:
+            lock = await acquire_chat_lock(chat_id, lock_timeout)
+        except asyncio.TimeoutError:
+            log.warning("[lock] Timeout waiting for lock on chat %s", chat_id)
+            with contextlib.suppress(Exception):
+                 # Ответ без создания чата: обычный _t через get_state завёл бы запись
+                 # даже тому, кого отшили «занято» (та же причина, что у лимита).
+                 await _tg_call(message.reply, _t_no_create(chat_id, "lock_busy"))
+            return
+    finally:
+        left = _chat_lock_waiters.get(chat_id, 1) - 1
+        if left > 0:
+            _chat_lock_waiters[chat_id] = left
+        else:
+            _chat_lock_waiters.pop(chat_id, None)
 
     try:
          await _handle_message_core(message)

lumen_chat_state.py

@@ -1278,6 +1278,41 @@ def _record_user_daily(user_id: int | None, *, gemini: bool = False, tts: bool =
     bot.mark_quota_dirty()
 
 
+def _reserve_user_daily(user_id: int | None, *, total: int = 0, tts: int = 0) -> bool:
+    """Атомарно резервирует счётчики ДО первого await: параллельные /tts иначе
+    читали 0 и обходили дневной лимит (аудит 28.10.2026). Возвращает False,
+    если резерв не влезает; счётчики в этом случае не меняются."""
+    import bot
+    if user_id is None or bot._is_owner(user_id):
+        return True
+    entry = _user_daily_entry(user_id)
+    used_total = int(entry.get("total") or 0)
+    used_tts = int(entry.get("tts") or 0)
+    if used_total + total > _user_daily_limit(user_id, "total", entry):
+        return False
+    if used_tts + tts > _user_daily_limit(user_id, "tts", entry):
+        return False
+    entry["total"] = used_total + total
+    if tts:
+        entry["tts"] = used_tts + tts
+    bot.mark_quota_dirty()
+    return True
+
+
+def _refund_user_daily(user_id: int | None, *, total: int = 0, tts: int = 0) -> None:
+    """Возвращает неиспользованный резерв (синтез/отправка не удались)."""
+    import bot
+    if user_id is None or bot._is_owner(user_id):
+        return
+    if not total and not tts:
+        return
+    entry = _user_daily_entry(user_id)
+    entry["total"] = max(0, int(entry.get("total") or 0) - total)
+    if tts:
+        entry["tts"] = max(0, int(entry.get("tts") or 0) - tts)
+    bot.mark_quota_dirty()
+
+
 def _user_key_for_message(message: Any) -> int | None:
     """user_id автора или ближайший устойчивый идентификатор (как у rate limit)."""
     if message is None:

lumen_commands.py

@@ -348,28 +348,33 @@ async def inline_tts(message: Message, text: str) -> None:
     # Считаем сразу все чанки: каждый — отдельный синтез, иначе длинный текст
     # уводил бы счётчик за лимит.
     uid = bot._user_key_for_message(message)
-    _tts_entry = bot._user_daily_peek(uid)
-    try:
-        _tts_over_total = int((_tts_entry or {}).get("total") or 0) + len(chunks) > bot._user_daily_limit(uid, "total", _tts_entry)
-        _tts_over_tts = int((_tts_entry or {}).get("tts") or 0) + len(chunks) > bot._user_daily_limit(uid, "tts", _tts_entry)
-    except (TypeError, ValueError):
-        _tts_over_total = _tts_over_tts = False
-    if bot._user_daily_total_exhausted(uid, _tts_entry) or _tts_over_total:
-        hours, mins = bot._user_daily_reset_in()
-        # Суточный счётчик /stats: отказ по лимиту, озвучки не будет.
-        bot._record_stats_event("daily_limit_denials")
-        await bot._safe_reply(message, bot._t(
-            message.chat.id, "user_daily_total",
-            used=(_tts_entry or {}).get("total", 0), limit=bot._user_daily_limit(uid, "total", _tts_entry),
-            hours=hours, mins=mins,
-        ))
-        return
-    if bot._user_daily_tts_exhausted(uid, _tts_entry) or _tts_over_tts:
-        bot._record_stats_event("daily_limit_denials")
-        await bot._safe_reply(message, bot._t(
-            message.chat.id, "user_daily_tts",
-            used=(_tts_entry or {}).get("tts", 0), limit=bot._user_daily_limit(uid, "tts", _tts_entry),
-        ))
+    # Атомарный резерв ДО первого await: параллельные /tts раньше читали 0
+    # и обходили дневной лимит (аудит 28.10.2026). Резерв списывает сразу все
+    # чанки, потому что каждый — отдельный синтез за квоту.
+    if not bot._reserve_user_daily(uid, total=len(chunks), tts=len(chunks)):
+        _tts_entry = bot._user_daily_peek(uid)
+        try:
+            _tts_over_total = int((_tts_entry or {}).get("total") or 0) + len(chunks) > bot._user_daily_limit(uid, "total", _tts_entry)
+            _tts_over_tts = int((_tts_entry or {}).get("tts") or 0) + len(chunks) > bot._user_daily_limit(uid, "tts", _tts_entry)
+        except (TypeError, ValueError):
+            _tts_over_total = _tts_over_tts = False
+        if bot._user_daily_total_exhausted(uid, _tts_entry) or _tts_over_total:
+            hours, mins = bot._user_daily_reset_in()
+            # Суточный счётчик /stats: отказ по лимиту, озвучки не будет.
+            bot._record_stats_event("daily_limit_denials")
+            await bot._safe_reply(message, bot._t(
+                message.chat.id, "user_daily_total",
+                used=(_tts_entry or {}).get("total", 0), limit=bot._user_daily_limit(uid, "total", _tts_entry),
+                hours=hours, mins=mins,
+            ))
+            return
+        if bot._user_daily_tts_exhausted(uid, _tts_entry) or _tts_over_tts:
+            bot._record_stats_event("daily_limit_denials")
+            await bot._safe_reply(message, bot._t(
+                message.chat.id, "user_daily_tts",
+                used=(_tts_entry or {}).get("tts", 0), limit=bot._user_daily_limit(uid, "tts", _tts_entry),
+            ))
+            return
         return
     status = await bot._tg_call(message.reply, bot._t(message.chat.id, "status_voicing"))
     # Общий дедлайн на все чанки: зависший синтез иначе держал per-chat lock без края.
@@ -404,6 +409,7 @@ async def inline_tts(message: Message, text: str) -> None:
         # Статус уже снесён выше (перед send_voice): если правка не прошла — дублируем реплаем.
         if not await bot._edit_message_quietly(status, user_err):
             await bot._safe_reply(message, user_err)
+        bot._refund_user_daily(uid, total=len(chunks), tts=len(chunks))
         return
     await bot._delete_message_quietly(status)
     for i, (final_audio, final_filename, voice_duration) in enumerate(voices):
@@ -418,9 +424,13 @@ async def inline_tts(message: Message, text: str) -> None:
             call_timeout=bot.TELEGRAM_MEDIA_TIMEOUT,
         )
         if sent is None:
+            # Неотправленные чанки возвращаем в лимит: резерв списал их заранее.
+            bot._refund_user_daily(uid, total=len(chunks) - i, tts=len(chunks) - i)
             raise RuntimeError("Telegram send_voice failed: connection timeout or proxy unavailable")
-        # Каждый чанк — отдельный синтез за квоту: списываем поштучно.
-        bot._record_user_daily(uid, tts=True)
+    unsent = len(chunks) - len(voices)
+    if unsent > 0:
+        # Обрезка по общему дедлайну: за несозданные чанки не списываем.
+        bot._refund_user_daily(uid, total=unsent, tts=unsent)
     bot._record_stats_event("answers_sent")
     if shortened:
         # Обрезка по общему дедлайну — говорим прямо, что озвучено начало.
@@ -454,6 +464,10 @@ async def cmd_reset(message: Message) -> None:
     state = bot.get_state(message.chat.id)
     state["history"] = []
     state["ctx"].clear()
+    # Сброс должен забывать и ссылки на медиа/имена: иначе старые файлы
+    # всплывали после /reset (аудит 28.10.2026).
+    state.get("recent_media_ids", {}).clear()
+    state.get("user_names", {}).clear()
     bot.mark_state_dirty(message.chat.id)
     await bot._tg_call(
         message.reply,

lumen_formatting.py

@@ -6,6 +6,24 @@ lumen_formatting.py — markdown Lumen в Telegram HTML.
 from __future__ import annotations
 
 import re
+from urllib.parse import urlparse
+
+_URL_LABEL_RE = re.compile(r"^(?:https?://|www\.)", re.IGNORECASE)
+
+
+def _safe_link_label(label: str, url: str) -> str:
+    """Метка-URL, ведущая на другой хост, — готовый фишинг: показываем реальный
+    адрес. Обычные текстовые метки ("Reuters") не трогаем (аудит 28.10.2026)."""
+    if not _URL_LABEL_RE.match(label.strip()):
+        return label
+    try:
+        label_host = urlparse(label if "://" in label else "https://" + label).netloc.lower()
+        url_host = urlparse(url).netloc.lower()
+    except ValueError:
+        return label
+    if label_host and url_host and label_host != url_host:
+        return url
+    return label
 
 _TABLE_SEP_RE = re.compile(r"^\s*\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)*\|?\s*$")
 # Регекс квадратичен на длинных пробельных хвостах: строку режем до match,
@@ -414,6 +432,7 @@ def _md_to_html(text: str) -> str:
             continue
         m = re.match(r"\[([^\[\]]+)\]\((https?://[^\s()]+)\)", orig, re.DOTALL)
         label, url = m.group(1), m.group(2)
+        label = _safe_link_label(label, url)
         label = label.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
         url = url.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace('"', "&quot;")
         text = text.replace(key, f'<a href="{url}">{label}</a>')
@@ -597,6 +616,7 @@ def _md_to_rich_html(text: str) -> str:
     for key, orig in _links.items():
         m = re.match(r"\[([^\[\]]+)\]\((https?://[^\s()]+)\)", orig, re.DOTALL)
         label, url = m.group(1), m.group(2)
+        label = _safe_link_label(label, url)
         label = label.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
         url = url.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace('"', "&quot;")
         text = text.replace(key, f'<a href="{url}">{label}</a>')

lumen_message_core.py

@@ -228,6 +228,10 @@ def _album_extra_sources(messages: list, main_msg: Any) -> list[tuple[str, str,
     return sources
 
 
+_PASSIVE_LINE_MAX_CHARS = 500
+_PASSIVE_CTX_MAX_CHARS = 12000
+
+
 def _record_passive_group_context(message: Message, state: dict[str, Any], t: str) -> None:
     """Фон группы без упоминания: только контекст и медиа в state, без ответа."""
     import bot
@@ -239,9 +243,13 @@ def _record_passive_group_context(message: Message, state: dict[str, Any], t: st
             getattr(sender, "username", None) if sender is not None else None,
             getattr(sender, "first_name", None) if sender is not None else None,
         )
-        state["ctx"].append(f"{display}: {t.strip()}")
+        state["ctx"].append(f"{display}: {t.strip()[:_PASSIVE_LINE_MAX_CHARS]}")
         # Общий лимит 100 сообщений на чат, старые фоновые уходят первыми.
         bot._trim_combined(state)
+        # Кап по символам: 100 сообщений по 4096 символов раздували промпт
+        # и позволяли одному участнику забить чужой контекст (аудит 28.10.2026).
+        while len(state["ctx"]) > 1 and sum(len(line) for line in state["ctx"]) > _PASSIVE_CTX_MAX_CHARS:
+            state["ctx"].popleft()
     bot._save_media_to_history(_msg_media_source(message), state, message.from_user.id if message.from_user else None)
     bot.mark_state_dirty(message.chat.id)
 
@@ -831,6 +839,7 @@ async def _handle_message_core(message: Message, extra_media: list[tuple[bytes,
             media=gemini_media_list, media_filename=med_name,
             youtube_url=youtube_url_to_analyze, allow_stream=allow_stream,
             deadline=route_deadline, provenance=provenance, status=status,
+            history_text=clean_prompt,
         )
         answered_grounded = answered_with_live_search(provenance)
         if needs_freshness and not snippets_injected and not answered_grounded and not reply_already_sent and not no_search_note:

lumen_routes.py

@@ -348,7 +348,7 @@ async def _or_chat_completion_with_fallback(
         stop_on=_account_wide, log_label="or", chat_id=chat_id, user_text=user_text,
     )
 
-async def ask_openrouter_text(chat_id: int, user_text: str, model_chain: list[str], *, deadline: float | None = None) -> str:
+async def ask_openrouter_text(chat_id: int, user_text: str, model_chain: list[str], *, deadline: float | None = None, history_text: str | None = None) -> str:
     import bot
     state = bot.get_state(chat_id)
     history = state.setdefault("history", [])
@@ -361,7 +361,7 @@ async def ask_openrouter_text(chat_id: int, user_text: str, model_chain: list[st
     answer, model_trial = await bot._or_chat_completion_with_fallback(messages, trial_models, primary_model_id, deadline=deadline, chat_id=chat_id, user_text=user_text)
 
     # В историю пишем текст с автором — модель видит кто спрашивал.
-    history.append({"role": "user", "content": _history_user_text(user_text)})
+    history.append({"role": "user", "content": _history_user_text(history_text or user_text)})
     history.append({"role": "assistant", "content": answer})
     # Обрезка с саммари старого (см. _trim_history), а не молчаливый срез.
     await bot._trim_history(history)
@@ -403,7 +403,7 @@ def _trim_messages_for_groq(messages: list[dict]) -> list[dict]:
     kept.reverse()
     return [head] + kept + ([tail] if len(messages) > 1 else [])
 
-async def ask_groq_text(chat_id: int, user_text: str, model_chain: list[str], *, deadline: float | None = None) -> str:
+async def ask_groq_text(chat_id: int, user_text: str, model_chain: list[str], *, deadline: float | None = None, history_text: str | None = None) -> str:
     """Обычный текстовый запрос через прямой Groq — по образцу ask_openrouter_text: одна попытка на модель, скраб утечек, расход в квоту "groq". Сообщения строит общий _build_openrouter_turn_messages (тот же OpenAI-формат). Историю под запрос режет _trim_messages_for_groq (иначе см. его комментарий)."""
     import bot
     from lumen_router_config import _GROQ_LIGHT_ORDER
@@ -427,7 +427,7 @@ async def ask_groq_text(chat_id: int, user_text: str, model_chain: list[str], *,
     )
 
     # В историю пишем текст пользователя с автором, как у остальных провайдеров.
-    history.append({"role": "user", "content": _history_user_text(user_text)})
+    history.append({"role": "user", "content": _history_user_text(history_text or user_text)})
     history.append({"role": "assistant", "content": answer})
     # Обрезка с саммари старого (см. _trim_history), а не молчаливый срез.
     await bot._trim_history(history)
@@ -562,7 +562,7 @@ async def _transcribe_audio(audio_bytes: bytes, mime: str, chat_id: int, deadlin
 
 async def ask_openrouter_multimodal(
     chat_id: int, user_text: str, media_tuple: tuple[bytes, str] | list[tuple[bytes, str]], media_filename: str,
-    model_chain: list[str], *, deadline: float | None = None,
+    model_chain: list[str], *, deadline: float | None = None, history_text: str | None = None,
 ) -> str:
     """Альбом для OpenRouter: все картинки одним сообщением (content-блоки image_url подряд) —
     раньше уходила только первая, остальные 2–9 молча терялись (найдено внешним аудитом)."""
@@ -604,7 +604,7 @@ async def ask_openrouter_multimodal(
 
     answer, model_trial = await bot._or_chat_completion_with_fallback(messages, trial_models, primary_model_id, deadline=deadline, chat_id=chat_id, user_text=user_text)
 
-    history.append({"role": "user", "content": _history_user_text(user_text)})
+    history.append({"role": "user", "content": _history_user_text(history_text or user_text)})
     history.append({"role": "assistant", "content": answer})
     # Обрезка с саммари старого (см. _trim_history), а не молчаливый срез.
     await bot._trim_history(history)
@@ -800,6 +800,7 @@ async def ask_gemini(
     chat_id: int, user_text: str, media: list[tuple[bytes, str]] | None = None,
     youtube_url: str | None = None, model_chain: list[str] | None = None,
     deadline: float | None = None, provenance: dict | None = None,
+    history_text: str | None = None,
 ) -> str:
     import bot
     state = bot.get_state(chat_id)
@@ -926,7 +927,7 @@ async def ask_gemini(
     bot._record_model_outcome("gemini", curr_model_id,
                               bad=_detect_garbled_mix(ans) and not _is_garbled_echo(ans, user_text))
 
-    hist.append({"role": "user", "content": _history_user_text(user_text)})
+    hist.append({"role": "user", "content": _history_user_text(history_text or user_text)})
     hist.append({"role": "assistant", "content": ans})
     # Обрезка с саммари старого (см. _trim_history), а не молчаливый срез.
     await bot._trim_history(hist)
@@ -1000,13 +1001,16 @@ async def _run_route(
     media: list[tuple[bytes, str]] | None = None, media_filename: str = "",
     youtube_url: str | None = None, allow_stream: bool = False,
     deadline: float | None = None, provenance: dict | None = None,
-    status: Any | None = None,
+    status: Any | None = None, history_text: str | None = None,
 ) -> tuple[str, bool]:
     """Идёт по маршруту _build_route: внутри провайдера — по одной попытке на модель, при отказе всего провайдера — резервный. Возвращает (ответ, reply_already_sent)."""
     import bot
     if not route:
         raise RuntimeError("Empty route — no model to choose from.")
     route_started = time.monotonic()
+    # В историю пишем чистый запрос пользователя, а не ai_prompt со сниппетами
+    # и датой: чужой текст не должен переживать ход (аудит 28.10.2026).
+    history_text = history_text or ai_prompt
     # Порядок внутри провайдера — по измеренным задержкам; сами блоки и защита квоты Gemini не трогаем.
     route = _reorder_route_by_speed(route)
     if deadline is None:
@@ -1046,7 +1050,7 @@ async def _run_route(
         head_model = route[0][1]
         if first_provider == "gemini" and GEMINI_MODELS.get(head_model, {}).get("stream", True):
             streamed, placeholder = await bot._try_gemini_streaming(
-                chat_id, ai_prompt, message, head_model, deadline=deadline, status=status)
+                chat_id, ai_prompt, message, head_model, deadline=deadline, status=status, history_text=history_text)
             if streamed is not None:
                 log.info('[router] chat=%s response received via streaming (gemini:%s)', chat_id, head_model)
                 _count_user_answer("gemini", head_model)
@@ -1056,7 +1060,7 @@ async def _run_route(
             reusable_placeholder = placeholder
         elif first_provider == "openrouter":
             streamed, placeholder = await bot._try_openrouter_streaming(
-                chat_id, ai_prompt, message, head_model, deadline=deadline, status=status)
+                chat_id, ai_prompt, message, head_model, deadline=deadline, status=status, history_text=history_text)
             if streamed is not None:
                 log.info('[router] chat=%s response received via streaming (openrouter:%s)', chat_id, head_model)
                 _count_user_answer("openrouter")
@@ -1066,7 +1070,7 @@ async def _run_route(
             reusable_placeholder = placeholder
         elif first_provider == "groq":
             streamed, placeholder = await bot._try_groq_streaming(
-                chat_id, ai_prompt, message, head_model, deadline=deadline, status=status)
+                chat_id, ai_prompt, message, head_model, deadline=deadline, status=status, history_text=history_text)
             if streamed is not None:
                 log.info('[router] chat=%s response received via streaming (groq:%s)', chat_id, head_model)
                 _count_user_answer("groq")
@@ -1092,15 +1096,15 @@ async def _run_route(
             break
         try:
             if provider == "gemini":
-                ans = await bot.ask_gemini(chat_id, ai_prompt, media=media, youtube_url=youtube_url, model_chain=ids, deadline=deadline, provenance=provenance)
+                ans = await bot.ask_gemini(chat_id, ai_prompt, media=media, youtube_url=youtube_url, model_chain=ids, deadline=deadline, provenance=provenance, history_text=history_text)
             elif provider == "groq":
-                ans = await bot.ask_groq_text(chat_id, ai_prompt, model_chain=ids, deadline=deadline)
+                ans = await bot.ask_groq_text(chat_id, ai_prompt, model_chain=ids, deadline=deadline, history_text=history_text)
                 _note_answered("groq", None)
             elif media:
-                ans = await bot.ask_openrouter_multimodal(chat_id, ai_prompt, media, media_filename, model_chain=ids, deadline=deadline)
+                ans = await bot.ask_openrouter_multimodal(chat_id, ai_prompt, media, media_filename, model_chain=ids, deadline=deadline, history_text=history_text)
                 _note_answered("openrouter", None)
             else:
-                ans = await bot.ask_openrouter_text(chat_id, ai_prompt, model_chain=ids, deadline=deadline)
+                ans = await bot.ask_openrouter_text(chat_id, ai_prompt, model_chain=ids, deadline=deadline, history_text=history_text)
                 _note_answered("openrouter", None)
 
             if status is not None:

lumen_security.py

@@ -44,6 +44,14 @@ def _leak_scan_window(full_text: str, latest_piece: str) -> str:
     window_size = max(_LEAK_SCAN_TAIL_CHARS, len(latest_piece) + 100)
     return full_text[-window_size:]
 
+_INVISIBLE_RE = re.compile(r"[\u00ad\u200b-\u200f\u202a-\u202e\u2060-\u206f]")
+
+def _normalize_leak_text(text: str) -> str:
+    """NFKC + удаление невидимых символов: fullwidth и zero-width обходили
+    выходной фильтр (аудит 28.10.2026). Гомоглифы (кириллическая «а» в Gemini)
+    этим не покрываются — остаточный риск отмечен в отчёте."""
+    return _INVISIBLE_RE.sub("", unicodedata.normalize("NFKC", text))
+
 
 # Слой Б — только точные фразы "я — бренд". Широкое окно рядом с "я" ложно ловило
 # рассказы про бренды: "я" — частый токен, а хеджирование вроде "я не могу
@@ -51,7 +59,7 @@ def _leak_scan_window(full_text: str, latest_piece: str) -> str:
 _LEAK_BRAND_TOKENS = (
     r"(gemini|gemma|gpt[\s\-]?(?:oss|\d)[\w\-]*|chatgpt|openai|claude|anthropic|deepmind|openrouter|"
     r"nemotron|qwen|llama|glm[\s\-]?4|hermes|mistral|dolphin[\s\-]?mistral|venice|laguna|"
-    r"deepseek|grok|meta(?:\s*ai)?|google|"
+    r"deepseek|grok|meta(?:\s*ai)?|google|groq|hugging\s*face|huggingface|"
     r"lfm[\s\-]?2\.5|нейросет\w*\s+google|модел\w*\s+google|google\s*ai|google\s+gemini)"
 )
 _IDENTITY_LEAK_RE = re.compile(
@@ -65,17 +73,26 @@ _IDENTITY_LEAK_RE = re.compile(
     # Google research" честные рассказы, не самоопределение (см. ниже проверку
     # по предложениям с _FIRST_PERSON_RE).
     rf"|\bэт[оауи]\s*(?:модел\w*|нейросет\w*)\s*(?:—|-|:)?\s*{_LEAK_BRAND_TOKENS}\b"
-    rf"|\bi\s*(?:am|'m)\s+{_LEAK_BRAND_TOKENS}\b"
+    # "I am a Gemini model": артикль перед брендом — обычная формулировка,
+    # которую старый узкий шаблон пропускал (аудит 28.10.2026). Слова между
+    # артиклем и брендом не разрешаем: "I am reading about Gemini" — не утечка.
+    rf"|\bi\s*(?:am|'m)\s+(?:an?\s+)?{_LEAK_BRAND_TOKENS}\b"
     # "built on / powered by / based on бренд" тоже только от первого лица,
     # иначе честный рассказ о чужом стеке блокировался целиком.
-    rf"|\bi\s+(?:was\s+)?(?:created|made)\s+by\s+(?:the\s+|company\s+)?{_LEAK_BRAND_TOKENS}\b"
-    rf"|\bi\s*(?:am|'m)\s+from\s+(?:the\s+|company\s+)?{_LEAK_BRAND_TOKENS}\b"
+    rf"|\bi\s*(?:am|'m|was|have\s+been|'ve\s+been)\s+(?:created|made|built|developed|trained|powered)\s+by\s+(?:the\s+|company\s+)?{_LEAK_BRAND_TOKENS}\b"
+    # То же с названием роли перед глаголом: "I am an AI model made by Google".
+    rf"|\bi\s*(?:am|'m)\s+(?:an?\s+)?(?:ai|language|large\s+language|llm|text|chat)\s+(?:model|assistant|chatbot|ai)\s+(?:created|made|built|developed|trained|powered)\s+by\s+(?:the\s+|company\s+)?{_LEAK_BRAND_TOKENS}\b"
+    # "I am a language model from Google" — роль обязательна, иначе ловился бы
+    # рассказ "I am reading a book by Google" (аудит 28.10.2026).
+    rf"|\bi\s*(?:am|'m)\s+(?:an?\s+)?(?:ai|language|large\s+language|llm|text|chat)\s+(?:model|assistant|chatbot|ai)\s+(?:from|by)\s+(?:the\s+|company\s+)?{_LEAK_BRAND_TOKENS}\b"
     rf"|\bmy\s+creators?\s+(?:is|are)\s+(?:the\s+|company\s+)?{_LEAK_BRAND_TOKENS}\b"
     # "я от Google" только как короткое самоопределение (дальше пунктуация/конец):
     # "я от Google узнал..." — честная фраза, а не утечка.
     rf"|\bя\s+от\s+(?:компании\s+)?{_LEAK_BRAND_TOKENS}(?=\s*[.!?…;:,]|$)"
     rf"|\bмо[йи]\s+создател\w*\s*(?:—|-|:)?\s*(?:компани\w*\s+)?{_LEAK_BRAND_TOKENS}\b"
     rf"|\bя\s*(?:—|-|:)?\s*(?:это\s+|являюсь\s+)?(?:модел\w*|нейросет\w*)\s+от\s+(?:компании\s+)?{_LEAK_BRAND_TOKENS}\b"
+    # "Я — языковая модель Google": модель/ассистент + бренд без "от".
+    rf"|\bя\s*(?:—|-|:)?\s*(?:это\s+|являюсь\s+)?(?:языков\w*\s+|ии[\s\-]?)?(?:модел\w*|нейросет\w*|ассистент\w*|бот\w*)\s+(?:компании\s+)?{_LEAK_BRAND_TOKENS}\b"
     rf"|{_LEAK_BRAND_TOKENS}\s*,?\s*а\s+не\s+lumen\b",
     re.IGNORECASE,
 )
@@ -131,12 +148,15 @@ _INJECTED_PAYLOAD_ECHO_FALLBACK = (
 )
 
 def _detect_injected_payload_echo(text: str) -> bool:
-    return bool(text) and bool(_INJECTED_PAYLOAD_ECHO_RE.search(text))
+    if not text:
+        return False
+    return bool(_INJECTED_PAYLOAD_ECHO_RE.search(_normalize_leak_text(text)))
 
 def _detect_identity_leak(text: str) -> bool:
     """Чистая проверка без лога: дёшево вызывать на каждый кусок стрима, лог только в _scrub_identity_leak."""
     if not text:
         return False
+    text = _normalize_leak_text(text)
     if _LEAK_LITERAL_RE is not None and _LEAK_LITERAL_RE.search(text):
         return True
     if _IDENTITY_LEAK_RE.search(text):

lumen_streaming.py

@@ -237,7 +237,7 @@ async def _groq_stream_pieces(model_id: str, messages: list[dict], *, deadline:
 
 async def _run_streaming_reply(
     chat_id: int, user_text: str, message: Message, *, provider: str, model_id: str, piece_agen,
-    deadline: float | None = None, status=None,
+    deadline: float | None = None, status=None, history_text=None,
 ) -> tuple[str | None, Message | None]:
     """Стриминг: генератор кусков + плейсхолдер, чанкинг, троттлинг, обрыв при утечке/инъекции, HTML-финал, запись в историю. Возвращает (ответ, плейсхолдер): успех — (текст, None); сбой до показа — (None, плейсхолдер для следующей модели); сбой после — (показанное + пометка, None)."""
     import bot
@@ -330,7 +330,7 @@ async def _run_streaming_reply(
                         await aclose()
                 final_answer = _IDENTITY_LEAK_FALLBACK if leak_kind == "identity" else _INJECTED_PAYLOAD_ECHO_FALLBACK
                 await bot._tg_call(sent_messages[-1].edit_text, final_answer, parse_mode=None, call_timeout=15.0)
-                hist.append({"role": "user", "content": _history_user_text(user_text)})
+                hist.append({"role": "user", "content": _history_user_text(history_text or user_text)})
                 hist.append({"role": "assistant", "content": final_answer})
                 # Обрезка с саммари старого (см. _trim_history), а не молчаливый срез.
                 await bot._trim_history(hist)
@@ -353,7 +353,7 @@ async def _run_streaming_reply(
                     with contextlib.suppress(Exception):
                         await bot._tg_call(sent_messages[idx].edit_text, _md_to_html(chunks[idx]) + note, parse_mode=ParseMode.HTML, call_timeout=15.0)
                     final_answer = full_text.strip()
-                    hist.append({"role": "user", "content": _history_user_text(user_text)})
+                    hist.append({"role": "user", "content": _history_user_text(history_text or user_text)})
                     hist.append({"role": "assistant", "content": final_answer})
                     # Обрезка с саммари (см. _trim_history): молчаливый срез оставлял
                     # саммаризацию только нестриминговым путям (аудит 26.09.2026).
@@ -397,6 +397,9 @@ async def _run_streaming_reply(
             ttf_sec=(first_piece_ts - overall_start_ts) if first_piece_ts is not None else None,
         )
 
+        # Финальный скраб ДО последней правки: иначе пользователь видел ответ,
+        # который в историю уже попал очищенным (аудит 28.10.2026).
+        full_text = _scrub_identity_leak(full_text.strip(), source=f"{provider}_stream_final:{model_id}")
         # "Довывод" остатка: бэкенды одним куском в конце показывали бы "…" до самого финала. Ограничено catchup-лимитом сверху.
         final_chunks = _split_text_chunks(full_text, bot.TG_MAX_LEN)
         target_full = final_chunks[-1]
@@ -513,10 +516,11 @@ async def _run_streaming_reply(
                 await aclose()
 
     # Пустой full_text сюда не доходит — ветки "Empty response" нет.
-    final_answer = _scrub_identity_leak(full_text.strip(), source=f"{provider}_stream_final:{model_id}")
+    # Скраб уже применён до финальной правки (см. выше).
+    final_answer = full_text
     bot._record_model_outcome(provider, model_id,
                               bad=_detect_garbled_mix(full_text.strip()) and not _is_garbled_echo(full_text.strip(), user_text))
-    hist.append({"role": "user", "content": _history_user_text(user_text)})
+    hist.append({"role": "user", "content": _history_user_text(history_text or user_text)})
     hist.append({"role": "assistant", "content": final_answer})
     # Тот же _trim_history, что в нестриминговых путях (см. комментарий выше).
     await bot._trim_history(hist)
@@ -524,7 +528,7 @@ async def _run_streaming_reply(
     bot._record_quota_usage(provider, model_id)
     return final_answer, None
 
-async def _try_gemini_streaming(chat_id: int, user_text: str, message: Message, model_id: str, *, deadline: float | None = None, status=None) -> tuple[str | None, Message | None]:
+async def _try_gemini_streaming(chat_id: int, user_text: str, message: Message, model_id: str, *, deadline: float | None = None, status=None, history_text=None) -> tuple[str | None, Message | None]:
     """Обёртка _run_streaming_reply для Gemini (строит contents/config)."""
     import bot
     conf = GEMINI_MODELS.get(model_id, {})
@@ -533,21 +537,21 @@ async def _try_gemini_streaming(chat_id: int, user_text: str, message: Message,
     contents = await bot._build_gemini_turn_contents(chat_id, user_text)
     call_contents, gconfig = bot._build_gemini_call_config(model_id, contents)
     piece_agen = _gemini_stream_pieces(model_id, call_contents, gconfig, deadline=deadline)
-    return await _run_streaming_reply(chat_id, user_text, message, provider="gemini", model_id=model_id, piece_agen=piece_agen, deadline=deadline, status=status)
+    return await _run_streaming_reply(chat_id, user_text, message, provider="gemini", model_id=model_id, piece_agen=piece_agen, deadline=deadline, status=status, history_text=history_text)
 
-async def _try_openrouter_streaming(chat_id: int, user_text: str, message: Message, model_id: str, *, deadline: float | None = None, status=None) -> tuple[str | None, Message | None]:
+async def _try_openrouter_streaming(chat_id: int, user_text: str, message: Message, model_id: str, *, deadline: float | None = None, status=None, history_text=None) -> tuple[str | None, Message | None]:
     """Обёртка _run_streaming_reply для OpenRouter (SSE через chat/completions)."""
     import bot
     messages = bot._build_openrouter_turn_messages(chat_id, user_text, model_id)
     # Генератор — через bot.: тесты подменяют bot._openrouter_stream_pieces фейком.
     piece_agen = bot._openrouter_stream_pieces(model_id, messages, deadline=deadline)
-    return await _run_streaming_reply(chat_id, user_text, message, provider="openrouter", model_id=model_id, piece_agen=piece_agen, deadline=deadline, status=status)
+    return await _run_streaming_reply(chat_id, user_text, message, provider="openrouter", model_id=model_id, piece_agen=piece_agen, deadline=deadline, status=status, history_text=history_text)
 
-async def _try_groq_streaming(chat_id: int, user_text: str, message: Message, model_id: str, *, deadline: float | None = None, status=None) -> tuple[str | None, Message | None]:
+async def _try_groq_streaming(chat_id: int, user_text: str, message: Message, model_id: str, *, deadline: float | None = None, status=None, history_text=None) -> tuple[str | None, Message | None]:
     """Обёртка _run_streaming_reply для Groq (SSE через chat/completions). Историю режем тем же _trim_messages_for_groq, что обычный путь, — иначе стрим-проба падает с 413 ещё до цепочки."""
     import bot
     from lumen_routes import _trim_messages_for_groq
     messages = _trim_messages_for_groq(bot._build_openrouter_turn_messages(chat_id, user_text, model_id))
     # Генератор — через bot.: тесты подменяют bot._groq_stream_pieces фейком.
     piece_agen = bot._groq_stream_pieces(model_id, messages, deadline=deadline)
-    return await _run_streaming_reply(chat_id, user_text, message, provider="groq", model_id=model_id, piece_agen=piece_agen, deadline=deadline, status=status)
+    return await _run_streaming_reply(chat_id, user_text, message, provider="groq", model_id=model_id, piece_agen=piece_agen, deadline=deadline, status=status, history_text=history_text)

lumen_tiktok_flow.py

@@ -483,6 +483,13 @@ async def _send_tiktok_single_video(
 
     raise TikTokUserFacingError(bot._t(message.chat.id, "tiktok_no_media"))
 
+def _record_tiktok_quota(message: Message) -> None:
+    """Успешная выдача TikTok — один ответ в дневной счётчик пользователя.
+    Раньше ветка возвращалась до _run_route и вообще не тратила лимит (аудит 28.10.2026)."""
+    import bot
+    bot._record_user_daily(bot._user_key_for_message(message))
+
+
 async def handle_tiktok(message: Message, url: str) -> None:
     import bot
     if bot.is_guest_message(message):
@@ -526,8 +533,10 @@ async def handle_tiktok(message: Message, url: str) -> None:
          author = (media_data.get("author") or {}).get("nickname") or bot._t(message.chat.id, "tiktok_author")
 
          if await _try_send_tiktok_slideshow(session, media_data, message, status, author, headers):
+              _record_tiktok_quota(message)
               return
          await _send_tiktok_single_video(session, media_data, message, status, author, headers)
+         _record_tiktok_quota(message)
     except Exception as exc:
           if isinstance(exc, (TelegramEntityTooLarge, TikTokUserFacingError)):
               # Известные исходы — warning без Sentry, неожиданные — exception с трейсбеком (LUMEN-1).

tests/test_bot_commands.py

@@ -1660,6 +1660,34 @@ def test_pick_callback_ignores_banned_user(monkeypatch):
     assert answered == [True]
 
 
+def test_cmd_reset_clears_media_refs_and_names(monkeypatch):
+    # Аудит 28.10.2026: /reset чистил историю, но старые ссылки на медиа
+    # и имена оставались в состоянии.
+    from collections import deque
+    from unittest.mock import AsyncMock
+    chat_id = 999806
+    bot.chat_state[chat_id] = {
+        "history": [{"role": "user", "content": "hi"}],
+        "ctx": deque(["фон"]),
+        "recent_media_ids": {"1": deque(["file-1"])},
+        "user_names": {"1": "User"},
+        "lang": "en",
+    }
+    incoming = _FakeIncomingMessage(chat_id)
+    incoming.from_user = SimpleNamespace(id=42)
+    monkeypatch.setattr(bot, "_is_privileged_in_chat", AsyncMock(return_value=True))
+    monkeypatch.setattr(bot, "_tg_call", AsyncMock())
+    try:
+        asyncio.run(bot.cmd_reset(incoming))
+        state = bot.chat_state[chat_id]
+        assert state["history"] == []
+        assert len(state["ctx"]) == 0
+        assert state["recent_media_ids"] == {}
+        assert state["user_names"] == {}
+    finally:
+        bot.chat_state.pop(chat_id, None)
+
+
 def test_banned_user_commands_send_nothing(monkeypatch):
     # Обход бана через прямые команды: catch-all с _is_banned не ловит
     # зарегистрированные раньше cmd_*, каждая проверяет первой строкой.

tests/test_bot_routes.py

@@ -233,7 +233,7 @@ def test_run_route_falls_back_to_second_provider_when_first_fully_fails():
     async def failing_or_text(*args, **kwargs):
         raise bot.OpenRouterAPIError("всё сломано", status_code=500)
 
-    async def fake_ask_gemini(cid, prompt, media=None, youtube_url=None, model_chain=None, deadline=None, provenance=None):
+    async def fake_ask_gemini(cid, prompt, media=None, youtube_url=None, model_chain=None, deadline=None, provenance=None, **kwargs):
         return "Ответ от Gemini (резерв)"
 
     original_or_text = bot.ask_openrouter_text
@@ -438,7 +438,7 @@ def test_run_route_reorders_slow_head_down(monkeypatch):
 
     seen = []
 
-    async def fake_ask(chat_id, prompt, model_chain, *, deadline=None):
+    async def fake_ask(chat_id, prompt, model_chain, *, deadline=None, **kwargs):
         seen.append(list(model_chain))
         return "ok"
 
@@ -462,7 +462,7 @@ def test_or_empty_response_falls_through_to_next_model(monkeypatch):
     # response" — пустой ответ обязан двигать цепочку дальше, а не идти в чат.
     calls = []
 
-    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         model = json_body["model"]
         calls.append(model)
         if model == "m1:free":
@@ -482,7 +482,7 @@ def test_or_empty_response_falls_through_to_next_model(monkeypatch):
 def test_chain_empty_responses_feed_quarantine_counter(monkeypatch):
     # Три пустых подряд в одну голову — карантин (реальная регрессия: мёртвая голова
     # жевала бы каждую попытку до конца суток вместо объезда после третьей).
-    async def fake_empty(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_empty(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         return {"choices": []}
 
     monkeypatch.setattr(bot, "_or_request", fake_empty)
@@ -502,7 +502,7 @@ def test_chain_garbled_response_delivered_but_feeds_quarantine(monkeypatch):
     mush = "результат: " + "dataданные fileфайл testтест " + "продолжение " + "я" * 80
     assert len(mush) >= 100
 
-    async def fake_mush(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_mush(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         return {"choices": [{"message": {"content": mush}}]}
 
     monkeypatch.setattr(bot, "_or_request", fake_mush)
@@ -522,7 +522,7 @@ def test_chain_echoed_mix_does_not_feed_quarantine(monkeypatch):
     mush = "результат: " + "dataданные fileфайл testтест " + "продолжение " + "я" * 80
     user_text = "повтори за мной: dataданные fileфайл testтест и дальше своими словами"
 
-    async def fake_mush(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_mush(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         return {"choices": [{"message": {"content": mush}}]}
 
     monkeypatch.setattr(bot, "_or_request", fake_mush)
@@ -597,7 +597,7 @@ def test_or_chain_stops_on_account_wide_limit(monkeypatch):
     # НЕ пробуются (иначе это минуты попыток впустую, как было в проде).
     calls = []
 
-    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         model = json_body["model"]
         calls.append(model)
         raise bot.OpenRouterAPIError(
@@ -618,7 +618,7 @@ def test_gemini_empty_response_falls_through_to_next_model(monkeypatch):
     chat_id = 999304
     extracts = ["", "хороший ответ"]
 
-    async def fake_extract(resp, *, model_id, call_contents, gconfig, deadline=None):
+    async def fake_extract(resp, *, model_id, call_contents, gconfig, deadline=None, **kwargs):
         return extracts.pop(0)
 
     fake_client = MagicMock()
@@ -637,7 +637,7 @@ def test_gemini_empty_response_falls_through_to_next_model(monkeypatch):
 def test_run_route_streams_openrouter_when_route_head_is_openrouter():
     chat_id = 999305
 
-    async def fake_or_stream(cid, prompt, message, model_id, deadline=None, status=None):
+    async def fake_or_stream(cid, prompt, message, model_id, deadline=None, status=None, **kwargs):
         return "Стримленный ответ от OpenRouter", None
 
     async def must_not_be_called(*args, **kwargs):
@@ -660,12 +660,12 @@ def test_run_route_streams_openrouter_when_route_head_is_openrouter():
 def test_run_route_falls_back_from_failed_openrouter_stream_to_non_streaming():
     chat_id = 999306
 
-    async def fake_or_stream_fail(cid, prompt, message, model_id, deadline=None, status=None):
+    async def fake_or_stream_fail(cid, prompt, message, model_id, deadline=None, status=None, **kwargs):
         return None, None  # ранний сбой без плейсхолдера (например, message.reply сам не удался)
 
     calls = []
 
-    async def fake_or_text(cid, prompt, model_chain, deadline=None):
+    async def fake_or_text(cid, prompt, model_chain, deadline=None, **kwargs):
         calls.append(model_chain)
         return "Ответ без стрима"
 
@@ -690,12 +690,12 @@ def test_run_route_tries_groq_head_with_stream_fallback_to_text():
     # Groq-подключение 21.09.2026: голова-groq стримится через _try_groq_streaming, при раннем сбое — обычный ask_groq_text без пере-пробы упавшей модели.
     chat_id = 999703
 
-    async def fake_groq_stream_fail(cid, prompt, message, model_id, deadline=None, status=None):
+    async def fake_groq_stream_fail(cid, prompt, message, model_id, deadline=None, status=None, **kwargs):
         return None, None
 
     calls = []
 
-    async def fake_groq_text(cid, prompt, model_chain, deadline=None):
+    async def fake_groq_text(cid, prompt, model_chain, deadline=None, **kwargs):
         calls.append(model_chain)
         return "Ответ Groq без стрима"
 
@@ -723,10 +723,10 @@ def test_run_route_reuses_stream_placeholder_when_fallback_succeeds():
     chat_id = 999307
     placeholder = _FakeSentMessage()
 
-    async def fake_or_stream_fail_with_placeholder(cid, prompt, message, model_id, deadline=None, status=None):
+    async def fake_or_stream_fail_with_placeholder(cid, prompt, message, model_id, deadline=None, status=None, **kwargs):
         return None, placeholder
 
-    async def fake_or_text(cid, prompt, model_chain, deadline=None):
+    async def fake_or_text(cid, prompt, model_chain, deadline=None, **kwargs):
         return "Ответ от резервной модели"
 
     original_stream = bot._try_openrouter_streaming
@@ -754,10 +754,10 @@ def test_run_route_reuse_adds_thought_block_in_private_chat(monkeypatch):
     placeholder = _FakeSentMessage()
     incoming = _FakeIncomingMessage(chat_id)
 
-    async def fake_stream_fail(cid, prompt, message, model_id, deadline=None, status=None):
+    async def fake_stream_fail(cid, prompt, message, model_id, deadline=None, status=None, **kwargs):
         return None, placeholder
 
-    async def fake_text(cid, prompt, model_chain, deadline=None):
+    async def fake_text(cid, prompt, model_chain, deadline=None, **kwargs):
         return "Ответ от резервной модели"
 
     monkeypatch.setattr(bot, "_try_openrouter_streaming", fake_stream_fail)
@@ -778,7 +778,7 @@ def test_run_route_deletes_orphaned_placeholder_when_whole_route_fails():
     chat_id = 999308
     placeholder = _FakeSentMessage()
 
-    async def fake_or_stream_fail_with_placeholder(cid, prompt, message, model_id, deadline=None, status=None):
+    async def fake_or_stream_fail_with_placeholder(cid, prompt, message, model_id, deadline=None, status=None, **kwargs):
         return None, placeholder
 
     async def failing_or_text(*args, **kwargs):
@@ -1152,7 +1152,7 @@ def test_ask_gemini_raises_when_route_budget_exceeded():
 def test_or_chat_completion_with_fallback_switches_model(status_code, message):
     # И минутный 429, и "постоянная" на вид 403 не обрывают переход к следующей
     # модели: при attempts_per_model=1 переход происходит независимо от классификации.
-    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         model = json_body["model"]
         if model == "model-a":
             raise bot.OpenRouterAPIError(message, status_code=status_code)
@@ -1174,7 +1174,7 @@ def test_ask_openrouter_multimodal_sends_all_album_images_not_just_first():
     chat_id = 999411
     captured = {}
 
-    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         captured["messages"] = json_body["messages"]
         return {"choices": [{"message": {"content": "вижу три фото"}}]}
 
@@ -1200,7 +1200,7 @@ def test_ask_openrouter_multimodal_skips_video_slides_for_gemini():
     chat_id = 999412
     captured = {}
 
-    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         captured["messages"] = json_body["messages"]
         return {"choices": [{"message": {"content": "вижу фото"}}]}
 
@@ -1301,7 +1301,7 @@ def test_probe_or_model_liveness_warns_on_dead_model_pattern(caplog):
     from datetime import date
     expected_model = bot._OR_LIGHT_ORDER[date.today().timetuple().tm_yday % len(bot._OR_LIGHT_ORDER)]
 
-    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         model = json_body["model"]
         if model == expected_model:
             raise bot.OpenRouterAPIError("This model is unavailable for free. use another slug", status_code=404)
@@ -1328,7 +1328,7 @@ def test_probe_or_model_liveness_rotates_by_day_of_year():
     from datetime import date
     calls = []
 
-    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         calls.append(json_body["model"])
         return {"choices": [{"message": {"content": "pong"}}]}
 
@@ -1352,7 +1352,7 @@ def test_probe_or_model_liveness_rotates_by_day_of_year():
 def test_probe_or_model_liveness_silent_when_all_alive(caplog):
     import logging
 
-    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         return {"choices": [{"message": {"content": "pong"}}]}
 
     original_request = bot._or_request
@@ -1421,7 +1421,7 @@ def test_ask_groq_text_success_records_groq_quota(monkeypatch):
     chat_id = 999701
     monkeypatch.setattr(bot, "get_state", lambda cid: {"history": [], "ctx": deque()})
 
-    async def fake_groq_request(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_groq_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         assert json_body["model"] == "qwen/qwen3.8-27b"
         return {"choices": [{"message": {"content": "Канберра."}}]}
 
@@ -1441,7 +1441,7 @@ def test_ask_groq_text_falls_back_to_next_model(monkeypatch):
     monkeypatch.setattr(bot, "get_state", lambda cid: {"history": [], "ctx": deque()})
     seen = []
 
-    async def fake_groq_request(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_groq_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         seen.append(json_body["model"])
         if json_body["model"] == "qwen/qwen3.8-27b":
             raise bot.GroqAPIError("overloaded", status_code=503)
@@ -1462,7 +1462,7 @@ def test_ask_groq_text_raises_last_error_when_whole_chain_fails(monkeypatch):
     chat_id = 999703
     monkeypatch.setattr(bot, "get_state", lambda cid: {"history": [], "ctx": deque()})
 
-    async def failing_groq_request(path, method="GET", *, json_body=None, deadline=None):
+    async def failing_groq_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         raise bot.GroqAPIError("overloaded", status_code=503)
 
     monkeypatch.setattr(bot, "_groq_request", failing_groq_request)
@@ -1485,7 +1485,7 @@ def test_ask_groq_text_trims_long_history_to_token_budget(monkeypatch):
     monkeypatch.setattr(bot, "get_state", lambda cid: {"history": history, "ctx": deque()})
     seen = {}
 
-    async def fake_groq_request(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_groq_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         # Первый запрос — сам ответ; второй (если будет) — саммаризатор истории
         # _trim_history, его не трогаем.
         seen.setdefault("messages", json_body["messages"])
@@ -1514,7 +1514,7 @@ def test_model_attempt_counters_track_chain_success_and_failure(monkeypatch):
     monkeypatch.setattr(bot, "get_state", lambda cid: {"history": [], "ctx": deque()})
     calls = {"n": 0}
 
-    async def fake_groq_request(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_groq_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         calls["n"] += 1
         if calls["n"] == 1:
             raise bot.GroqAPIError("boom", status_code=500)
@@ -1750,7 +1750,7 @@ def test_text_provider_trims_history_with_summary_not_silent_cut(monkeypatch, as
     async def fake_fallback(messages, trial_models, primary_model_id, **kwargs):
         return answer, trial_models[0]
 
-    async def fake_groq_request(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_groq_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         return {"choices": [{"message": {"content": answer}}]}
 
     stubs = {"_or_chat_completion_with_fallback": fake_fallback, "_groq_request": fake_groq_request}
@@ -1785,7 +1785,7 @@ def test_text_providers_keep_media_note_out_of_history(monkeypatch):
     async def fake_fallback(messages, trial_models, primary_model_id, **kwargs):
         return "ответ", trial_models[0]
 
-    async def fake_groq_request(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_groq_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         return {"choices": [{"message": {"content": "ответ"}}]}
 
     monkeypatch.setattr(bot, "_or_chat_completion_with_fallback", fake_fallback)
@@ -1806,10 +1806,10 @@ def test_run_route_marks_unsupported_media_for_text_fallback(monkeypatch):
     chat_id = 999815
     captured = {}
 
-    async def failing_gemini(cid, prompt, media=None, youtube_url=None, model_chain=None, deadline=None, provenance=None):
+    async def failing_gemini(cid, prompt, media=None, youtube_url=None, model_chain=None, deadline=None, provenance=None, **kwargs):
         raise ValueError("Тип вложения 'application/x-foo' не поддерживается для анализа.")
 
-    async def fake_groq_text(cid, prompt, model_chain, deadline=None):
+    async def fake_groq_text(cid, prompt, model_chain, deadline=None, **kwargs):
         captured["prompt"] = prompt
         return "не вижу файла, пришлите его"
 
@@ -1860,7 +1860,7 @@ def test_run_route_records_user_daily_on_gemini_success():
     incoming = _FakeIncomingMessage(chat_id)
     incoming.from_user = SimpleNamespace(id=777011)
 
-    async def fake_ask_gemini(cid, prompt, media=None, youtube_url=None, model_chain=None, deadline=None, provenance=None):
+    async def fake_ask_gemini(cid, prompt, media=None, youtube_url=None, model_chain=None, deadline=None, provenance=None, **kwargs):
         return "Ответ от Gemini"
 
     original = bot.ask_gemini
@@ -1909,7 +1909,7 @@ def test_run_route_keeps_route_block_order(monkeypatch):
     calls = []
 
     async def fake_ask_gemini(cid, prompt, media=None, youtube_url=None, model_chain=None,
-                              deadline=None, provenance=None):
+                              deadline=None, provenance=None, **kwargs):
         calls.append(("gemini", list(model_chain)))
         if model_chain == ["gemini-3.8-flash"]:
             if provenance is not None:
@@ -1917,11 +1917,11 @@ def test_run_route_keeps_route_block_order(monkeypatch):
             return "резерв Gemini"
         raise RuntimeError("gemma недоступна")
 
-    async def failing_groq(cid, prompt, model_chain, deadline=None):
+    async def failing_groq(cid, prompt, model_chain, deadline=None, **kwargs):
         calls.append(("groq", list(model_chain)))
         raise bot.GroqAPIError("overloaded", status_code=503)
 
-    async def failing_or(cid, prompt, model_chain, deadline=None):
+    async def failing_or(cid, prompt, model_chain, deadline=None, **kwargs):
         calls.append(("openrouter", list(model_chain)))
         raise bot.OpenRouterAPIError("сломано", status_code=500)
 
@@ -1954,7 +1954,7 @@ def test_run_route_gemma_answer_does_not_spend_gemini_user_limit():
     incoming.from_user = SimpleNamespace(id=777013)
 
     async def fake_ask_gemini(cid, prompt, media=None, youtube_url=None, model_chain=None,
-                              deadline=None, provenance=None):
+                              deadline=None, provenance=None, **kwargs):
         if provenance is not None:
             provenance.update(provider="gemini", model="gemma-4-26b-a4b-it")
         return "Ответ Gemma"
@@ -1992,10 +1992,10 @@ def test_handled_message_grows_provider_quota_user_daily_and_stats(rate_guard_se
     monkeypatch.setattr(bot, "_try_openrouter_streaming", AsyncMock(return_value=(None, None)))
     monkeypatch.setattr(bot, "_try_groq_streaming", AsyncMock(return_value=(None, None)))
 
-    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         return {"choices": [{"message": {"content": "Привет! Как сам?"}}]}
 
-    async def failing_groq_request(path, method="GET", *, json_body=None, deadline=None):
+    async def failing_groq_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         raise bot.GroqAPIError("overloaded", status_code=503)
 
     monkeypatch.setattr(bot, "_or_request", fake_or_request)
@@ -2130,7 +2130,7 @@ def test_openrouter_success_logs_token_usage_when_api_returns_it(caplog, monkeyp
     import logging
     chat_id = 999903
 
-    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None):
+    async def fake_or_request(path, method="GET", *, json_body=None, deadline=None, **kwargs):
         return {"choices": [{"message": {"content": "ответ"}}],
                 "usage": {"prompt_tokens": 11, "completion_tokens": 22, "total_tokens": 33}}
 

tests/test_bot_state.py

@@ -2925,6 +2925,23 @@ def test_user_daily_record_counts_by_provider(monkeypatch):
         bot.GLOBAL_QUOTA.get("user_daily", {}).pop(str(uid), None)
 
 
+def test_user_daily_reserve_is_atomic_and_refundable(monkeypatch):
+    # Аудит 28.10.2026: проверка-потом-списание позволяла параллельным /tts
+    # обойти дневной лимит. Резерв обязан отказывать второму вызову сразу.
+    monkeypatch.setattr(bot, "DAILY_USER_TTS_LIMIT", 5)
+    monkeypatch.setattr(bot, "DAILY_USER_MESSAGE_LIMIT", 20)
+    uid = 999888773
+    try:
+        assert bot._reserve_user_daily(uid, total=5, tts=5) is True
+        assert bot._reserve_user_daily(uid, total=5, tts=5) is False
+        assert bot.GLOBAL_QUOTA["user_daily"][str(uid)]["tts"] == 5
+        bot._refund_user_daily(uid, total=5, tts=5)
+        assert bot.GLOBAL_QUOTA["user_daily"][str(uid)]["tts"] == 0
+        assert bot._reserve_user_daily(uid, total=5, tts=5) is True
+    finally:
+        bot.GLOBAL_QUOTA.get("user_daily", {}).pop(str(uid), None)
+
+
 def test_user_daily_owner_and_unknown_are_unlimited():
     # Новое: владелец не ограничен и не оставляет записей — регрессия
     # "владелец заблокирован собственными лимитами".
@@ -3155,6 +3172,28 @@ def test_combined_memory_caps_background_at_100():
         bot._dirty_chat_ids.discard(9001)
 
 
+def test_passive_context_caps_line_and_total_chars():
+    # Аудит 28.10.2026: 100 сообщений по 4096 символов раздували промпт и
+    # позволяли одному участнику забить чужой контекст.
+    from collections import deque
+    from lumen_message_core import _PASSIVE_CTX_MAX_CHARS
+    state = {"history": [], "ctx": deque(), "recent_media_ids": {}, "user_names": {}}
+    try:
+        def _msg():
+            return SimpleNamespace(chat=SimpleNamespace(id=9002),
+                                   from_user=SimpleNamespace(id=8, username="u", first_name="U"),
+                                   text="x")
+
+        bot._record_passive_group_context(_msg(), state, "я" * 5000)
+        assert len(state["ctx"]) == 1
+        assert len(state["ctx"][0]) <= 600
+        for _ in range(50):
+            bot._record_passive_group_context(_msg(), state, "x" * 400)
+        assert sum(len(line) for line in state["ctx"]) <= _PASSIVE_CTX_MAX_CHARS + 600
+    finally:
+        bot._dirty_chat_ids.discard(9002)
+
+
 def test_sender_directory_resolves_nicknames():
     # Прозвища резолвятся по username и first_name: иначе "блинчик" терялся.
     state = {"history": [], "user_names": {}}

tests/test_bot_streaming.py

@@ -764,6 +764,29 @@ def test_streaming_plain_text_adds_collapsed_thought_block():
         bot.chat_state.pop(chat_id, None)
 
 
+def test_streaming_stores_clean_history_text_not_full_prompt():
+    # Аудит 28.10.2026: в историю уходил ai_prompt со сниппетами и датой;
+    # сохраняем только чистый запрос пользователя.
+    chat_id = 999323
+
+    async def pieces():
+        yield "Ответ"
+
+    incoming = _FakeIncomingMessage(chat_id)
+    try:
+        answer, _ = asyncio.run(bot._run_streaming_reply(
+            chat_id, "полный промпт со сниппетами", incoming,
+            provider="openrouter", model_id="y:free", piece_agen=pieces(),
+            history_text="чистый вопрос",
+        ))
+        assert answer == "Ответ"
+        history = bot.chat_state[chat_id]["history"]
+        assert history[-2] == {"role": "user", "content": "чистый вопрос"}
+        assert history[-1] == {"role": "assistant", "content": "Ответ"}
+    finally:
+        bot.chat_state.pop(chat_id, None)
+
+
 def test_streaming_reuses_status_bubble_instead_of_sending_new_placeholder():
     # Живой статус уже в чате: стрим пишет ответ в него, второго «…» нет.
     chat_id = 999320

tests/test_lumen_formatting.py

@@ -622,6 +622,15 @@ def test_md_to_html_converts_markdown_link():
     assert result == '<a href="https://example.com/page">почитать здесь</a>'
 
 
+def test_md_to_html_replaces_mismatched_url_label():
+    # Аудит 28.10.2026: метка-URL на чужой хост — готовый фишинг.
+    html = lumen_formatting._md_to_html("[https://bank.example](https://attacker.example/x)")
+    assert ">https://attacker.example/x<" in html
+    assert "bank.example" not in html
+    # Обычная текстовая метка не трогается.
+    assert ">Reuters<" in lumen_formatting._md_to_html("[Reuters](https://reuters.com/x)")
+
+
 def test_md_to_html_link_with_underscores_in_url_not_corrupted_by_italic():
     # Регрессия: URL с двумя "_" мог бы ошибочно засчитаться за пару italic-
     # маркеров, если бы конвертация ссылок шла раньше bold/italic в Phase 3.

tests/test_lumen_security.py

@@ -41,6 +41,35 @@ def test_detect_identity_leak_based_on_needs_first_person():
     assert lumen_security._detect_identity_leak("Меня создала Google") is True
 
 
+def test_detect_identity_leak_catches_articles_created_by_and_invisible_chars():
+    # Аудит 28.10.2026: узкий шаблон пропускал обычные формулировки с артиклем,
+    # built/trained by и fullwidth/zero-width символами.
+    for text in (
+        "I am a Gemini model.",
+        "I am created by Google.",
+        "I am built by Google.",
+        "I am an AI model made by Anthropic.",
+        "I am a language model trained by Google.",
+        "I am a language model from Google.",
+        "Я — языковая модель Google.",
+        "\uff29 am a Gemini model.",  # fullwidth I нормализуется NFKC
+        "I am a Gemini\u200b model.",  # zero-width внутри фразы
+    ):
+        assert lumen_security._detect_identity_leak(text) is True, ascii(text)
+
+
+def test_detect_identity_leak_does_not_flag_third_person_or_reports():
+    # Расширение шаблонов не должно ловить честные рассказы о чужих моделях.
+    for text in (
+        "I am a big fan of Google.",
+        "I am reading about Gemini.",
+        "I am reading a book created by Google.",
+        "This model was created by Google.",
+        "Я — фанат Google.",
+    ):
+        assert lumen_security._detect_identity_leak(text) is False, ascii(text)
+
+
 def test_detect_identity_leak_literal_matches_whole_token_only():
     # Полный ID отдельным токеном утечка, слаг внутри длинного слова нет.
     assert lumen_security._detect_identity_leak("Использую модель gemini-3.5-flash для ответа") is True