linkgravity 1.5.12 → 1.5.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkgravity",
-  "version": "1.5.12",
+  "version": "1.5.14",
   "description": "Discord/Telegram bot bridge for the Antigravity (agy) CLI, with voice interaction support",
   "scripts": {
     "start": "node npm-scripts/run-dev.js",

package/src/api/ui_routes.py

@@ -6,18 +6,13 @@ import uuid
 
 from aiohttp import web
 
+from api.server import is_tool_allowed
 from config import APPROVAL_TIMEOUT_SEC, MAX_EMBED_LEN, logger, session_manager
 from messengers.base import ScopeOption
 from messengers.registry import get_adapter_for_platform, get_adapter_for_thread
 from utils.utils import split_message
 
 
-def is_tool_allowed(tool_name, tool_input):
-    from api.server import is_tool_allowed as is_tool_allowed_orig
-
-    return is_tool_allowed_orig(tool_name, tool_input)
-
-
 async def send_ordered(target_thread_id, send_coro_factory):
     """Routes through the same per-conversation stream queue as the answer
     text, so tool-call messages can't arrive out of order. Falls back to

package/src/approval/tool_formatter.py

@@ -57,9 +57,6 @@ def format_tool_display(tool_name: str, tool_input: dict) -> tuple[str, str, dic
 
 
 def format_bash_display(sub_cmd: str) -> tuple[str, str, dict]:
-    """
-    Formats a single bash sub-command for display.
-    """
     is_long = "\n" in sub_cmd or len(sub_cmd) > 50
     display_cmd = sub_cmd.split("\n")[0][:50] + "..." if is_long else sub_cmd
     tool_msg_text = f"● Bash({display_cmd})"

package/src/cogs/general_cog.py

@@ -18,6 +18,7 @@ from config import (
     save_bot_settings,
     session_manager,
 )
+from core.agy_runner import clean_model_name
 from core.atomic_io import atomic_write_json, safe_load_json
 from utils.utils import get_default_cwd
 
@@ -35,7 +36,8 @@ def load_cached_models():
         "Claude Opus 4.6 (Thinking)",
         "GPT-OSS 120B (Medium)",
     ]
-    return safe_load_json(MODELS_CACHE_FILE, default_models, logger=logger)
+    cached = safe_load_json(MODELS_CACHE_FILE, default_models, logger=logger)
+    return [clean_model_name(m) for m in cached]
 
 
 cached_models = load_cached_models()
@@ -79,7 +81,7 @@ async def fetch_models_background():
             line = line.strip()
             line = re.sub(r"[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]", "", line).strip()
             if line and "Fetching available models" not in line:
-                models.append(line)
+                models.append(clean_model_name(line))
 
         if models:
             cached_models = models

package/src/cogs/voice/enrollment.py

@@ -91,8 +91,6 @@ class SampleConfirmView(discord.ui.View):
 
 
 class EnrollmentManager:
-    """Owns /sound's recording flow - see _commit_enrollment."""
-
     def __init__(self, bot, voice_state: dict, play_audio, bot_settings: dict, save_bot_settings, logger):
         self.bot = bot
         self._voice_state = voice_state  # shared with VoiceCog
@@ -109,11 +107,7 @@ class EnrollmentManager:
     def stop(self):
         self.cleanup_stale_enrollments.cancel()
 
-    def is_enrolling(self, user_id: str) -> bool:
-        return user_id in self._enrollment
-
     async def handle_voice_service_down(self):
-        """Called when Node dies."""
         stale_user_ids = list(self._enrollment.keys())
         for uid in stale_user_ids:
             session = self._enrollment.pop(uid, None)
@@ -181,7 +175,6 @@ class EnrollmentManager:
             self.logger.warning(f"Failed to send enrollment status message: {e}")
 
     async def start_wake_word_recording(self, interaction: discord.Interaction, word: str) -> bool:
-        """Called by /sound's wake_word param."""
         guild_id = interaction.guild_id
         user_id = str(interaction.user.id)
 
@@ -241,7 +234,6 @@ class EnrollmentManager:
         return True
 
     async def handle_enroll_sample(self, user_id: str, audio_bytes: bytes):
-        """Called via /enroll_sample for each captured sample."""
         session = self._enrollment.get(user_id)
         if not session:
             return  # stray sample - recording already finished/cancelled/expired

package/src/cogs/voice/stt_session.py

@@ -19,13 +19,11 @@ class SttSessionTracker:
         self._partial_msg = {}
 
     def is_active(self, guild_id: str) -> bool:
-        """Whether the "stay awake" window is still open for this guild."""
         active_duration = self.bot_settings.get("active_timer", 60)
         last_active = self._last_active_time.get(str(guild_id), 0)
         return (time.time() - last_active) < active_duration
 
     def mark_tts_finished(self, guild_id: str):
-        """Called via /tts_finished once the spoken reply finishes playing."""
         self.extend_active_window(str(guild_id))
 
     def extend_active_window(self, guild_id: str):

package/src/cogs/voice_cog.py

@@ -1,5 +1,6 @@
 import asyncio
 import math
+import re
 import time
 
 import aiohttp
@@ -9,6 +10,7 @@ from discord.ext import commands, tasks
 
 from config import allowed, logger
 from messengers.registry import get_adapter_for_platform
+from services.audio_service import LANGUAGES, TTS_VOICES, default_voice_for, resolve_language
 
 from .voice.enrollment import EnrollmentManager
 from .voice.stt_session import SttSessionTracker
@@ -34,7 +36,6 @@ class VoiceCog(commands.Cog):
     def __init__(
         self,
         bot,
-        stt,
         tts,
         send_agy_response,
         agy_send,
@@ -46,8 +47,6 @@ class VoiceCog(commands.Cog):
         logger,
     ):
         self.bot = bot
-        # Unused by the voice pipeline now (STT moved to Node); kept for other callers.
-        self.stt = stt
         self.tts = tts
         self.send_agy_response = send_agy_response
         self.agy_send = agy_send
@@ -140,37 +139,36 @@ class VoiceCog(commands.Cog):
                 opts.append(app_commands.Choice(name=str(v), value=v))
         return opts
 
-    async def tts_voice_autocomplete(
+    async def language_autocomplete(
         self, interaction: discord.Interaction, current: str
     ) -> list[app_commands.Choice[str]]:
-        current_val = self.bot_settings.get("tts_voice", "en-US-AriaNeural")
-        options = [
-            "en-US-AriaNeural",
-            "en-US-GuyNeural",
-            "en-US-AnaNeural",
-            "en-US-ChristopherNeural",
-            "en-US-EricNeural",
-            "en-US-MichelleNeural",
-            "en-US-RogerNeural",
-            "en-GB-SoniaNeural",
-            "en-GB-RyanNeural",
-            "en-AU-NatashaNeural",
-            "en-AU-WilliamNeural",
-            "ko-KR-SunHiNeural",
-            "ko-KR-InJoonNeural",
-            "ja-JP-NanamiNeural",
-            "ja-JP-KeitaNeural",
-            "fr-FR-DeniseNeural",
-            "de-DE-KatjaNeural",
-            "es-ES-ElviraNeural",
-        ]
+        current_val = resolve_language()
+        query = _autocomplete_query(current).lower()
 
         choices = []
-        if current.lower() in current_val.lower() or not current:
+        if query in current_val.lower() or not query:
             choices.append(app_commands.Choice(name=f"{current_val} (current)", value=current_val))
+        for opt in LANGUAGES:
+            if query in opt.lower() and opt != current_val and len(choices) < 25:
+                choices.append(app_commands.Choice(name=opt, value=opt))
+        return choices
 
-        for opt in options:
-            if current.lower() in opt.lower() and opt != current_val and len(choices) < 25:
+    async def tts_voice_autocomplete(
+        self, interaction: discord.Interaction, current: str
+    ) -> list[app_commands.Choice[str]]:
+        # Only same-language voices - a voice from another language would read the reply
+        # with that language's pronunciation.
+        language = resolve_language()
+        current_val = self.bot_settings.get("tts_voice") or default_voice_for(language)
+        query = _autocomplete_query(current).lower()
+
+        choices = []
+        if query in current_val.lower() or not query:
+            choices.append(app_commands.Choice(name=f"{current_val} (current)", value=current_val))
+        for opt in TTS_VOICES:
+            if not opt.startswith(f"{language}-") or opt == current_val:
+                continue
+            if query in opt.lower() and len(choices) < 25:
                 choices.append(app_commands.Choice(name=opt, value=opt))
         return choices
 
@@ -325,7 +323,8 @@ class VoiceCog(commands.Cog):
         active_times="Duration in seconds the bot stays awake",
         interrupt_threshold="Mic volume that interrupts (barges into) TTS playback (1000~10000)",
         wake_sensitivity="Wake word match sensitivity (0.1~0.9, lower = easier to trigger but more false wakes)",
-        tts_voice="Select the AI TTS voice",
+        language="Language I listen and speak in (BCP-47, e.g. en-US)",
+        tts_voice="Pick a different voice within that language",
         tts_enabled="Turn Text-to-Speech ON or OFF",
         tts_speed="TTS playback speed multiplier, e.g. 1.3 for 1.3x (0.5~2.0)",
         require_wake_word="Require your wake word before I listen (default ON) - turn OFF if you use push-to-talk",
@@ -334,6 +333,7 @@ class VoiceCog(commands.Cog):
         active_times=active_times_autocomplete,
         interrupt_threshold=interrupt_threshold_autocomplete,
         wake_sensitivity=wake_sensitivity_autocomplete,
+        language=language_autocomplete,
         tts_voice=tts_voice_autocomplete,
         tts_enabled=tts_enabled_autocomplete,
         tts_speed=tts_speed_autocomplete,
@@ -346,6 +346,7 @@ class VoiceCog(commands.Cog):
         active_times: int = None,
         interrupt_threshold: int = None,
         wake_sensitivity: float = None,
+        language: str = None,
         tts_voice: str = None,
         tts_enabled: str = None,
         tts_speed: float = None,
@@ -362,6 +363,7 @@ class VoiceCog(commands.Cog):
             and active_times is None
             and interrupt_threshold is None
             and wake_sensitivity is None
+            and language is None
             and tts_voice is None
             and tts_enabled is None
             and tts_speed is None
@@ -371,7 +373,8 @@ class VoiceCog(commands.Cog):
             curr_timer = self.bot_settings.get("active_timer", 60)
             curr_interrupt_thresh = self._vad_threshold(interaction.user.id)
             curr_wake_sens = self._wake_threshold(interaction.user.id)
-            curr_tts = self.bot_settings.get("tts_voice", "en-US-AriaNeural")
+            curr_lang = resolve_language()
+            curr_tts = self.bot_settings.get("tts_voice") or default_voice_for(curr_lang)
             curr_tts_on = "ON" if self.bot_settings.get("tts_enabled", True) else "OFF"
             curr_tts_speed = self.bot_settings.get("tts_speed", 1.0)
             curr_required = self._wake_word_required(interaction.user.id)
@@ -382,6 +385,7 @@ class VoiceCog(commands.Cog):
             embed.add_field(name="⏱️ Active Time", value=f"`{curr_timer}s`", inline=False)
             embed.add_field(name="🎯 Wake Sensitivity", value=f"`{curr_wake_sens}`", inline=False)
             embed.add_field(name="🔊 Interrupt Threshold", value=f"`{curr_interrupt_thresh}`", inline=False)
+            embed.add_field(name="🌐 Language", value=f"`{curr_lang}`", inline=False)
             embed.add_field(name="🗣️ TTS Voice", value=f"`{curr_tts}`", inline=False)
             embed.add_field(name="🔊 TTS Enabled", value=f"`{curr_tts_on}`", inline=False)
             embed.add_field(name="⏩ TTS Speed", value=f"`{curr_tts_speed}x`", inline=False)
@@ -420,6 +424,13 @@ class VoiceCog(commands.Cog):
             except (aiohttp.ClientError, asyncio.TimeoutError) as e:
                 self.logger.warning(f"Node.js wake-threshold sync failed for {interaction.user.id}: {e}")
                 updated.append(f"(⚠️ Node.js Sync Failed: {e})")
+        if language is not None:
+            self.bot_settings["language"] = language
+            self.bot_settings["tts_voice"] = default_voice_for(language)
+            updated.append(
+                f"🌐 Language: `{language}` (voice set to `{self.bot_settings['tts_voice']}`; "
+                "run `lgy restart` to apply it to speech recognition)"
+            )
         if tts_voice is not None:
             self.bot_settings["tts_voice"] = tts_voice
             updated.append(f"🗣️ TTS Voice: `{tts_voice}`")
@@ -532,7 +543,6 @@ class VoiceCog(commands.Cog):
                 return
 
             import difflib
-            import re
 
             # Wake detection is Node's Rustpotter detector's job - no text-similarity fallback.
             is_waking_up = bool(data.get("wake_confirmed"))

package/src/config.py

@@ -31,6 +31,9 @@ DEFAULT_LGY_CONFIG = {
     "voice_thresholds": {},
     "active_timer": 60,
     "tts_voice": "ko-KR-SunHiNeural",
+    # BCP-47 tag driving both speech recognition and the TTS voice.
+    # Empty means derive it from tts_voice, which is how pre-1.6 configs carry their language.
+    "language": "",
     "tts_enabled": True,
     # Sticky default for /new sessions, set whenever /model succeeds.
     "default_model": "",

package/src/core/agy_runner.py

@@ -339,13 +339,18 @@ async def run_agy(
         _intentionally_stopped.discard(thread_id)
 
 
+def clean_model_name(model: str) -> str:
+    # agy models prints "<id>\t<display name>" but --model only accepts the display name.
+    return model.split("\t")[-1].strip()
+
+
 async def agy_new_conversation(
     content: str, model: str = None, stream_queue: asyncio.Queue = None, thread_id: str = None, cwd: str = None
 ) -> tuple[str, str]:
     # --print consumes the next token as the prompt, so the flag must come first.
     args = ["--dangerously-skip-permissions", "--print", content]
     if model:
-        args.extend(["--model", model])
+        args.extend(["--model", clean_model_name(model)])
     result_text = await run_agy(*args, stream_queue=stream_queue, thread_id=thread_id, cwd=cwd)
     conv_id = await _get_latest_conversation_id()
     return result_text, conv_id
@@ -361,7 +366,7 @@ async def agy_send_message(
 ) -> str:
     args = ["--dangerously-skip-permissions", "--print", content, "--conversation", conv_id]
     if model:
-        args.extend(["--model", model])
+        args.extend(["--model", clean_model_name(model)])
     return await run_agy(*args, stream_queue=stream_queue, thread_id=thread_id, cwd=cwd)
 
 

package/src/core/platform_health.py

@@ -22,7 +22,3 @@ def set_status(platform: str, status: str, detail: str = "") -> None:
         "at": datetime.now().isoformat(),
     }
     atomic_write_json(path, data)
-
-
-def get_all() -> dict:
-    return safe_load_json(_path(), {})

package/src/core/session_manager.py

@@ -7,8 +7,6 @@ from core.atomic_io import atomic_write_json, safe_load_json
 
 
 class SessionManager:
-    """Manages conversation state, async streaming queues, and user approval states."""
-
     def __init__(self, data_dir: Path):
         self.session_file = data_dir / "sessions.json"
         self.persistent_file = data_dir / "persistent_tools.json"
@@ -120,9 +118,6 @@ class SessionManager:
         if conv_id:
             self.active_approval_by_conv[conv_id] = approval_key
 
-    def get_pending_approval(self, approval_key: str) -> asyncio.Future | None:
-        return self.pending_approvals.get(approval_key)
-
     def get_pending_approval_by_conv(self, conv_id: str) -> asyncio.Future | None:
         """Looks up whichever approval is CURRENTLY active for a given
         conversation - for callers that only have the stable

package/src/main_discord.py

@@ -17,7 +17,7 @@ from messengers.discord_adapter import DiscordAdapter
 from messengers.registry import register_adapter
 from services.response import send_agy_response
 from services.streaming import stream_thinking_latest
-from utils.utils import agy_new_conversation, agy_send_message, stt, tts
+from utils.utils import agy_new_conversation, agy_send_message, tts
 
 voice_process = None
 _voice_shutting_down = False
@@ -290,7 +290,6 @@ async def run_discord(stop_event: asyncio.Event) -> None:
         await bot.add_cog(
             VoiceCog(
                 bot=bot,
-                stt=stt,
                 tts=tts,
                 send_agy_response=send_agy_response,
                 agy_send=agy_send_message,

package/src/main_slack.py

@@ -1,6 +1,3 @@
-"""Slack bot setup. Runs in the same process as Discord/Telegram (see
-main.py), which starts all enabled platforms concurrently."""
-
 import asyncio
 import re
 import uuid

package/src/main_telegram.py

@@ -1,6 +1,3 @@
-"""Telegram bot setup. Runs in the same process as Discord (see main.py),
-which starts both concurrently when both platforms are enabled."""
-
 import asyncio
 import uuid
 from datetime import datetime

package/src/messengers/base.py

@@ -1,6 +1,4 @@
-"""Core messenger interface. Every backend (Discord now, Slack/Telegram
-later) implements MessengerAdapter; business logic never touches
-platform SDK types directly.
+"""Core messenger interface. Business logic never touches platform SDK types directly.
 
 Futures for approval/question prompts are owned by business logic, not
 the adapter - the same future can also be resolved by a typed reply,
@@ -17,7 +15,7 @@ from typing import Any
 
 @dataclass
 class IncomingAttachment:
-    """A file on an inbound message; reader defers fetching bytes until needed."""
+    """reader defers fetching bytes until the attachment is actually read."""
 
     filename: str
     content_type: str | None
@@ -144,10 +142,6 @@ class MessengerAdapter(ABC):
     ) -> PromptHandle:
         raise NotImplementedError
 
-    @property
-    def supports_voice(self) -> bool:
-        return isinstance(self, VoiceCapable)
-
 
 class VoiceCapable(ABC):
     @abstractmethod

package/src/messengers/registry.py

@@ -1,7 +1,6 @@
-"""Per-platform messenger adapter registry, populated once at startup by
-main.py. Both bots now share one process, so callers must say which
-platform they mean - either directly (voice/Discord-only code) or by
-looking up which platform a given thread_id/conversation belongs to."""
+"""Per-platform messenger adapter registry, populated once at startup by main.py. All platforms
+share one process, so callers must say which platform they mean - either directly (voice/
+Discord-only code) or by looking up which platform a thread_id belongs to."""
 
 from messengers.base import MessengerAdapter
 
@@ -24,12 +23,3 @@ def get_adapter_for_thread(thread_id: str) -> MessengerAdapter:
     session = session_manager.get_session(thread_id) or {}
     platform = session.get("platform", "discord")  # pre-multi-platform sessions have no tag - assume discord
     return get_adapter_for_platform(platform)
-
-
-def get_adapter_for_conv_id(conv_id: str) -> MessengerAdapter | None:
-    from config import session_manager
-
-    for _thread_id, sess in session_manager.get_all_sessions().items():
-        if sess.get("conversation_id") == conv_id:
-            return get_adapter_for_platform(sess.get("platform", "discord"))
-    return None

package/src/messengers/slack_adapter.py

@@ -46,8 +46,8 @@ def decode_conversation_id(conversation_id: str) -> tuple[str, str] | None:
 
 def latest_channel_session(channel: str) -> tuple[str, dict] | None:
     """Most recently created Slack session in a channel - used as a fallback for un-threaded
-    messages (users rarely bother clicking "Reply in thread") and for /model, /credit, which
-    can't target a specific thread since Slack slash commands can't be invoked inside one."""
+    messages (users rarely bother clicking "Reply in thread") and for /model, which can't target
+    a specific thread since Slack slash commands can't be invoked inside one."""
     candidates = [
         (cid, s)
         for cid, s in session_manager.get_all_sessions().items()
@@ -59,8 +59,6 @@ def latest_channel_session(channel: str) -> tuple[str, dict] | None:
 
 
 class SlackConversationRef:
-    """conversation_ref for Slack - a channel + the thread_ts all replies go under."""
-
     __slots__ = ("channel", "thread_ts")
 
     def __init__(self, channel: str, thread_ts: str):
@@ -77,8 +75,6 @@ class SlackConversationRef:
 
 
 class SlackMessageRef:
-    """message_ref for edit_message - a specific message within a channel."""
-
     __slots__ = ("channel", "ts")
 
     def __init__(self, channel: str, ts: str):

package/src/services/audio_service.py

@@ -6,9 +6,102 @@ from pathlib import Path
 
 from config import TTS_VOICE, bot_settings, logger
 
+# Verified against edge-tts's live voice list; a name that isn't in it fails at synthesis time.
+# Ordered - the first voice of a language is that language's default.
+TTS_VOICES = [
+    "en-US-AriaNeural",
+    "en-US-GuyNeural",
+    "en-US-AnaNeural",
+    "en-US-ChristopherNeural",
+    "en-US-EricNeural",
+    "en-US-MichelleNeural",
+    "en-US-RogerNeural",
+    "en-GB-SoniaNeural",
+    "en-GB-RyanNeural",
+    "en-AU-NatashaNeural",
+    "en-AU-WilliamMultilingualNeural",
+    "ko-KR-SunHiNeural",
+    "ko-KR-InJoonNeural",
+    "ja-JP-NanamiNeural",
+    "ja-JP-KeitaNeural",
+    "zh-CN-XiaoxiaoNeural",
+    "zh-CN-YunxiNeural",
+    "fr-FR-DeniseNeural",
+    "de-DE-KatjaNeural",
+    "es-ES-ElviraNeural",
+    "it-IT-ElsaNeural",
+    "pt-BR-FranciscaNeural",
+    "ru-RU-SvetlanaNeural",
+    "hi-IN-SwaraNeural",
+    "id-ID-GadisNeural",
+    "vi-VN-HoaiMyNeural",
+    "th-TH-PremwadeeNeural",
+    "tr-TR-EmelNeural",
+    "pl-PL-ZofiaNeural",
+    "nl-NL-ColetteNeural",
+    "ar-SA-ZariyahNeural",
+]
+
+LANGUAGES = list(dict.fromkeys(v.rsplit("-", 1)[0] for v in TTS_VOICES))
+
+DEFAULT_LANGUAGE = "en-US"
+
+# Ordered: the first script reaching the share threshold wins, so Hangul beats Latin in mixed
+# Korean/English text, and kana beats Han in Japanese (which is written with both).
+SCRIPT_PATTERNS = [
+    ("ko", re.compile(r"[가-힣]")),
+    ("ja", re.compile(r"[ぁ-ゖァ-ヺ]")),
+    ("ru", re.compile(r"[\u0400-\u04ff]")),
+    ("ar", re.compile(r"[\u0600-\u06ff]")),
+    ("th", re.compile(r"[\u0e00-\u0e7f]")),
+    ("hi", re.compile(r"[\u0900-\u097f]")),
+    ("zh", re.compile(r"[\u4e00-\u9fff]")),
+    ("en", re.compile(r"[a-zA-Z]")),
+]
+
+SCRIPT_SHARE = 0.3
+
+
+def detect_script(text: str) -> str | None:
+    counts = {tag: len(pattern.findall(text)) for tag, pattern in SCRIPT_PATTERNS}
+    total = sum(counts.values())
+    if not total:
+        return None
+    for tag, _ in SCRIPT_PATTERNS:
+        if counts[tag] / total >= SCRIPT_SHARE:
+            return tag
+    return max(counts, key=counts.get)
+
+
+def default_voice_for(tag: str) -> str:
+    for voice in TTS_VOICES:
+        if voice.startswith(f"{tag}-"):
+            return voice
+    if "-" in tag:
+        return default_voice_for(tag.split("-")[0])
+    return TTS_VOICES[0]
+
+
+def resolve_language() -> str:
+    # Mirrored by resolveLanguage() in voice-service/stt.js, which is what reaches Google.
+    configured = bot_settings.get("language")
+    if configured:
+        return configured
+    voice = bot_settings.get("tts_voice") or TTS_VOICE or ""
+    return voice.rsplit("-", 1)[0] if voice.count("-") >= 2 else DEFAULT_LANGUAGE
+
+
+def voice_for(text: str) -> str:
+    # Latin script covers dozens of languages, so a configured en-GB voice must survive a bare
+    # "en" detection instead of being reset to the en-US default.
+    configured = bot_settings.get("tts_voice") or TTS_VOICE
+    script = detect_script(text)
+    if script is None or configured.startswith(f"{script}-"):
+        return configured
+    return default_voice_for(script)
+
 
 async def tts(text: str, voice: str = None) -> bytes | None:
-    voice = voice or bot_settings.get("tts_voice", TTS_VOICE)
     try:
         import edge_tts
 
@@ -17,24 +110,12 @@ async def tts(text: str, voice: str = None) -> bytes | None:
         clean = re.sub(r"\n+", ". ", clean).strip()[:800]
         if not clean:
             return None
-        hangul_chars = len(re.findall(r"[가-힣]", clean))
-        alpha_chars = len(re.findall(r"[a-zA-Z]", clean))
-        total_letters = hangul_chars + alpha_chars
-        ko_voice = os.getenv("TTS_VOICE_KO", "ko-KR-SunHiNeural")
-        en_voice = os.getenv("TTS_VOICE_EN", "en-US-AriaNeural")
-
-        if total_letters == 0:
-            active_voice = TTS_VOICE
-        elif (hangul_chars / total_letters) >= 0.3:
-            active_voice = ko_voice
-        else:
-            active_voice = en_voice
 
         speed = bot_settings.get("tts_speed", 1.0)
         pct = round((speed - 1.0) * 100)
         rate = f"{'+' if pct >= 0 else ''}{pct}%"
 
-        communicate = edge_tts.Communicate(clean, active_voice, rate=rate)
+        communicate = edge_tts.Communicate(clean, voice or voice_for(clean), rate=rate)
         with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as f:
             tmp = f.name
         await communicate.save(tmp)
@@ -58,7 +139,7 @@ async def stt(audio_bytes: bytes) -> str | None:
             with sr.AudioFile(io.BytesIO(audio_bytes)) as source:
                 audio = r.record(source)
             try:
-                return r.recognize_google(audio, language="ko-KR")
+                return r.recognize_google(audio, language=resolve_language())
             except sr.UnknownValueError:
                 return None
             except sr.RequestError as e:

package/voice-service/logger.js

@@ -1,6 +1,8 @@
 const originalLog = console.log;
 const originalError = console.error;
 
+const debugEnabled = (process.env.LOG_LEVEL || 'INFO').toUpperCase() === 'DEBUG';
+
 function getTimestamp() {
     const now = new Date();
     const offset = now.getTimezoneOffset() * 60000;
@@ -14,3 +16,8 @@ console.log = function (...args) {
 console.error = function (...args) {
     originalError(`${getTimestamp()} ERROR Voice:`, ...args);
 };
+console.debug = function (...args) {
+    if (debugEnabled) {
+        originalLog(`${getTimestamp()} DEBUG Voice:`, ...args);
+    }
+};

package/voice-service/receiver.js

@@ -148,7 +148,7 @@ function setupReceiver(connection, guildId, client) {
                 const dynamicThreshold = isBotPlaying ? baseThreshold * 3 : baseThreshold;
                 if (rms > dynamicThreshold) {
                     if (interruptTTS(guildId)) {
-                        console.log(
+                        console.debug(
                             `[VAD] Loud voice detected (${Math.round(rms)}), interrupting TTS (Threshold: ${dynamicThreshold})`,
                         );
                         hasInterrupted = true;
@@ -236,15 +236,18 @@ function setupReceiver(connection, guildId, client) {
                 const threshold = wakeThresholdFor(userId);
                 wakeConfirmed = bestWakeScoreName !== null;
                 matchedWakeWord = wakeConfirmed ? bestWakeScoreName : null;
-                console.log(
-                    wakeConfirmed
-                        ? `[Wake] ${userId}: CONFIRMED (score ${bestWakeScore.toFixed(3)} for ` +
-                              `"${bestWakeScoreName}", threshold ${threshold})`
-                        : `[Wake] ${userId}: no match (score ${bestWakeScore.toFixed(3)}, ` +
-                              `threshold ${threshold}; diagnostic-only closeness ` +
-                              `${bestDiagScore.toFixed(3)} for "${bestDiagScoreName ?? 'n/a'}" - ` +
-                              `different scoring config, not directly comparable to the threshold)`,
-                );
+                if (wakeConfirmed) {
+                    console.log(
+                        `[Wake] ${userId}: CONFIRMED (score ${bestWakeScore.toFixed(3)} for ` +
+                            `"${bestWakeScoreName}", threshold ${threshold})`,
+                    );
+                } else {
+                    console.debug(
+                        `[Wake] ${userId}: no match (threshold ${threshold}; diagnostic-only ` +
+                            `closeness ${bestDiagScore.toFixed(3)} for "${bestDiagScoreName ?? 'n/a'}" - ` +
+                            `different scoring config, not directly comparable to the threshold)`,
+                    );
+                }
             }
 
             const pcmBuffer = Buffer.concat(chunks);

package/voice-service/stt.js

@@ -1,9 +1,20 @@
 const { spawn } = require('child_process');
 const ffmpegPath = require('ffmpeg-static');
+const { aglConfig } = require('./config');
 
 // Unofficial Google STT key - same default Python's SpeechRecognition (recognize_google) ships with.
 const GOOGLE_STT_KEY = 'AIzaSyBOti4mM-6x9WDnZIjIeyEU21OpBXqWBgw';
 
+// Mirrored by resolve_language() in src/services/audio_service.py. edge-tts voice names are
+// <lang>-<REGION>-<Name>, so a pre-1.6 config carries its language in tts_voice alone.
+function resolveLanguage() {
+    if (aglConfig.language) return aglConfig.language;
+    const match = /^([a-z]{2}-[A-Z]{2})-/.exec(aglConfig.tts_voice || '');
+    return match ? match[1] : 'en-US';
+}
+
+const LANGUAGE = resolveLanguage();
+
 function flacEncode(wavBuffer) {
     return new Promise((resolve, reject) => {
         const ff = spawn(ffmpegPath, [
@@ -29,7 +40,7 @@ function flacEncode(wavBuffer) {
     });
 }
 
-async function googleSTT(wavBuffer, lang = 'ko-KR') {
+async function googleSTT(wavBuffer, lang = LANGUAGE) {
     let flacBuffer;
     try {
         flacBuffer = await flacEncode(wavBuffer);
@@ -54,6 +65,7 @@ async function googleSTT(wavBuffer, lang = 'ko-KR') {
     }
 
     const raw = await res.text();
+    console.debug('[STT] raw:', raw.trim().replace(/\n/g, ' | '));
     // Response is newline-delimited JSON, one object per line.
     for (const line of raw.trim().split('\n')) {
         if (!line) continue;

package/voice-service/tts.js

@@ -14,7 +14,7 @@ function interruptTTS(guildId) {
 
     if (player && player.state.status !== AudioPlayerStatus.Idle) {
         player.stop();
-        console.log(`[VAD] Interrupted TTS in guild ${guildId}`);
+        console.debug(`[VAD] Interrupted TTS in guild ${guildId}`);
         interrupted = true;
     }