Reliability wave 3: router skips quota-exhausted models, prune never drops a chat holding the lock

lumen_chat_state.py

@@ -551,16 +551,26 @@ def _t(chat_id: int | None, key: str, **kwargs: Any) -> str:
 def _prune_old_chats() -> None:
     import bot
     sorted_ids = sorted(chat_state.keys(), key=lambda cid: chat_state[cid].get("last_activity", 0))
-    to_remove = len(chat_state) - PRUNED_CHAT_TARGET
-    removed_ids = sorted_ids[:to_remove]
+    # Лок ЗАНЯТ = в чате идёт ответ. Такой чат вытеснять нельзя: идущий маршрут
+    # продолжал бы писать в отвязанный state, а следующее сообщение создало бы
+    # новый лок — два параллельных ответа в одном чате и порча истории
+    # (аудит 26.09.2026). Такой чат просто не попадает в выборку.
+    def _is_busy(cid: int) -> bool:
+        lock = bot._chat_locks.get(cid)
+        return lock is not None and lock.locked()
+
+    removable = [cid for cid in sorted_ids if not _is_busy(cid)]
+    to_remove = max(0, len(removable) - PRUNED_CHAT_TARGET)
+    removed_ids = removable[:to_remove]
     for cid in removed_ids:
         chat_state.pop(cid, None)
         bot._chat_locks.pop(cid, None)
     # Вытесненные чаты должны реально исчезнуть из хранилища (иначе их собственные
-    # ключи/файлы бесхозно копятся навсегда) — ставим в очередь на удаление,
+    # ключи/файлы бесхозно копятся вечно) — ставим в очередь на удаление,
     # обрабатывается в _flush_dirty_state вместе с обычным сбросом.
     _pending_chat_deletions.update(removed_ids)
-    bot.mark_state_dirty()
+    if removed_ids:
+        bot.mark_state_dirty()
 
 def get_chat_lock(chat_id: int) -> asyncio.Lock:
     import bot

lumen_router_config.py

@@ -291,13 +291,34 @@ def _check_scheduled_removals_due() -> None:
                 model_id, removal_date.isoformat(), today.isoformat(),
             )
 
+def _is_quota_exhausted(provider: str, model_id: str) -> bool:
+    """Помечена ли модель как исчерпавшая квоту (метка _mark_quota_exhausted после 429).
+    Раньше роутер её не читал: каждое сообщение снова упиралось в 429 заведомо мёртвой
+    модели и тратило ROUTE_MODEL_TIMEOUT_SEC попытки (аудит 26.09.2026). Сброс —
+    смена суток (_reset_quota_if_new_day) либо успешный ответ, который чистит метку."""
+    try:
+        import bot
+        sub = bot.GLOBAL_QUOTA.get(provider) or {}
+        entry = sub.get(model_id) or {}
+        return bool(entry.get("exhausted_at"))
+    except Exception:
+        return False
+
+def _skip_exhausted(provider: str, models: list[str]) -> list[str]:
+    """Выкидывает модели с меткой «квота исчерпана», но НИКОГДА не оставляет список
+    пустым: пустой маршрут означал бы «упасть сразу», а один заведомо мёртвый
+    вариант всё ещё даёт пользователю честное сообщение о лимите (аудит 26.09.2026)."""
+    alive = [m for m in models if not _is_quota_exhausted(provider, m)]
+    return alive or list(models)
+
 def _or_route(models: list[str]) -> list[tuple[str, str]]:
     """Превращает список ID моделей OpenRouter в список (provider, model_id) для
-    маршрута, попутно исключая модели из _ROUTER_EXCLUDED_OR_MODELS."""
-    return [("openrouter", m) for m in models if m not in _ROUTER_EXCLUDED_OR_MODELS]
+    маршрута, попутно исключая модели из _ROUTER_EXCLUDED_OR_MODELS и уже помеченные
+    как исчерпавшие квоту (иначе они каждый раз съедали бы попытку до 429)."""
+    return [("openrouter", m) for m in _skip_exhausted("openrouter", models) if m not in _ROUTER_EXCLUDED_OR_MODELS]
 
 def _gemini_route(models: list[str]) -> list[tuple[str, str]]:
-    return [("gemini", m) for m in models]
+    return [("gemini", m) for m in _skip_exhausted("gemini", models)]
 
 # ── Groq (прямой провайдер, не через OpenRouter) ──
 # Калибровка русского живьём 21.09.2026 (4 пробы на модель через API с VPN): Qwen отвечает чисто и по делу, gpt-oss-120b тоже верен, но представляется ChatGPT от OpenAI (ловит фильтр утечек) и тратит 30-70 reasoning-токенов на ответ — они едят минутный бюджет. Поэтому Qwen голова, gpt-oss второй. Лимиты free-плана по офиц. доке: 30 RPM / 1000 RPD / 8K TPM / 200K TPD на модель.
@@ -308,7 +329,7 @@ _GROQ_LIGHT_ORDER: list[str] = [
 ]
 
 def _groq_route(models: list[str]) -> list[tuple[str, str]]:
-    return [("groq", m) for m in models]
+    return [("groq", m) for m in _skip_exhausted("groq", models)]
 
 
 # ── "Лёгкие" запросы — САМЫЙ ЧАСТЫЙ маршрут, целиком OpenRouter (квоту Gemini не трогаем).

tests/test_bot_state.py

@@ -631,6 +631,45 @@ def test_process_media_group_buffers_holds_chat_lock():
         bot.chat_state.pop(chat_id, None)
 
 
+def test_prune_old_chats_never_drops_a_chat_with_held_lock():
+    # Регрессия (аудит 26.09.2026): чат с ЗАНЯТЫМ локом вытеснялся из памяти
+    # вместе с локом — идущий маршрут писал в отвязанный state, а следующее
+    # сообщение создавало новый лок: два параллельных ответа и порча истории.
+    import asyncio as _asyncio
+    import lumen_chat_state as lcs
+
+    busy_id, idle_id = 999801, 999802
+    orig_target = lcs.PRUNED_CHAT_TARGET
+    orig_states = dict(lcs.chat_state)
+    lcs.PRUNED_CHAT_TARGET = 0
+    lcs.chat_state.clear()
+    lcs.chat_state.update({
+        busy_id: {"last_activity": 0.0, "history": []},
+        idle_id: {"last_activity": 1.0, "history": []},
+    })
+    real_lock = asyncio.Lock()
+    lcs._pending_chat_deletions.discard(busy_id)
+    lcs._pending_chat_deletions.discard(idle_id)
+    original_locks = bot._chat_locks
+    bot._chat_locks = {busy_id: real_lock, idle_id: asyncio.Lock()}
+    try:
+        async def run():
+            await real_lock.acquire()
+            bot._prune_old_chats()
+        _asyncio.run(run())
+        assert busy_id in lcs.chat_state, "чат с занятым локом вытеснять нельзя"
+        assert idle_id not in lcs.chat_state
+        assert busy_id not in lcs._pending_chat_deletions
+        assert idle_id in lcs._pending_chat_deletions
+    finally:
+        bot._chat_locks = original_locks
+        lcs.PRUNED_CHAT_TARGET = orig_target
+        lcs.chat_state.clear()
+        lcs.chat_state.update(orig_states)
+        lcs._pending_chat_deletions.discard(busy_id)
+        lcs._pending_chat_deletions.discard(idle_id)
+
+
 def test_process_media_group_buffers_cleanup_on_cancel():
     # Отмена во сне (рестарт/дренаж) — записи буфера и задачи уходят, а не висят вечно.
     bot._mg_buffers["mgcancel"] = ["m1"]

tests/test_lumen_router_config.py

@@ -638,3 +638,50 @@ def test_fish_audio_disabled_after_free_tier_gone():
     # Зеркало снято с бесплатного каталога OpenRouter — первая попытка в inline_tts
     # пропускается флагом, сама функция оставлена для тестов/возврата.
     assert lumen_router_config.FISH_AUDIO_ENABLED is False
+
+
+# ─────────────── исчерпавшая квота больше не тратит попытку (аудит 26.09.2026) ───────────────
+
+def test_or_route_skips_models_marked_exhausted():
+    import bot
+    bot.GLOBAL_QUOTA.setdefault("openrouter", {})["probe/exhausted:free"] = {"used": 0, "exhausted_at": 123.0}
+    try:
+        route = lumen_router_config._or_route(["probe/exhausted:free", "nvidia/nemotron-3.5-lightning:free"])
+        assert [m for _, m in route] == ["nvidia/nemotron-3.5-lightning:free"]
+    finally:
+        bot.GLOBAL_QUOTA["openrouter"].pop("probe/exhausted:free", None)
+
+
+def test_gemini_and_groq_routes_skip_exhausted_models():
+    import bot
+    bot.GLOBAL_QUOTA.setdefault("gemini", {})["gemini-probe-dead"] = {"used": 0, "exhausted_at": 123.0}
+    bot.GLOBAL_QUOTA.setdefault("groq", {})["qwen/probe-dead"] = {"used": 0, "exhausted_at": 123.0}
+    try:
+        assert [m for _, m in lumen_router_config._gemini_route(["gemini-probe-dead", "gemini-3.8-flash"])] == ["gemini-3.8-flash"]
+        assert [m for _, m in lumen_router_config._groq_route(["qwen/probe-dead", "qwen/qwen3.8-27b"])] == ["qwen/qwen3.8-27b"]
+    finally:
+        bot.GLOBAL_QUOTA["gemini"].pop("gemini-probe-dead", None)
+        bot.GLOBAL_QUOTA["groq"].pop("qwen/probe-dead", None)
+
+
+def test_route_never_becomes_empty_when_all_models_exhausted():
+    # Пустой маршрут = мгновенный отказ вместо внятного сообщения о лимите,
+    # поэтому последний вариант оставляем.
+    import bot
+    bot.GLOBAL_QUOTA.setdefault("openrouter", {})["probe/all-dead:free"] = {"used": 0, "exhausted_at": 123.0}
+    try:
+        assert lumen_router_config._or_route(["probe/all-dead:free"]) == [("openrouter", "probe/all-dead:free")]
+    finally:
+        bot.GLOBAL_QUOTA["openrouter"].pop("probe/all-dead:free", None)
+
+
+def test_successful_usage_clears_exhausted_mark():
+    # Метка снимается успешным ответом, иначе после сброса суток или починки
+    # провайдера модель навсегда выпадала бы из роутинга.
+    import bot
+    bot.GLOBAL_QUOTA.setdefault("openrouter", {})["probe/recover:free"] = {"used": 3, "exhausted_at": 123.0}
+    try:
+        bot._record_quota_usage("openrouter", "probe/recover:free")
+        assert [m for _, m in lumen_router_config._or_route(["probe/recover:free"])] == ["probe/recover:free"]
+    finally:
+        bot.GLOBAL_QUOTA["openrouter"].pop("probe/recover:free", None)