feat: refine assistant logic and update docs

.env.example

@@ -2,10 +2,15 @@
 # Если одновременно указать несколько AI ключей, колонка выдаст ошибку.
 AI_PROVIDER=
 
-# Perplexity
+# OpenRouter
-# PERPLEXITY_API_KEY=your_perplexity_api_key_here
+# OPENROUTER_API_KEY=your_openrouter_api_key_here
-PERPLEXITY_MODEL=llama-3.1-sonar-small-128k-chat
+OPENROUTER_MODEL=openai/gpt-4o-mini
-PERPLEXITY_API_URL=https://api.perplexity.ai/chat/completions
+OPENROUTER_API_URL=https://openrouter.ai/api/v1/chat/completions
+AI_CHAT_TEMPERATURE=0.9
+AI_CHAT_MAX_TOKENS=160
+AI_CHAT_MAX_CHARS=240
+AI_INTENT_TEMPERATURE=0.0
+AI_TRANSLATION_TEMPERATURE=0.2
 
 # OpenAI
 # OPENAI_API_KEY=your_openai_api_key_here
@@ -27,13 +32,39 @@ ZAI_API_URL=https://api.z.ai/api/paas/v4/chat/completions
 ANTHROPIC_MODEL=claude-sonnet-4-20250514
 ANTHROPIC_API_URL=https://api.anthropic.com/v1/messages
 ANTHROPIC_API_VERSION=2023-06-01
+
+# Ollama (локально; без API key)
+# AI_PROVIDER=ollama
+OLLAMA_MODEL=llama3.1:8b
+OLLAMA_API_URL=http://localhost:11434/v1/chat/completions
 DEEPGRAM_API_KEY=your_deepgram_api_key_here
 PORCUPINE_ACCESS_KEY=your_porcupine_access_key_here
 PORCUPINE_SENSITIVITY=0.8
+# Anti-phantom wake word filter (RMS gate).
+# Increase values if random activations persist; lower them if wake word becomes too hard to trigger.
+# If the mic reopens and instantly re-triggers, keep RMS as-is and raise WAKEWORD_REOPEN_GRACE_SECONDS.
+# WAKEWORD_MIN_RMS=120
+# WAKEWORD_RMS_MULTIPLIER=1.7
+# WAKEWORD_HIT_COOLDOWN_SECONDS=1.2
+# WAKEWORD_REOPEN_GRACE_SECONDS=0.45
+# Optional audio device overrides (substring match by name or exact PortAudio index)
+# AUDIO_INPUT_DEVICE_NAME=pulse
+# AUDIO_INPUT_DEVICE_INDEX=2
+# AUDIO_OUTPUT_DEVICE_NAME=pulse
+# AUDIO_OUTPUT_DEVICE_INDEX=5
+# STT start sound (played after wake word before listening)
+# STT_START_SOUND_PATH=assets/sounds/alisa-golosovoj-pomoschnik.mp3
+# STT_START_SOUND_VOLUME=0.25
 TTS_EN_SPEAKER=en_0
 WEATHER_LAT=63.56
 WEATHER_LON=53.69
 WEATHER_CITY=Ухта
+
+# Navidrome (приоритетный источник музыки; при ошибке — fallback на Spotify)
+NAVIDROME_URL=https://navidrome.example.com
+NAVIDROME_USERNAME=your_navidrome_username
+NAVIDROME_PASSWORD=your_navidrome_password
+
 SPOTIFY_CLIENT_ID=your_spotify_client_id
 SPOTIFY_CLIENT_SECRET=your_spotify_client_secret
 SPOTIFY_REDIRECT_URI=http://localhost:8888/callback

.gitignore

@@ -13,8 +13,14 @@ env.bak/
 venv.bak/
 .qwen
 qwen.md
+.tmp/
 
 
+# AI configs
+11.py
+.qwen/
+QWEN.md
+
 # Distribution / packaging
 build/
 develop-eggs/
@@ -41,6 +47,9 @@ vosk-model-*/
 # VS Code
 .vscode/
 
+# Runtime state
+data/music_state.json
+
 
 .beads
 .gitattributes

Makefile

@@ -1,7 +1,12 @@
 .PHONY: run check qwen-context
 
+PYTHON := python3
+ifneq ($(wildcard .venv/bin/python),)
+PYTHON := .venv/bin/python
+endif
+
 run:
-	python run.py
+	$(PYTHON) run.py
 
 check:
 	./scripts/qwen-check.sh

README.md

@@ -15,30 +15,31 @@
 
 ## Что это
 
-`Alexander Smart Speaker` слушает ключевое слово `Alexandr`, распознает речь, маршрутизирует команду в нужный модуль и озвучивает ответ.
+`Alexander Smart Speaker` слушает ключевое слово `Waltron`, распознает речь, маршрутизирует команду в нужный модуль и озвучивает ответ.
 Проект оптимизирован под русский язык, но поддерживает RU/EN сценарии (включая перевод и mixed-language TTS).
 
 Проект собран как локальная голосовая колонка под Linux: активация по wake word, распознавание речи, маршрутизация команд, ответ через AI или встроенные модули и затем озвучка результата.
 
 ## Возможности
 
-- Активация по wake word `Alexandr` (Porcupine).
+- Активация по wake word `Waltron` (Porcupine).
 - Follow-up окно 4 секунды после ответа: если пользователь молчит, ассистент возвращается к ожиданию wake word.
 - Распознавание речи через Deepgram (WebSocket, VAD, fast stop).
 - Озвучка через Silero TTS (RU + EN, с прерыванием по wake word).
-- AI-диалог через Perplexity, OpenAI, Gemini, Z.ai и Anthropic Claude API со streaming-ответом и контекстом.
+- AI-диалог через OpenRouter, OpenAI, Gemini, Z.ai и Anthropic Claude API со streaming-ответом и контекстом.
 - Перевод RU -> EN и EN -> RU.
 - Погода: текущий прогноз по городу по умолчанию или по названию города.
 - Таймеры, будильники (включая будни/выходные), секундомеры.
 - Управление громкостью системы (через `pactl`/`amixer`).
-- Управление Spotify (play/pause/next/what's playing).
+- Управление музыкой через Navidrome (приоритет) с fallback на Spotify.
+- Persistent resume: `пауза`/`продолжи` продолжают с сохранённой позиции даже после перезапуска колонки.
 - Мини-игра "Города".
 
 ## Как это работает
 
 ```mermaid
 flowchart TD
-    A[Wake Word: Alexandr] --> B[STT: Deepgram]
+    A[Wake Word: Waltron] --> B[STT: Deepgram]
     B --> C{Маршрутизация команды}
     C --> D[Feature modules]
     C --> E[AI/Translation]
@@ -47,12 +48,13 @@ flowchart TD
     F --> G[Follow-up режим или ожидание wake word]
 ```
 
-## Что Важно В Этой Реализации
+## Что важно в этой реализации
 
 - Контекст диалога хранится в памяти текущей сессии, поэтому после первого вопроса можно продолжать разговор без потери нити.
 - Системная роль ассистента и `ROLE_JSON` сохраняются для всех поддерживаемых AI-провайдеров.
 - Для AI используется строго один активный API key. Если в `.env` оставить несколько ключей, ассистент покажет ошибку конфигурации вместо случайного выбора.
 - Поддержка провайдеров сделана внутри одного модуля, но с разным форматом запросов для OpenAI-compatible API и Anthropic.
+- Локальные модели через Ollama поддерживаются без API key (через OpenAI-compatible endpoint).
 
 ## Быстрый старт
 
@@ -60,13 +62,13 @@ flowchart TD
 
 ```bash
 sudo apt-get update
-sudo apt-get install -y portaudio19-dev libasound2-dev mpg123 pulseaudio-utils alsa-utils
+sudo apt-get install -y portaudio19-dev libasound2-dev mpg123 mpv pulseaudio-utils alsa-utils
 ```
 
 ### 2) Установка Python-зависимостей
 
 ```bash
-git clone <URL_ВАШЕГО_РЕПОЗИТОРИЯ>
+git clone https://gitea.futuree.ru/future/alexander_smart-speaker.git
 cd alexander_smart-speaker
 python3 -m venv venv
 source venv/bin/activate
@@ -84,7 +86,7 @@ cp .env.example .env
 ```ini
 AI_PROVIDER=            # опционально; можно оставить пустым
 # Раскомментируйте только один AI API KEY:
-# PERPLEXITY_API_KEY=...
+# OPENROUTER_API_KEY=...
 # OPENAI_API_KEY=...
 # GEMINI_API_KEY=...
 # ZAI_API_KEY=...
@@ -116,16 +118,22 @@ make run
 python run.py
 ```
 
-После запуска ассистент перейдет в режим ожидания фразы `Alexandr`.
+После запуска ассистент перейдет в режим ожидания фразы `Waltron`.
+
+### Кросс-платформенный аудио режим
+
+- Приложение автоматически подбирает рабочий микрофон/динамик через PortAudio.
+- Если основное аудио-устройство не подходит, включается fallback по другим устройствам и sample rate.
+- При проблемах можно явно задать устройство через `.env` (`AUDIO_*_DEVICE_NAME` или `AUDIO_*_DEVICE_INDEX`).
 
 ## Конфигурация `.env`
 
 | Переменная | Обязательно | По умолчанию | Назначение |
 |---|---|---|---|
-| `AI_PROVIDER` | Нет | `perplexity` | Опциональный провайдер AI (`perplexity`, `openai`, `gemini`, `zai`, `anthropic`; также понимает `claude`) |
+| `AI_PROVIDER` | Нет | `openrouter` | Опциональный провайдер AI (`openrouter`, `openai`, `gemini`, `zai`, `anthropic`, `ollama`; также понимает `claude`) |
-| `PERPLEXITY_API_KEY` | Да* | - | Ключ Perplexity API (*если выбран Perplexity и только этот AI ключ активен) |
+| `OPENROUTER_API_KEY` | Да* | - | Ключ OpenRouter API (*если выбран OpenRouter и только этот AI ключ активен) |
-| `PERPLEXITY_MODEL` | Нет | `llama-3.1-sonar-small-128k-chat` | Модель Perplexity |
+| `OPENROUTER_MODEL` | Нет | `openai/gpt-4o-mini` | Модель OpenRouter |
-| `PERPLEXITY_API_URL` | Нет | `https://api.perplexity.ai/chat/completions` | Endpoint Perplexity Chat Completions |
+| `OPENROUTER_API_URL` | Нет | `https://openrouter.ai/api/v1/chat/completions` | Endpoint OpenRouter Chat Completions |
 | `OPENAI_API_KEY` | Да* | - | Ключ OpenAI API (*если выбран OpenAI и только этот AI ключ активен) |
 | `OPENAI_MODEL` | Нет | `gpt-4o-mini` | Модель OpenAI |
 | `OPENAI_API_URL` | Нет | `https://api.openai.com/v1/chat/completions` | Endpoint OpenAI Chat Completions |
@@ -139,13 +147,24 @@ python run.py
 | `ANTHROPIC_MODEL` | Нет | `claude-sonnet-4-20250514` | Модель Claude |
 | `ANTHROPIC_API_URL` | Нет | `https://api.anthropic.com/v1/messages` | Endpoint Anthropic Messages API |
 | `ANTHROPIC_API_VERSION` | Нет | `2023-06-01` | Версия Anthropic API |
+| `OLLAMA_MODEL` | Нет | `llama3.1:8b` | Модель Ollama (локально) |
+| `OLLAMA_API_URL` | Нет | `http://localhost:11434/v1/chat/completions` | OpenAI-compatible endpoint Ollama |
 | `DEEPGRAM_API_KEY` | Да | - | Ключ Deepgram STT |
 | `PORCUPINE_ACCESS_KEY` | Да | - | Ключ PicoVoice Porcupine |
 | `PORCUPINE_SENSITIVITY` | Нет | `0.8` | Чувствительность wake word |
+| `AUDIO_INPUT_DEVICE_NAME` | Нет | auto | Подстрока имени микрофона (например `pulse`), если нужно выбрать конкретный input device |
+| `AUDIO_INPUT_DEVICE_INDEX` | Нет | auto | Индекс PortAudio для микрофона (приоритетнее `AUDIO_INPUT_DEVICE_NAME`) |
+| `AUDIO_OUTPUT_DEVICE_NAME` | Нет | auto | Подстрока имени динамика/выхода (например `pulse`) |
+| `AUDIO_OUTPUT_DEVICE_INDEX` | Нет | auto | Индекс PortAudio для вывода (приоритетнее `AUDIO_OUTPUT_DEVICE_NAME`) |
+| `STT_START_SOUND_PATH` | Нет | `assets/sounds/alisa-golosovoj-pomoschnik.mp3` | Короткий звук после wake word и перед стартом STT (wav/mp3) |
+| `STT_START_SOUND_VOLUME` | Нет | `1.0` | Громкость звука старта STT (в текущей версии фиксирована на 100%) |
 | `TTS_EN_SPEAKER` | Нет | `en_0` | Английский голос TTS |
 | `WEATHER_LAT` | Нет | - | Широта города по умолчанию |
 | `WEATHER_LON` | Нет | - | Долгота города по умолчанию |
 | `WEATHER_CITY` | Нет | `Ухта` | Город по умолчанию для погоды |
+| `NAVIDROME_URL` | Нет | - | URL Navidrome (например `https://navidrome.example.com`) |
+| `NAVIDROME_USERNAME` | Нет | - | Логин Navidrome |
+| `NAVIDROME_PASSWORD` | Нет | - | Пароль Navidrome |
 | `SPOTIFY_CLIENT_ID` | Нет | - | Spotify OAuth Client ID |
 | `SPOTIFY_CLIENT_SECRET` | Нет | - | Spotify OAuth Client Secret |
 | `SPOTIFY_REDIRECT_URI` | Нет | `http://localhost:8888/callback` | Redirect URI для Spotify |
@@ -154,7 +173,7 @@ python run.py
 
 | Категория | Примеры |
 |---|---|
-| Активация | `Alexandr` |
+| Активация | `Waltron` |
 | AI-диалог | `Почему небо голубое?` |
 | Перевод | `Переведи на английский: как дела` |
 | Погода | `Какая погода?`, `Погода в Москве` |
@@ -162,7 +181,7 @@ python run.py
 | Будильник | `Поставь будильник на 7:30`, `Будильник по будням в 8:00` |
 | Секундомер | `Запусти секундомер`, `Покажи активные секундомеры` |
 | Громкость | `Громкость 7` |
-| Spotify | `Включи музыку`, `Пауза`, `Что сейчас играет` |
+| Музыка (Navidrome first) | `Включи музыку`, `Пауза`, `Продолжи`, `Следующий`, `Предыдущий`, `Что играет`, `Включи жанр electronic`, `Включи папку crystal castles` |
 | Игра | `Давай сыграем в города` |
 | Управление диалогом | `Повтори`, `Стоп`, `Хватит` |
 
@@ -206,11 +225,14 @@ alexander_smart-speaker/
 
 | Проблема | Что проверить |
 |---|---|
-| Не реагирует на `Alexandr` | `PORCUPINE_ACCESS_KEY`, микрофон, чувствительность `PORCUPINE_SENSITIVITY` |
+| Не реагирует на `Waltron` | `PORCUPINE_ACCESS_KEY`, микрофон, чувствительность `PORCUPINE_SENSITIVITY` |
 | STT не распознает речь | `DEEPGRAM_API_KEY`, сетевой доступ, выбранный микрофон |
 | Нет звука | корректное аудиоустройство и доступность `pactl`/`amixer` |
+| `Audio input/output initialization failed` | проверить, что звук-сервер запущен (PipeWire/PulseAudio), и при необходимости задать `AUDIO_INPUT_DEVICE_NAME`/`AUDIO_OUTPUT_DEVICE_NAME` |
 | Будильник/таймер не звонит | наличие `mpg123` в системе |
 | Ошибка про несколько AI API | в `.env` должен остаться только один незакомментированный AI ключ |
+| Navidrome не воспроизводит | заполнены `NAVIDROME_*`, доступен `NAVIDROME_URL`, установлен `mpv` |
+| Fallback ушёл в Spotify | проверить доступность Navidrome, SSL и корректность `NAVIDROME_USERNAME`/`NAVIDROME_PASSWORD` |
 | Spotify не управляется | заполнены `SPOTIFY_*`, есть активное устройство, Premium-аккаунт |
 
 ## Лицензия

app/audio/sound_level.py

@@ -11,20 +11,57 @@ import re
 import platform
 from ..core.roman import replace_roman_numerals
 
+try:
+    import pymorphy3
+
+    _MORPH = pymorphy3.MorphAnalyzer()
+except Exception:
+    _MORPH = None
+
 # Карта для перевода слов в цифры ("пять" -> 5)
 NUMBER_MAP = {
+    "ноль": 0,
     "один": 1,
+    "одна": 1,
     "раз": 1,
+    "единица": 1,
+    "единичка": 1,
     "два": 2,
+    "две": 2,
+    "двойка": 2,
+    "двоечка": 2,
     "три": 3,
+    "тройка": 3,
+    "троечка": 3,
     "четыре": 4,
+    "четверка": 4,
+    "четверочка": 4,
     "пять": 5,
+    "пятерка": 5,
+    "пятерочка": 5,
     "шесть": 6,
+    "шестерка": 6,
+    "шестерочка": 6,
     "семь": 7,
+    "семерка": 7,
+    "семерочка": 7,
     "восемь": 8,
+    "восьмерка": 8,
+    "восьмерочка": 8,
     "девять": 9,
+    "девятка": 9,
+    "девяточка": 9,
     "десять": 10,
+    "десятка": 10,
+    "десяточка": 10,
 }
+_VOLUME_COMMAND_RE = re.compile(r"\b(громкост\w*|звук\w*|volume)\b")
+
+
+def _lemmatize(token: str) -> str:
+    if _MORPH is None:
+        return token
+    return _MORPH.parse(token)[0].normal_form.replace("ё", "е")
 
 
 def _get_volume_command(level: int):
@@ -149,16 +186,25 @@ def parse_volume_text(text: str) -> int | None:
     Пытается найти число громкости в тексте.
     Понимает и цифры ("5"), и слова ("пять").
     """
-    text = replace_roman_numerals(text.lower())
+    text = replace_roman_numerals(text.lower().replace("ё", "е"))
 
-    # 1. Ищем цифры (1-10)
+    # 1. Ищем цифры в любом месте фразы.
-    num_match = re.search(r"\b(10|[1-9])\b", text)
+    for match in re.finditer(r"\d+", text):
-    if num_match:
+        value = int(match.group())
-        return int(num_match.group())
+        if 1 <= value <= 10:
+            return value
 
-    # 2. Ищем слова из словаря
+    # 2. Ищем числительные и разговорные формы по леммам:
-    for word, value in NUMBER_MAP.items():
+    # "семерку", "десяточку", "на двух" -> 7, 10, 2.
-        if word in text:
+    for token in re.findall(r"[a-zA-Zа-яА-ЯёЁ]+", text):
+        value = NUMBER_MAP.get(_lemmatize(token))
+        if value is not None and 1 <= value <= 10:
             return value
 
     return None
+
+
+def is_volume_command(text: str) -> bool:
+    if not text:
+        return False
+    return bool(_VOLUME_COMMAND_RE.search(text.lower().replace("ё", "е")))

app/audio/stt.py

@@ -8,10 +8,11 @@ Supports Russian (default) and English.
 # Использует Deepgram API через веб-сокеты для потокового распознавания в реальном времени.
 
 import asyncio
-import re
 import time
 import pyaudio
 import logging
+import contextlib
+import threading
 from datetime import datetime, timedelta
 from ..core.config import DEEPGRAM_API_KEY, SAMPLE_RATE
 from deepgram import (
@@ -23,14 +24,20 @@ from deepgram import (
 import deepgram.clients.common.v1.abstract_sync_websocket as sdk_ws
 import websockets.sync.client
 from ..core.audio_manager import get_audio_manager
+from ..core.commands import is_fast_command
 
 # --- Патч (исправление) для библиотеки websockets ---
 # Явно задаём таймауты подключения, чтобы не зависать на долгом handshake.
 _original_connect = websockets.sync.client.connect
 
-DEEPGRAM_CONNECT_TIMEOUT_SECONDS = 3.0
+DEEPGRAM_CONNECT_TIMEOUT_SECONDS = 5.0
-DEEPGRAM_CONNECT_WAIT_SECONDS = 1.5
+DEEPGRAM_CONNECT_WAIT_SECONDS = 6.5
 DEEPGRAM_CONNECT_POLL_SECONDS = 0.001
+SENDER_STOP_WAIT_SECONDS = 2.5
+SENDER_FORCE_RELEASE_WAIT_SECONDS = 2.5
+DEEPGRAM_FINALIZE_TIMEOUT_SECONDS = 1.5
+DEEPGRAM_FINALIZATION_GRACE_SECONDS = 0.35
+DEEPGRAM_FINISH_TIMEOUT_SECONDS = 4.0
 
 
 def _patched_connect(*args, **kwargs):
@@ -50,42 +57,23 @@ logging.getLogger("deepgram").setLevel(logging.WARNING)
 
 # Базовые пороги для остановки STT
 INITIAL_SILENCE_TIMEOUT_SECONDS = 5.0
-POST_SPEECH_SILENCE_TIMEOUT_SECONDS = 3.5
+POST_SPEECH_SILENCE_TIMEOUT_SECONDS = 2.0
 # Длинный защитный предел, чтобы не обрывать обычную длинную фразу.
-# Фактическое завершение происходит примерно после 3.5 сек тишины после речи.
+# Фактическое завершение происходит примерно после 2.0 сек тишины после речи.
 MAX_ACTIVE_SPEECH_SECONDS = 300.0
 
-_FAST_STOP_UTTERANCE_RE = re.compile(
-    r"^(?:(?:александр|алесандр|alexander|alexandr)\s+)?"
-    r"(?:стоп|хватит|перестань|прекрати|замолчи|тихо|пауза)"
-    r"(?:\s+(?:пожалуйста|please))?$",
-    flags=re.IGNORECASE,
-)
-
-
-def _normalize_command_text(text: str) -> str:
-    normalized = text.lower().replace("ё", "е")
-    normalized = re.sub(r"[^\w\s]+", " ", normalized, flags=re.UNICODE)
-    normalized = re.sub(r"\s+", " ", normalized, flags=re.UNICODE).strip()
-    return normalized
-
-
-def _is_fast_stop_utterance(text: str) -> bool:
-    normalized = _normalize_command_text(text)
-    if not normalized:
-        return False
-    return _FAST_STOP_UTTERANCE_RE.fullmatch(normalized) is not None
-
-
 class SpeechRecognizer:
     """Класс распознавания речи через Deepgram."""
 
     def __init__(self):
         self.dg_client = None
         self.pa = None
+        self.audio_manager = None
         self.stream = None
         self.transcript = ""
         self.last_successful_operation = datetime.now()
+        self._input_device_index = None
+        self._stream_sample_rate = SAMPLE_RATE
 
     def initialize(self):
         """Инициализация клиента Deepgram и PyAudio."""
@@ -102,7 +90,9 @@ class SpeechRecognizer:
             print(f"❌ Ошибка при создании клиента Deepgram: {e}")
             raise
 
-        self.pa = get_audio_manager().get_pyaudio()
+        self.audio_manager = get_audio_manager()
+        self.pa = self.audio_manager.get_pyaudio()
+        self._input_device_index = self.audio_manager.get_input_device_index()
         print("✅ Deepgram клиент готов")
         # Обновляем время последней успешной операции
         self.last_successful_operation = datetime.now()
@@ -128,15 +118,136 @@ class SpeechRecognizer:
     def _get_stream(self):
         """Открывает аудиопоток PyAudio, если он еще не открыт."""
         if self.stream is None:
-            self.stream = self.pa.open(
+            if self.audio_manager is None:
-                rate=SAMPLE_RATE,
+                self.audio_manager = get_audio_manager()
-                channels=1,
+            self.stream, self._input_device_index, self._stream_sample_rate = (
-                format=pyaudio.paInt16,
+                self.audio_manager.open_input_stream(
-                input=True,
+                    rate=SAMPLE_RATE,
-                frames_per_buffer=4096,
+                    channels=1,
+                    format=pyaudio.paInt16,
+                    frames_per_buffer=4096,
+                    preferred_index=self._input_device_index,
+                    fallback_rates=[48000, 44100, 32000, 22050, 16000, 8000],
+                )
             )
+            if self._stream_sample_rate != SAMPLE_RATE:
+                print(
+                    f"⚠️ STT mic stream uses fallback rate={self._stream_sample_rate} "
+                    f"(requested {SAMPLE_RATE})"
+                )
         return self.stream
 
+    def _open_stream_for_session(self):
+        """Открывает отдельный входной поток для одной STT-сессии."""
+        if self.audio_manager is None:
+            self.audio_manager = get_audio_manager()
+        stream, self._input_device_index, sample_rate = self.audio_manager.open_input_stream(
+            rate=SAMPLE_RATE,
+            channels=1,
+            format=pyaudio.paInt16,
+            frames_per_buffer=4096,
+            preferred_index=self._input_device_index,
+            fallback_rates=[48000, 44100, 32000, 22050, 16000, 8000],
+        )
+        if sample_rate != SAMPLE_RATE:
+            print(
+                f"⚠️ STT mic stream uses fallback rate={sample_rate} "
+                f"(requested {SAMPLE_RATE})"
+            )
+        return stream, int(sample_rate)
+
+    def _stop_stream_quietly(self):
+        if not self.stream:
+            return
+        try:
+            if self.stream.is_active():
+                self.stream.stop_stream()
+        except Exception:
+            pass
+
+    def _release_stream(self):
+        if not self.stream:
+            return
+        self._stop_stream_quietly()
+        try:
+            self.stream.close()
+        except Exception:
+            pass
+        self.stream = None
+
+    async def _wait_for_thread(self, thread, timeout_seconds: float) -> bool:
+        """Асинхронно ждет завершения daemon-thread без блокировки event loop."""
+        deadline = time.monotonic() + timeout_seconds
+        while thread.is_alive() and time.monotonic() < deadline:
+            await asyncio.sleep(0.05)
+        return not thread.is_alive()
+
+    async def _run_blocking_cleanup(
+        self, func, timeout_seconds: float, label: str, quiet: bool = False
+    ) -> bool:
+        """Запускает потенциально подвисающий cleanup в daemon-thread и ждет ограниченное время."""
+        done_event = threading.Event()
+        error_holder = {}
+
+        def runner():
+            try:
+                func()
+            except Exception as exc:
+                error_holder["error"] = exc
+            finally:
+                done_event.set()
+
+        thread = threading.Thread(target=runner, daemon=True, name=label)
+        thread.start()
+
+        deadline = time.monotonic() + timeout_seconds
+        while not done_event.is_set() and time.monotonic() < deadline:
+            await asyncio.sleep(0.05)
+
+        if not done_event.is_set():
+            if not quiet:
+                print(f"⚠️ {label} timed out; continuing cleanup.")
+            return False
+
+        error = error_holder.get("error")
+        if error is not None:
+            if not quiet:
+                print(f"⚠️ {label} failed: {error}")
+            return False
+
+        return True
+
+    def _run_blocking_cleanup_sync(
+        self, func, timeout_seconds: float, label: str, quiet: bool = False
+    ) -> bool:
+        """Sync-версия _run_blocking_cleanup() для use-case в listen()."""
+        done_event = threading.Event()
+        error_holder = {}
+
+        def runner():
+            try:
+                func()
+            except Exception as exc:
+                error_holder["error"] = exc
+            finally:
+                done_event.set()
+
+        thread = threading.Thread(target=runner, daemon=True, name=label)
+        thread.start()
+
+        done_event.wait(timeout=max(0.0, float(timeout_seconds)))
+        if not done_event.is_set():
+            if not quiet:
+                print(f"⚠️ {label} timed out; continuing cleanup.")
+            return False
+
+        error = error_holder.get("error")
+        if error is not None:
+            if not quiet:
+                print(f"⚠️ {label} failed: {error}")
+            return False
+        return True
+
     async def _process_audio(
         self, dg_connection, timeout_seconds, detection_timeout, fast_stop
     ):
@@ -147,13 +258,13 @@ class SpeechRecognizer:
             dg_connection: Активное соединение с Deepgram.
             timeout_seconds: Аварийный лимит длительности активной речи.
             detection_timeout: Время ожидания начала речи.
-            fast_stop: Если True, короткая стоп-фраза завершает STT после 1с тишины.
+            fast_stop: Если True, короткие системные команды завершают STT раньше.
         """
         self.transcript = ""
         transcript_parts = []
+        latest_interim = ""
 
         loop = asyncio.get_running_loop()
-        stream = self._get_stream()
         effective_detection_timeout = (
             detection_timeout
             if detection_timeout is not None
@@ -163,8 +274,11 @@ class SpeechRecognizer:
         # События для синхронизации
         stop_event = asyncio.Event()  # Пора останавливаться
         speech_started_event = asyncio.Event()  # Речь обнаружена (VAD)
+        connection_ready_event = threading.Event()  # WS с Deepgram готов
+        connection_failed_event = threading.Event()  # WS с Deepgram завершился ошибкой
         last_speech_activity = time.monotonic()
         first_speech_activity_at = None
+        session_error = {"message": None}
 
         def mark_speech_activity():
             nonlocal last_speech_activity, first_speech_activity_at
@@ -174,30 +288,52 @@ class SpeechRecognizer:
                 first_speech_activity_at = now
             speech_started_event.set()
 
+        def mark_session_error(message: str):
+            if not session_error["message"]:
+                session_error["message"] = str(message)
+
+        def is_benign_disconnect(message: str) -> bool:
+            if not message:
+                return False
+            lowered = message.lower()
+            return (
+                "connectionclosed" in lowered
+                or "code 1006" in lowered
+                or "no_close_frame" in lowered
+                or "websocket" in lowered
+            )
+
         # --- Обработчики событий Deepgram ---
         def on_transcript(unused_self, result, **kwargs):
             """Вызывается, когда приходит часть текста."""
+            nonlocal latest_interim
             sentence = result.channel.alternatives[0].transcript
             if len(sentence) == 0:
                 return
+            sentence = sentence.strip()
+            if not sentence:
+                return
             try:
                 loop.call_soon_threadsafe(mark_speech_activity)
             except RuntimeError:
                 pass
 
-            if fast_stop:
+            if fast_stop and is_fast_command(sentence):
-                if _is_fast_stop_utterance(sentence):
+                self.transcript = sentence
-                    self.transcript = sentence.strip()
+                try:
-                    try:
+                    loop.call_soon_threadsafe(request_stop)
-                        loop.call_soon_threadsafe(stop_event.set)
+                except RuntimeError:
-                    except RuntimeError:
+                    pass
-                        pass
+                return
-                    return
 
             if result.is_final:
                 # Собираем только финальные (подтвержденные) фразы
                 transcript_parts.append(sentence)
                 self.transcript = " ".join(transcript_parts).strip()
+                latest_interim = ""
+            else:
+                # Fallback: некоторые сессии завершаются без is_final.
+                latest_interim = sentence
 
         def on_speech_started(unused_self, speech_started, **kwargs):
             """Вызывается, когда VAD (Voice Activity Detection) слышит голос."""
@@ -214,9 +350,11 @@ class SpeechRecognizer:
             return
 
         def on_error(unused_self, error, **kwargs):
+            if stop_event.is_set():
+                return
             print(f"Deepgram Error: {error}")
             try:
-                loop.call_soon_threadsafe(stop_event.set)
+                loop.call_soon_threadsafe(request_stop)
             except RuntimeError:
                 # Event loop might be closed, ignore
                 pass
@@ -227,27 +365,36 @@ class SpeechRecognizer:
         dg_connection.on(LiveTranscriptionEvents.UtteranceEnd, on_utterance_end)
         dg_connection.on(LiveTranscriptionEvents.Error, on_error)
 
-        # Параметры распознавания
-        options = LiveOptions(
-            model="nova-2",  # Самая быстрая и точная модель
-            language=self.current_lang,
-            smart_format=True,  # Расстановка знаков препинания
-            encoding="linear16",
-            channels=1,
-            sample_rate=SAMPLE_RATE,
-            interim_results=True,
-            utterance_end_ms=int(POST_SPEECH_SILENCE_TIMEOUT_SECONDS * 1000),
-            vad_events=True,
-            # Сглаженный порог endpointing, чтобы не резать речь на коротких паузах.
-            endpointing=int(POST_SPEECH_SILENCE_TIMEOUT_SECONDS * 1000),
-        )
-
         # --- Задача отправки аудио с буферизацией ---
-        async def send_audio():
+        sender_stop_event = threading.Event()
+        stream_holder = {"stream": None}
+
+        def request_stop():
+            stop_event.set()
+            sender_stop_event.set()
+
+        def send_audio():
             chunks_sent = 0
             audio_buffer = []  # Буфер для накопления звука во время подключения
+            stream = None
 
             try:
+                stream, stream_sample_rate = self._open_stream_for_session()
+                stream_holder["stream"] = stream
+                options = LiveOptions(
+                    model="nova-2",  # Самая быстрая и точная модель
+                    language=self.current_lang,
+                    smart_format=True,  # Расстановка знаков препинания
+                    encoding="linear16",
+                    channels=1,
+                    sample_rate=stream_sample_rate,
+                    interim_results=True,
+                    utterance_end_ms=int(POST_SPEECH_SILENCE_TIMEOUT_SECONDS * 1000),
+                    vad_events=True,
+                    # Сглаженный порог endpointing, чтобы не резать речь на коротких паузах.
+                    endpointing=int(POST_SPEECH_SILENCE_TIMEOUT_SECONDS * 1000),
+                )
+
                 # 1. Сразу начинаем захват звука, не дожидаясь сети!
                 stream.start_stream()
                 print("🎤 Stream started (buffering)...")
@@ -255,36 +402,75 @@ class SpeechRecognizer:
                 # 2. Запускаем подключение к Deepgram в фоне (через ThreadPool, т.к. start() блокирующий)
                 # Но в данном SDK start() возвращает bool, он может быть блокирующим.
                 # Deepgram Python SDK v3+ start() делает handshake.
+                connect_result = {"done": False, "ok": None, "error": None}
 
-                connect_future = loop.run_in_executor(
+                def start_connection():
-                    None, lambda: dg_connection.start(options)
+                    try:
+                        connect_result["ok"] = dg_connection.start(options)
+                    except Exception as exc:
+                        connect_result["error"] = exc
+                    finally:
+                        connect_result["done"] = True
+
+                connect_thread = threading.Thread(
+                    target=start_connection, daemon=True
                 )
+                connect_thread.start()
 
                 # Пока подключаемся, копим данные.
                 # Ждём коротко: если сеть подвисла, быстрее перезапускаем попытку.
                 connect_deadline = time.monotonic() + DEEPGRAM_CONNECT_WAIT_SECONDS
                 while (
-                    not connect_future.done()
+                    not connect_result["done"]
                     and time.monotonic() < connect_deadline
+                    and not sender_stop_event.is_set()
                 ):
                     if stream.is_active():
-                        data = stream.read(4096, exception_on_overflow=False)
+                        try:
+                            data = stream.read(4096, exception_on_overflow=False)
+                        except Exception as read_error:
+                            if sender_stop_event.is_set():
+                                return
+                            mark_session_error(f"Audio read error during connect: {read_error}")
+                            print(f"Audio read error during connect: {read_error}")
+                            with contextlib.suppress(RuntimeError):
+                                loop.call_soon_threadsafe(request_stop)
+                            return
                         audio_buffer.append(data)
-                    await asyncio.sleep(DEEPGRAM_CONNECT_POLL_SECONDS)
+                    time.sleep(DEEPGRAM_CONNECT_POLL_SECONDS)
 
-                if not connect_future.done():
+                if sender_stop_event.is_set():
+                    return
+
+                if not connect_result["done"]:
+                    mark_session_error(
+                        f"Timeout connecting to Deepgram ({DEEPGRAM_CONNECT_WAIT_SECONDS:.1f}s)"
+                    )
                     print(
                         f"⏰ Timeout connecting to Deepgram ({DEEPGRAM_CONNECT_WAIT_SECONDS:.1f}s)"
                     )
-                    stop_event.set()
+                    connection_failed_event.set()
+                    loop.call_soon_threadsafe(request_stop)
                     return
 
                 # Проверяем результат подключения
-                if connect_future.result() is False:
+                if connect_result["error"] is not None:
-                    print("Failed to start Deepgram connection")
+                    mark_session_error(
-                    stop_event.set()
+                        f"Failed to start Deepgram connection: {connect_result['error']}"
+                    )
+                    print(f"Failed to start Deepgram connection: {connect_result['error']}")
+                    connection_failed_event.set()
+                    loop.call_soon_threadsafe(request_stop)
                     return
 
+                if connect_result["ok"] is False:
+                    mark_session_error("Failed to start Deepgram connection")
+                    print("Failed to start Deepgram connection")
+                    connection_failed_event.set()
+                    loop.call_soon_threadsafe(request_stop)
+                    return
+
+                connection_ready_event.set()
                 print(f"🚀 Connected! Sending buffer ({len(audio_buffer)} chunks)...")
 
                 # 3. Отправляем накопленный буфер
@@ -295,23 +481,49 @@ class SpeechRecognizer:
                 audio_buffer = None  # Освобождаем память
 
                 # 4. Продолжаем стримить в реальном времени до события остановки.
-                while not stop_event.is_set():
+                while not sender_stop_event.is_set():
-                    if stream.is_active():
+                    if not stream.is_active():
+                        break
+                    try:
                         data = stream.read(4096, exception_on_overflow=False)
-                        dg_connection.send(data)
+                    except Exception as read_error:
-                        chunks_sent += 1
+                        if sender_stop_event.is_set():
-                        if chunks_sent % 50 == 0:
+                            break
-                            print(".", end="", flush=True)
+                        mark_session_error(f"Audio read error: {read_error}")
-                    await asyncio.sleep(0.002)  # Уменьшаем задержку для более быстрого реагирования
+                        print(f"Audio read error: {read_error}")
+                        with contextlib.suppress(RuntimeError):
+                            loop.call_soon_threadsafe(request_stop)
+                        break
+                    if sender_stop_event.is_set():
+                        break
+                    dg_connection.send(data)
+                    chunks_sent += 1
+                    if chunks_sent % 50 == 0:
+                        print(".", end="", flush=True)
+                    time.sleep(0.002)  # Уменьшаем задержку для более быстрого реагирования
 
             except Exception as e:
+                mark_session_error(f"Audio send error: {e}")
                 print(f"Audio send error: {e}")
+                connection_failed_event.set()
+                with contextlib.suppress(RuntimeError):
+                    loop.call_soon_threadsafe(request_stop)
             finally:
-                if stream.is_active():
+                with contextlib.suppress(Exception):
-                    stream.stop_stream()
+                    if stream and stream.is_active():
+                        stream.stop_stream()
+                with contextlib.suppress(Exception):
+                    if stream:
+                        stream.close()
+                stream_holder["stream"] = None
                 print(f"\n🛑 Stream stopped. Chunks sent: {chunks_sent}")
 
-        sender_task = asyncio.create_task(send_audio())
+        sender_thread = threading.Thread(
+            target=send_audio,
+            daemon=True,
+            name="deepgram-audio-sender",
+        )
+        sender_thread.start()
 
         if False:  # dg_connection.start(options) перенесен внутрь send_audio
             pass
@@ -323,25 +535,55 @@ class SpeechRecognizer:
                 and effective_detection_timeout > 0
                 and not stop_event.is_set()
             ):
-                speech_wait_task = asyncio.create_task(speech_started_event.wait())
+                # Важно: не считаем пользователя "молчаливым", пока WS-соединение
-                stop_wait_task = asyncio.create_task(stop_event.wait())
+                # с Deepgram еще не поднялось.
-                try:
+                connect_ready_deadline = time.monotonic() + max(
-                    done, pending = await asyncio.wait(
+                    effective_detection_timeout + 0.25,
-                        {speech_wait_task, stop_wait_task},
+                    DEEPGRAM_CONNECT_WAIT_SECONDS + 0.75,
-                        timeout=effective_detection_timeout,
+                )
-                        return_when=asyncio.FIRST_COMPLETED,
+                while (
-                    )
+                    not stop_event.is_set()
-                finally:
+                    and not connection_ready_event.is_set()
-                    for task in (speech_wait_task, stop_wait_task):
+                    and time.monotonic() < connect_ready_deadline
-                        if not task.done():
+                ):
-                            task.cancel()
+                    if connection_failed_event.is_set():
-                    await asyncio.gather(
+                        break
-                        speech_wait_task, stop_wait_task, return_exceptions=True
+                    await asyncio.sleep(0.05)
-                    )
 
-                if not done:
+                if (
-                    # Если за detection_timeout никто не начал говорить, выходим
+                    not stop_event.is_set()
-                    stop_event.set()
+                    and not connection_ready_event.is_set()
+                    and not connection_failed_event.is_set()
+                ):
+                    mark_session_error("Deepgram connection was not ready before speech timeout.")
+                    request_stop()
+
+                if (
+                    stop_event.is_set()
+                    or connection_failed_event.is_set()
+                    or not connection_ready_event.is_set()
+                ):
+                    request_stop()
+                else:
+                    speech_wait_task = asyncio.create_task(speech_started_event.wait())
+                    stop_wait_task = asyncio.create_task(stop_event.wait())
+                    try:
+                        done, pending = await asyncio.wait(
+                            {speech_wait_task, stop_wait_task},
+                            timeout=effective_detection_timeout,
+                            return_when=asyncio.FIRST_COMPLETED,
+                        )
+                    finally:
+                        for task in (speech_wait_task, stop_wait_task):
+                            if not task.done():
+                                task.cancel()
+                        await asyncio.gather(
+                            speech_wait_task, stop_wait_task, return_exceptions=True
+                        )
+
+                    if not done:
+                        # Если за detection_timeout после поднятия WS никто не начал говорить, выходим.
+                        request_stop()
 
             # 2. После старта речи завершаем только по тишине POST_SPEECH_SILENCE_TIMEOUT_SECONDS.
             # Добавляем длинный защитный лимит, чтобы сессия не зависла навсегда.
@@ -359,7 +601,7 @@ class SpeechRecognizer:
                             now - last_speech_activity
                             >= POST_SPEECH_SILENCE_TIMEOUT_SECONDS
                         ):
-                            stop_event.set()
+                            request_stop()
                             break
 
                         if (
@@ -368,7 +610,7 @@ class SpeechRecognizer:
                             >= max_active_speech_seconds
                         ):
                             print("⏱️ Достигнут защитный лимит активного прослушивания.")
-                            stop_event.set()
+                            request_stop()
                             break
 
                     await asyncio.sleep(0.05)
@@ -378,19 +620,72 @@ class SpeechRecognizer:
         except Exception as e:
             print(f"Error in waiting for events: {e}")
 
-        stop_event.set()
+        request_stop()
-        try:
+        heard_speech = speech_started_event.is_set()
-            await sender_task
+        sender_stopped = await self._wait_for_thread(
-        except Exception as e:
+            sender_thread,
-            print(f"Error waiting for sender task: {e}")
+            timeout_seconds=max(SENDER_STOP_WAIT_SECONDS, SENDER_FORCE_RELEASE_WAIT_SECONDS),
+        )
+        cleanup_unhealthy = False
+        if not sender_stopped:
+            def force_close_stream():
+                stream = stream_holder.get("stream")
+                if not stream:
+                    return
+                with contextlib.suppress(Exception):
+                    if stream.is_active():
+                        stream.stop_stream()
+                with contextlib.suppress(Exception):
+                    stream.close()
+                stream_holder["stream"] = None
+
+            await self._run_blocking_cleanup(
+                force_close_stream,
+                timeout_seconds=SENDER_FORCE_RELEASE_WAIT_SECONDS,
+                label="STT audio stream force close",
+                quiet=True,
+            )
+
+            # Дадим шанс потоку выйти после принудительного закрытия.
+            sender_stopped = await self._wait_for_thread(sender_thread, timeout_seconds=0.6)
+            if not sender_stopped:
+                cleanup_unhealthy = True
+
+        # Сначала мягко просим Deepgram дослать хвост распознавания.
+        if heard_speech:
+            await self._run_blocking_cleanup(
+                dg_connection.finalize,
+                timeout_seconds=DEEPGRAM_FINALIZE_TIMEOUT_SECONDS,
+                label="Deepgram finalize",
+                quiet=True,
+            )
+            await asyncio.sleep(DEEPGRAM_FINALIZATION_GRACE_SECONDS)
 
         # Завершаем соединение и ждем последние результаты
-        try:
+        finish_ok = await self._run_blocking_cleanup(
-            dg_connection.finish()
+            dg_connection.finish,
-        except Exception as e:
+            timeout_seconds=DEEPGRAM_FINISH_TIMEOUT_SECONDS,
-            print(f"Error finishing connection: {e}")
+            label="Deepgram finish",
+            quiet=True,
+        )
+        if not finish_ok:
+            cleanup_unhealthy = True
 
-        return self.transcript
+        final_text = self.transcript.strip()
+        if not final_text:
+            final_text = latest_interim.strip()
+        self.transcript = final_text
+        if session_error["message"] and not final_text:
+            # Частый случай после музыки: соединение Deepgram закрывается (1006)
+            # до начала речи. Это штатное завершение, не ошибка.
+            if not heard_speech and is_benign_disconnect(session_error["message"]):
+                return ""
+            raise RuntimeError(session_error["message"])
+        if cleanup_unhealthy:
+            # Если cleanup подвис, не валим текущую команду и не запускаем ложный retry.
+            # Просто пересоздаем клиента перед следующим прослушиванием.
+            self.dg_client = None
+        return final_text
 
     def listen(
         self,
@@ -406,7 +701,7 @@ class SpeechRecognizer:
             timeout_seconds: Защитный лимит длительности активной речи.
             detection_timeout: Сколько ждать начала речи перед тем как сдаться.
             lang: Язык ("ru" или "en").
-            fast_stop: Быстрое завершение для коротких stop-команд.
+            fast_stop: Быстрое завершение для коротких системных команд.
         """
         if not self.dg_client:
             self.initialize()
@@ -451,10 +746,21 @@ class SpeechRecognizer:
                 # Закрываем соединение, если оно было создано
                 if dg_connection:
                     try:
-                        dg_connection.finish()
+                        self._run_blocking_cleanup_sync(
+                            dg_connection.finish,
+                            timeout_seconds=DEEPGRAM_FINISH_TIMEOUT_SECONDS,
+                            label="Deepgram finish (error cleanup)",
+                            quiet=True,
+                        )
                     except:
                         pass  # Игнорируем ошибки при завершении
 
+                # Принудительно сбрасываем клиента, чтобы след. попытка не унаследовала
+                # подвисшее соединение SDK.
+                self.dg_client = None
+                with contextlib.suppress(Exception):
+                    self.initialize()
+
             if attempt < 2:  # Не ждем после последней попытки
                 print(f"⚠️ Не удалось подключиться к Deepgram, попытка {attempt + 1}/3, повторяю...")
                 time.sleep(1)  # Уменьшаем задержку между попытками

app/audio/tts.py

@@ -6,7 +6,7 @@ Supports interruption via wake word detection using threading.
 
 # Модуль синтеза речи (TTS - Text-to-Speech).
 # Использует нейросеть Silero TTS для качественной русской речи.
-# Также поддерживает прерывание речи, если пользователь скажет "Alexandr".
+# Также поддерживает прерывание речи по wake word.
 
 import re
 import threading
@@ -14,15 +14,19 @@ import time
 import warnings
 
 import numpy as np
+import pyaudio
 import sounddevice as sd
 import torch
 
-from ..core.config import TTS_EN_SPEAKER, TTS_SAMPLE_RATE, TTS_SPEAKER
+from ..core.audio_manager import get_audio_manager
+from ..core.config import TTS_EN_SPEAKER, TTS_SAMPLE_RATE, TTS_SPEAKER, TTS_SPEED
 
 # Подавляем предупреждения Silero о длинном тексте (мы сами его режем)
 warnings.filterwarnings("ignore", message="Text string is longer than 1000 symbols")
 
 _EN_WORD_RE = re.compile(r"[A-Za-z][A-Za-z0-9'-]*")
+_MIXED_TTS_BUFFERED_SWITCHES = 3
+_INTERRUPT_POLL_SECONDS = 0.01
 
 
 class TextToSpeech:
@@ -32,10 +36,30 @@ class TextToSpeech:
         self.model_ru = None
         self.model_en = None
         self.sample_rate = TTS_SAMPLE_RATE
+        self.speed_factor = float(TTS_SPEED)
         self.speaker_ru = TTS_SPEAKER
         self.speaker_en = TTS_EN_SPEAKER
         self._interrupted = False
         self._stop_flag = threading.Event()
+        self._audio_manager = None
+        self._output_device_index = None
+
+    def _apply_speed(self, audio_np: np.ndarray) -> np.ndarray:
+        """Применяет небольшой time-stretch без изменения остальной логики TTS."""
+        audio = np.asarray(audio_np, dtype=np.float32)
+        if audio.size == 0:
+            return audio
+
+        speed = max(0.85, min(1.15, float(self.speed_factor)))
+        if abs(speed - 1.0) < 0.01:
+            return audio
+
+        # speed < 1.0 -> медленнее (длина массива больше), speed > 1.0 -> быстрее.
+        target_length = max(1, int(round(audio.size / speed)))
+        x_old = np.arange(audio.size, dtype=np.float32)
+        x_new = np.linspace(0.0, float(max(0, audio.size - 1)), target_length)
+        stretched = np.interp(x_new, x_old, audio)
+        return np.asarray(stretched, dtype=np.float32)
 
     def _load_model(self, language: str):
         """
@@ -48,21 +72,12 @@ class TextToSpeech:
             if self.model_en:
                 return self.model_en
             print("📦 Загрузка модели Silero TTS (en)...")
-            try:
+            model, _ = torch.hub.load(
-                model, _ = torch.hub.load(
+                repo_or_dir="snakers4/silero-models",
-                    repo_or_dir="snakers4/silero-models",
+                model="silero_tts",
-                    model="silero_tts",
+                language="en",
-                    language="en",
+                speaker="v3_en",
-                    speaker="v5_en",
+            )
-                )
-            except Exception as exc:
-                print(f"⚠️ Не удалось загрузить v5_en, пробую v3_en: {exc}")
-                model, _ = torch.hub.load(
-                    repo_or_dir="snakers4/silero-models",
-                    model="silero_tts",
-                    language="en",
-                    speaker="v3_en",
-                )
             model.to(device)
             self.model_en = model
             return model
@@ -181,28 +196,7 @@ class TextToSpeech:
         if not text.strip():
             return True
 
-        # Выбор модели
+        model, speaker = self._get_model_and_speaker(language)
-        if language == "en":
-            model = self._load_model("en")
-            speaker = self.speaker_en
-        else:
-            model = self._load_model("ru")
-            speaker = self.speaker_ru
-
-        # Проверка наличия спикера в модели (защита от ошибок конфига).
-        # Для русского языка сохраняем мужской голос по умолчанию.
-        if hasattr(model, "speakers") and model.speakers:
-            if language == "ru":
-                male_speakers = ("eugene", "aidar")
-                if speaker not in model.speakers or speaker not in male_speakers:
-                    for candidate in male_speakers:
-                        if candidate in model.speakers:
-                            speaker = candidate
-                            break
-                    else:
-                        speaker = model.speakers[0]
-            elif speaker not in model.speakers:
-                speaker = model.speakers[0]
 
         # Разбиваем текст на куски
         chunks = self._split_text(text)
@@ -229,17 +223,16 @@ class TextToSpeech:
                 )
 
                 # Конвертация в numpy массив для sounddevice
-                audio_np = audio.numpy()
+                audio_np = self._apply_speed(audio.numpy())
 
                 if check_interrupt:
-                    # Воспроизведение с проверкой прерывания (сложная логика)
+                    if not self._play_audio_with_interrupt(audio_np, check_interrupt):
-                    if not self._play_with_interrupt(audio_np, check_interrupt):
                         success = False
                         break
                 else:
-                    # Обычное воспроизведение (блокирующее)
+                    if not self._play_audio_blocking(audio_np):
-                    sd.play(audio_np, self.sample_rate)
+                        success = False
-                    sd.wait()
+                        break
 
             except Exception as e:
                 print(f"❌ Ошибка TTS (часть {i + 1}/{total_chunks}): {e}")
@@ -253,10 +246,104 @@ class TextToSpeech:
         else:
             return False
 
+    def _get_model_and_speaker(self, language: str):
+        """Возвращает модель и подходящий голос для языка."""
+        # Выбор модели
+        if language == "en":
+            model = self._load_model("en")
+            speaker = self.speaker_en
+        else:
+            model = self._load_model("ru")
+            speaker = self.speaker_ru
+
+        # Проверка наличия спикера в модели (защита от ошибок конфига).
+        # Для русского языка сохраняем мужской голос по умолчанию.
+        if hasattr(model, "speakers") and model.speakers:
+            if language == "ru":
+                male_speakers = ("eugene", "aidar")
+                if speaker not in model.speakers or speaker not in male_speakers:
+                    for candidate in male_speakers:
+                        if candidate in model.speakers:
+                            speaker = candidate
+                            break
+                    else:
+                        speaker = model.speakers[0]
+            elif speaker not in model.speakers:
+                speaker = model.speakers[0]
+
+        return model, speaker
+
+    def _synthesize_language_audio(self, text: str, language: str) -> np.ndarray | None:
+        """Собирает аудио для одного языка без промежуточного воспроизведения."""
+        if not text.strip():
+            return np.asarray([], dtype=np.float32)
+
+        model, speaker = self._get_model_and_speaker(language)
+        chunks = self._split_text(text)
+        audio_parts = []
+
+        for chunk in chunks:
+            if self._interrupted:
+                return None
+            audio = model.apply_tts(text=chunk, speaker=speaker, sample_rate=self.sample_rate)
+            audio_parts.append(self._apply_speed(audio.numpy()))
+
+        if not audio_parts:
+            return np.asarray([], dtype=np.float32)
+
+        return np.concatenate(audio_parts)
+
+    def _count_language_switches(self, segments: list[tuple[str, str]]) -> int:
+        if len(segments) < 2:
+            return 0
+        return sum(
+            1
+            for idx in range(1, len(segments))
+            if segments[idx - 1][1] != segments[idx][1]
+        )
+
+    def _speak_mixed_buffered(
+        self, segments: list[tuple[str, str]], check_interrupt=None
+    ) -> bool:
+        """Сначала собирает mixed RU/EN аудио, затем проигрывает единым потоком."""
+        print(f"🔊 Mixed TTS: буферизация сегментов ({len(segments)} шт.)")
+        self._interrupted = False
+        self._stop_flag.clear()
+
+        audio_parts = []
+        for idx, (segment, lang) in enumerate(segments, start=1):
+            if not segment.strip():
+                continue
+            if check_interrupt and check_interrupt():
+                self._interrupted = True
+                return False
+            try:
+                audio_np = self._synthesize_language_audio(segment, language=lang)
+            except Exception as exc:
+                print(f"❌ Ошибка mixed TTS (сегмент {idx}/{len(segments)}): {exc}")
+                return False
+            if audio_np is None:
+                return False
+            if audio_np.size:
+                audio_parts.append(audio_np)
+
+        if not audio_parts:
+            return True
+
+        full_audio = np.concatenate(audio_parts)
+        if check_interrupt:
+            return self._play_audio_with_interrupt(full_audio, check_interrupt)
+        return self._play_audio_blocking(full_audio)
+
     def _speak_mixed(
         self, segments: list[tuple[str, str]], check_interrupt=None
     ) -> bool:
         """Озвучивание текста с переключением RU/EN по сегментам."""
+        if self._count_language_switches(segments) >= _MIXED_TTS_BUFFERED_SWITCHES:
+            return self._speak_mixed_buffered(
+                segments, check_interrupt=check_interrupt
+            )
+
         for segment, lang in segments:
             if not segment.strip():
                 continue
@@ -283,6 +370,9 @@ class TextToSpeech:
         if not text.strip():
             return True
 
+        if check_interrupt is None:
+            check_interrupt = self._default_interrupt_checker()
+
         if language == "ru":
             text = self._preprocess_text(text)
             segments = self._split_mixed_language(text)
@@ -293,6 +383,83 @@ class TextToSpeech:
             text, check_interrupt=check_interrupt, language=language
         )
 
+    def _default_interrupt_checker(self):
+        try:
+            from .wakeword import check_wakeword_once
+
+            return check_wakeword_once
+        except Exception:
+            return None
+
+    def _resample_audio(self, audio_np: np.ndarray, src_rate: int, dst_rate: int):
+        if src_rate == dst_rate:
+            return audio_np.astype(np.float32, copy=False)
+        if audio_np.size == 0:
+            return np.asarray([], dtype=np.float32)
+
+        target_length = max(1, int(round(audio_np.size * dst_rate / src_rate)))
+        x_old = np.arange(audio_np.size, dtype=np.float32)
+        x_new = np.linspace(0.0, float(max(0, audio_np.size - 1)), target_length)
+        resampled = np.interp(x_new, x_old, audio_np.astype(np.float32))
+        return np.asarray(resampled, dtype=np.float32)
+
+    def _play_audio_blocking(self, audio_np: np.ndarray) -> bool:
+        try:
+            sd.play(audio_np, self.sample_rate)
+            sd.wait()
+            return True
+        except Exception as exc:
+            print(f"⚠️ sounddevice playback failed, fallback to PyAudio: {exc}")
+            return self._play_with_pyaudio(audio_np, check_interrupt=None)
+
+    def _play_audio_with_interrupt(self, audio_np: np.ndarray, check_interrupt) -> bool:
+        try:
+            return self._play_with_interrupt_sounddevice(audio_np, check_interrupt)
+        except Exception as exc:
+            print(
+                "⚠️ sounddevice playback-with-interrupt failed, fallback to PyAudio: "
+                f"{exc}"
+            )
+            return self._play_with_pyaudio(audio_np, check_interrupt=check_interrupt)
+
+    def _play_with_pyaudio(self, audio_np: np.ndarray, check_interrupt=None) -> bool:
+        if self._audio_manager is None:
+            self._audio_manager = get_audio_manager()
+
+        output_stream = None
+        try:
+            output_stream, self._output_device_index, out_rate = (
+                self._audio_manager.open_output_stream(
+                    rate=self.sample_rate,
+                    channels=1,
+                    format=pyaudio.paFloat32,
+                    preferred_index=self._output_device_index,
+                    fallback_rates=[48000, 44100, 32000, 22050],
+                )
+            )
+            pcm = self._resample_audio(audio_np, self.sample_rate, out_rate)
+            chunk_size = max(256, int(out_rate * 0.03))
+
+            for offset in range(0, len(pcm), chunk_size):
+                if check_interrupt and check_interrupt():
+                    self._interrupted = True
+                    return False
+                output_stream.write(pcm[offset : offset + chunk_size].tobytes())
+            return True
+        except Exception as exc:
+            print(f"❌ PyAudio playback failed: {exc}")
+            return False
+        finally:
+            if output_stream is not None:
+                try:
+                    output_stream.stop_stream()
+                except Exception:
+                    pass
+                try:
+                    output_stream.close()
+                except Exception:
+                    pass
+
     def _check_interrupt_worker(self, check_interrupt):
         """
         Фоновая функция для потока: постоянно опрашивает check_interrupt.
@@ -307,8 +474,11 @@ class TextToSpeech:
                     return
             except Exception:
                 pass
+            time.sleep(_INTERRUPT_POLL_SECONDS)
 
-    def _play_with_interrupt(self, audio_np: np.ndarray, check_interrupt) -> bool:
+    def _play_with_interrupt_sounddevice(
+        self, audio_np: np.ndarray, check_interrupt
+    ) -> bool:
         """
         Воспроизводит аудио, параллельно проверяя условие прерывания в отдельном потоке.
         """
@@ -322,11 +492,18 @@ class TextToSpeech:
             # Запускаем воспроизведение (неблокирующее)
             sd.play(audio_np, self.sample_rate)
 
-            # Ждем окончания воспроизведения в цикле
+            # Ждем окончания воспроизведения в цикле.
-            while sd.get_stream().active:
+            while True:
                 if self._interrupted:
                     break
-                time.sleep(0.02)  # Уменьшаем задержку для более быстрого реагирования
+                stream = sd.get_stream()
+                if stream is None or not stream.active:
+                    break
+                time.sleep(0.02)
+
+            if not self._interrupted:
+                # Добираем хвост буфера даже если stream.active мигнул в False чуть раньше.
+                sd.wait()
 
         finally:
             # Сообщаем потоку-наблюдателю, что пора завершаться

app/audio/wakeword.py

@@ -1,18 +1,34 @@
 """
 Wake word detection module using Porcupine.
-Listens for the "Alexandr" wake word.
+Listens for the configured wake word.
 """
 
 # Этот модуль отвечает за "уши" ассистента в режиме ожидания.
-# Он использует библиотеку Porcupine для эффективного (мало CPU) обнаружения ключевой фразы "Alexandr".
+# Он использует библиотеку Porcupine для эффективного (мало CPU) обнаружения ключевой фразы.
 
 import pvporcupine
 import pyaudio
 import struct
+import io
+import wave
+import time
+import numpy as np
+import httpx
+from collections import deque
+from deepgram import DeepgramClient
+from deepgram.clients.listen.v1.rest.options import PrerecordedOptions
 from ..core.config import (
+    DEEPGRAM_API_KEY,
     PORCUPINE_ACCESS_KEY,
     PORCUPINE_KEYWORD_PATH,
     PORCUPINE_SENSITIVITY,
+    WAKEWORD_HIT_COOLDOWN_SECONDS,
+    WAKEWORD_ENABLE_FALLBACK_STT,
+    WAKEWORD_MIN_RMS,
+    WAKEWORD_REOPEN_GRACE_SECONDS,
+    WAKEWORD_RMS_MULTIPLIER,
+    WAKE_WORD,
+    WAKE_WORD_ALIASES,
 )
 from ..core.audio_manager import get_audio_manager
 
@@ -24,8 +40,26 @@ class WakeWordDetector:
         self.porcupine = None
         self.audio_stream = None
         self.pa = None
+        self._audio_manager = None
+        self._input_device_index = None
+        self._capture_sample_rate = None
+        self._capture_frame_length = None
+        self._resampled_pcm_buffer = np.array([], dtype=np.int16)
         self._stream_closed = True  # Флаг состояния потока (закрыт/открыт)
         self._last_hit_ts = 0.0
+        self._fallback_dg_client = None
+        self._fallback_pre_roll = deque(maxlen=4)
+        self._fallback_frames = []
+        self._fallback_active = False
+        self._fallback_silence_frames = 0
+        self._fallback_last_attempt_ts = 0.0
+        self._fallback_last_error_ts = 0.0
+        self._stream_opened_ts = 0.0
+        self._rms_history = deque(maxlen=220)
+        self._wakeword_aliases_compact = {
+            self._compact_text(WAKE_WORD),
+            *(self._compact_text(alias) for alias in WAKE_WORD_ALIASES),
+        }
 
     def initialize(self):
         """Инициализация Porcupine и PyAudio."""
@@ -37,9 +71,13 @@ class WakeWordDetector:
         )
 
         # Используем общий экземпляр PyAudio
-        self.pa = get_audio_manager().get_pyaudio()
+        self._audio_manager = get_audio_manager()
+        self.pa = self._audio_manager.get_pyaudio()
         self._open_stream()
-        print(f"🎤 Ожидание wake word 'Alexandr' (sens={PORCUPINE_SENSITIVITY:.2f})...")
+        print(
+            f"🎤 Ожидание wake word '{WAKE_WORD}' "
+            f"(sens={PORCUPINE_SENSITIVITY:.2f}, mic_rate={self._capture_sample_rate})..."
+        )
 
     def _open_stream(self):
         """Открытие аудиопотока с микрофона."""
@@ -53,15 +91,234 @@ class WakeWordDetector:
             except Exception:
                 pass
 
-        # Открываем поток с параметрами, которые требует Porcupine
+        target_rate = int(self.porcupine.sample_rate)
-        self.audio_stream = self.pa.open(
+        fallback_rates = [48000, 44100, 32000, 22050, 16000]
-            rate=self.porcupine.sample_rate,
+        self.audio_stream, self._input_device_index, actual_rate = self._audio_manager.open_input_stream(
+            rate=target_rate,
             channels=1,
             format=pyaudio.paInt16,
-            input=True,
             frames_per_buffer=self.porcupine.frame_length,
+            preferred_index=self._input_device_index,
+            fallback_rates=fallback_rates,
         )
+        self._capture_sample_rate = int(actual_rate)
+        self._capture_frame_length = max(
+            64,
+            int(
+                round(
+                    self.porcupine.frame_length
+                    * self._capture_sample_rate
+                    / target_rate
+                )
+            ),
+        )
+        self._resampled_pcm_buffer = np.array([], dtype=np.int16)
         self._stream_closed = False
+        self._stream_opened_ts = time.time()
+        self._reset_fallback_state()
+
+    @staticmethod
+    def _compute_rms(pcm: np.ndarray) -> float:
+        if pcm.size == 0:
+            return 0.0
+        as_float = pcm.astype(np.float32)
+        return float(np.sqrt(np.mean(as_float * as_float)))
+
+    @staticmethod
+    def _compact_text(text: str) -> str:
+        text = str(text or "").lower().replace("ё", "е")
+        return "".join(ch for ch in text if ch.isalnum())
+
+    def _remember_rms(self, rms: float):
+        if rms <= 0:
+            return
+        self._rms_history.append(float(rms))
+
+    def _noise_floor_rms(self) -> float:
+        if not self._rms_history:
+            return 0.0
+        # Низкий процентиль устойчив к редким всплескам/голосу.
+        return float(np.percentile(np.asarray(self._rms_history, dtype=np.float32), 20))
+
+    def _wakeword_rms_threshold(self) -> float:
+        floor = self._noise_floor_rms()
+        dynamic = floor * float(WAKEWORD_RMS_MULTIPLIER)
+        # Защитный максимум, чтобы в очень шумном окружении не "убить" детект полностью.
+        dynamic = min(dynamic, float(WAKEWORD_MIN_RMS) * 4.0)
+        return max(float(WAKEWORD_MIN_RMS), dynamic)
+
+    def _is_hit_in_guard_window(
+        self, now_ts: float, *, ignore_hit_cooldown: bool = False
+    ) -> bool:
+        if (
+            not ignore_hit_cooldown
+            and now_ts - self._last_hit_ts < float(WAKEWORD_HIT_COOLDOWN_SECONDS)
+        ):
+            return True
+        if (
+            self._stream_opened_ts > 0
+            and now_ts - self._stream_opened_ts < float(WAKEWORD_REOPEN_GRACE_SECONDS)
+        ):
+            return True
+        return False
+
+    def _accept_porcupine_hit(
+        self,
+        pcm: np.ndarray,
+        now_ts: float,
+        *,
+        ignore_hit_cooldown: bool = False,
+        during_tts: bool = False,
+    ) -> bool:
+        if self._is_hit_in_guard_window(
+            now_ts, ignore_hit_cooldown=ignore_hit_cooldown
+        ):
+            return False
+        rms = self._compute_rms(pcm)
+        # Для "чистого" Porcupine оставляем мягкий амплитудный фильтр:
+        # он отсеивает тишину/щелчки и ложные фаны от фонового шума.
+        # Во время TTS делаем фильтр строже, чтобы собственная колонка
+        # не "будила" ассистента.
+        factor = 0.95 if during_tts else 0.75
+        threshold = max(80.0, self._wakeword_rms_threshold() * factor)
+        if rms < threshold:
+            return False
+        self._last_hit_ts = now_ts
+        return True
+
+    def _reset_fallback_state(self):
+        self._fallback_pre_roll.clear()
+        self._fallback_frames = []
+        self._fallback_active = False
+        self._fallback_silence_frames = 0
+
+    def _get_fallback_client(self):
+        if not WAKEWORD_ENABLE_FALLBACK_STT:
+            return None
+        if not DEEPGRAM_API_KEY:
+            return None
+        if self._fallback_dg_client is None:
+            self._fallback_dg_client = DeepgramClient(DEEPGRAM_API_KEY)
+        return self._fallback_dg_client
+
+    def _pcm_to_wav_bytes(self, pcm: np.ndarray) -> bytes:
+        buffer = io.BytesIO()
+        with wave.open(buffer, "wb") as wav_file:
+            wav_file.setnchannels(1)
+            wav_file.setsampwidth(2)
+            wav_file.setframerate(int(self.porcupine.sample_rate))
+            wav_file.writeframes(np.asarray(pcm, dtype=np.int16).tobytes())
+        return buffer.getvalue()
+
+    def _transcribe_wakeword_candidate(self, pcm: np.ndarray) -> bool:
+        client = self._get_fallback_client()
+        if client is None or pcm.size == 0:
+            return False
+
+        try:
+            response = client.listen.rest.v("1").transcribe_file(
+                {"buffer": self._pcm_to_wav_bytes(pcm)},
+                PrerecordedOptions(
+                    model="nova-2",
+                    language="ru",
+                    smart_format=False,
+                    punctuate=False,
+                    utterances=False,
+                    numerals=False,
+                ),
+                timeout=httpx.Timeout(2.2, connect=2.2, read=2.2, write=2.2),
+            )
+        except Exception as exc:
+            now = time.time()
+            if now - self._fallback_last_error_ts >= 30.0:
+                print(f"⚠️ Wake word fallback STT failed: {exc}")
+                self._fallback_last_error_ts = now
+            return False
+
+        transcript = ""
+        confidence = None
+        try:
+            channels = response.results.channels or []
+            if channels and channels[0].alternatives:
+                first_alt = channels[0].alternatives[0]
+                transcript = str(first_alt.transcript or "").strip()
+                try:
+                    confidence = float(first_alt.confidence)
+                except Exception:
+                    confidence = None
+        except Exception:
+            transcript = ""
+            confidence = None
+
+        compact = self._compact_text(transcript)
+        if confidence is not None and confidence < 0.62:
+            return False
+        if compact in self._wakeword_aliases_compact:
+            print(f"✅ Wake word обнаружен fallback STT: {transcript}")
+            return True
+        return False
+
+    def _check_fallback_wakeword(
+        self,
+        pcm: np.ndarray,
+        *,
+        during_tts: bool = False,
+        ignore_hit_cooldown: bool = False,
+    ) -> bool:
+        if not WAKEWORD_ENABLE_FALLBACK_STT:
+            return False
+        if self.porcupine is None:
+            return False
+
+        rms = self._compute_rms(pcm)
+        base_threshold = self._wakeword_rms_threshold()
+        speech_factor = 1.1 if during_tts else 0.85
+        speech_threshold = max(170.0, base_threshold * speech_factor)
+        silence_threshold = max(95.0, speech_threshold * 0.55)
+        silence_frames_to_finalize = 10 if during_tts else 8
+        min_frames = 10 if during_tts else 7
+        max_frames = 40
+        min_attempt_interval = 2.5 if during_tts else 1.0
+
+        if rms >= speech_threshold:
+            if not self._fallback_active:
+                self._fallback_active = True
+                self._fallback_frames = list(self._fallback_pre_roll)
+                self._fallback_silence_frames = 0
+            self._fallback_frames.append(np.asarray(pcm, dtype=np.int16))
+        elif self._fallback_active:
+            self._fallback_frames.append(np.asarray(pcm, dtype=np.int16))
+            if rms <= silence_threshold:
+                self._fallback_silence_frames += 1
+            else:
+                self._fallback_silence_frames = 0
+
+            if len(self._fallback_frames) > max_frames:
+                self._reset_fallback_state()
+            elif self._fallback_silence_frames >= silence_frames_to_finalize:
+                candidate = np.concatenate(self._fallback_frames) if self._fallback_frames else np.asarray([], dtype=np.int16)
+                self._reset_fallback_state()
+                if len(candidate) >= min_frames * int(self.porcupine.frame_length):
+                    now = time.time()
+                    candidate_rms = self._compute_rms(candidate)
+                    candidate_threshold = self._wakeword_rms_threshold() * (
+                        0.95 if during_tts else 0.75
+                    )
+                    candidate_threshold = max(float(WAKEWORD_MIN_RMS), candidate_threshold)
+                    if (
+                        now - self._fallback_last_attempt_ts >= min_attempt_interval
+                        and not self._is_hit_in_guard_window(
+                            now, ignore_hit_cooldown=ignore_hit_cooldown
+                        )
+                        and candidate_rms >= candidate_threshold
+                    ):
+                        self._fallback_last_attempt_ts = now
+                        if self._transcribe_wakeword_candidate(candidate):
+                            self._last_hit_ts = now
+                            return True
+
+        self._fallback_pre_roll.append(np.asarray(pcm, dtype=np.int16))
+        return False
 
     def stop_monitoring(self):
         """Явная остановка и закрытие потока (чтобы освободить микрофон для других задач)."""
@@ -72,10 +329,46 @@ class WakeWordDetector:
             except Exception:
                 pass
             self._stream_closed = True
+            self._stream_opened_ts = 0.0
+        self._reset_fallback_state()
+
+    def _resample_to_target_rate(self, pcm: np.ndarray) -> np.ndarray:
+        target_rate = int(self.porcupine.sample_rate)
+        source_rate = int(self._capture_sample_rate or target_rate)
+        if source_rate == target_rate:
+            return pcm
+        if pcm.size == 0:
+            return np.array([], dtype=np.int16)
+        target_length = max(1, int(round(pcm.size * target_rate / source_rate)))
+        x_old = np.arange(pcm.size, dtype=np.float32)
+        x_new = np.linspace(0.0, float(max(0, pcm.size - 1)), target_length)
+        resampled = np.interp(x_new, x_old, pcm.astype(np.float32))
+        return np.asarray(resampled, dtype=np.int16)
+
+    def _read_porcupine_frame(self):
+        target_length = int(self.porcupine.frame_length)
+        if self._capture_sample_rate == self.porcupine.sample_rate:
+            pcm = self.audio_stream.read(target_length, exception_on_overflow=False)
+            return np.asarray(struct.unpack_from("h" * target_length, pcm), dtype=np.int16)
+
+        while self._resampled_pcm_buffer.size < target_length:
+            raw = self.audio_stream.read(
+                self._capture_frame_length, exception_on_overflow=False
+            )
+            captured = np.frombuffer(raw, dtype=np.int16)
+            converted = self._resample_to_target_rate(captured)
+            if converted.size:
+                self._resampled_pcm_buffer = np.concatenate(
+                    (self._resampled_pcm_buffer, converted)
+                )
+
+        frame = self._resampled_pcm_buffer[:target_length]
+        self._resampled_pcm_buffer = self._resampled_pcm_buffer[target_length:]
+        return frame
 
     def wait_for_wakeword(self, timeout: float = None) -> bool:
         """
-        Блокирующая функция: ждет, пока не будет услышана фраза "Alexandr"
+        Блокирующая функция: ждет, пока не будет услышана wake word
         или пока не истечет timeout.
 
         Args:
@@ -100,19 +393,21 @@ class WakeWordDetector:
                 return False
 
             # Читаем небольшой кусочек аудио (frame)
-            pcm = self.audio_stream.read(
+            pcm = self._read_porcupine_frame()
-                self.porcupine.frame_length, exception_on_overflow=False
+            self._remember_rms(self._compute_rms(pcm))
-            )
-            # Конвертируем байты в кортеж чисел (требование Porcupine)
-            pcm = struct.unpack_from("h" * self.porcupine.frame_length, pcm)
 
             # Обрабатываем фрейм через Porcupine
-            keyword_index = self.porcupine.process(pcm)
+            keyword_index = self.porcupine.process(pcm.tolist())
 
             # Если keyword_index >= 0, значит ключевое слово обнаружено
             if keyword_index >= 0:
-                print("✅ Wake word обнаружен!")
+                now = time.time()
-                # Важно: закрываем поток, чтобы освободить микрофон для STT (Deepgram)
+                if self._accept_porcupine_hit(pcm, now, during_tts=False):
+                    print("✅ Wake word обнаружен!")
+                    # Важно: закрываем поток, чтобы освободить микрофон для STT (Deepgram)
+                    self.stop_monitoring()
+                    return True
+            if self._check_fallback_wakeword(pcm):
                 self.stop_monitoring()
                 return True
 
@@ -133,19 +428,26 @@ class WakeWordDetector:
         try:
             self._open_stream()
 
-            pcm = self.audio_stream.read(
+            pcm = self._read_porcupine_frame()
-                self.porcupine.frame_length, exception_on_overflow=False
+            self._remember_rms(self._compute_rms(pcm))
-            )
-            pcm = struct.unpack_from("h" * self.porcupine.frame_length, pcm)
 
-            keyword_index = self.porcupine.process(pcm)
+            keyword_index = self.porcupine.process(pcm.tolist())
             if keyword_index >= 0:
                 now = time.time()
-                if now - self._last_hit_ts < 0.2:  # Уменьшаем интервал для более быстрой реакции
+                if not self._accept_porcupine_hit(
+                    pcm,
+                    now,
+                    ignore_hit_cooldown=True,
+                    during_tts=True,
+                ):
                     return False
-                self._last_hit_ts = now
                 print("🛑 Wake word обнаружен во время ответа!")
                 return True
+            if self._check_fallback_wakeword(
+                pcm, during_tts=True, ignore_hit_cooldown=True
+            ):
+                print("🛑 Wake word обнаружен fallback STT во время ответа!")
+                return True
             return False
         except Exception:
             return False

app/core/ai.py

@@ -7,7 +7,12 @@ from typing import Optional
 import requests
 
 from .config import (
+    AI_CHAT_MAX_CHARS,
     AI_PROVIDER,
+    AI_CHAT_MAX_TOKENS,
+    AI_CHAT_TEMPERATURE,
+    AI_INTENT_TEMPERATURE,
+    AI_TRANSLATION_TEMPERATURE,
     ANTHROPIC_API_KEY,
     ANTHROPIC_API_URL,
     ANTHROPIC_API_VERSION,
@@ -15,29 +20,46 @@ from .config import (
     GEMINI_API_KEY,
     GEMINI_API_URL,
     GEMINI_MODEL,
+    OLLAMA_API_URL,
+    OLLAMA_MODEL,
     OPENAI_API_KEY,
     OPENAI_API_URL,
     OPENAI_MODEL,
-    PERPLEXITY_API_KEY,
+    OPENROUTER_API_KEY,
-    PERPLEXITY_API_URL,
+    OPENROUTER_API_URL,
-    PERPLEXITY_MODEL,
+    OPENROUTER_MODEL,
+    WAKE_WORD,
+    WAKE_WORD_ALIASES,
     ZAI_API_KEY,
     ZAI_API_URL,
     ZAI_MODEL,
 )
 
 _HTTP = requests.Session()
+_CITATION_SQUARE_RE = re.compile(r"(?:\s*\[\d+\])+")
+_CITATION_FULLWIDTH_RE = re.compile(r"【\d+[^】]*】")
+_PUNCT_SPACING_RE = re.compile(r"\s+([,.;:!?…])")
+_SENTENCE_BOUNDARY_RE = re.compile(r"([.!?…])\s+")
+_SENTENCE_SPLIT_RE = re.compile(r"(?<=[.!?…])\s+")
 
 # Системный промпт
-SYSTEM_PROMPT = """Ты — Александр, умный голосовой ассистент с человеческим поведением.
+_wake_word_aliases_text = ", ".join(WAKE_WORD_ALIASES)
+SYSTEM_PROMPT = f"""Ты — умный голосовой ассистент с человеческим поведением.
 Веди себя как живой человек: будь дружелюбным, естественным и немного эмоциональным, где это уместно.
 Твоя главная цель — помогать пользователю и поддерживать интересный диалог.
-Отвечай кратко и по существу, на русском языке.
+Отвечай на русском языке кратко и по существу: обычно 1-2 коротких предложения.
+Если пользователь явно просит подробнее, можно до 4 коротких предложений без повторов и лишних вводных.
 Избегай длинных списков, сложного форматирования и спецсимволов, так как твои ответы озвучиваются голосом.
+Не добавляй ссылки, сноски и маркеры источников (например, [1], [2], URL).
 Пиши в разговорном стиле, как при живом общении, но не забывай о вежливости и правильности твоих ответов.
-ВАЖНО: Не используй в ответах панибратские или сленговые приветствия и обращения, такие как "Эй", "Хэй", "Слушай" в начале фразы и подобные."""
+Понимай юмор, иронию, сарказм, образные выражения, намеки и переносный смысл фраз.
+Если пользователь шутит или говорит образно, сначала правильно восстанови его реальное намерение, затем ответь естественно и по смыслу.
+Если в шутке или метафоре скрыта команда или просьба, трактуй ее по смыслу, а не буквально.
+ВАЖНО: Не используй в ответах панибратские или сленговые приветствия и обращения, такие как "Эй", "Хэй", "Слушай" в начале фразы и подобные.
+Тебя активируют словом "{WAKE_WORD}". Никогда не произноси это слово и его варианты ({_wake_word_aliases_text}) ни в каком ответе.
+Если пользователь спрашивает, как тебя зовут или как к тебе обращаться, отвечай нейтрально: "Я ваш голосовой ассистент"."""
 SYSTEM_PROMPT += (
-    '\nROLE_JSON: {"name":"Александр","role":"умный голосовой ассистент",'
+    '\nROLE_JSON: {"name":"голосовой ассистент","role":"умный голосовой ассистент",'
     '"language":"ru","style":["дружелюбный","естественный","краткий"],"format":"plain"}'
 )
 
@@ -49,15 +71,48 @@ No explanations, no quotes, no comments.
 Separate variants with " / " (space slash space).
 Keep the translation максимально кратким и естественным, без лишних слов."""
 
+INTENT_SYSTEM_PROMPT = """Ты NLU-модуль голосовой колонки.
+Твоя задача: распознать намерение пользователя и вернуть СТРОГО JSON без markdown и пояснений.
+Всегда возвращай объект c ключами:
+{
+  "intent": "none|music|timer|alarm|weather|volume|translation|cities|repeat|stop|smalltalk|chat",
+  "normalized_command": "<краткая нормализованная команда на русском или пусто>",
+  "music_action": "none|play|pause|resume|next|previous|current|play_genre|play_folder|play_query",
+  "music_query": "<запрос для музыки/жанра/папки или пусто>",
+  "confidence": 0.0
+}
+Правила:
+- Если это музыка, ставь intent=music и выбирай music_action.
+- "Включи музыку" и любые эквиваленты = music_action=play.
+- Для "пауза/останови музыку/выключи музыку" = music_action=pause.
+- Для "что играет" = music_action=current.
+- Для "включи жанр X" = music_action=play_genre, music_query=X.
+- Для "включи папку X" = music_action=play_folder, music_query=X.
+- Если это будильник, ставь intent=alarm и нормализуй команду в одну из форм:
+  1) Создание/изменение: "поставь будильник на HH:MM [по будням|по выходным|каждый день|по <дням>]"
+  2) Показ списка: "покажи активные будильники"
+  3) Удаление конкретного: "удали будильник на HH:MM [по будням|по выходным|по <дням>]"
+  4) Удаление всех: "отмени все будильники"
+- Если пользователь просит поставить/удалить будильник, но время не названо, normalized_command должен быть:
+  "поставь будильник" или "удали будильник".
+- normalized_command должен быть пригоден для командного парсера (без лишних слов).
+- Понимай разговорные, шутливые, переносные, косвенные и ироничные формулировки.
+- Восстанавливай намерение по смыслу, а не только по буквальным словам.
+- Если в фразе есть скрытая прикладная команда для колонки, верни соответствующий intent и normalized_command.
+- Если пользователь просто шутит или разговаривает без прикладной команды, выбирай smalltalk или chat, а не случайную системную команду.
+- Если уверенность низкая, ставь intent=none, music_action=none, confidence <= 0.4."""
+
 _PROVIDER_ALIASES = {
-    "": "perplexity",
+    "": "openrouter",
     "anthropic": "anthropic",
     "claude": "anthropic",
     "claude_anthropic": "anthropic",
     "gemini": "gemini",
     "google": "gemini",
+    "olama": "ollama",
+    "ollama": "ollama",
     "openai": "openai",
-    "perplexity": "perplexity",
+    "openrouter": "openrouter",
     "z.ai": "zai",
     "z-ai": "zai",
     "z_ai": "zai",
@@ -66,15 +121,15 @@ _PROVIDER_ALIASES = {
 
 # В .env нужен только один AI-ключ
 _PROVIDER_SETTINGS = {
-    "perplexity": {
+    "openrouter": {
-        "provider": "perplexity",
+        "provider": "openrouter",
         "protocol": "openai_compatible",
-        "api_key": PERPLEXITY_API_KEY,
+        "api_key": OPENROUTER_API_KEY,
-        "model": PERPLEXITY_MODEL,
+        "model": OPENROUTER_MODEL,
-        "api_url": PERPLEXITY_API_URL,
+        "api_url": OPENROUTER_API_URL,
-        "name": "Perplexity",
+        "name": "OpenRouter",
-        "key_var": "PERPLEXITY_API_KEY",
+        "key_var": "OPENROUTER_API_KEY",
-        "model_var": "PERPLEXITY_MODEL",
+        "model_var": "OPENROUTER_MODEL",
     },
     "openai": {
         "provider": "openai",
@@ -120,6 +175,18 @@ _PROVIDER_SETTINGS = {
         "key_var": "ANTHROPIC_API_KEY",
         "model_var": "ANTHROPIC_MODEL",
     },
+    "ollama": {
+        "provider": "ollama",
+        "protocol": "openai_compatible",
+        # Ollama обычно локальный и не требует API key.
+        "api_key": None,
+        "requires_api_key": False,
+        "model": OLLAMA_MODEL,
+        "api_url": OLLAMA_API_URL,
+        "name": "Ollama",
+        "key_var": "OLLAMA_API_KEY",
+        "model_var": "OLLAMA_MODEL",
+    },
 }
 
 
@@ -169,10 +236,10 @@ def _get_provider_settings():
 
     supported = ", ".join(sorted(_PROVIDER_SETTINGS))
     print(
-        f"⚠️ Неизвестный AI_PROVIDER={AI_PROVIDER!r}, используем Perplexity. "
+        f"⚠️ Неизвестный AI_PROVIDER={AI_PROVIDER!r}, используем OpenRouter. "
         f"Поддерживаются: {supported}."
     )
-    return _PROVIDER_SETTINGS["perplexity"], None
+    return _PROVIDER_SETTINGS["openrouter"], None
 
 
 def _content_to_text(content) -> str:
@@ -196,7 +263,7 @@ def _content_to_text(content) -> str:
 def _get_provider_config_error(cfg) -> Optional[str]:
     if not cfg:
         return "Не настроен AI-провайдер. Проверьте файл .env."
-    if not cfg["api_key"]:
+    if cfg.get("requires_api_key", True) and not cfg.get("api_key"):
         return f"Не настроен {cfg['key_var']}. Проверьте файл .env."
     if not cfg["model"]:
         return f"Не настроен {cfg['model_var']}. Проверьте файл .env."
@@ -211,10 +278,9 @@ def _build_headers(cfg):
             "Content-Type": "application/json",
         }
 
-    headers = {
+    headers = {"Content-Type": "application/json"}
-        "Authorization": f"Bearer {cfg['api_key']}",
+    if cfg.get("api_key"):
-        "Content-Type": "application/json",
+        headers["Authorization"] = f"Bearer {cfg['api_key']}"
-    }
     headers.update(cfg.get("extra_headers") or {})
     return headers
 
@@ -283,11 +349,7 @@ def _extract_response_content(cfg, data: dict) -> str:
 
 
 def _iter_openai_compatible_stream(response):
-    for line in response.iter_lines(decode_unicode=True):
+    for data_str in _iter_sse_data_lines(response):
-        if not line or not line.startswith("data:"):
-            continue
-
-        data_str = line[5:].strip()
         if data_str == "[DONE]":
             break
 
@@ -317,11 +379,7 @@ def _iter_openai_compatible_stream(response):
 
 
 def _iter_anthropic_stream(response):
-    for line in response.iter_lines(decode_unicode=True):
+    for data_str in _iter_sse_data_lines(response):
-        if not line or not line.startswith("data:"):
-            continue
-
-        data_str = line[5:].strip()
         if data_str == "[DONE]":
             break
 
@@ -344,6 +402,28 @@ def _iter_anthropic_stream(response):
                 yield str(text)
 
 
+def _iter_sse_data_lines(response):
+    """
+    Читает SSE-стрим и возвращает только payload после "data:".
+    Явно декодируем как UTF-8, чтобы избежать mojibake вида "Пр...".
+    """
+    for raw_line in response.iter_lines(decode_unicode=False):
+        if not raw_line:
+            continue
+
+        if isinstance(raw_line, bytes):
+            line = raw_line.decode("utf-8", errors="replace")
+        else:
+            line = str(raw_line)
+
+        if not line.startswith("data:"):
+            continue
+
+        data_str = line[5:].strip()
+        if data_str:
+            yield data_str
+
+
 def _iter_stream_chunks(cfg, response):
     if cfg["protocol"] == "anthropic":
         yield from _iter_anthropic_stream(response)
@@ -362,6 +442,86 @@ def _log_request_exception(cfg, error: Exception):
     print(f"❌ Ошибка API ({cfg['name']}): {error}{details}")
 
 
+def _extract_json_object(raw_text: str) -> Optional[dict]:
+    text = str(raw_text or "").strip()
+    if not text:
+        return None
+
+    try:
+        payload = json.loads(text)
+        if isinstance(payload, dict):
+            return payload
+    except json.JSONDecodeError:
+        pass
+
+    match = re.search(r"\{.*\}", text, flags=re.DOTALL)
+    if not match:
+        return None
+
+    candidate = match.group(0).strip()
+    try:
+        payload = json.loads(candidate)
+    except json.JSONDecodeError:
+        return None
+    if isinstance(payload, dict):
+        return payload
+    return None
+
+
+def _sanitize_chat_response(text: str) -> str:
+    cleaned = str(text or "")
+    if not cleaned:
+        return ""
+
+    cleaned = _CITATION_SQUARE_RE.sub("", cleaned)
+    cleaned = _CITATION_FULLWIDTH_RE.sub("", cleaned)
+    cleaned = _PUNCT_SPACING_RE.sub(r"\1", cleaned)
+    cleaned = re.sub(r"[ \t]+", " ", cleaned)
+    cleaned = re.sub(r"\n{3,}", "\n\n", cleaned)
+    return cleaned.strip()
+
+
+def _truncate_chat_response(text: str, max_chars: int) -> str:
+    cleaned = str(text or "").strip()
+    if not cleaned:
+        return ""
+
+    safe_limit = max(120, int(max_chars))
+    if len(cleaned) <= safe_limit:
+        return cleaned
+
+    sentences = [part.strip() for part in _SENTENCE_SPLIT_RE.split(cleaned) if part.strip()]
+    if sentences:
+        selected = []
+        current_length = 0
+        for sentence in sentences:
+            projected = current_length + len(sentence) + (1 if selected else 0)
+            if projected > safe_limit:
+                break
+            selected.append(sentence)
+            current_length = projected
+
+        if selected:
+            result = " ".join(selected).rstrip(" ,;:-")
+            if result and result[-1] not in ".!?…":
+                result += "."
+            return result
+
+        # Если первое предложение слишком длинное, режем аккуратно по слову.
+        first = sentences[0]
+    else:
+        first = cleaned
+
+    clipped = first[:safe_limit].rstrip()
+    word_boundary = clipped.rfind(" ")
+    if word_boundary >= int(safe_limit * 0.6):
+        clipped = clipped[:word_boundary].rstrip()
+    clipped = clipped.rstrip(" ,;:-")
+    if clipped.endswith((".", "!", "?", "…")):
+        return clipped
+    return f"{clipped}..."
+
+
 def _send_request(messages, max_tokens, temperature, error_text):
     """
     Внутренняя функция для отправки HTTP-запроса к выбранному AI-провайдеру.
@@ -403,6 +563,98 @@ def _send_request(messages, max_tokens, temperature, error_text):
         return "Не удалось обработать ответ от AI."
 
 
+def interpret_assistant_intent(text: str) -> dict:
+    """
+    Interprets voice command semantics for downstream command routers.
+    Returns a normalized dict even when AI is unavailable.
+    """
+    result = {
+        "intent": "none",
+        "normalized_command": "",
+        "music_action": "none",
+        "music_query": "",
+        "confidence": 0.0,
+    }
+    cleaned_text = str(text or "").strip()
+    if not cleaned_text:
+        return result
+
+    cfg, selection_error = _get_provider_settings()
+    if selection_error:
+        return result
+    if _get_provider_config_error(cfg):
+        return result
+
+    messages = [
+        {"role": "system", "content": INTENT_SYSTEM_PROMPT},
+        {"role": "user", "content": cleaned_text},
+    ]
+    response = _send_request(
+        messages,
+        max_tokens=220,
+        temperature=AI_INTENT_TEMPERATURE,
+        error_text="",
+    )
+    payload = _extract_json_object(response)
+    if not payload:
+        return result
+
+    allowed_intents = {
+        "none",
+        "music",
+        "timer",
+        "alarm",
+        "weather",
+        "volume",
+        "translation",
+        "cities",
+        "repeat",
+        "stop",
+        "smalltalk",
+        "chat",
+    }
+    allowed_music_actions = {
+        "none",
+        "play",
+        "pause",
+        "resume",
+        "next",
+        "previous",
+        "current",
+        "play_genre",
+        "play_folder",
+        "play_query",
+    }
+
+    intent = str(payload.get("intent", "none")).strip().lower()
+    if intent not in allowed_intents:
+        intent = "none"
+
+    music_action = str(payload.get("music_action", "none")).strip().lower()
+    if music_action not in allowed_music_actions:
+        music_action = "none"
+
+    try:
+        confidence = float(payload.get("confidence", 0.0))
+    except (TypeError, ValueError):
+        confidence = 0.0
+    confidence = max(0.0, min(1.0, confidence))
+
+    normalized_command = str(payload.get("normalized_command", "")).strip()
+    music_query = str(payload.get("music_query", "")).strip()
+
+    result.update(
+        {
+            "intent": intent,
+            "normalized_command": normalized_command,
+            "music_action": music_action,
+            "music_query": music_query,
+            "confidence": confidence,
+        }
+    )
+    return result
+
+
 def ask_ai(messages_history: list) -> str:
     """
     Запрос к AI в режиме чата.
@@ -424,10 +676,12 @@ def ask_ai(messages_history: list) -> str:
 
     response = _send_request(
         messages,
-        max_tokens=500,
+        max_tokens=AI_CHAT_MAX_TOKENS,
-        temperature=1.0,  # Высокая температура для более живого общения
+        temperature=AI_CHAT_TEMPERATURE,
         error_text="Произошла ошибка при обращении к AI. Попробуйте ещё раз.",
     )
+    response = _sanitize_chat_response(response)
+    response = _truncate_chat_response(response, AI_CHAT_MAX_CHARS)
 
     if response:
         print(f"💬 Ответ AI: {response[:100]}...")
@@ -438,6 +692,7 @@ def ask_ai_stream(messages_history: list):
     """
     Generator that yields chunks of the AI response as they arrive.
     """
+    response = None
     cfg, selection_error = _get_provider_settings()
     if selection_error:
         yield selection_error
@@ -465,14 +720,46 @@ def ask_ai_stream(messages_history: list):
         response = _HTTP.post(
             cfg["api_url"],
             headers=_build_headers(cfg),
-            json=_build_payload(cfg, messages, 500, 1.0, stream=True),
+            json=_build_payload(
+                cfg,
+                messages,
+                AI_CHAT_MAX_TOKENS,
+                AI_CHAT_TEMPERATURE,
+                stream=True,
+            ),
             timeout=15,
             stream=True,
         )
         response.raise_for_status()
 
+        # Для устойчивости TTS сначала собираем поток, затем чистим и аккуратно
+        # ограничиваем длину по границе предложения.
+        raw_parts = []
         for chunk in _iter_stream_chunks(cfg, response):
-            yield chunk
+            if chunk:
+                raw_parts.append(chunk)
+
+        full_text = _sanitize_chat_response("".join(raw_parts))
+        full_text = _truncate_chat_response(full_text, AI_CHAT_MAX_CHARS)
+        if not full_text:
+            return
+
+        # Отдаем кусками по предложениям, чтобы main.py мог начинать озвучку раньше.
+        parts = _SENTENCE_BOUNDARY_RE.split(full_text)
+        if not parts:
+            yield full_text
+            return
+
+        sentence = ""
+        for part in parts:
+            if not part:
+                continue
+            sentence += part
+            if part in ".!?…":
+                yield sentence.strip() + " "
+                sentence = ""
+        if sentence.strip():
+            yield sentence.strip()
     except requests.exceptions.Timeout:
         yield f"Извините, сервер {cfg['name']} не отвечает. Попробуйте позже."
     except requests.exceptions.RequestException as error:
@@ -481,6 +768,12 @@ def ask_ai_stream(messages_history: list):
     except Exception as error:
         print(f"❌ Streaming Error ({cfg['name']}): {error}")
         yield "Произошла ошибка связи."
+    finally:
+        if response is not None:
+            try:
+                response.close()
+            except Exception:
+                pass
 
 
 def translate_text(text: str, source_lang: str, target_lang: str) -> str:
@@ -511,17 +804,18 @@ def translate_text(text: str, source_lang: str, target_lang: str) -> str:
     response = _send_request(
         messages,
         max_tokens=160,
-        temperature=0.2,  # Низкая температура для точности перевода
+        temperature=AI_TRANSLATION_TEMPERATURE,
         error_text="Произошла ошибка при переводе. Попробуйте ещё раз.",
     )
-    cleaned = response.strip()
+    cleaned = _sanitize_chat_response(response).strip()
+    cleaned = re.sub(r"[*_`]+", "", cleaned)
     if not cleaned:
         return cleaned
 
     # Normalize to 2-3 variants separated by " / "
     parts = []
     for chunk in re.split(r"(?:\s*/\s*|\n|;|\|)", cleaned):
-        item = chunk.strip(" \t-•")
+        item = chunk.strip(" \t-•\"'“”«»")
         if item:
             parts.append(item)
     if not parts:

app/core/audio_manager.py

@@ -1,6 +1,13 @@
 import pyaudio
 import threading
 
+from .config import (
+    AUDIO_INPUT_DEVICE_INDEX,
+    AUDIO_INPUT_DEVICE_NAME,
+    AUDIO_OUTPUT_DEVICE_INDEX,
+    AUDIO_OUTPUT_DEVICE_NAME,
+)
+
 
 class AudioManager:
     _instance = None
@@ -11,12 +18,351 @@ class AudioManager:
             if cls._instance is None:
                 cls._instance = super(AudioManager, cls).__new__(cls)
                 cls._instance.pa = pyaudio.PyAudio()
+                cls._instance._input_device_index = None
+                cls._instance._output_device_index = None
+                cls._instance._input_device_resolved = False
+                cls._instance._output_device_resolved = False
                 print("🔊 AudioManager: PyAudio initialized (Global)")
             return cls._instance
 
     def get_pyaudio(self):
         return self.pa
 
+    def get_input_device_index(self):
+        """
+        Returns PortAudio input device index or None (let PortAudio pick default).
+        Raises a RuntimeError with a helpful message if no input devices exist.
+        """
+        if self._input_device_resolved:
+            return self._input_device_index
+
+        self._input_device_index = self._resolve_input_device_index()
+        self._input_device_resolved = True
+        return self._input_device_index
+
+    def get_output_device_index(self):
+        """
+        Returns PortAudio output device index or None (let PortAudio pick default).
+        Raises a RuntimeError with a helpful message if no output devices exist.
+        """
+        if self._output_device_resolved:
+            return self._output_device_index
+
+        self._output_device_index = self._resolve_output_device_index()
+        self._output_device_resolved = True
+        return self._output_device_index
+
+    def _get_device_count(self) -> int:
+        if self.pa is None:
+            return 0
+        return int(self.pa.get_device_count() or 0)
+
+    def _is_input_device(self, idx: int) -> bool:
+        try:
+            info = self.pa.get_device_info_by_index(idx)
+        except Exception:
+            return False
+        return int(info.get("maxInputChannels") or 0) > 0
+
+    def _is_output_device(self, idx: int) -> bool:
+        try:
+            info = self.pa.get_device_info_by_index(idx)
+        except Exception:
+            return False
+        return int(info.get("maxOutputChannels") or 0) > 0
+
+    def _find_device_by_name(self, needle: str, input_kind: bool):
+        if not needle:
+            return None
+        lowered = needle.lower()
+        count = self._get_device_count()
+        for idx in range(count):
+            if input_kind and not self._is_input_device(idx):
+                continue
+            if not input_kind and not self._is_output_device(idx):
+                continue
+            try:
+                name = str(self.pa.get_device_info_by_index(idx).get("name") or "")
+            except Exception:
+                continue
+            if lowered in name.lower():
+                return idx
+        return None
+
+    def _get_default_input_index(self):
+        try:
+            info = self.pa.get_default_input_device_info()
+            idx = int(info.get("index"))
+            if self._is_input_device(idx):
+                return idx
+        except Exception:
+            pass
+        return None
+
+    def _get_default_output_index(self):
+        try:
+            info = self.pa.get_default_output_device_info()
+            idx = int(info.get("index"))
+            if self._is_output_device(idx):
+                return idx
+        except Exception:
+            pass
+        return None
+
+    def _resolve_input_device_index(self):
+        if self.pa is None:
+            return None
+
+        device_count = self._get_device_count()
+
+        if AUDIO_INPUT_DEVICE_INDEX is not None:
+            idx = int(AUDIO_INPUT_DEVICE_INDEX)
+            if 0 <= idx < device_count and self._is_input_device(idx):
+                return idx
+            raise RuntimeError(
+                "Audio input initialization failed: invalid AUDIO_INPUT_DEVICE_INDEX="
+                f"{AUDIO_INPUT_DEVICE_INDEX}. Available input devices:\n"
+                + self.describe_input_devices()
+            )
+
+        if AUDIO_INPUT_DEVICE_NAME:
+            match_idx = self._find_device_by_name(AUDIO_INPUT_DEVICE_NAME, input_kind=True)
+            if match_idx is not None:
+                return match_idx
+
+            print(
+                "⚠️ AUDIO_INPUT_DEVICE_NAME was set but no matching input device was found: "
+                f"{AUDIO_INPUT_DEVICE_NAME!r}. Falling back to default input selection."
+            )
+
+        # Default input device (if PortAudio has one).
+        default_idx = self._get_default_input_index()
+        if default_idx is not None:
+            return default_idx
+
+        # Fallback: first input device.
+        for idx in range(device_count):
+            if self._is_input_device(idx):
+                return idx
+
+        raise RuntimeError(
+            "Audio input initialization failed: no input devices found. "
+            "Check microphone connection and PipeWire/PulseAudio. "
+            "PortAudio devices:\n"
+            + self.describe_input_devices()
+        )
+
+    def _resolve_output_device_index(self):
+        if self.pa is None:
+            return None
+
+        device_count = self._get_device_count()
+
+        if AUDIO_OUTPUT_DEVICE_INDEX is not None:
+            idx = int(AUDIO_OUTPUT_DEVICE_INDEX)
+            if 0 <= idx < device_count and self._is_output_device(idx):
+                return idx
+            raise RuntimeError(
+                "Audio output initialization failed: invalid AUDIO_OUTPUT_DEVICE_INDEX="
+                f"{AUDIO_OUTPUT_DEVICE_INDEX}. Available output devices:\n"
+                + self.describe_output_devices()
+            )
+
+        if AUDIO_OUTPUT_DEVICE_NAME:
+            match_idx = self._find_device_by_name(
+                AUDIO_OUTPUT_DEVICE_NAME, input_kind=False
+            )
+            if match_idx is not None:
+                return match_idx
+            print(
+                "⚠️ AUDIO_OUTPUT_DEVICE_NAME was set but no matching output device was found: "
+                f"{AUDIO_OUTPUT_DEVICE_NAME!r}. Falling back to default output selection."
+            )
+
+        default_idx = self._get_default_output_index()
+        if default_idx is not None:
+            return default_idx
+
+        for idx in range(device_count):
+            if self._is_output_device(idx):
+                return idx
+
+        raise RuntimeError(
+            "Audio output initialization failed: no output devices found. "
+            "Check speaker connection and PipeWire/PulseAudio. "
+            "PortAudio devices:\n"
+            + self.describe_output_devices()
+        )
+
+    def _ordered_input_candidates(self, preferred_index=None):
+        candidates = []
+
+        def add(idx):
+            if idx not in candidates:
+                candidates.append(idx)
+
+        if preferred_index is not None:
+            add(preferred_index)
+        else:
+            try:
+                add(self.get_input_device_index())
+            except Exception:
+                pass
+            add(self._get_default_input_index())
+            add(None)  # Let PortAudio decide default path.
+            for idx in range(self._get_device_count()):
+                if self._is_input_device(idx):
+                    add(idx)
+
+        return [idx for idx in candidates if idx is None or self._is_input_device(idx)]
+
+    def _ordered_output_candidates(self, preferred_index=None):
+        candidates = []
+
+        def add(idx):
+            if idx not in candidates:
+                candidates.append(idx)
+
+        if preferred_index is not None:
+            add(preferred_index)
+        else:
+            try:
+                add(self.get_output_device_index())
+            except Exception:
+                pass
+            add(self._get_default_output_index())
+            add(None)  # Let PortAudio decide default path.
+            for idx in range(self._get_device_count()):
+                if self._is_output_device(idx):
+                    add(idx)
+
+        return [idx for idx in candidates if idx is None or self._is_output_device(idx)]
+
+    def open_input_stream(
+        self,
+        *,
+        rate: int,
+        channels: int,
+        format,
+        frames_per_buffer: int,
+        preferred_index=None,
+        fallback_rates=None,
+    ):
+        if self.pa is None:
+            raise RuntimeError("PyAudio is not initialized")
+
+        fallback_rates = fallback_rates or []
+        rates = [int(rate)] + [int(r) for r in fallback_rates if int(r) > 0 and int(r) != int(rate)]
+        errors = []
+
+        for device_idx in self._ordered_input_candidates(preferred_index):
+            for attempt_rate in rates:
+                fb = max(
+                    64, int(round(frames_per_buffer * attempt_rate / max(1, int(rate))))
+                )
+                kwargs = {
+                    "rate": attempt_rate,
+                    "channels": channels,
+                    "format": format,
+                    "input": True,
+                    "frames_per_buffer": fb,
+                }
+                if device_idx is not None:
+                    kwargs["input_device_index"] = device_idx
+                try:
+                    stream = self.pa.open(**kwargs)
+                    return stream, device_idx, attempt_rate
+                except Exception as exc:
+                    errors.append(
+                        f"device={device_idx!r}, rate={attempt_rate}: {exc}"
+                    )
+
+        joined_errors = "\n".join(errors[:12])
+        raise RuntimeError(
+            "Audio input initialization failed. Tried multiple devices/rates.\n"
+            f"{joined_errors}\nAvailable input devices:\n{self.describe_input_devices()}"
+        )
+
+    def open_output_stream(
+        self,
+        *,
+        rate: int,
+        channels: int,
+        format,
+        preferred_index=None,
+        fallback_rates=None,
+    ):
+        if self.pa is None:
+            raise RuntimeError("PyAudio is not initialized")
+
+        fallback_rates = fallback_rates or []
+        rates = [int(rate)] + [int(r) for r in fallback_rates if int(r) > 0 and int(r) != int(rate)]
+        errors = []
+
+        for device_idx in self._ordered_output_candidates(preferred_index):
+            for attempt_rate in rates:
+                kwargs = {
+                    "rate": attempt_rate,
+                    "channels": channels,
+                    "format": format,
+                    "output": True,
+                }
+                if device_idx is not None:
+                    kwargs["output_device_index"] = device_idx
+                try:
+                    stream = self.pa.open(**kwargs)
+                    return stream, device_idx, attempt_rate
+                except Exception as exc:
+                    errors.append(
+                        f"device={device_idx!r}, rate={attempt_rate}: {exc}"
+                    )
+
+        joined_errors = "\n".join(errors[:12])
+        raise RuntimeError(
+            "Audio output initialization failed. Tried multiple devices/rates.\n"
+            f"{joined_errors}\nAvailable output devices:\n{self.describe_output_devices()}"
+        )
+
+    def describe_input_devices(self, limit: int = 20) -> str:
+        if self.pa is None:
+            return "<PyAudio not initialized>"
+
+        items = []
+        count = self._get_device_count()
+        for idx in range(count):
+            try:
+                info = self.pa.get_device_info_by_index(idx)
+            except Exception:
+                continue
+            max_in = int(info.get("maxInputChannels") or 0)
+            if max_in <= 0:
+                continue
+            name = str(info.get("name") or "").strip()
+            items.append(f"[{idx}] {name} (in={max_in})")
+            if len(items) >= limit:
+                break
+        return "\n".join(items) if items else "<no input devices>"
+
+    def describe_output_devices(self, limit: int = 20) -> str:
+        if self.pa is None:
+            return "<PyAudio not initialized>"
+
+        items = []
+        count = self._get_device_count()
+        for idx in range(count):
+            try:
+                info = self.pa.get_device_info_by_index(idx)
+            except Exception:
+                continue
+            max_out = int(info.get("maxOutputChannels") or 0)
+            if max_out <= 0:
+                continue
+            name = str(info.get("name") or "").strip()
+            items.append(f"[{idx}] {name} (out={max_out})")
+            if len(items) >= limit:
+                break
+        return "\n".join(items) if items else "<no output devices>"
+
     def cleanup(self):
         if self.pa:
             self.pa.terminate()

app/core/cleaner.py

@@ -3,6 +3,7 @@
 import re
 import pymorphy3
 from num2words import num2words
+from .config import WAKE_WORD, WAKE_WORD_ALIASES
 from .roman import roman_to_int
 
 morph = pymorphy3.MorphAnalyzer()
@@ -83,6 +84,10 @@ MONTHS_GENITIVE = [
 
 # Время
 TIME_UNIT_LEMMAS = {"час", "минута", "секунда"}
+WAKE_WORD_BLOCKED_PATTERNS = [
+    re.compile(rf"\b{re.escape(alias)}\b", flags=re.IGNORECASE)
+    for alias in set(WAKE_WORD_ALIASES) | {WAKE_WORD.lower()}
+]
 
 # Суффиксы порядковых
 _ORDINAL_SUFFIX_MAP = {
@@ -142,6 +147,73 @@ def numbers_to_words(text: str) -> str:
 
     preps_list = "|".join(map(re.escape, PREPOSITION_CASES.keys()))
 
+    # Время вида "в 7:00" / "во 7:00" / "к 7:05" / "07:00" -> человеческая русская форма.
+    # Важно: "в семь" (не "в семи"), "к семи" (дательный).
+    def _minute_words(minute_val: int) -> str:
+        if minute_val == 0:
+            return "ровно"
+        if minute_val < 10:
+            return "ноль " + convert_number(
+                str(minute_val), context_type="cardinal", case="nominative", gender="m"
+            )
+        return convert_number(str(minute_val), context_type="cardinal", case="nominative", gender="m")
+
+    def replace_time_match(match):
+        prep = match.group(1) or ""
+        hour_str = match.group(2)
+        minute_str = match.group(3)
+
+        try:
+            hour_val = int(hour_str)
+            minute_val = int(minute_str)
+        except Exception:
+            return match.group(0)
+
+        if not (0 <= hour_val <= 23 and 0 <= minute_val <= 59):
+            return match.group(0)
+
+        prep_clean = prep.strip().lower()
+        if prep_clean in {"в", "во"}:
+            hour_case = "accusative"
+        elif prep_clean in {"к", "ко"}:
+            hour_case = "dative"
+        else:
+            hour_case = "nominative"
+
+        hour_words = convert_number(str(hour_val), context_type="cardinal", case=hour_case, gender="m")
+        minute_words = _minute_words(minute_val)
+
+        prefix = f"{prep} " if prep else ""
+        return f"{prefix}{hour_words} {minute_words}"
+
+    def replace_time_no_prep_match(match):
+        hour_str = match.group(1)
+        minute_str = match.group(2)
+
+        try:
+            hour_val = int(hour_str)
+            minute_val = int(minute_str)
+        except Exception:
+            return match.group(0)
+
+        if not (0 <= hour_val <= 23 and 0 <= minute_val <= 59):
+            return match.group(0)
+
+        hour_words = convert_number(str(hour_val), context_type="cardinal", case="nominative", gender="m")
+        minute_words = _minute_words(minute_val)
+        return f"{hour_words} {minute_words}"
+
+    text = re.sub(
+        r"(?i)\b(в|во|к|ко)\s+(\d{1,2})\s*:\s*(\d{2})\b",
+        replace_time_match,
+        text,
+    )
+    text = re.sub(
+        r"\b(\d{1,2})\s*:\s*(\d{2})\b",
+        replace_time_no_prep_match,
+        text,
+    )
+
     # Года с суффиксом
     def replace_year_suffix_match(match):
         prep = match.group(1)
@@ -270,6 +342,7 @@ def numbers_to_words(text: str) -> str:
         case = "nominative"
         gender = "m"
         prep_clean = prep.strip().lower() if prep else None
+        parsed = None
 
         if prep_clean:
             morph_case = get_case_from_preposition(prep_clean)
@@ -287,6 +360,7 @@ def numbers_to_words(text: str) -> str:
         # Спец-случай: "на 1 час"
         if (
             prep_clean == "на"
+            and parsed is not None
             and parsed.normal_form in TIME_UNIT_LEMMAS
             and parsed.tag.gender in ("masc", "neut")
         ):
@@ -419,6 +493,10 @@ def clean_response(text: str, language: str = "ru") -> str:
         flags=re.IGNORECASE | re.MULTILINE,
     )
 
+    # Запрет на произнесение wake word в любых ответах ассистента.
+    for pattern in WAKE_WORD_BLOCKED_PATTERNS:
+        text = pattern.sub("ассистент", text)
+
     # Числа в слова
     if language == "ru":
         text = roman_numerals_to_words(text)

app/core/commands.py

@@ -4,6 +4,9 @@ Command parsing helpers.
 
 import re
 
+from .config import WAKE_WORD, WAKE_WORD_ALIASES
+from ..audio.sound_level import is_volume_command, parse_volume_text
+
 _STOP_WORDS_STRICT = {
     "стоп",
     "хватит",
@@ -31,6 +34,28 @@ _STOP_PATTERNS_LENIENT = [
     r"\bдостаточно\b",
 ]
 _STOP_PATTERNS_LENIENT_COMPILED = [re.compile(p) for p in _STOP_PATTERNS_LENIENT]
+_FAST_WEATHER_PHRASES = {
+    "какая погода",
+    "какая погода на улице",
+    "какая сейчас погода",
+    "какая сейчас погода на улице",
+    "что по погоде",
+    "погода",
+    "погода на улице",
+    "что на улице",
+    "что там на улице",
+    "че там на улице",
+}
+_FAST_MUSIC_PHRASES = {
+    "включи музыку",
+    "поставь музыку",
+    "играй музыку",
+    "play music",
+}
+_WAKEWORD_PREFIX_RE = re.compile(
+    rf"^(?:{'|'.join(re.escape(alias) for alias in sorted({WAKE_WORD.lower(), *WAKE_WORD_ALIASES}, key=len, reverse=True))})(?:\s+|$)",
+    re.IGNORECASE,
+)
 
 
 def _normalize_text(text: str) -> str:
@@ -40,6 +65,13 @@ def _normalize_text(text: str) -> str:
     return text
 
 
+def normalize_command_text(text: str) -> str:
+    normalized = _normalize_text(text)
+    if not normalized:
+        return ""
+    return _WAKEWORD_PREFIX_RE.sub("", normalized, count=1).strip()
+
+
 def is_stop_command(text: str, mode: str = "strict") -> bool:
     """
     Detect stop commands in text.
@@ -64,3 +96,27 @@ def is_stop_command(text: str, mode: str = "strict") -> bool:
             return True
 
     return False
+
+
+def is_fast_command(text: str) -> bool:
+    """
+    Detect short commands that can stop STT early without waiting
+    for full utterance finalization.
+    """
+    normalized = normalize_command_text(text)
+    if not normalized:
+        return False
+
+    if is_stop_command(normalized, mode="strict"):
+        return True
+
+    if normalized in _FAST_WEATHER_PHRASES:
+        return True
+
+    if normalized in _FAST_MUSIC_PHRASES:
+        return True
+
+    if is_volume_command(normalized) and parse_volume_text(normalized) is not None:
+        return True
+
+    return False

app/core/config.py

@@ -7,28 +7,78 @@ Loads environment variables from .env file.
 # Он загружает настройки из файла .env (переменные окружения) и определяет константы.
 
 import os
+import re
 import time
+from io import StringIO
 from pathlib import Path
-from dotenv import load_dotenv
+from dotenv import dotenv_values
 
 # Базовая директория проекта (корневая папка, где лежит .env)
 BASE_DIR = Path(__file__).resolve().parents[2]
 
-# Загружаем переменные из файла .env в корневом каталоге
+def _load_project_env(env_path: Path) -> None:
-load_dotenv(BASE_DIR / ".env")
+    """
+    Загружает .env, игнорируя строковый "шум" без формата KEY=VALUE.
+    Это делает конфиг устойчивым к человеческим комментариям без символа '#'.
+    """
+    if not env_path.exists():
+        return
+
+    raw_text = env_path.read_text(encoding="utf-8")
+    sanitized_lines = []
+
+    for line in raw_text.splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            sanitized_lines.append(line)
+            continue
+
+        if "=" in line:
+            key = line.split("=", 1)[0].strip()
+            if re.match(r"^[A-Za-z_][A-Za-z0-9_]*$", key):
+                sanitized_lines.append(line)
+                continue
+
+        # Игнорируем невалидные строки, чтобы dotenv не шумел warning'ами.
+        sanitized_lines.append(f"# ignored invalid env line: {line}")
+
+    parsed = dotenv_values(stream=StringIO("\n".join(sanitized_lines)))
+    for key, value in parsed.items():
+        if key and value is not None and os.getenv(key) is None:
+            os.environ[key] = value
+
+
+# Загружаем переменные из .env в корневом каталоге
+_load_project_env(BASE_DIR / ".env")
 
 # --- Настройки AI ---
 # AI_PROVIDER опционален. Приоритет у единственного активного AI API key.
 # Если активных ключей несколько, AI-модуль вернет ошибку конфигурации.
-AI_PROVIDER = os.getenv("AI_PROVIDER", "perplexity").strip().lower()
+AI_PROVIDER = os.getenv("AI_PROVIDER", "openrouter").strip().lower()
 
-# Perplexity
+# OpenRouter
-PERPLEXITY_API_KEY = os.getenv("PERPLEXITY_API_KEY")
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
-PERPLEXITY_MODEL = os.getenv("PERPLEXITY_MODEL", "llama-3.1-sonar-small-128k-chat")
+OPENROUTER_MODEL = os.getenv("OPENROUTER_MODEL", "openai/gpt-4o-mini")
-PERPLEXITY_API_URL = os.getenv(
+OPENROUTER_API_URL = os.getenv(
-    "PERPLEXITY_API_URL", "https://api.perplexity.ai/chat/completions"
+    "OPENROUTER_API_URL", "https://openrouter.ai/api/v1/chat/completions"
 )
 
+
+def _read_clamped_float_env(name: str, default: str, minimum: float, maximum: float) -> float:
+    try:
+        value = float(os.getenv(name, default))
+    except Exception:
+        value = float(default)
+    return max(minimum, min(maximum, value))
+
+
+def _read_clamped_int_env(name: str, default: str, minimum: int, maximum: int) -> int:
+    try:
+        value = int(os.getenv(name, default))
+    except Exception:
+        value = int(default)
+    return max(minimum, min(maximum, value))
+
 # OpenAI
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
@@ -59,6 +109,20 @@ ANTHROPIC_API_URL = os.getenv(
 )
 ANTHROPIC_API_VERSION = os.getenv("ANTHROPIC_API_VERSION", "2023-06-01")
 
+# Ollama (локальные модели; OpenAI-compatible endpoint)
+# Обычно Ollama слушает http://localhost:11434 и предоставляет /v1/chat/completions.
+OLLAMA_MODEL = os.getenv("OLLAMA_MODEL", "llama3.1:8b")
+OLLAMA_API_URL = os.getenv(
+    "OLLAMA_API_URL", "http://localhost:11434/v1/chat/completions"
+)
+AI_CHAT_TEMPERATURE = _read_clamped_float_env("AI_CHAT_TEMPERATURE", "0.9", 0.0, 2.0)
+AI_CHAT_MAX_TOKENS = _read_clamped_int_env("AI_CHAT_MAX_TOKENS", "220", 80, 700)
+AI_CHAT_MAX_CHARS = _read_clamped_int_env("AI_CHAT_MAX_CHARS", "320", 120, 1200)
+AI_INTENT_TEMPERATURE = _read_clamped_float_env("AI_INTENT_TEMPERATURE", "0.0", 0.0, 1.0)
+AI_TRANSLATION_TEMPERATURE = _read_clamped_float_env(
+    "AI_TRANSLATION_TEMPERATURE", "0.2", 0.0, 1.0
+)
+
 # --- Настройки распознавания речи (Deepgram) ---
 # Ключ для облачного STT (Speech-to-Text)
 DEEPGRAM_API_KEY = os.getenv("DEEPGRAM_API_KEY")
@@ -66,16 +130,87 @@ DEEPGRAM_API_KEY = os.getenv("DEEPGRAM_API_KEY")
 # --- Настройки активации голосом (Porcupine) ---
 # Ключ доступа PicoVoice
 PORCUPINE_ACCESS_KEY = os.getenv("PORCUPINE_ACCESS_KEY")
+# Wake word label and common ASR aliases.
+WAKE_WORD = "Waltron"
+WAKE_WORD_ALIASES = (
+    "waltron",
+    "voltron",
+    "волтрон",
+    "уолтрон",
+    "валтрон",
+)
 # Путь к файлу модели ключевого слова (.ppn), который лежит в папке assets/models
-PORCUPINE_KEYWORD_PATH = BASE_DIR / "assets" / "models" / "Alexandr_en_linux_v4_0_0.ppn"
+PORCUPINE_KEYWORD_PATH = BASE_DIR / "assets" / "models" / "Waltron_en_linux_v4_0_0.ppn"
 # Чувствительность wake word (0..1). Выше = ловит легче, но больше ложных срабатываний.
 PORCUPINE_SENSITIVITY = float(os.getenv("PORCUPINE_SENSITIVITY", "0.8"))
+# Антифантомный фильтр wake word по RMS-сигналу.
+# Чем выше WAKEWORD_MIN_RMS / WAKEWORD_RMS_MULTIPLIER, тем меньше ложных срабатываний,
+# но тем выше риск не распознать очень тихую активацию.
+try:
+    WAKEWORD_MIN_RMS = float(os.getenv("WAKEWORD_MIN_RMS", "120"))
+except Exception:
+    WAKEWORD_MIN_RMS = 120.0
+WAKEWORD_MIN_RMS = max(0.0, WAKEWORD_MIN_RMS)
+try:
+    WAKEWORD_RMS_MULTIPLIER = float(os.getenv("WAKEWORD_RMS_MULTIPLIER", "1.7"))
+except Exception:
+    WAKEWORD_RMS_MULTIPLIER = 1.7
+WAKEWORD_RMS_MULTIPLIER = max(1.0, WAKEWORD_RMS_MULTIPLIER)
+try:
+    WAKEWORD_HIT_COOLDOWN_SECONDS = float(
+        os.getenv("WAKEWORD_HIT_COOLDOWN_SECONDS", "1.2")
+    )
+except Exception:
+    WAKEWORD_HIT_COOLDOWN_SECONDS = 1.2
+WAKEWORD_HIT_COOLDOWN_SECONDS = max(0.0, WAKEWORD_HIT_COOLDOWN_SECONDS)
+try:
+    WAKEWORD_REOPEN_GRACE_SECONDS = float(
+        os.getenv("WAKEWORD_REOPEN_GRACE_SECONDS", "0.45")
+    )
+except Exception:
+    WAKEWORD_REOPEN_GRACE_SECONDS = 0.45
+WAKEWORD_REOPEN_GRACE_SECONDS = max(0.0, WAKEWORD_REOPEN_GRACE_SECONDS)
+WAKEWORD_ENABLE_FALLBACK_STT = (
+    os.getenv("WAKEWORD_ENABLE_FALLBACK_STT", "0").strip().lower()
+    in {"1", "true", "yes", "on"}
+)
+# При активации wake word музыка приглушается до указанного процента от текущего уровня.
+WAKEWORD_MUSIC_DUCK_PERCENT = _read_clamped_int_env(
+    "WAKEWORD_MUSIC_DUCK_PERCENT", "20", 1, 100
+)
+WAKEWORD_MUSIC_DUCK_RATIO = WAKEWORD_MUSIC_DUCK_PERCENT / 100.0
 
 # --- Параметры аудио ---
 # Частота дискретизации для микрофона (стандарт для распознавания речи)
 SAMPLE_RATE = 16000
 CHANNELS = 1
 
+# Выбор устройства ввода (микрофона).
+# Если не задано, используем default input device PortAudio (если есть).
+# Пример:
+# - AUDIO_INPUT_DEVICE_NAME=pulse
+# - AUDIO_INPUT_DEVICE_INDEX=2
+AUDIO_INPUT_DEVICE_NAME = os.getenv("AUDIO_INPUT_DEVICE_NAME", "").strip() or None
+_audio_index_raw = os.getenv("AUDIO_INPUT_DEVICE_INDEX", "").strip()
+try:
+    AUDIO_INPUT_DEVICE_INDEX = int(_audio_index_raw) if _audio_index_raw else None
+except Exception:
+    AUDIO_INPUT_DEVICE_INDEX = None
+
+# Выбор устройства вывода (динамик).
+# Если не задано, используем default output device PortAudio (если есть).
+# Пример:
+# - AUDIO_OUTPUT_DEVICE_NAME=pulse
+# - AUDIO_OUTPUT_DEVICE_INDEX=5
+AUDIO_OUTPUT_DEVICE_NAME = os.getenv("AUDIO_OUTPUT_DEVICE_NAME", "").strip() or None
+_audio_out_index_raw = os.getenv("AUDIO_OUTPUT_DEVICE_INDEX", "").strip()
+try:
+    AUDIO_OUTPUT_DEVICE_INDEX = (
+        int(_audio_out_index_raw) if _audio_out_index_raw else None
+    )
+except Exception:
+    AUDIO_OUTPUT_DEVICE_INDEX = None
+
 # --- Настройка времени ---
 # Устанавливаем часовой пояс на Москву, чтобы будильник работал корректно
 
@@ -83,14 +218,33 @@ os.environ["TZ"] = "Europe/Moscow"
 time.tzset()
 
 # --- Настройки синтеза речи (TTS) ---
+
+# --- Sound effects (SFX) ---
+# Короткий "beep" после wake word и перед запуском STT, чтобы пользователь понял:
+# можно начинать говорить. Поддерживает wav/mp3 (если pygame mixer поддерживает mp3),
+# иначе будет использован mpg123 как fallback.
+_stt_sfx_default = BASE_DIR / "assets" / "sounds" / "alisa-golosovoj-pomoschnik.mp3"
+if not _stt_sfx_default.exists():
+    _stt_sfx_default = Path.home() / "Music" / "alisa-golosovoj-pomoschnik.mp3"
+STT_START_SOUND_PATH = os.getenv("STT_START_SOUND_PATH", "").strip() or str(_stt_sfx_default)
+# Звук старта STT всегда на 100% громкости, чтобы по уровню был как обычный TTS-ответ.
+STT_START_SOUND_VOLUME = 1.0
 # Голос для русского языка (eugene - мужской голос)
 TTS_SPEAKER = "eugene"  # Доступные (ru): aidar, baya, kseniya, xenia, eugene
 # Голос для английского языка
 TTS_EN_SPEAKER = os.getenv("TTS_EN_SPEAKER", "en_0")
 # Частота дискретизации для воспроизведения (качество звука)
 TTS_SAMPLE_RATE = 48000
+# Скорость TTS: 1.0 = обычная, <1.0 = медленнее, >1.0 = быстрее.
+# По умолчанию чуть медленнее для более разборчивой речи.
+TTS_SPEED = _read_clamped_float_env("TTS_SPEED", "0.96", 0.85, 1.15)
 
 # --- Настройки погоды ---
 WEATHER_LAT = os.getenv("WEATHER_LAT")
 WEATHER_LON = os.getenv("WEATHER_LON")
 WEATHER_CITY = os.getenv("WEATHER_CITY", "Ухта")
+
+# --- Настройки Navidrome (музыка) ---
+NAVIDROME_URL = os.getenv("NAVIDROME_URL", "").strip().rstrip("/")
+NAVIDROME_USERNAME = os.getenv("NAVIDROME_USERNAME", "").strip()
+NAVIDROME_PASSWORD = os.getenv("NAVIDROME_PASSWORD", "")

app/features/alarm.py

@@ -18,6 +18,164 @@ ALARM_FILE = BASE_DIR / "data" / "alarms.json"
 ALARM_SOUND = BASE_DIR / "assets" / "sounds" / "Apex-1.mp3"
 ASK_ALARM_TIME_PROMPT = "На какое время мне поставить будильник?"
 
+_NUMBER_UNITS = {
+    "ноль": 0,
+    "один": 1,
+    "одна": 1,
+    "два": 2,
+    "две": 2,
+    "три": 3,
+    "четыре": 4,
+    "пять": 5,
+    "шесть": 6,
+    "семь": 7,
+    "восемь": 8,
+    "девять": 9,
+}
+_NUMBER_TEENS = {
+    "десять": 10,
+    "одиннадцать": 11,
+    "двенадцать": 12,
+    "тринадцать": 13,
+    "четырнадцать": 14,
+    "пятнадцать": 15,
+    "шестнадцать": 16,
+    "семнадцать": 17,
+    "восемнадцать": 18,
+    "девятнадцать": 19,
+}
+_NUMBER_TENS = {
+    "двадцать": 20,
+    "тридцать": 30,
+    "сорок": 40,
+    "пятьдесят": 50,
+}
+_PARTS_OF_DAY = {"утра", "дня", "вечера", "ночи"}
+_FILLER_WORDS = {"мне", "меня", "пожалуйста", "на", "в", "во", "к", "и"}
+_HOUR_WORDS = {"час", "часа", "часов"}
+_MINUTE_WORDS = {"минута", "минуту", "минуты", "минут"}
+_ALARM_MARKERS = {"будильник", "разбуди", "поставь", "установи", "включи", "на", "в", "к"}
+_ALARM_LIST_RE = re.compile(
+    r"\b(какие|какой|список|активн|покажи|показать|сколько|есть ли|перечисли)\b"
+)
+_ALARM_CANCEL_RE = re.compile(
+    r"\b(отмени|отмена|удали|удалить|выключи|отключи|деактивир|сбрось|очисти)\b"
+)
+_ALARM_CREATE_RE = re.compile(
+    r"\b(постав|установ|запусти|включи|разбуди|создай|добавь|измени|перенес|назнач)\b"
+)
+
+
+def _parse_number_tokens(tokens, start_index: int):
+    if start_index >= len(tokens):
+        return None, 0
+
+    token = tokens[start_index]
+    if token.isdigit():
+        return int(token), 1
+
+    if token in _NUMBER_TEENS:
+        return _NUMBER_TEENS[token], 1
+
+    if token in _NUMBER_TENS:
+        value = _NUMBER_TENS[token]
+        if start_index + 1 < len(tokens):
+            next_token = tokens[start_index + 1]
+            if next_token in _NUMBER_UNITS:
+                value += _NUMBER_UNITS[next_token]
+                return value, 2
+        return value, 1
+
+    if token in _NUMBER_UNITS:
+        return _NUMBER_UNITS[token], 1
+
+    return None, 0
+
+
+def _apply_part_of_day(hour: int, part_of_day: str | None) -> int:
+    if not part_of_day:
+        return hour
+
+    if part_of_day == "утра":
+        return 0 if hour == 12 else hour
+    if part_of_day == "ночи":
+        return 0 if hour == 12 else hour
+    if part_of_day in {"дня", "вечера"} and hour < 12:
+        return hour + 12
+    return hour
+
+
+def _extract_alarm_time_words(text: str):
+    tokens = re.findall(r"[a-zа-я0-9]+", text.lower().replace("ё", "е"))
+
+    for index, token in enumerate(tokens):
+        if token not in _ALARM_MARKERS:
+            continue
+
+        current = index + 1
+        while current < len(tokens) and tokens[current] in _FILLER_WORDS:
+            current += 1
+
+        hour, consumed = _parse_number_tokens(tokens, current)
+        if hour is None:
+            continue
+        current += consumed
+
+        if current < len(tokens) and tokens[current] in _HOUR_WORDS:
+            current += 1
+
+        minute = 0
+        if current < len(tokens) and tokens[current] not in _PARTS_OF_DAY:
+            parsed_minute, minute_consumed = _parse_number_tokens(tokens, current)
+            if parsed_minute is not None:
+                minute = parsed_minute
+                current += minute_consumed
+                if current < len(tokens) and tokens[current] in _MINUTE_WORDS:
+                    current += 1
+
+        part_of_day = None
+        if current < len(tokens) and tokens[current] in _PARTS_OF_DAY:
+            part_of_day = tokens[current]
+
+        if 0 <= hour <= 23 and 0 <= minute <= 59:
+            return _apply_part_of_day(hour, part_of_day), minute
+
+    return None
+
+
+def _extract_alarm_time(text: str):
+    # Формат "7:30", "7.30", "7-30" и варианты с "в/на/к".
+    match = re.search(r"(?:\b(?:на|в|во|к)\s+)?(\d{1,2})[:.-](\d{2})\b", text)
+    if match:
+        h, m = int(match.group(1)), int(match.group(2))
+        period_match = re.search(
+            r"\b(?:на|в|во|к)?\s*"
+            + re.escape(match.group(0).strip())
+            + r"\s+(утра|дня|вечера|ночи)\b",
+            text,
+        )
+        part_of_day = period_match.group(1) if period_match else None
+        h = _apply_part_of_day(h, part_of_day)
+        if 0 <= h <= 23 and 0 <= m <= 59:
+            return h, m
+
+    # Формат цифрами: "в 7 утра", "на 7", "к 6 30".
+    match_time = re.search(
+        r"(?:\b(?:на|в|во|к)\s+)?(\d{1,2})(?:\s*(?:часов|часа|час))?"
+        r"(?:\s+(\d{1,2})(?:\s*(?:минут|минуты|минута))?)?"
+        r"(?:\s+(утра|дня|вечера|ночи))?\b",
+        text,
+    )
+    if match_time:
+        h = int(match_time.group(1))
+        m = int(match_time.group(2)) if match_time.group(2) else 0
+        h = _apply_part_of_day(h, match_time.group(3))
+        if 0 <= h <= 23 and 0 <= m <= 59:
+            return h, m
+
+    # Формат словами: "в семь утра", "будильник семь тридцать".
+    return _extract_alarm_time_words(text)
+
 
 class AlarmClock:
     def __init__(self):
@@ -70,10 +228,10 @@ class AlarmClock:
         if re.search(r"\b(каждый день|ежедневно)\b", text):
             return [0, 1, 2, 3, 4, 5, 6]
 
-        if re.search(r"\b(по будн|в будн|будние)\b", text):
+        if re.search(r"\b(?:по\s+будн\w*|в\s+будн\w*|будн\w*)\b", text):
             days.update([0, 1, 2, 3, 4])
 
-        if re.search(r"\b(по выходн|в выходн|выходные)\b", text):
+        if re.search(r"\b(?:по\s+выходн\w*|в\s+выходн\w*|выходн\w*)\b", text):
             days.update([5, 6])
 
         day_patterns = {
@@ -114,7 +272,14 @@ class AlarmClock:
         return self.add_alarm_with_days(hour, minute, days=None)
 
     def add_alarm_with_days(self, hour: int, minute: int, days=None):
-        """Добавление нового будильника (или обновление существующего) с днями недели."""
+        """
+        Добавление нового будильника (или обновление существующего) с днями недели.
+
+        Returns:
+            "created" - создан новый будильник
+            "reactivated" - найден существующий неактивный, включён обратно
+            "already_active" - такой будильник уже активен
+        """
         days_key = self._days_key(days)
         for alarm in self.alarms:
             if (
@@ -122,11 +287,13 @@ class AlarmClock:
                 and alarm.get("minute") == minute
                 and self._days_key(alarm.get("days")) == days_key
             ):
+                if alarm.get("active"):
+                    return "already_active"
                 alarm["active"] = True
                 alarm["days"] = days_key
                 alarm["last_triggered"] = None
                 self.save_alarms()
-                return
+                return "reactivated"
 
         self.alarms.append(
             {"hour": hour, "minute": minute, "active": True, "days": days_key}
@@ -135,6 +302,7 @@ class AlarmClock:
         days_phrase = self._format_days_phrase(days_key)
         suffix = f" {days_phrase}" if days_phrase else ""
         print(f"⏰ Будильник установлен на {hour:02d}:{minute:02d}{suffix}")
+        return "created"
 
     def cancel_all_alarms(self):
         """Выключение (деактивация) всех будильников."""
@@ -143,6 +311,33 @@ class AlarmClock:
         self.save_alarms()
         print("🔕 Все будильники отменены.")
 
+    def remove_alarms(self, hour: int, minute: int, days=None) -> int:
+        """
+        Удаляет будильники по времени.
+        Если переданы days, удаляются только будильники с совпадающими днями.
+        """
+        days_key = self._days_key(days)
+        kept = []
+        removed = 0
+
+        for alarm in self.alarms:
+            alarm_hour = alarm.get("hour")
+            alarm_minute = alarm.get("minute")
+            if alarm_hour != hour or alarm_minute != minute:
+                kept.append(alarm)
+                continue
+
+            if days_key is not None and self._days_key(alarm.get("days")) != days_key:
+                kept.append(alarm)
+                continue
+
+            removed += 1
+
+        if removed:
+            self.alarms = kept
+            self.save_alarms()
+        return removed
+
     def describe_alarms(self) -> str:
         """Возвращает текстовое описание активных будильников."""
         active = [
@@ -250,64 +445,60 @@ class AlarmClock:
 
     def parse_command(self, text: str) -> str | None:
         """
-        Парсинг команды установки будильника из текста.
+        Парсинг команд управления будильниками.
-        Примеры: "разбуди в 7:30", "будильник на 8 утра".
+        Примеры: "разбуди в 7:30", "удали будильник на 8:00", "какие будильники".
         """
-        text = replace_roman_numerals(text.lower())
+        text = replace_roman_numerals(text.lower().replace("ё", "е"))
-        if "будильник" not in text and "разбуди" not in text:
+        if not re.search(r"\b(будильник\w*|разбуд\w*)\b", text):
             return None
 
-        if "будильник" in text and re.search(
+        if _ALARM_LIST_RE.search(text):
-            r"(какие|какой|список|активн|покажи|сколько|есть ли)", text
-        ):
             return self.describe_alarms()
 
-        if "отмени" in text:
+        if _ALARM_CANCEL_RE.search(text):
-            self.cancel_all_alarms()
+            cancel_time = _extract_alarm_time(text)
-            return "Хорошо, я отменил все будильники."
+            cancel_days = self._extract_alarm_days(text)
+            if cancel_time:
+                h, m = cancel_time
+                removed = self.remove_alarms(h, m, days=cancel_days)
+                if removed:
+                    days_phrase = self._format_days_phrase(cancel_days)
+                    suffix = f" {days_phrase}" if days_phrase else ""
+                    return f"Удалил {removed} будильник(а) на {h:02d}:{m:02d}{suffix}."
+                return f"Не нашел будильник на {h:02d}:{m:02d}."
+
+            if re.search(r"\b(все|всех)\b", text) or "будильники" in text:
+                self.cancel_all_alarms()
+                return "Хорошо, я отменил все будильники."
+
+            return (
+                "Скажите время будильника, который нужно удалить. "
+                "Например: удалите будильник на 7:30."
+            )
 
         days = self._extract_alarm_days(text)
+        alarm_time = _extract_alarm_time(text)
+        if alarm_time:
+            h, m = alarm_time
+            add_status = self.add_alarm_with_days(h, m, days=days)
+            if add_status == "already_active":
+                return "Такой будильник уже установлен."
+            days_phrase = self._format_days_phrase(days)
+            suffix = f" {days_phrase}" if days_phrase else ""
+            return f"Хорошо, разбужу вас в {h}:{m:02d}{suffix}."
 
-        # Поиск формата "7:30", "7.30"
+        if _ALARM_CREATE_RE.search(text) or text.strip() in {
-        match = re.search(r"\b(\d{1,2})[:.-](\d{2})\b", text)
-        if match:
-            h, m = int(match.group(1)), int(match.group(2))
-            if 0 <= h <= 23 and 0 <= m <= 59:
-                self.add_alarm_with_days(h, m, days=days)
-                days_phrase = self._format_days_phrase(days)
-                suffix = f" {days_phrase}" if days_phrase else ""
-                return f"Я установил будильник на {h} часов {m} минут{suffix}."
-
-        # Поиск формата словами "на 7 часов 15 минут"
-        match_time = re.search(
-            r"на\s+(\d{1,2})(?:\s*(?:часов|часа|час))?(?:\s+(\d{1,2})(?:\s*(?:минут|минуты|минута))?)?",
-            text,
-        )
-
-        if match_time:
-            h = int(match_time.group(1))
-            m = int(match_time.group(2)) if match_time.group(2) else 0
-
-            # Умная коррекция времени (если говорят "в 8", а сейчас 9, то это скорее 8 вечера или 8 утра завтра)
-            # Здесь простая логика AM/PM
-            if "вечера" in text and h < 12:
-                h += 12
-            elif "утра" in text and h == 12:
-                h = 0
-
-            if 0 <= h <= 23 and 0 <= m <= 59:
-                self.add_alarm_with_days(h, m, days=days)
-                days_phrase = self._format_days_phrase(days)
-                suffix = f" {days_phrase}" if days_phrase else ""
-                return f"Хорошо, разбужу вас в {h}:{m:02d}{suffix}."
-
-        if re.search(r"(постав|установ|запусти|включи|разбуди)", text) or text.strip() in {
             "будильник",
             "поставь будильник",
+            "создай будильник",
+            "добавь будильник",
         }:
             return ASK_ALARM_TIME_PROMPT
 
-        return "Я не понял время для будильника. Пожалуйста, скажите точное время, например 'семь тридцать'."
+        return (
+            "Я не понял команду для будильника. "
+            "Скажите, например: поставь на 7:30, покажи будильники или удали будильник на 7:30."
+        )
 
 
 # Глобальный экземпляр

app/features/weather.py

@@ -3,11 +3,120 @@ Weather feature module.
 Fetches weather data from Open-Meteo API.
 """
 
+import re
 import requests
 from datetime import datetime
 from ..core.config import WEATHER_LAT, WEATHER_LON, WEATHER_CITY
 
 _HTTP = requests.Session()
+_CITY_PREFIX_RE = re.compile(
+    r"^(?:в|во)\s+(?:город(?:е|у)?\s+)?",
+    flags=re.IGNORECASE,
+)
+_CITY_SPACING_RE = re.compile(r"\s+")
+_KNOWN_CITY_VARIATIONS = {
+    "нью йорк": "Нью-Йорк",
+    "нью-йорк": "Нью-Йорк",
+    "нью йорке": "Нью-Йорк",
+    "нью-йорке": "Нью-Йорк",
+    "нью йорка": "Нью-Йорк",
+    "нью-йорка": "Нью-Йорк",
+    "нью йорком": "Нью-Йорк",
+    "нью-йорком": "Нью-Йорк",
+    "санкт петербург": "Санкт-Петербург",
+    "санкт-петербург": "Санкт-Петербург",
+    "санкт петербурге": "Санкт-Петербург",
+    "санкт-петербурге": "Санкт-Петербург",
+    "санкт петербурга": "Санкт-Петербург",
+    "санкт-петербурга": "Санкт-Петербург",
+    "санкт петербургом": "Санкт-Петербург",
+    "санкт-петербургом": "Санкт-Петербург",
+    "нижний новгород": "Нижний Новгород",
+    "нижнем новгороде": "Нижний Новгород",
+    "нижнего новгорода": "Нижний Новгород",
+    "ростов на дону": "Ростов-на-Дону",
+    "ростове на дону": "Ростов-на-Дону",
+    "ростова на дону": "Ростов-на-Дону",
+    "лос анджелес": "Лос-Анджелес",
+    "лос-анджелес": "Лос-Анджелес",
+    "лос анджелесе": "Лос-Анджелес",
+    "лос-анджелесе": "Лос-Анджелес",
+    "сан франциско": "Сан-Франциско",
+    "сан-франциско": "Сан-Франциско",
+    "улан удэ": "Улан-Удэ",
+    "улан-удэ": "Улан-Удэ",
+}
+_SINGLE_WORD_CITY_VARIATIONS = {
+    "москве": "Москва",
+    "москвы": "Москва",
+    "москвой": "Москва",
+    "москву": "Москва",
+    "лондоне": "Лондон",
+    "лондона": "Лондон",
+    "лондоном": "Лондон",
+    "париже": "Париж",
+    "парижа": "Париж",
+    "парижем": "Париж",
+    "берлине": "Берлин",
+    "берлина": "Берлин",
+    "берлином": "Берлин",
+    "пекине": "Пекин",
+    "пекина": "Пекин",
+    "пекином": "Пекин",
+    "роме": "Рим",
+    "рима": "Рим",
+    "римом": "Рим",
+    "мадриде": "Мадрид",
+    "мадрида": "Мадрид",
+    "мадридом": "Мадрид",
+    "сиднее": "Сидней",
+    "сиднея": "Сидней",
+    "сиднеем": "Сидней",
+    "вашингтоне": "Вашингтон",
+    "вашингтона": "Вашингтон",
+    "вашингтоном": "Вашингтон",
+    "сиэтле": "Сиэтл",
+    "сиэтла": "Сиэтл",
+    "сиэтлом": "Сиэтл",
+    "бостоне": "Бостон",
+    "бостона": "Бостон",
+    "бостоном": "Бостон",
+    "денвере": "Денвер",
+    "денвера": "Денвер",
+    "денвером": "Денвер",
+    "хьюстоне": "Хьюстон",
+    "хьюстона": "Хьюстон",
+    "хьюстоном": "Хьюстон",
+    "фениксе": "Феникс",
+    "феникса": "Феникс",
+    "фениксом": "Феникс",
+    "атланте": "Атланта",
+    "атланты": "Атланта",
+    "атлантой": "Атланта",
+    "портленде": "Портленд",
+    "портленда": "Портленд",
+    "портлендом": "Портленд",
+    "остине": "Остин",
+    "остина": "Остин",
+    "остином": "Остин",
+    "нэшвилле": "Нэшвилл",
+    "нэшвилла": "Нэшвилл",
+    "нэшвиллом": "Нэшвилл",
+    "токио": "Токио",
+    "торонто": "Торонто",
+    "чикаго": "Чикаго",
+    "майами": "Майами",
+}
+
+
+def _smart_title_city(text: str) -> str:
+    parts = []
+    for word in text.split():
+        hyphen_parts = [part.capitalize() for part in word.split("-") if part]
+        parts.append("-".join(hyphen_parts))
+    return " ".join(parts)
+
+
 def get_wmo_description(code: int) -> str:
     """Decodes WMO weather code to Russian description."""
     codes = {
@@ -72,143 +181,45 @@ def normalize_city_name(city_name: str) -> str:
     Converts city names from various grammatical cases to the base form for geocoding.
     Handles common Russian grammatical cases (падежи) for city names.
     """
-    # Convert to lowercase for comparison
+    lowered = str(city_name or "").lower().replace("ё", "е").strip()
-    lower_city = city_name.lower()
+    if not lowered:
-    
+        return city_name
-    # Remove common Russian location descriptors that might be included by mistake
+
-    # For example, if someone says "в городе Волгоград", the city_name might be "городе волгоград"
+    lowered = _CITY_PREFIX_RE.sub("", lowered)
-    # So we want to extract just "волгоград"
+    lowered = _CITY_SPACING_RE.sub(" ", lowered).strip(" -")
-    if 'городе' in lower_city:
+    if not lowered:
-        # Extract the part after "городе"
+        return city_name
-        parts = lower_city.split('городе')
+
-        if len(parts) > 1:
+    exact_match = _KNOWN_CITY_VARIATIONS.get(lowered)
-            lower_city = parts[1].strip()
+    if exact_match:
-    elif 'город' in lower_city:
+        return exact_match
-        # Extract the part after "город"
+
-        parts = lower_city.split('город')
+    single_word_match = _SINGLE_WORD_CITY_VARIATIONS.get(lowered)
-        if len(parts) > 1:
+    if single_word_match:
-            lower_city = parts[1].strip()
+        return single_word_match
-    
+
-    # Common endings for different cases in Russian
+    spaced = lowered.replace("-", " ")
-    # Prepositional case endings (-е, -и, -у, etc.)
+    exact_match = _KNOWN_CITY_VARIATIONS.get(spaced)
-    prepositional_endings = ['е', 'и', 'у', 'о', 'й']
+    if exact_match:
-    genitive_endings = ['а', 'я', 'ов', 'ев', 'ин', 'ын'] 
+        return exact_match
-    instrumental_endings = ['ом', 'ем', 'ой', 'ей']
+
-    
+    if " " not in spaced:
-    # If the city ends with a prepositional ending, try removing it to get the base form
+        for suffix, replacement in (
-    if lower_city.endswith(tuple(prepositional_endings)):
+            ("ом", ""),
-        # Try to remove the ending and see if we get a valid base form
+            ("ем", ""),
-        base_form = lower_city
+            ("ой", "а"),
-        # Try removing 1-2 characters to get the base form
+            ("ей", "а"),
-        for i in range(2, 0, -1):  # Try removing 2 chars, then 1 char
+            ("е", ""),
-            if len(base_form) > i:
+            ("у", "а"),
-                potential_base = base_form[:-i]
+            ("ю", "я"),
-                # Check if the removed part is a common ending
+        ):
-                if base_form[-i:] in ['ке', 'ме', 'не', 'ве', 'ге', 'де', 'те']:
+            if spaced.endswith(suffix) and len(spaced) > len(suffix) + 2:
-                    base_form = potential_base
+                candidate = spaced[: -len(suffix)] + replacement
-                    break
+                mapped = _SINGLE_WORD_CITY_VARIATIONS.get(candidate)
-                elif base_form[-1] in prepositional_endings:
+                if mapped:
-                    base_form = base_form[:-1]
+                    return mapped
-                    break
+
-        
+    return _smart_title_city(lowered)
-        # Special handling for common patterns
-        if base_form.endswith('йорке'):  # "нью-йорке" -> "нью-йорк"
-            base_form = base_form[:-1] + 'к'
-        elif base_form.endswith('ске'):  # "москве" -> "москва", "париже" -> "париж" 
-            # This is more complex, but for "москве" -> "москва", "париже" -> "париж"
-            # We'll handle the most common cases
-            if base_form == 'москве':
-                base_form = 'москва'
-            elif base_form == 'париже':
-                base_form = 'париж'
-            elif base_form == 'лондоне':
-                base_form = 'лондон'
-            elif base_form == 'берлине':
-                base_form = 'берлин'
-            elif base_form == 'токио':  # токио stays токио
-                base_form = 'токио'
-            else:
-                # General rule: replace -е with -а or -ь
-                if base_form.endswith('ске'):
-                    base_form = base_form[:-1] + 'а'
-                elif base_form.endswith('ие'):
-                    base_form = base_form[:-2] + 'ия'
-        
-        # Capitalize appropriately
-        if base_form != lower_city:
-            return base_form.capitalize()
-    
-    # Dictionary mapping specific known variations
-    case_variations = {
-        "нью-йорке": "Нью-Йорк",
-        "нью-йорка": "Нью-Йорк",
-        "нью-йорком": "Нью-Йорк",
-        "москве": "Москва",
-        "москвы": "Москва",
-        "москвой": "Москва",
-        "москву": "Москва",
-        "лондоне": "Лондон",
-        "лондона": "Лондон",
-        "лондоном": "Лондон",
-        "париже": "Париж",
-        "парижа": "Париж",
-        "парижем": "Париж",
-        "берлине": "Берлин",
-        "берлина": "Берлин",
-        "берлином": "Берлин",
-        "пекине": "Пекин",
-        "пекина": "Пекин",
-        "пекином": "Пекин",
-        "роме": "Рим",
-        "рима": "Рим",
-        "римом": "Рим",
-        "мадриде": "Мадрид",
-        "мадрида": "Мадрид",
-        "мадридом": "Мадрид",
-        "сиднее": "Сидней",
-        "сиднея": "Сидней",
-        "сиднеем": "Сидней",
-        "вашингтоне": "Вашингтон",
-        "вашингтона": "Вашингтон",
-        "вашингтоном": "Вашингтон",
-        "лос-анджелесе": "Лос-Анджелес",
-        "лос-анджелеса": "Лос-Анджелес",
-        "лос-анджелесом": "Лос-Анджелес",
-        "сиэтле": "Сиэтл",
-        "сиэтла": "Сиэтл",
-        "сиэтлом": "Сиэтл",
-        "бостоне": "Бостон",
-        "бостона": "Бостон",
-        "бостоном": "Бостон",
-        "денвере": "Денвер",
-        "денвера": "Денвер",
-        "денвером": "Денвер",
-        "хьюстоне": "Хьюстон",
-        "хьюстона": "Хьюстон",
-        "хьюстоном": "Хьюстон",
-        "фениксе": "Феникс",
-        "феникса": "Феникс",
-        "фениксом": "Феникс",
-        "атланте": "Атланта",
-        "атланты": "Атланта",
-        "атлантой": "Атланта",
-        "портленде": "Портленд",
-        "портленда": "Портленд",
-        "портлендом": "Портленд",
-        "остине": "Остин",
-        "остина": "Остин",
-        "остином": "Остин",
-        "нэшвилле": "Нэшвилл",
-        "нэшвилла": "Нэшвилл",
-        "нэшвиллом": "Нэшвилл",
-        "сан-франциско": "Сан-Франциско",
-        "токио": "Токио",
-        "торонто": "Торонто",
-        "чикаго": "Чикаго",
-        "майами": "Майами",
-    }
-    
-    return case_variations.get(lower_city, city_name)
 
 def get_coordinates_by_city(city_name: str) -> tuple:
     """
@@ -220,8 +231,9 @@ def get_coordinates_by_city(city_name: str) -> tuple:
 
     # Add normalized version
     normalized_city = normalize_city_name(city_name)
-    if normalized_city != city_name:
+    if normalized_city and normalized_city not in try_names:
         try_names.append(normalized_city)
+    normalized_lower = str(normalized_city or city_name).lower().replace("ё", "е").strip()
 
     # Also try with English version if it's a known translation
     city_to_eng = {
@@ -334,8 +346,18 @@ def get_coordinates_by_city(city_name: str) -> tuple:
     }
     
     eng_name = city_to_eng.get(city_name.lower())
-    if eng_name:
+    normalized_eng_name = city_to_eng.get(normalized_lower)
+    if eng_name and eng_name not in try_names:
         try_names.append(eng_name)
+    if normalized_eng_name and normalized_eng_name not in try_names:
+        try_names.append(normalized_eng_name)
+
+    if normalized_city:
+        hyphen_variant = normalized_city.replace(" ", "-")
+        space_variant = normalized_city.replace("-", " ")
+        for variant in (hyphen_variant, space_variant):
+            if variant and variant not in try_names:
+                try_names.append(variant)
 
     # Try each name in sequence
     for name_to_try in try_names:

assets/models/LICENSE.txt

@@ -0,0 +1 @@
+A copy of license terms is available at https://picovoice.ai/docs/terms-of-use/

data/alarms.json

@@ -39,5 +39,53 @@
         "days": [
             1
         ]
+    },
+    {
+        "hour": 8,
+        "minute": 0,
+        "active": false,
+        "days": [
+            0,
+            1,
+            2,
+            3,
+            4
+        ],
+        "last_triggered": null
+    },
+    {
+        "hour": 7,
+        "minute": 0,
+        "active": true,
+        "days": [
+            0,
+            1,
+            2,
+            3,
+            4
+        ],
+        "last_triggered": "2026-04-07T07:00:00.445214"
+    },
+    {
+        "hour": 7,
+        "minute": 0,
+        "active": false,
+        "days": [
+            5
+        ]
+    },
+    {
+        "hour": 9,
+        "minute": 30,
+        "active": false,
+        "days": null,
+        "last_triggered": "2026-04-04T09:30:00.423048"
+    },
+    {
+        "hour": 17,
+        "minute": 30,
+        "active": false,
+        "days": null,
+        "last_triggered": "2026-04-04T17:30:00.113480"
     }
 ]

scripts/qwen-check.sh

@@ -4,8 +4,13 @@ set -euo pipefail
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 cd "$ROOT"
 
+PYTHON_BIN="python3"
+if [ -x "$ROOT/.venv/bin/python" ]; then
+  PYTHON_BIN="$ROOT/.venv/bin/python"
+fi
+
 echo "[qwen-check] Python syntax compile check"
-python -m compileall app run.py >/dev/null
+"$PYTHON_BIN" -m compileall app run.py >/dev/null
 
 echo "[qwen-check] Optional ruff check"
 if command -v ruff >/dev/null 2>&1; then