linkgravity 1.5.7 → 1.5.8

package/bin/cli.js

@@ -175,7 +175,10 @@ function verifyStartup() {
             `${color.cyan}▶${color.reset} Verifying startup status (waiting for bot to come online)...`,
         );
 
-        let cp = spawn('npx', ['-y', 'pm2', 'logs', LGY_PM2_NAME, '--raw', '--lines', '20'], {
+        // Spawned directly instead of through npx: npx wraps pm2 in "npm exec" + "sh -c", so cp.kill()
+        // reaps only the wrapper and leaves the real pm2 logs process orphaned onto init.
+        const pm2Bin = require.resolve('pm2/bin/pm2');
+        let cp = spawn(process.execPath, [pm2Bin, 'logs', LGY_PM2_NAME, '--raw', '--lines', '0'], {
             cwd: path.join(__dirname, '..'),
         });
 
@@ -188,12 +191,6 @@ function verifyStartup() {
             resolve(ok);
         };
 
-        // Give the --lines 20 replay burst a moment to flush before treating error text as a fresh crash, not old log noise.
-        let errorDetectionArmed = false;
-        setTimeout(() => {
-            errorDetectionArmed = true;
-        }, 1500);
-
         let timer = setTimeout(() => {
             console.log(
                 `\n\n${color.yellow}⏳ Startup verification timed out. Run 'lgy logs' to check status manually.${color.reset}`,
@@ -212,7 +209,6 @@ function verifyStartup() {
                 console.log(`\n${color.green}✔${color.reset} Bot successfully came online!\n`);
                 finish(true);
             } else if (
-                errorDetectionArmed &&
                 (str.includes('Traceback (most recent call last):') ||
                     str.includes('Error:') ||
                     str.includes('Exception:')) &&
@@ -593,6 +589,9 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
         process.exit(0);
     }
 
+    const procBeforeUpdate = getPm2Proc();
+    const wasOnline = !!procBeforeUpdate && procBeforeUpdate.pm2_env.status === 'online';
+
     info(`Updating: v${currentVersion} -> v${latestVersion}...`);
     const installResult = spawnSync('npm', ['install', '-g', 'linkgravity@latest'], {
         stdio: 'inherit',
@@ -603,27 +602,18 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     }
     success(`Installed v${latestVersion}.`);
 
-    info('Restarting daemon to apply the update...');
-    const restartResult = spawnSync('npx', ['-y', 'pm2', 'restart', LGY_PM2_NAME, '--update-env'], {
-        stdio: 'pipe',
-        cwd: path.join(__dirname, '..'),
-        env: { ...process.env, PYTHONUNBUFFERED: '1' },
-    });
-
-    if (restartResult.status === 0) {
-        runPm2(['reset', LGY_PM2_NAME]);
-        verifyStartup().then((ok) => process.exit(ok ? 0 : 1));
-    } else if ((restartResult.stderr || '').toString().includes('not found')) {
-        // Wasn't running before the update - start fresh instead of a false "restarted".
+    if (!procBeforeUpdate) {
         info("Daemon wasn't running - starting it fresh...");
         runPm2(['start', LGY_SCRIPT_PATH, '--interpreter', pythonExe, '--name', LGY_PM2_NAME]);
         verifyStartup().then((ok) => process.exit(ok ? 0 : 1));
+    } else if (wasOnline) {
+        info('Restarting daemon to apply the update...');
+        runPm2(['restart', LGY_PM2_NAME, '--update-env']);
+        runPm2(['reset', LGY_PM2_NAME]);
+        verifyStartup().then((ok) => process.exit(ok ? 0 : 1));
     } else {
-        console.error((restartResult.stderr || '').toString().trim());
-        console.error(
-            `\n${color.yellow}⚠${color.reset} Update installed, but restarting the daemon failed - run 'lgy restart' manually.`,
-        );
-        process.exit(1);
+        success(`Daemon was stopped - leaving it stopped. Run 'lgy start' when you're ready.\n`);
+        process.exit(0);
     }
 } else if (cmd === 'help') {
     console.log(
@@ -693,7 +683,6 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
         spawnSync(process.argv[0], [process.argv[1], action], { stdio: 'inherit' });
     })();
 } else {
-    // If no valid command was provided, show help
     console.log(
         `\n❌ Unknown command: ${cmd || 'none'}\n💡 Run 'lgy help' to see available commands.`,
     );

package/package.json

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

package/requirements.txt

@@ -4,12 +4,9 @@ slack-bolt>=1.20.0
 PyNaCl>=1.5.0
 numpy>=1.24.0
 edge-tts
-google-genai>=1.0.0
 aiohttp==3.10.3
 aiofiles==24.1.0
 SpeechRecognition>=3.17.0
-schedule==1.2.1
 jamo>=0.4.1
 loguru>=0.7.0
-mcp>=1.0.0
 requests>=2.31.0

package/src/api/ui_routes.py

@@ -9,6 +9,7 @@ from aiohttp import web
 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):
@@ -57,8 +58,8 @@ def allow_response(tool_name, tool_input):
 async def _send_chunked(adapter, thread, text: str) -> None:
     if not text:
         return
-    for i in range(0, len(text), MAX_EMBED_LEN):
-        await adapter.send_message(thread, text[i : i + MAX_EMBED_LEN])
+    for part in split_message(text, MAX_EMBED_LEN):
+        await adapter.send_message(thread, part)
 
 
 def _persist_scope_if_granted(prompt_handle):
@@ -324,58 +325,3 @@ async def handle_approve_request(request):
         for key in registered_approval_keys:
             session_manager.clear_pending_approval(key)
         return web.json_response({"decision": "allow"})
-
-
-async def handle_mcp_ask(request):
-    try:
-        data = await request.json()
-        thread_id = data.get("thread_id")
-
-        question = _clean_inline(data.get("question", "No question provided."))
-        options = [(_clean_inline(str(opt)) or "Option")[:80] for opt in data.get("options", [])]
-
-        adapter = get_adapter_for_thread(thread_id)
-        thread = adapter.resolve_conversation(thread_id)
-        if not thread:
-            return web.json_response({"answer": "Thread not found"}, status=400)
-
-        future = asyncio.get_event_loop().create_future()
-        # conv_id is always None here - key just needs to be unique for cleanup.
-        approval_key = f"mcp_ask:{thread_id}:{uuid.uuid4().hex}"
-        session_manager.set_pending_approval(approval_key, future, "ask_question")
-
-        prompt = adapter.create_question_prompt(future, question, options, allow_write_in=True)
-        msg = await prompt.send(thread)
-        session_manager.pending_approval_messages[approval_key] = msg
-
-        try:
-            answer = await asyncio.wait_for(future, timeout=300)
-            return web.json_response({"answer": answer})
-        except asyncio.TimeoutError:
-            return web.json_response({"answer": "User did not respond in time."})
-        finally:
-            await prompt.finalize()
-            session_manager.pending_approval_messages.pop(approval_key, None)
-            session_manager.clear_pending_approval(approval_key)
-    except Exception as e:
-        return web.json_response({"answer": f"Error: {e}"}, status=500)
-
-
-async def handle_mcp_send_channel(request):
-    try:
-        data = await request.json()
-        channel_id = data.get("channel_id")
-        message = data.get("message", "")
-
-        adapter = get_adapter_for_thread(channel_id)
-        channel = adapter.resolve_conversation(channel_id)
-        if not channel:
-            return web.json_response({"error": "Channel not found"}, status=400)
-
-        chunks = [message[i : i + MAX_EMBED_LEN] for i in range(0, len(message), MAX_EMBED_LEN)]
-        for chunk in chunks:
-            await adapter.send_message(channel, chunk)
-
-        return web.json_response({"answer": "success"})
-    except Exception as e:
-        return web.json_response({"error": str(e)}, status=500)

package/src/cogs/voice_cog.py

@@ -1,4 +1,5 @@
 import asyncio
+import math
 import time
 
 import aiohttp
@@ -15,6 +16,18 @@ from .voice.stt_session import SttSessionTracker
 NODE_VOICE_API = "http://localhost:18081"
 # Default aiohttp timeout is 5 minutes - too long for a dead voice service.
 NODE_REQUEST_TIMEOUT = aiohttp.ClientTimeout(total=5)
+# Must match DEFAULT_WAKE_THRESHOLD / DEFAULT_VAD_THRESHOLD in voice-service - the two processes
+# decide these independently, and only voice-service's values actually gate anything.
+DEFAULT_WAKE_THRESHOLD = 0.4
+DEFAULT_VAD_THRESHOLD = 3000
+
+
+def _autocomplete_query(current) -> str:
+    # discord.py hands a focused NUMBER option back as float('nan') when the input box is empty,
+    # and passes INTEGER options through unconverted - neither is guaranteed to be a str.
+    if isinstance(current, float) and math.isnan(current):
+        return ""
+    return str(current)
 
 
 class VoiceCog(commands.Cog):
@@ -60,6 +73,12 @@ class VoiceCog(commands.Cog):
     def _wake_word_required(self, user_id) -> bool:
         return (self.bot_settings.get("wake_word_required") or {}).get(str(user_id), True)
 
+    def _wake_threshold(self, user_id) -> float:
+        return (self.bot_settings.get("wake_thresholds") or {}).get(str(user_id), DEFAULT_WAKE_THRESHOLD)
+
+    def _vad_threshold(self, user_id) -> int:
+        return (self.bot_settings.get("voice_thresholds") or {}).get(str(user_id), DEFAULT_VAD_THRESHOLD)
+
     async def handle_voice_service_down(self):
         await self.enrollment.handle_voice_service_down()
 
@@ -83,8 +102,9 @@ class VoiceCog(commands.Cog):
         self, interaction: discord.Interaction, current: str
     ) -> list[app_commands.Choice[int]]:
         current_val = int(self.bot_settings.get("active_timer", 60))
+        query = _autocomplete_query(current)
         opts = []
-        if str(current_val) in current or not current:
+        if str(current_val) in query or not query:
             opts.append(app_commands.Choice(name=f"{current_val} (current)", value=current_val))
 
         for v in [30, 60, 120, 300]:
@@ -95,9 +115,10 @@ class VoiceCog(commands.Cog):
     async def interrupt_threshold_autocomplete(
         self, interaction: discord.Interaction, current: str
     ) -> list[app_commands.Choice[int]]:
-        current_val = int(self.bot_settings.get("voice_threshold", 3000))
+        current_val = self._vad_threshold(interaction.user.id)
+        query = _autocomplete_query(current)
         opts = []
-        if str(current_val) in current or not current:
+        if str(current_val) in query or not query:
             opts.append(app_commands.Choice(name=f"{current_val} (current)", value=current_val))
 
         for v in [1000, 2000, 3000, 5000]:
@@ -108,9 +129,10 @@ class VoiceCog(commands.Cog):
     async def wake_sensitivity_autocomplete(
         self, interaction: discord.Interaction, current: str
     ) -> list[app_commands.Choice[float]]:
-        current_val = float(self.bot_settings.get("wake_threshold", 0.4))
+        current_val = self._wake_threshold(interaction.user.id)
+        query = _autocomplete_query(current)
         opts = []
-        if str(current_val) in current or not current:
+        if str(current_val) in query or not query:
             opts.append(app_commands.Choice(name=f"{current_val} (current)", value=current_val))
 
         for v in [0.2, 0.3, 0.4, 0.5, 0.6]:
@@ -184,8 +206,9 @@ class VoiceCog(commands.Cog):
         self, interaction: discord.Interaction, current: str
     ) -> list[app_commands.Choice[float]]:
         current_val = float(self.bot_settings.get("tts_speed", 1.0))
+        query = _autocomplete_query(current)
         opts = []
-        if str(current_val) in current or not current:
+        if str(current_val) in query or not query:
             opts.append(app_commands.Choice(name=f"{current_val}x (current)", value=current_val))
 
         for v in [0.75, 1.0, 1.25, 1.3, 1.5, 1.75, 2.0]:
@@ -346,8 +369,8 @@ class VoiceCog(commands.Cog):
         ):
             curr_wake = (self.bot_settings.get("wake_words") or {}).get(str(interaction.user.id), "None")
             curr_timer = self.bot_settings.get("active_timer", 60)
-            curr_interrupt_thresh = self.bot_settings.get("voice_threshold", 3000)
-            curr_wake_sens = self.bot_settings.get("wake_threshold", 0.4)
+            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_tts_on = "ON" if self.bot_settings.get("tts_enabled", True) else "OFF"
             curr_tts_speed = self.bot_settings.get("tts_speed", 1.0)
@@ -373,30 +396,30 @@ class VoiceCog(commands.Cog):
             self.bot_settings["active_timer"] = active_times
             updated.append(f"⏱️ Active Timer: `{active_times}s`")
         if interrupt_threshold is not None:
-            self.bot_settings["voice_threshold"] = interrupt_threshold
+            self.bot_settings.setdefault("voice_thresholds", {})[str(interaction.user.id)] = interrupt_threshold
             updated.append(f"🔊 Interrupt Threshold: `{interrupt_threshold}`")
             try:
                 async with aiohttp.ClientSession(timeout=NODE_REQUEST_TIMEOUT) as session:
-                    await session.post(f"{NODE_VOICE_API}/set_config", json={"voice_threshold": interrupt_threshold})
-            except aiohttp.ClientError as e:
-                self.logger.warning(f"Node.js sync failed for {interaction.guild_id}: {e}")
+                    await session.post(
+                        f"{NODE_VOICE_API}/set_vad_threshold",
+                        json={"user_id": str(interaction.user.id), "threshold": interrupt_threshold},
+                    )
+            except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+                self.logger.warning(f"Node.js vad-threshold sync failed for {interaction.user.id}: {e}")
                 updated.append(f"(⚠️ Node.js Sync Failed: {e})")
-            except asyncio.TimeoutError:
-                self.logger.warning(f"Node.js sync timeout for {interaction.guild_id}")
-                updated.append("(⚠️ Node.js Sync Timeout)")
         if wake_sensitivity is not None:
             clamped_wake = max(0.05, min(0.95, wake_sensitivity))
-            self.bot_settings["wake_threshold"] = clamped_wake
+            self.bot_settings.setdefault("wake_thresholds", {})[str(interaction.user.id)] = clamped_wake
             updated.append(f"🎯 Wake Sensitivity: `{clamped_wake}`")
             try:
                 async with aiohttp.ClientSession(timeout=NODE_REQUEST_TIMEOUT) as session:
-                    await session.post(f"{NODE_VOICE_API}/set_config", json={"wake_threshold": clamped_wake})
-            except aiohttp.ClientError as e:
-                self.logger.warning(f"Node.js sync failed for {interaction.guild_id}: {e}")
+                    await session.post(
+                        f"{NODE_VOICE_API}/set_wake_threshold",
+                        json={"user_id": str(interaction.user.id), "threshold": clamped_wake},
+                    )
+            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})")
-            except asyncio.TimeoutError:
-                self.logger.warning(f"Node.js sync timeout for {interaction.guild_id}")
-                updated.append("(⚠️ Node.js Sync Timeout)")
         if tts_voice is not None:
             self.bot_settings["tts_voice"] = tts_voice
             updated.append(f"🗣️ TTS Voice: `{tts_voice}`")

package/src/config.py

@@ -25,8 +25,11 @@ DEFAULT_LGY_CONFIG = {
     "allowed_user_ids": "",
     # user_id (str) -> registered word, one per person (see EnrollmentManager._commit_enrollment).
     "wake_words": {},
+    # user_id (str) -> wake-word match threshold; absent means voice-service's own default.
+    "wake_thresholds": {},
+    # user_id (str) -> interrupt/VAD RMS threshold; absent means voice-service's own default.
+    "voice_thresholds": {},
     "active_timer": 60,
-    "voice_threshold": 3000,
     "tts_voice": "ko-KR-SunHiNeural",
     "tts_enabled": True,
     # Sticky default for /new sessions, set whenever /model succeeds.

package/src/handlers/thread_reply.py

@@ -74,7 +74,7 @@ async def handle_pending_session(
             await stream_task
 
             response_text = result_text
-            if adapter.can_rename(thread) and thread.name.startswith("Session-"):
+            if adapter.should_auto_title(thread):
                 new_title = await generate_thread_title(content, response_text)
                 await adapter.rename_conversation(thread, new_title)
                 await update_agy_conversation_title(new_conv_id, new_title)

package/src/messengers/base.py

@@ -96,9 +96,7 @@ class MessengerAdapter(ABC):
     async def start_conversation(self, origin_ref: Any, title: str) -> Any:
         raise NotImplementedError
 
-    def can_rename(self, conversation_ref: Any) -> bool:
-        """Per-conversation version of supports_renaming - lets a single adapter answer
-        differently depending on the target (e.g. Discord threads vs. Discord DMs)."""
+    def should_auto_title(self, conversation_ref: Any) -> bool:
         return self.supports_renaming
 
     @abstractmethod

package/src/messengers/discord_adapter.py

@@ -149,8 +149,8 @@ class DiscordAdapter(MessengerAdapter):
     async def start_conversation(self, origin_ref: discord.Message, title: str) -> discord.Thread:
         return await origin_ref.create_thread(name=title[:100], auto_archive_duration=1440)
 
-    def can_rename(self, conversation_ref: Any) -> bool:
-        return isinstance(conversation_ref, discord.Thread)
+    def should_auto_title(self, conversation_ref: Any) -> bool:
+        return isinstance(conversation_ref, discord.Thread) and conversation_ref.name.startswith("Session-")
 
     async def rename_conversation(self, conversation_ref: discord.Thread, title: str) -> None:
         if not isinstance(conversation_ref, discord.Thread):

package/src/services/discord_helpers.py

@@ -74,7 +74,7 @@ def check_approval_intent(text: str) -> str:
         "ㅇㅇ",
         "ㅇㅋ",
         "해",
-        "콜",
+        "그래",
         "네",
         "sure",
         "yeah",
@@ -92,3 +92,31 @@ def check_approval_intent(text: str) -> str:
         if word in exact_allow:
             return "allow"
     return None
+
+
+def split_message(text: str, limit: int) -> list[str]:
+    parts = []
+    fence = None
+    remaining = text
+    while remaining:
+        # A chunk that ends mid-code-block gets closed here and reopened at the top of the next one,
+        # otherwise the client renders the rest of the message as one runaway code block.
+        prefix = f"{fence}\n" if fence else ""
+        budget = limit - len(prefix) - len("\n```")
+        if len(remaining) <= budget:
+            body, remaining = remaining, ""
+        else:
+            window = remaining[:budget]
+            cuts = [pos + len(d) for d in ("\n\n", "\n", " ") if (pos := window.rfind(d)) > 0]
+            cut = next((c for c in cuts if c > budget // 2), max(cuts, default=0))
+            body, remaining = remaining[: cut or budget], remaining[cut or budget :]
+        chunk = prefix + body
+        fence = None
+        for match in re.finditer(r"^```(\S*)", chunk, re.MULTILINE):
+            fence = None if fence else f"```{match.group(1)}"
+        if fence:
+            chunk += "\n```"
+        if parts and not re.sub(r"^```\S*$", "", chunk, flags=re.MULTILINE).strip():
+            continue
+        parts.append(chunk)
+    return parts or [""]

package/src/services/response.py

@@ -3,6 +3,7 @@ from typing import Any
 
 from config import MAX_EMBED_LEN, MODEL_CHOICES, session_manager
 from messengers.registry import get_adapter_for_platform
+from services.discord_helpers import split_message
 from utils.utils import get_current_model
 
 
@@ -17,24 +18,20 @@ async def send_agy_response(
     adapter = get_adapter_for_platform(session.get("platform", "discord"))
     session_manager.save_sessions()
 
-    parts = [response_text[i : i + MAX_EMBED_LEN] for i in range(0, max(len(response_text), 1), MAX_EMBED_LEN)]
-    for idx, part in enumerate(parts):
-        is_last = idx == len(parts) - 1
+    session_model = session.get("model")
+    model_display = MODEL_CHOICES.get(session_model, session_model) if session_model else get_current_model()
 
-        if is_last:
+    parts = split_message(response_text, MAX_EMBED_LEN)
+    for idx, part in enumerate(parts):
+        if idx == len(parts) - 1:
             if not part.strip():
                 continue
+            part = f"{part}\n-# 🤖 {model_display}"
 
-            session_model = session.get("model")
-            model_display = MODEL_CHOICES.get(session_model, session_model) if session_model else get_current_model()
-            text_to_send = f"{part}\n-# 🤖 {model_display}"
-
-            status_msg = ctx.get("status_msg") if ctx else None
-            if status_msg and await adapter.edit_message(status_msg, text_to_send):
-                continue
-            await adapter.send_message(thread, text_to_send)
-        else:
-            await adapter.send_message(thread, part)
+        status_msg = ctx.get("status_msg") if ctx and idx == 0 else None
+        if status_msg and await adapter.edit_message(status_msg, part):
+            continue
+        await adapter.send_message(thread, part)
 
     files_to_send = []
     if conv_id and start_time:

package/src/services/streaming.py

@@ -7,7 +7,7 @@ import discord  # only for voice/TTS text cleanup below; messaging goes through
 
 from config import MAX_EMBED_LEN, STREAM_RATE_LIMIT_SEC, bot_settings, logger, session_manager
 from messengers.registry import get_adapter_for_thread
-from utils.utils import clean_ansi
+from utils.utils import clean_ansi, split_message
 
 
 def _clear_current_tool(thread_id: str):
@@ -46,7 +46,7 @@ class StreamUpdater:
     async def split(self):
         full_text = self.current_text.strip()
         if full_text:
-            parts = [full_text[i : i + self.MAX_EMBED_LEN] for i in range(0, len(full_text), self.MAX_EMBED_LEN)]
+            parts = split_message(full_text, self.MAX_EMBED_LEN)
             for idx, part in enumerate(parts):
                 await self._update(part, force_new=(idx > 0))
         self.status_msg = None

package/src/utils/utils.py

@@ -16,6 +16,7 @@ from services.discord_helpers import (
     clean_ansi,
     cleanup_images,
     handle_image_attachments,
+    split_message,
 )
 
 __all__ = [
@@ -33,6 +34,7 @@ __all__ = [
     "cleanup_images",
     "build_content_with_images",
     "clean_ansi",
+    "split_message",
     "check_approval_intent",
     "get_default_cwd",
 ]

package/voice-service/index.js

@@ -18,8 +18,11 @@ process.on('uncaughtException', (err) => {
 
 const { registerRoutes } = require('./routes');
 
-if (aglConfig.voice_threshold) {
-    state.runtime.vadThreshold = parseInt(aglConfig.voice_threshold) || 3000;
+for (const [userId, value] of Object.entries(aglConfig.voice_thresholds || {})) {
+    state.vadThresholds.set(userId, parseInt(value));
+}
+for (const [userId, value] of Object.entries(aglConfig.wake_thresholds || {})) {
+    state.wakeThresholds.set(userId, parseFloat(value));
 }
 
 const app = express();

package/voice-service/receiver.js

@@ -2,12 +2,18 @@ const { EndBehaviorType } = require('@discordjs/voice');
 const prism = require('prism-media');
 const { stereoToMono, createWavHeader } = require('./audioUtils');
 const { googleSTT } = require('./stt');
-const { getDetectorForUser, feedPCMToDetector, WAKE_MATCH_THRESHOLD } = require('./wakeword');
+const { getDetectorForUser, feedPCMToDetector, wakeThresholdFor } = require('./wakeword');
 const { interruptTTS } = require('./tts');
 const state = require('./state');
 const { aglConfig } = require('./config');
-const { activeStreams, enrollingUsers, isPlaying, wakeWordOptedOut, runtime, isGuildActive } =
-    state;
+const {
+    activeStreams,
+    enrollingUsers,
+    isPlaying,
+    wakeWordOptedOut,
+    vadThresholdFor,
+    isGuildActive,
+} = state;
 
 function setupReceiver(connection, guildId, client) {
     const receiver = connection.receiver;
@@ -138,9 +144,8 @@ function setupReceiver(connection, guildId, client) {
             const isBotPlaying = isPlaying.get(guildId) || false;
 
             if (!hasInterrupted) {
-                const dynamicThreshold = isBotPlaying
-                    ? runtime.vadThreshold * 3
-                    : runtime.vadThreshold;
+                const baseThreshold = vadThresholdFor(userId);
+                const dynamicThreshold = isBotPlaying ? baseThreshold * 3 : baseThreshold;
                 if (rms > dynamicThreshold) {
                     if (interruptTTS(guildId)) {
                         console.log(
@@ -226,15 +231,17 @@ function setupReceiver(connection, guildId, client) {
                     bestDiagScoreName = diagPaddingDetection.getName();
                 }
 
-                // Real pass/fail uses bestWakeScore; bestDiagScore is a separate, much looser detector shown only for "how close" - not on the same scale, not comparable to WAKE_MATCH_THRESHOLD.
-                wakeConfirmed = bestWakeScore >= WAKE_MATCH_THRESHOLD;
+                // rustpotter only emits a detection once its own per-user threshold is met, so any
+                // score reaching here is already a pass; the number below is for the log line only.
+                const threshold = wakeThresholdFor(userId);
+                wakeConfirmed = bestWakeScoreName !== null;
                 matchedWakeWord = wakeConfirmed ? bestWakeScoreName : null;
                 console.log(
                     wakeConfirmed
                         ? `[Wake] ${userId}: CONFIRMED (score ${bestWakeScore.toFixed(3)} for ` +
-                              `"${bestWakeScoreName}", threshold ${WAKE_MATCH_THRESHOLD})`
+                              `"${bestWakeScoreName}", threshold ${threshold})`
                         : `[Wake] ${userId}: no match (score ${bestWakeScore.toFixed(3)}, ` +
-                              `threshold ${WAKE_MATCH_THRESHOLD}; diagnostic-only closeness ` +
+                              `threshold ${threshold}; diagnostic-only closeness ` +
                               `${bestDiagScore.toFixed(3)} for "${bestDiagScoreName ?? 'n/a'}" - ` +
                               `different scoring config, not directly comparable to the threshold)`,
                 );

package/voice-service/routes.js

@@ -108,6 +108,19 @@ function registerRoutes(app, client) {
         res.json({ success: true, was_cached: deleted });
     });
 
+    app.post('/set_wake_threshold', (req, res) => {
+        const { user_id, threshold } = req.body;
+        if (!user_id || typeof threshold !== 'number') {
+            return res.status(400).json({ error: 'user_id and numeric threshold required' });
+        }
+        state.wakeThresholds.set(user_id, threshold);
+        // The threshold is baked into the rustpotter config at build time, so the cached detector
+        // has to go with it - otherwise the new value only takes effect after some unrelated reset.
+        state.detectorCache.delete(user_id);
+        console.log(`[Wake] Threshold for ${user_id} set to ${threshold}`);
+        res.json({ success: true });
+    });
+
     app.post('/build_wakeword', async (req, res) => {
         // Builds a .rpw in-process via WakewordRefCreator, instead of shelling out to rustpotter-cli.
         try {
@@ -139,12 +152,13 @@ function registerRoutes(app, client) {
         }
     });
 
-    app.post('/set_config', (req, res) => {
-        const { voice_threshold } = req.body;
-        if (voice_threshold) {
-            state.runtime.vadThreshold = voice_threshold;
-            console.log(`[Config] Updated VAD threshold to ${state.runtime.vadThreshold}`);
+    app.post('/set_vad_threshold', (req, res) => {
+        const { user_id, threshold } = req.body;
+        if (!user_id || typeof threshold !== 'number') {
+            return res.status(400).json({ error: 'user_id and numeric threshold required' });
         }
+        state.vadThresholds.set(user_id, threshold);
+        console.log(`[Config] VAD threshold for ${user_id} set to ${threshold}`);
         res.json({ success: true });
     });
 

package/voice-service/state.js

@@ -19,8 +19,18 @@ const suppressNotifyMap = new Map();
 // userId -> { rustpotter, samplesPerFrame, residual: Int16Array }
 const detectorCache = new Map();
 
+// user_id -> wake-word match threshold; absent means DEFAULT_WAKE_THRESHOLD.
+const wakeThresholds = new Map();
+
 // Object property, not a plain `let` - a `let` wouldn't propagate its reassignment across modules.
-const runtime = { vadThreshold: 3000 };
+// user_id -> interrupt/VAD RMS threshold; absent means DEFAULT_VAD_THRESHOLD.
+const vadThresholds = new Map();
+
+const DEFAULT_VAD_THRESHOLD = 3000;
+
+function vadThresholdFor(userId) {
+    return vadThresholds.get(userId) ?? DEFAULT_VAD_THRESHOLD;
+}
 
 function isGuildActive(guildId) {
     return Date.now() < (activeUntil.get(guildId) || 0);
@@ -37,6 +47,9 @@ module.exports = {
     wakeWordOptedOut,
     suppressNotifyMap,
     detectorCache,
-    runtime,
+    wakeThresholds,
+    vadThresholds,
+    DEFAULT_VAD_THRESHOLD,
+    vadThresholdFor,
     isGuildActive,
 };

package/voice-service/wakeword.js

@@ -1,7 +1,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { detectorCache } = require('./state');
+const { detectorCache, wakeThresholds } = require('./state');
 
 // Rustpotter wake-word detection runs entirely in-process here, no Python round trip.
 const WAKE_REF_DIR = path.join(os.homedir(), '.gemini', 'linkgravity', 'wake_refs');
@@ -21,7 +21,11 @@ function loadRustpotterModule() {
 }
 
 // Wake-word confirm cutoff - must stay well above ~0.05 (rustpotter's countdown never finalizes if noise/silence clears it too); 0.4 chosen after live use kept narrowly missing genuine hits just under 0.5.
-const WAKE_MATCH_THRESHOLD = 0.4;
+const DEFAULT_WAKE_THRESHOLD = 0.4;
+
+function wakeThresholdFor(userId) {
+    return wakeThresholds.get(userId) ?? DEFAULT_WAKE_THRESHOLD;
+}
 
 async function getDetectorForUser(userId) {
     if (detectorCache.has(userId)) return detectorCache.get(userId);
@@ -37,7 +41,7 @@ async function getDetectorForUser(userId) {
     config.setSampleRate(48000);
     config.setSampleFormat(mod.SampleFormat.i16);
     config.setChannels(1);
-    config.setThreshold(WAKE_MATCH_THRESHOLD);
+    config.setThreshold(wakeThresholdFor(userId));
     config.setAveragedThreshold(0);
     // Live logs showed genuine attempts peaking above threshold but not sustaining 4 positive-scoring
     // frames; lowered from 4. STT-side prefix-similarity check is the backstop against false wakes.
@@ -107,7 +111,8 @@ function feedPCMToDetector(entry, chunk) {
 
 module.exports = {
     WAKE_REF_DIR,
-    WAKE_MATCH_THRESHOLD,
+    DEFAULT_WAKE_THRESHOLD,
+    wakeThresholdFor,
     loadRustpotterModule,
     getDetectorForUser,
     feedPCMToDetector,