linkgravity 1.5.7 → 1.5.9

package/README.md

@@ -2,13 +2,15 @@
 
 A Discord, Telegram, and Slack bot interface for the Antigravity agentic AI system. It translates Antigravity CLI prompts into chat UI components and provides voice interaction capabilities.
 
+![Tool approval buttons and session threads in Discord](https://raw.githubusercontent.com/dev-sseul/linkgravity/main/docs/images/approval-flow.png)
+
 ## Features
 
-- **Environment Sync:** Automatically syncs with the host's `~/.gemini` configuration.
-- **Voice Interaction:** Supports voice channels with adaptive voice activity detection to segment speech and filter environmental noise, plus live "listening..." feedback while you're still talking.
-  - **Wake Word Recognition:** Uses phoneme-level similarity to detect wake words and activate voice commands.
+- **Sessions as Threads:** Each `agy` conversation lives in its own thread, so several can run side by side and stay readable later. Threads get named from what you actually talked about instead of staying `Session-XXXX`.
 - **Approval Flow:** Command and tool-call approvals become interactive chat buttons. Chained shell commands are approved individually, and any approval can be scoped to auto-allow that command or tool going forward - something plain `agy` doesn't do.
+- **Voice Interaction:** Talk to the agent from a Discord voice channel and hear its replies. Say your wake word to get its attention, so side conversation in the channel doesn't set it off.
 - **Multi-Modal Input:** Attach files for the AI to read, including audio, which gets transcribed to text automatically.
+- **Same Agent as Your Terminal:** Reads the `agy` setup already on the machine, so sessions started from chat use the same models and settings you use locally.
 
 ## Supported Platforms
 
@@ -58,7 +60,7 @@ Slack has more moving parts than the others - two separate tokens, and a few set
     - It's easy to grab the wrong token here - the page also shows a **User OAuth Token** (`xoxp-...`) further down, which is a different thing and won't work for this bot.
 5. **App Home** (left sidebar) > under **Show Tabs**, turn on **Messages Tab**, then check **Allow users to send Slash commands and messages from the messages tab** - this is what lets you DM the bot at all. (If this section looks greyed out, it's because step 3 hasn't been saved/installed yet - go back and do that first.)
 6. **Event Subscriptions** (left sidebar) > toggle **Enable Events** on > under **Subscribe to bot events**, add `message.channels`, `message.groups`, `message.im`, and `message.mpim` > **Save Changes**.
-7. **Slash Commands** (left sidebar) > **Create New Command**, three times, for `/new`, `/model`, and `/credit` (any description/hint text is fine - only the command name matters).
+7. **Slash Commands** (left sidebar) > **Create New Command**, four times, for `/new`, `/model`, `/credit`, and `/permissions` (any description/hint text is fine - only the command name matters).
 8. Back on **OAuth & Permissions**, since scopes/events changed after the initial install, click **Reinstall to Workspace** to push those changes live. Any time you change scopes or events later, you'll need to repeat this step.
 9. In Slack itself, for any **channel** (not DM) you want the bot usable in, run `/invite @<your bot's name>` there first - the bot can't post in a channel it hasn't been added to.
 

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.9",
   "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):
@@ -196,10 +197,7 @@ async def handle_approve_request(request):
                                 break
                     except ValueError:
                         pass
-                elif is_tool_allowed(tool_name, {"CommandLine": sub_cmd}) or (
-                    conv_id in session_manager.session_allowed_tools
-                    and tool_name in session_manager.session_allowed_tools[conv_id]
-                ):
+                elif is_tool_allowed(tool_name, {"CommandLine": sub_cmd}):
                     is_auto_allowed = True
 
                 if is_auto_allowed:
@@ -270,14 +268,7 @@ async def handle_approve_request(request):
             return allow_response(tool_name, tool_input)
 
         else:
-            is_auto_allowed = False
-            if is_tool_allowed(tool_name, tool_input) or (
-                conv_id in session_manager.session_allowed_tools
-                and tool_name in session_manager.session_allowed_tools[conv_id]
-            ):
-                is_auto_allowed = True
-
-            if is_auto_allowed:
+            if is_tool_allowed(tool_name, tool_input):
                 if target_thread and tool_msg_text:
                     await send_ordered(
                         target_thread_id, lambda: _send_chunked(adapter, target_thread, tool_msg_formatted)
@@ -324,58 +315,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/general_cog.py

@@ -255,6 +255,23 @@ class GeneralCog(commands.Cog):
         except Exception as e:
             await interaction.response.send_message(f"⚠️ Failed to update settings: {e}", ephemeral=True)
 
+    @app_commands.command(name="permissions", description="View and remove previously allowed tools and commands")
+    async def cmd_permissions(self, interaction: discord.Interaction):
+        if not allowed(interaction.user.id):
+            return await interaction.response.send_message("❌ Denied", ephemeral=True)
+
+        from messengers.registry import get_adapter_for_platform
+        from services import permissions
+
+        adapter = get_adapter_for_platform("discord")
+
+        async def on_revoke(entry):
+            permissions.revoke(entry)
+
+        handle = adapter.create_permission_list(on_revoke)
+        await handle.send(interaction.channel)
+        await interaction.response.send_message("🔐 Permission list posted above.", ephemeral=True)
+
     @app_commands.command(
         name="stop", description="Stop the currently generating response or task (Equivalent to ESC in CLI)"
     )
@@ -278,9 +295,21 @@ class GeneralCog(commands.Cog):
             # Must clear conversation_id too, not just status - pending requires both unset.
             session_manager.set_session(thread_id, {**session, "status": "pending", "conversation_id": None})
 
+        # The typing indicator only clears when the handler leaves its `async with adapter.typing()`
+        # block, and that block outlives the agy process (title generation, final send), so killing
+        # the process alone can leave the thread stuck showing "is thinking...".
+        handler = session_manager.get_handler_task(thread_id)
+        cancelled = bool(handler and handler is not asyncio.current_task() and not handler.done())
+        if cancelled:
+            handler.cancel()
+            session_manager.remove_handler_task(thread_id)
+
         from core.agy_runner import stop_active_process
 
         if stop_active_process(thread_id):
-            await interaction.response.send_message("🛑 Process stopped natively.", ephemeral=True)
+            msg = "🛑 Process stopped natively."
+        elif cancelled:
+            msg = "🛑 Stopped."
         else:
-            await interaction.response.send_message("🛑 Process stopped.", ephemeral=True)
+            msg = "🛑 Nothing was running."
+        await interaction.response.send_message(msg, ephemeral=True)

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/core/session_manager.py

@@ -24,7 +24,6 @@ class SessionManager:
         self.active_approval_by_conv: dict[str, str] = {}
 
         self.persistent_allowed: dict = self._load_persistent()
-        self.session_allowed_tools: dict[str, set] = {}
 
     def _load_sessions(self) -> dict:
         from config import logger

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

@@ -14,7 +14,12 @@ from config import SLACK_APP_TOKEN, SLACK_BOT_TOKEN, allowed, bot_settings, logg
 from core import platform_health
 from handlers.message_router import handle_message
 from messengers.registry import register_adapter
-from messengers.slack_adapter import SlackAdapter, encode_conversation_id, latest_channel_session
+from messengers.slack_adapter import (
+    SlackAdapter,
+    SlackConversationRef,
+    encode_conversation_id,
+    latest_channel_session,
+)
 from utils.utils import get_default_cwd
 
 
@@ -129,6 +134,25 @@ async def cmd_model(ack, body, respond, context) -> None:
     await respond(f"🤖 Model changed: *{final_model}*\n💾 Also set as the default for new sessions.")
 
 
+async def cmd_permissions(ack, body, respond, context) -> None:
+    await ack()
+    adapter: SlackAdapter = context["adapter"]
+    user_id = body["user_id"]
+    channel = body["channel_id"]
+
+    if not allowed(user_id, "slack"):
+        await respond("❌ Denied")
+        return
+
+    from services import permissions
+
+    async def on_revoke(entry):
+        permissions.revoke(entry)
+
+    handle = adapter.create_permission_list(on_revoke)
+    await handle.send(SlackConversationRef(channel=channel, thread_ts=None))
+
+
 async def cmd_credit(ack, body, respond, context) -> None:
     await ack()
     adapter: SlackAdapter = context["adapter"]
@@ -212,6 +236,7 @@ def build_app() -> tuple[AsyncApp, SlackAdapter]:
     app.command("/new")(cmd_new)
     app.command("/model")(cmd_model)
     app.command("/credit")(cmd_credit)
+    app.command("/permissions")(cmd_permissions)
     app.event("message")(on_message)
     app.action(re.compile(".*"))(on_action)
     app.view(re.compile(".*"))(on_view_submission)

package/src/main_telegram.py

@@ -135,6 +135,23 @@ async def cmd_model(update: Update, context) -> None:
     )
 
 
+async def cmd_permissions(update: Update, context) -> None:
+    user = update.effective_user
+    adapter: TelegramAdapter = context.bot_data["adapter"]
+
+    if not allowed(user.id, "telegram"):
+        await update.message.reply_text("❌ Denied")
+        return
+
+    from services import permissions
+
+    async def on_revoke(entry):
+        permissions.revoke(entry)
+
+    handle = adapter.create_permission_list(on_revoke)
+    await handle.send(update.effective_chat.id)
+
+
 async def cmd_credit(update: Update, context) -> None:
     user = update.effective_user
     adapter: TelegramAdapter = context.bot_data["adapter"]
@@ -207,6 +224,7 @@ async def on_ready(app: Application) -> None:
             BotCommand("new", "Start a new session (or /start)"),
             BotCommand("model", "Change the AI model for this session"),
             BotCommand("credit", "Turn AI Credits on/off"),
+            BotCommand("permissions", "View and remove allowed tools and commands"),
         ]
     )
     logger.info(f"✅ Bot is fully online and ready! Logged in as @{app.bot.username}")
@@ -221,6 +239,7 @@ def build_application() -> Application:
     app.add_handler(CommandHandler(["new", "start"], cmd_new))
     app.add_handler(CommandHandler("model", cmd_model))
     app.add_handler(CommandHandler("credit", cmd_credit))
+    app.add_handler(CommandHandler("permissions", cmd_permissions))
     app.add_handler(CallbackQueryHandler(adapter.handle_callback_query))
     app.add_handler(MessageHandler(filters.ALL & ~filters.COMMAND, on_message))
     app.add_error_handler(on_error)

package/src/messengers/base.py

@@ -54,6 +54,18 @@ class ToolApprovalOutcome:
     scope: ScopeOption | None = None
 
 
+@dataclass
+class PermissionEntry:
+    kind: str
+    scope: str
+
+
+class PermissionListHandle(ABC):
+    @abstractmethod
+    async def send(self, conversation_ref: Any) -> Any:
+        raise NotImplementedError
+
+
 class PromptHandle(ABC):
     outcome: ToolApprovalOutcome | None = None
 
@@ -96,9 +108,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
@@ -119,6 +129,10 @@ class MessengerAdapter(ABC):
     ) -> PromptHandle:
         raise NotImplementedError
 
+    @abstractmethod
+    def create_permission_list(self, on_revoke: Callable[[PermissionEntry], Awaitable[None]]) -> PermissionListHandle:
+        raise NotImplementedError
+
     @abstractmethod
     def create_question_prompt(
         self,

package/src/messengers/discord_adapter.py

@@ -12,6 +12,7 @@ from messengers.base import (
     IncomingAttachment,
     IncomingMessage,
     MessengerAdapter,
+    PermissionListHandle,
     PromptHandle,
     ScopeOption,
     ToolApprovalOutcome,
@@ -32,6 +33,58 @@ class _ErrorLoggingView(discord.ui.View):
             pass
 
 
+class _DiscordPermissionList(PermissionListHandle):
+    def __init__(self, on_revoke):
+        self.on_revoke = on_revoke
+        self.page = 0
+        self.message: discord.Message | None = None
+
+    def _build(self):
+        from services import permissions
+
+        entries = permissions.list_entries()
+        page_entries, self.page, total_pages = permissions.page_of(entries, self.page)
+        embed = discord.Embed(
+            title="🔐 Allowed Permissions",
+            description=permissions.render_body(page_entries, self.page, total_pages),
+            color=discord.Color.blurple(),
+        )
+        view = _ErrorLoggingView(timeout=None)
+
+        for entry in page_entries:
+            label = f"🗑️ {permissions.entry_label(entry)}"
+            button = discord.ui.Button(label=label[:80], style=discord.ButtonStyle.gray)
+
+            async def revoke_callback(interaction: discord.Interaction, entry=entry):
+                await self.on_revoke(entry)
+                await self._refresh(interaction)
+
+            button.callback = revoke_callback
+            view.add_item(button)
+
+        if total_pages > 1:
+            for label, delta in (("◀ Prev", -1), ("Next ▶", 1)):
+                nav = discord.ui.Button(label=label, style=discord.ButtonStyle.blurple)
+
+                async def nav_callback(interaction: discord.Interaction, delta=delta):
+                    self.page += delta
+                    await self._refresh(interaction)
+
+                nav.callback = nav_callback
+                view.add_item(nav)
+
+        return embed, view
+
+    async def _refresh(self, interaction: discord.Interaction) -> None:
+        embed, view = self._build()
+        await interaction.response.edit_message(embed=embed, view=view)
+
+    async def send(self, conversation_ref: discord.abc.Messageable) -> discord.Message:
+        embed, view = self._build()
+        self.message = await conversation_ref.send(embed=embed, view=view)
+        return self.message
+
+
 class _DiscordPromptHandle(PromptHandle):
     def __init__(self, embed: discord.Embed, view: discord.ui.View):
         self.embed = embed
@@ -149,8 +202,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):
@@ -215,6 +268,9 @@ class DiscordAdapter(MessengerAdapter):
 
         return handle
 
+    def create_permission_list(self, on_revoke) -> PermissionListHandle:
+        return _DiscordPermissionList(on_revoke)
+
     def create_question_prompt(
         self,
         answer_future: asyncio.Future,

package/src/messengers/slack_adapter.py

@@ -17,6 +17,7 @@ from messengers.base import (
     IncomingAttachment,
     IncomingMessage,
     MessengerAdapter,
+    PermissionListHandle,
     PromptHandle,
     ScopeOption,
     ToolApprovalOutcome,
@@ -85,6 +86,77 @@ class SlackMessageRef:
         self.ts = ts
 
 
+class _SlackPermissionList(PermissionListHandle):
+    def __init__(self, client: AsyncWebClient, callbacks: dict, on_revoke):
+        self.client = client
+        self._callbacks = callbacks
+        self.on_revoke = on_revoke
+        self.page = 0
+        self.list_id = uuid.uuid4().hex[:12]
+        self._keys: list[str] = []
+        self.channel: str | None = None
+        self.ts: str | None = None
+
+    def _build(self):
+        from services import permissions
+
+        for key in self._keys:
+            self._callbacks.pop(key, None)
+        self._keys = []
+
+        entries = permissions.list_entries()
+        page_entries, self.page, total_pages = permissions.page_of(entries, self.page)
+        body = permissions.render_body(page_entries, self.page, total_pages)
+        text = f"*🔐 Allowed Permissions*\n\n{body}"
+        blocks = [{"type": "section", "text": {"type": "mrkdwn", "text": text[:2990]}}]
+        elements = []
+
+        for i, entry in enumerate(page_entries):
+            key = f"{self.list_id}:revoke:{i}"
+            self._callbacks[key] = lambda b, c, entry=entry: self._revoke(entry)
+            self._keys.append(key)
+            label = f"🗑️ {permissions.entry_label(entry)}"
+            elements.append({"type": "button", "text": {"type": "plain_text", "text": label[:75]}, "action_id": key})
+
+        if total_pages > 1:
+            for label, delta in (("◀ Prev", -1), ("Next ▶", 1)):
+                key = f"{self.list_id}:page:{delta}"
+                self._callbacks[key] = lambda b, c, delta=delta: self._turn(delta)
+                self._keys.append(key)
+                elements.append({"type": "button", "text": {"type": "plain_text", "text": label}, "action_id": key})
+
+        # 25 is Slack's hard per-block limit on action elements.
+        for chunk_start in range(0, len(elements), 25):
+            blocks.append({"type": "actions", "elements": elements[chunk_start : chunk_start + 25]})
+
+        return text, blocks
+
+    async def _redraw(self) -> None:
+        text, blocks = self._build()
+        if self.channel and self.ts:
+            await self.client.chat_update(channel=self.channel, ts=self.ts, text=text, blocks=blocks)
+
+    async def _revoke(self, entry) -> None:
+        await self.on_revoke(entry)
+        await self._redraw()
+
+    async def _turn(self, delta: int) -> None:
+        self.page += delta
+        await self._redraw()
+
+    async def send(self, conversation_ref: SlackConversationRef) -> dict:
+        text, blocks = self._build()
+        resp = await self.client.chat_postMessage(
+            channel=conversation_ref.channel,
+            thread_ts=conversation_ref.api_thread_ts,
+            text=text,
+            blocks=blocks,
+        )
+        self.channel = resp["channel"]
+        self.ts = resp["ts"]
+        return resp
+
+
 class _SlackPromptHandle(PromptHandle):
     def __init__(
         self, client: AsyncWebClient, text: str, blocks: list[dict], cleanup: Callable[[], None] | None = None
@@ -358,6 +430,9 @@ class SlackAdapter(MessengerAdapter):
         )
         return handle
 
+    def create_permission_list(self, on_revoke) -> PermissionListHandle:
+        return _SlackPermissionList(self.client, self._callbacks, on_revoke)
+
     def create_question_prompt(
         self,
         answer_future: asyncio.Future,

package/src/messengers/telegram_adapter.py

@@ -19,6 +19,7 @@ from messengers.base import (
     IncomingAttachment,
     IncomingMessage,
     MessengerAdapter,
+    PermissionListHandle,
     PromptHandle,
     ScopeOption,
     ToolApprovalOutcome,
@@ -52,6 +53,63 @@ async def safe_query_edit(query, **kwargs) -> None:
         raise
 
 
+class _TelegramPermissionList(PermissionListHandle):
+    def __init__(self, bot, callbacks: dict, on_revoke):
+        self.bot = bot
+        self._callbacks = callbacks
+        self.on_revoke = on_revoke
+        self.page = 0
+        self.list_id = uuid.uuid4().hex[:12]
+        self._keys: list[str] = []
+
+    def _build(self):
+        from services import permissions
+
+        for key in self._keys:
+            self._callbacks.pop(key, None)
+        self._keys = []
+
+        entries = permissions.list_entries()
+        page_entries, self.page, total_pages = permissions.page_of(entries, self.page)
+        body = permissions.render_body(page_entries, self.page, total_pages)
+        text = f"<b>🔐 Allowed Permissions</b>\n\n{html.escape(body)}"
+        keyboard: list[list[InlineKeyboardButton]] = []
+
+        for i, entry in enumerate(page_entries):
+            key = f"{self.list_id}:revoke:{i}"
+            self._callbacks[key] = lambda query, entry=entry: self._revoke(entry, query)
+            self._keys.append(key)
+            keyboard.append([InlineKeyboardButton(f"🗑️ {permissions.entry_label(entry)}"[:64], callback_data=key)])
+
+        if total_pages > 1:
+            row = []
+            for label, delta in (("◀ Prev", -1), ("Next ▶", 1)):
+                key = f"{self.list_id}:page:{delta}"
+                self._callbacks[key] = lambda query, delta=delta: self._turn(delta, query)
+                self._keys.append(key)
+                row.append(InlineKeyboardButton(label, callback_data=key))
+            keyboard.append(row)
+
+        return text, InlineKeyboardMarkup(keyboard)
+
+    async def _redraw(self, query) -> None:
+        text, markup = self._build()
+        await query.answer()
+        await safe_query_edit(query, text=text, parse_mode="HTML", reply_markup=markup)
+
+    async def _revoke(self, entry, query) -> None:
+        await self.on_revoke(entry)
+        await self._redraw(query)
+
+    async def _turn(self, delta: int, query) -> None:
+        self.page += delta
+        await self._redraw(query)
+
+    async def send(self, conversation_ref: int) -> Message:
+        text, markup = self._build()
+        return await self.bot.send_message(chat_id=conversation_ref, text=text, reply_markup=markup, parse_mode="HTML")
+
+
 class _TelegramPromptHandle(PromptHandle):
     def __init__(self, bot, text: str, reply_markup, cleanup: Callable[[], None] | None = None):
         self.bot = bot
@@ -285,6 +343,9 @@ class TelegramAdapter(MessengerAdapter):
         )
         return handle
 
+    def create_permission_list(self, on_revoke) -> PermissionListHandle:
+        return _TelegramPermissionList(self.bot, self._callbacks, on_revoke)
+
     def create_question_prompt(
         self,
         answer_future: asyncio.Future,

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

@@ -0,0 +1,42 @@
+from config import session_manager
+from messengers.base import PermissionEntry
+
+# Discord allows 25 components per message; the rest is headroom for paging buttons.
+PAGE_SIZE = 20
+
+
+def list_entries() -> list[PermissionEntry]:
+    allowed = session_manager.persistent_allowed
+    return [
+        PermissionEntry(kind=kind, scope=scope) for kind in ("tools", "commands") for scope in allowed.get(kind) or []
+    ]
+
+
+def revoke(entry: PermissionEntry) -> bool:
+    bucket = session_manager.persistent_allowed.get(entry.kind) or []
+    if entry.scope not in bucket:
+        return False
+    bucket.remove(entry.scope)
+    session_manager.save_persistent()
+    return True
+
+
+def page_of(entries: list[PermissionEntry], page: int) -> tuple[list[PermissionEntry], int, int]:
+    total_pages = max(1, -(-len(entries) // PAGE_SIZE))
+    page = max(0, min(page, total_pages - 1))
+    start = page * PAGE_SIZE
+    return entries[start : start + PAGE_SIZE], page, total_pages
+
+
+def entry_label(entry: PermissionEntry) -> str:
+    suffix = " (tool)" if entry.kind == "tools" else ""
+    return f"{entry.scope}{suffix}"
+
+
+def render_body(entries: list[PermissionEntry], page: int, total_pages: int) -> str:
+    if not entries:
+        return "No permissions have been allowed yet."
+    lines = [f"• {entry_label(e)}" for e in entries]
+    if total_pages > 1:
+        lines.append(f"\nPage {page + 1} of {total_pages}")
+    return "\n".join(lines)

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,