linkgravity 1.5.13 → 1.6.0

package/bin/setup.js

@@ -112,13 +112,16 @@ async function collectSessionScopes(existingScopes) {
     return scopes;
 }
 
-async function collectUserIds(existingIds, platformLabel) {
+async function collectUserIds(existingIds, platformLabel, required = false) {
     const ids = [];
     const hasExisting = existingIds && existingIds.length > 0;
 
     p.note(
-        'ONLY these users can use the bot (leave completely empty to allow EVERYONE). ' +
-            'Not related to DMs - this only gates the channel/threads configured above.',
+        required
+            ? 'ONLY these users can use the bot. At least one is required - anyone who knows the ' +
+                  'bot username can message it, and there is no channel scope to fall back on.'
+            : 'ONLY these users can use the bot (leave completely empty to allow EVERYONE). ' +
+                  'Not related to DMs - this only gates the channel/threads configured above.',
         `Allowed ${platformLabel} Users`,
     );
 
@@ -143,7 +146,9 @@ async function collectUserIds(existingIds, platformLabel) {
     while (true) {
         const userId = await p.text({
             message: isFirst
-                ? `${platformLabel} User ID to allow (leave empty to allow EVERYONE):`
+                ? required
+                    ? `${platformLabel} User ID to allow (required - message @userinfobot to find yours):`
+                    : `${platformLabel} User ID to allow (leave empty to allow EVERYONE):`
                 : `Another ${platformLabel} user ID to allow (leave empty if done):`,
         });
         if (p.isCancel(userId)) {
@@ -151,7 +156,13 @@ async function collectUserIds(existingIds, platformLabel) {
             process.exit(0);
         }
 
-        if (!userId) break;
+        if (!userId) {
+            if (required && isFirst) {
+                p.note(`At least one allowed user is required for ${platformLabel}.`, 'Required');
+                continue;
+            }
+            break;
+        }
         isFirst = false;
 
         ids.push(userId.trim());
@@ -334,7 +345,7 @@ async function configureTelegram(existingSettings) {
     const existingTelegramUserIds = existingSettings.telegram_allowed_user_ids
         ? splitIds(existingSettings.telegram_allowed_user_ids)
         : [];
-    const telegramUserIds = await collectUserIds(existingTelegramUserIds, 'Telegram');
+    const telegramUserIds = await collectUserIds(existingTelegramUserIds, 'Telegram', true);
 
     const updates = {};
     if (telegramToken) updates.telegram_token = telegramToken;

package/package.json

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

package/src/approval/diff_preview.py

@@ -0,0 +1,143 @@
+import difflib
+import os
+import re
+from pathlib import Path
+
+MAX_LINES = 120
+TAIL_LINES = 30
+MAX_CHARS = 5000
+CONTEXT_LINES = 3
+
+PATH_KEYS = ("TargetFile", "AbsolutePath")
+
+HUNK_HEADER = re.compile(r"^@@ -(\d+)(?:,\d+)? \+(\d+)")
+
+MISSING = object()
+
+
+def _existing_text(tool_input: dict):
+    path = next((tool_input[k] for k in PATH_KEYS if tool_input.get(k)), None)
+    if not path:
+        return MISSING, None
+    if not os.path.isfile(path):
+        return "", path
+    try:
+        return Path(path).read_text(encoding="utf-8"), path
+    except (OSError, UnicodeDecodeError):
+        return MISSING, path
+
+
+def _find_replaced_text(tool_input: dict, haystack: str, replacement: str) -> str | None:
+    # agy doesn't say which key holds the replaced text, so candidates are checked against the
+    # file instead of trusted by name.
+    best = None
+    for key, value in tool_input.items():
+        if key in PATH_KEYS or not isinstance(value, str) or not value or value == replacement:
+            continue
+        if haystack.count(value) == 1 and (best is None or len(value) > len(best)):
+            best = value
+    return best
+
+
+def _entries(old: list[str], new: list[str], first_line: int, width: int) -> list[tuple[int, bool, str]]:
+    out, old_no, new_no = [], first_line, first_line
+    for line in difflib.unified_diff(old, new, lineterm="", n=CONTEXT_LINES):
+        if line.startswith(("---", "+++")):
+            continue
+
+        header = HUNK_HEADER.match(line)
+        if header:
+            # difflib counts from the start of what it was given, which is a slice of the file
+            # for chunk edits.
+            old_no = int(header.group(1)) + first_line - 1
+            new_no = int(header.group(2)) + first_line - 1
+            continue
+
+        sign, body = line[0], line[1:]
+        number = old_no if sign == "-" else new_no
+        # A removed line still sits at new_no, but it doesn't occupy one, so it anchors the gap
+        # marker without advancing past it.
+        out.append((new_no, sign != "-", f"{sign} {number:>{width}} | {body}"))
+        if sign in " -":
+            old_no += 1
+        if sign in " +":
+            new_no += 1
+    return out
+
+
+def _with_gaps(entries: list[tuple[int, bool, str]], total: int, width: int) -> list[str]:
+    def gap(count):
+        return f"{'':>{width + 5}}... ({count} unchanged {'line' if count == 1 else 'lines'})"
+
+    out, last = [], 0
+    for position, occupies, text in entries:
+        if position > last + 1:
+            out.append(gap(position - last - 1))
+        out.append(text)
+        last = position if occupies else max(last, position - 1)
+    if total > last:
+        out.append(gap(total - last))
+    return out
+
+
+def _clip(lines: list[str]) -> str:
+    if len(lines) > MAX_LINES:
+        head = MAX_LINES - TAIL_LINES - 1
+        lines = [*lines[:head], f"... ({len(lines) - head - TAIL_LINES} more lines)", *lines[-TAIL_LINES:]]
+    kept, size = [], 0
+    for line in lines:
+        if size + len(line) > MAX_CHARS:
+            kept.append(f"... ({len(lines) - len(kept)} more lines)")
+            break
+        kept.append(line)
+        size += len(line) + 1
+    return "\n".join(kept)
+
+
+def _render(name: str, entries, total: int, width: int) -> str | None:
+    if not entries:
+        return None
+    added = sum(1 for *_, text in entries if text.startswith("+"))
+    removed = sum(1 for *_, text in entries if text.startswith("-"))
+    return f"{name} · +{added} -{removed}\n{_clip(_with_gaps(entries, total, width))}"
+
+
+def build_diff(tool_input: dict) -> str | None:
+    before, path = _existing_text(tool_input)
+    if before is MISSING:
+        return None
+    name = os.path.basename(path)
+    on_disk = os.path.isfile(path)
+
+    chunks = tool_input.get("ReplacementChunks")
+    if chunks:
+        if not on_disk:
+            return None
+        existing = before.splitlines()
+        total = len(existing)
+        entries, width = [], len(str(total))
+        for chunk in chunks:
+            start, end = chunk.get("StartLine"), chunk.get("EndLine")
+            replacement = chunk.get("ReplacementContent")
+            if not isinstance(start, int) or not isinstance(end, int) or replacement is None:
+                return None
+            replaced_lines = replacement.splitlines()
+            total += len(replaced_lines) - (end - start + 1)
+            entries += _entries(existing[start - 1 : end], replaced_lines, start, width)
+        return _render(name, entries, total, width)
+
+    if "CodeContent" in tool_input:
+        content = tool_input["CodeContent"]
+    else:
+        replacement = tool_input.get("ReplacementContent")
+        if replacement is None or not on_disk:
+            return None
+        replaced = _find_replaced_text(tool_input, before, replacement)
+        if replaced is None:
+            return None
+        content = before.replace(replaced, replacement, 1)
+
+    old_lines, new_lines = before.splitlines(), content.splitlines()
+    width = len(str(max(len(old_lines), len(new_lines))))
+    label = f"{name} (new file)" if not on_disk else name
+    return _render(label, _entries(old_lines, new_lines, 1, width), len(new_lines), width)

package/src/approval/tool_formatter.py

@@ -1,6 +1,8 @@
 import json
 import os
 
+from approval.diff_preview import build_diff
+
 TOOL_DISPLAY_NAMES = {
     "view_file": "Read",
     "write_to_file": "Write",
@@ -39,14 +41,17 @@ def format_tool_display(tool_name: str, tool_input: dict) -> tuple[str, str, dic
             fields_text += f"**{k}**: {v}\n"
 
     code_text = ""
-    if "CodeContent" in tool_input:
-        code_text = f"\n**Code Content:**\n```python\n{tool_input['CodeContent'][:1000]}\n```"
+    diff = build_diff(tool_input)
+    if diff:
+        code_text = f"\n**Changes:**\n```diff\n{diff}\n```"
+    elif "CodeContent" in tool_input:
+        code_text = f"\n**Code Content:**\n```\n{tool_input['CodeContent'][:1000]}\n```"
     elif "ReplacementChunks" in tool_input:
         for i, chunk in enumerate(tool_input["ReplacementChunks"]):
             code_text += f"\n**Replacement Chunk #{i + 1} (Lines {chunk.get('StartLine')}-{chunk.get('EndLine')}):**\n"
-            code_text += f"```python\n{chunk.get('ReplacementContent')[:500]}\n```"
+            code_text += f"```\n{chunk.get('ReplacementContent')[:500]}\n```"
     elif "ReplacementContent" in tool_input:
-        code_text += f"\n**Replacement Content:**\n```python\n{tool_input['ReplacementContent'][:1000]}\n```"
+        code_text += f"\n**Replacement Content:**\n```\n{tool_input['ReplacementContent'][:1000]}\n```"
 
     if fields_text or code_text:
         desc_json = f"\n{fields_text}{code_text}"

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_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
 
@@ -292,12 +290,13 @@ class VoiceCog(commands.Cog):
 
                     if own_word or not required:
                         if self.bot_settings.get("tts_enabled", True):
-                            welcome_audio = await self.tts("Voice connected.")
+                            welcome_audio = await self.tts("Voice connected.", cache=True)
                             if welcome_audio:
                                 await self._play_audio(str(guild_id), welcome_audio, suppress_active_window=True)
                     elif self.bot_settings.get("tts_enabled", True):
                         prompt_audio = await self.tts(
-                            "No wake word is set up yet. Please use the sound command to set one."
+                            "No wake word is set up yet. Please use the sound command to set one.",
+                            cache=True,
                         )
                         if prompt_audio:
                             await self._play_audio(str(guild_id), prompt_audio, suppress_active_window=True)
@@ -325,7 +324,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 +334,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 +347,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 +364,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 +374,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 +386,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 +425,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 +544,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"))
@@ -627,7 +638,7 @@ class VoiceCog(commands.Cog):
             if not text_to_ai:
                 self.logger.debug("STT: isolated wake word handled via direct TTS")
                 if self.bot_settings.get("tts_enabled", True):
-                    audio_reply = await self.tts("Yes, I am listening.")
+                    audio_reply = await self.tts("Yes, I am listening.", cache=True)
                     if audio_reply:
                         await self._play_audio(str(guild_id), audio_reply)
                 return

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": "",
@@ -162,8 +165,10 @@ session_manager = SessionManager(DATA_DIR)
 
 def allowed(user_id, platform: str = "discord") -> bool:
     if platform == "telegram":
-        ids = TELEGRAM_ALLOWED_IDS
-    elif platform == "slack":
+        # Anyone who knows a Telegram bot's username can DM it, and there is no channel scope to
+        # fall back on, so an empty list must mean nobody rather than everyone.
+        return user_id in TELEGRAM_ALLOWED_IDS
+    if platform == "slack":
         ids = SLACK_ALLOWED_IDS
         user_id = str(user_id)  # Slack IDs are strings, not ints like Discord/Telegram
     else:

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/main_discord.py

@@ -1,3 +1,6 @@
+"""Discord bot setup. Runs in the same process as Telegram (see main.py),
+which starts both concurrently when both platforms are enabled."""
+
 import asyncio
 import atexit
 import os
@@ -14,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
@@ -287,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_telegram.py

@@ -6,7 +6,15 @@ from pathlib import Path
 from telegram import BotCommand, InlineKeyboardButton, InlineKeyboardMarkup, Update
 from telegram.ext import Application, ApplicationBuilder, CallbackQueryHandler, CommandHandler, MessageHandler, filters
 
-from config import TELEGRAM_TOKEN, allowed, bot_settings, logger, save_bot_settings, session_manager
+from config import (
+    TELEGRAM_ALLOWED_IDS,
+    TELEGRAM_TOKEN,
+    allowed,
+    bot_settings,
+    logger,
+    save_bot_settings,
+    session_manager,
+)
 from core.atomic_io import atomic_write_json, safe_load_json
 from handlers.message_router import handle_message
 from messengers.registry import register_adapter
@@ -252,6 +260,14 @@ async def run_telegram(stop_event: asyncio.Event) -> None:
         logger.critical("Missing TELEGRAM_TOKEN - set telegram_token in lgy.json first.")
         return
 
+    if not TELEGRAM_ALLOWED_IDS:
+        logger.critical(
+            "No telegram_allowed_user_ids configured - refusing to start. A Telegram bot is "
+            "reachable by anyone who knows its username, so run 'lgy setup' and register your "
+            "user ID (message @userinfobot to find it)."
+        )
+        return
+
     app = build_application()
     logger.info("✅ Telegram bot starting (polling mode)...")
     await app.initialize()

package/src/messengers/discord_adapter.py

@@ -7,7 +7,7 @@ from typing import Any
 
 import discord
 
-from config import logger
+from config import allowed, logger
 from messengers.base import (
     IncomingAttachment,
     IncomingMessage,
@@ -21,6 +21,14 @@ from messengers.base import (
 
 
 class _ErrorLoggingView(discord.ui.View):
+    async def interaction_check(self, interaction: discord.Interaction) -> bool:
+        # discord.py lets anyone who can see the message press the button, so the allow-list has
+        # to be applied here as well as on the inbound message path.
+        if allowed(interaction.user.id):
+            return True
+        await interaction.response.send_message("⛔ You are not allowed to use this bot.", ephemeral=True)
+        return False
+
     async def on_error(self, interaction: discord.Interaction, error: Exception, item) -> None:
         logger.exception(f"Discord button interaction error: {error}")
         error_msg = "⚠️ **An error occurred while processing this button.** Please try again later or check the logs."

package/src/messengers/slack_adapter.py

@@ -12,7 +12,7 @@ from slack_bolt.app.async_app import AsyncApp
 from slack_sdk.errors import SlackApiError
 from slack_sdk.web.async_client import AsyncWebClient
 
-from config import logger, session_manager
+from config import allowed, logger, session_manager
 from messengers.base import (
     IncomingAttachment,
     IncomingMessage,
@@ -222,12 +222,28 @@ class SlackAdapter(MessengerAdapter):
         actions = body.get("actions") or []
         if not actions:
             return
+        if not await self._reject_unauthorized(body):
+            return
         action_id = actions[0].get("action_id")
         handler = self._callbacks.pop(action_id, None)
         if handler is None:
             return  # expired/unknown action - nothing to do, Bolt already acked
         await handler(body, self.client)
 
+    async def _reject_unauthorized(self, body: dict) -> bool:
+        user_id = (body.get("user") or {}).get("id")
+        if allowed(user_id, "slack"):
+            return True
+        channel = (body.get("channel") or {}).get("id")
+        if channel and user_id:
+            try:
+                await self.client.chat_postEphemeral(
+                    channel=channel, user=user_id, text="⛔ You are not allowed to use this bot."
+                )
+            except SlackApiError as e:
+                logger.warning(f"Failed to notify unauthorized Slack user {user_id}: {e}")
+        return False
+
     async def handle_view_submission(self, body: dict) -> None:
         callback_id = (body.get("view") or {}).get("callback_id")
         handler = self._view_callbacks.pop(callback_id, None)

package/src/messengers/telegram_adapter.py

@@ -14,7 +14,7 @@ from telegram.constants import ChatAction
 from telegram.error import TelegramError
 from telegram.ext import ContextTypes
 
-from config import logger
+from config import allowed, logger
 from messengers.base import (
     IncomingAttachment,
     IncomingMessage,
@@ -162,6 +162,9 @@ class TelegramAdapter(MessengerAdapter):
         query = update.callback_query
         if query is None or query.data is None:
             return
+        if query.from_user is None or not allowed(query.from_user.id, "telegram"):
+            await query.answer("You are not allowed to use this bot.", show_alert=True)
+            return
         handler = self._callbacks.pop(query.data, None)
         if handler is None:
             await query.answer("This action has expired.", show_alert=True)

package/src/services/audio_service.py

@@ -6,9 +6,105 @@ 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.
+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",
+]
 
-async def tts(text: str, voice: str = None) -> bytes | None:
-    voice = voice or bot_settings.get("tts_voice", TTS_VOICE)
+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:
+    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)
+
+
+# Synthesising a prompt costs a network round trip that lands directly in the wake-word
+# response time, so the fixed ones are kept rather than rebuilt.
+_fixed_phrase_cache: dict[tuple[str, str, str], bytes] = {}
+
+
+async def tts(text: str, voice: str = None, cache: bool = False) -> bytes | None:
     try:
         import edge_tts
 
@@ -17,29 +113,25 @@ 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}%"
 
+        active_voice = voice or voice_for(clean)
+
+        key = (clean, active_voice, rate)
+        if cache and key in _fixed_phrase_cache:
+            return _fixed_phrase_cache[key]
+
         communicate = edge_tts.Communicate(clean, active_voice, rate=rate)
         with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as f:
             tmp = f.name
         await communicate.save(tmp)
         data = Path(tmp).read_bytes()
         os.unlink(tmp)
+        if cache:
+            _fixed_phrase_cache[key] = data
         return data
     except Exception as e:
         logger.exception(f"TTS error: {e}")
@@ -58,7 +150,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/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';
 
+// edge-tts voice names are <lang>-<REGION>-<Name>, so a config predating the language setting
+// 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,8 @@ function flacEncode(wavBuffer) {
     });
 }
 
-async function googleSTT(wavBuffer, lang = 'ko-KR') {
+async function googleSTT(wavBuffer, lang = LANGUAGE) {
+    const startedAt = Date.now();
     let flacBuffer;
     try {
         flacBuffer = await flacEncode(wavBuffer);
@@ -38,6 +50,8 @@ async function googleSTT(wavBuffer, lang = 'ko-KR') {
         return null;
     }
 
+    const encodedAt = Date.now();
+
     let res;
     try {
         res = await fetch(
@@ -54,6 +68,11 @@ async function googleSTT(wavBuffer, lang = 'ko-KR') {
     }
 
     const raw = await res.text();
+    console.debug(
+        `[STT] ${Math.round(wavBuffer.length / 192)}ms audio: flac ${encodedAt - startedAt}ms, ` +
+            `google ${Date.now() - encodedAt}ms`,
+    );
+    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;