linkgravity 1.2.1 → 1.3.0

package/README.md

@@ -1,33 +1,32 @@
-# LinkGravity (lgy)
+# LinkGravity
 
-A Discord bot interface for the Antigravity (agy) agentic AI system. It translates Antigravity CLI prompts into Discord UI components and provides voice interaction capabilities.
+A Discord bot interface for the Antigravity agentic AI system. It translates Antigravity CLI prompts into Discord UI components and provides voice interaction capabilities.
 
 ## Features
 
 - **Environment Sync:** Automatically syncs with the host's `~/.gemini` configuration.
-- **Voice Interaction:** Supports voice channels with adaptive VAD (Voice Activity Detection) to segment speech and filter environmental noise, plus live "listening..." feedback while you're still talking.
+- **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.
-- **CLI Prompt Interception:** Converts CLI prompts (`ask_question`, `run_command` approvals) into interactive Discord buttons.
-- **Command Security:** Parses chained shell commands (`&&`, `||`, `;`) and requires individual approval for each command. Supports prefix-based scope whitelisting.
-- **Multi-Modal Input:** Attach any file (not just images) for the AI to read; audio attachments (`.ogg`/`.mp3`/`.m4a`/`.wav`) are transcribed to text automatically.
+- **Approval Flow:** Command and tool-call approvals become interactive Discord 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.
+- **Multi-Modal Input:** Attach files for the AI to read, including audio, which gets transcribed to text automatically.
 
-## Prerequisites
+## Requirements
 
 - Node.js >= 18
 - Python >= 3.10
-- `agy` (Antigravity CLI) installed on this machine
-- `ffmpeg` on your PATH (needed for TTS/voice playback)
-- A Discord bot token, and at least one server/channel to allow it in
+- Antigravity CLI installed on this machine
+- A messenger bot token, and at least one server/channel to allow it in
+  - **Discord** - currently the only one supported
 
 ### Creating the Discord bot
 
 In the [Discord Developer Portal](https://discord.com/developers/applications), create an application and bot, then:
 
-- Under **Bot**, enable the **Message Content** privileged intent (required - the bot reads message text/attachments).
+- Under **Bot**, enable the **Message Content** privileged intent - required, since the bot reads message text/attachments.
 - Under **OAuth2 → URL Generator**, select the **bot** and **applications.commands** scopes, then these bot permissions:
   - Send Messages, Send Messages in Threads, Create Public Threads
   - Read Message History, Attach Files, Embed Links, Add Reactions
-  - Connect, Speak (for voice channel support)
+  - Connect, Speak - for voice channel support
 - Use the generated URL to invite the bot to your server.
 
 ## Installation
@@ -36,7 +35,7 @@ In the [Discord Developer Portal](https://discord.com/developers/applications),
 npm install -g linkgravity
 ```
 
-This runs a postinstall step that creates a Python virtual environment at `~/.gemini/linkgravity/venv/` (kept outside the package install location on purpose - see `npm-scripts/venv-paths.js`) and installs `requirements.txt` into it - no manual `pip install` needed.
+Sets up its own Python environment automatically - no manual `pip install` needed.
 
 ## Setup
 
@@ -46,11 +45,11 @@ Run the configuration wizard once to set your bot token, allowed servers/channel
 lgy setup
 ```
 
-This writes to `~/.gemini/linkgravity/lgy.json` (outside the package directory, so `npm update`/reinstall never touches it). You can re-run `lgy setup` any time to change settings later - each field keeps its current value if you leave it empty.
+This writes to `~/.gemini/linkgravity/lgy.json`, outside the package directory, so `npm update`/reinstall never touches it. You can re-run `lgy setup` any time to change settings later - each field keeps its current value if you leave it empty.
 
 During setup you'll be asked for one or more Discord servers to allow, and optionally specific channels within each:
 
-- Leave the channel list empty for a server → **the whole server** is allowed (any channel can start a session).
+- Leave the channel list empty for a server → **the whole server** is allowed - any channel can start a session.
 - List specific channel IDs for a server → **only those channels** in that server are allowed.
 
 A new session is only ever started with the **`/new`** slash command in Discord - never just by typing a message. `/new` works both in a regular channel and from inside an existing thread.
@@ -58,57 +57,35 @@ A new session is only ever started with the **`/new`** slash command in Discord
 ## Usage
 
 ```bash
-lgy start      # Start the bot as a background daemon (via PM2)
+lgy start      # Start the bot as a background daemon via PM2
 lgy stop       # Stop it
 lgy restart    # Restart it
-lgy logs       # View live logs (add -f to follow, --tail N for more lines)
+lgy logs       # View live logs - add -f to follow, --tail N for more lines
 lgy enable     # Register the bot to auto-start on system boot
 lgy disable    # Remove it from system boot
-lgy            # Interactive menu (same commands, picked from a list)
+lgy            # Interactive menu - same commands, picked from a list
 ```
 
 ## Development
 
-This project uses [Ruff](https://docs.astral.sh/ruff/) for Python linting/formatting and [Prettier](https://prettier.io/) for the Node.js side. `npm install` sets both up automatically (installs `requirements-dev.txt` into the venv at `~/.gemini/linkgravity/venv/`, registers git hooks) - manual install is only needed if you want to run them yourself outside of a commit. The venv lives outside this checkout (see `npm-scripts/venv-paths.js` for why), so on macOS/Linux:
-
 ```bash
-~/.gemini/linkgravity/venv/bin/ruff check src/    # lint
-~/.gemini/linkgravity/venv/bin/ruff format src/   # format
-
-npm run format:check        # check JS formatting
-npm run format              # format JS
+npm i
 ```
 
-(On Windows, replace `venv/bin/ruff` with `venv\Scripts\ruff.exe` under the same `~/.gemini/linkgravity/` directory.)
-
-Git hooks (via [pre-commit](https://pre-commit.com/), config in `.pre-commit-config.yaml`) run automatically once you `npm install`:
-
-- **pre-commit**: runs `ruff` (lint + format) and `prettier` on staged files, auto-fixing what it can.
-- **commit-msg**: enforces [Conventional Commits](https://www.conventionalcommits.org/) (e.g. `fix: ...`, `feat: ...`, `docs: ...`) via [conventional-pre-commit](https://github.com/compilerla/conventional-pre-commit).
-
-If a hook doesn't seem to be running, check `git config --get core.hooksPath` - it should be unset (or point at `.git/hooks`, pre-commit's default). A leftover `.husky` value from an older checkout will silently make git skip pre-commit's hooks entirely; `git config --unset core.hooksPath` fixes it.
+That's it - it wires up [Ruff](https://docs.astral.sh/ruff/) for Python and [Prettier](https://prettier.io/) for Node, plus git hooks that lint/format on commit and enforce [Conventional Commits](https://www.conventionalcommits.org/) commit messages.
 
 ## Debugging
 
-Set `LOG_LEVEL=DEBUG` in your shell before `lgy restart` for verbose logs, including agy's raw stdout for each turn (`lgy` passes your shell's environment through to the daemon on restart). Defaults to `INFO`. Use `lgy logs -t` (or `--timestamp`) to include timestamps - they're stripped by default.
-
-## Known Issues
-
-**Wake word false positives on short words** (e.g. "시리", "잼민이"): Rustpotter's phoneme matching carries less signal for 1-2 syllable words, so genuine-match and unrelated-speech score distributions overlap - no single threshold cleanly separates them. Current mitigations in `voice-service/index.js`'s `getDetectorForUser` and `cogs/voice_cog.py`'s `handle_stt_input`:
-
-- `score_mode: Max` (each of the 5 enrollment samples can cover a different natural tone/pace, instead of requiring all 5 to be delivered consistently like `Median` did)
-- `min_scores: 4` (requires a candidate to keep winning across several frames, compensating for `Max` being more permissive per-frame)
-- The STT-based text cross-check is tightened specifically for short wake words (similarity floor 0.55, vs. 0.35 for longer ones) - this is currently doing most of the real work of rejecting false positives
-
-This isn't fully solved. If issues persist after real-world use, prefer these over further threshold guessing:
+```bash
+LOG_LEVEL=DEBUG lgy start
+```
 
-1. Encourage re-enrolling with a longer/more distinctive wake word (a 1-2 syllable word is close to a hard ceiling for this approach, regardless of tuning)
-2. Log `bestWakeScore` + outcome (no raw audio) during a trial period and re-tune the constants above against that data instead of guessing
+Use `lgy logs -t` to include timestamps.
 
 ## Security Warning
 
 This bot gives an AI agent broad access to the machine it runs on - **that's inherent to what it does, so don't expose it publicly or run it somewhere you don't fully trust its users.**
 
-- `allowed_user_ids` (set via `lgy setup`) is your primary access control - always set it.
-- Tool calls (including shell commands) go through an approval flow in Discord by default; treat anyone in `allowed_user_ids` as having effectively full control of this machine.
+- `allowed_user_ids`, set via `lgy setup`, is your primary access control - always set it.
+- Tool calls, including shell commands, go through an approval flow in Discord by default; treat anyone in `allowed_user_ids` as having effectively full control of this machine.
 - Your Discord token and other settings live in `~/.gemini/linkgravity/lgy.json`, outside this repo/package directory - never commit or share that file.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkgravity",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Discord bot bridge for the Antigravity (agy) CLI, with voice interaction support",
   "scripts": {
     "postinstall": "node npm-scripts/postinstall.js",

package/src/api/ui_routes.py

@@ -112,10 +112,12 @@ async def handle_approve_request(request):
                     target_thread_id = thread_id_str
                     break
 
-        if target_thread_id and session_manager.get_session(target_thread_id):
-            session_manager.update_session(target_thread_id, "current_tool", tool_name)
+        def _set_tool_status(key: str):
+            if target_thread_id and session_manager.get_session(target_thread_id):
+                session_manager.update_session(target_thread_id, key, tool_name)
 
         if "ask_question" in tool_name:
+            _set_tool_status("current_tool")  # no separate approval phase here - it's waiting on the user either way
             if not target_thread:
                 return web.json_response({"decision": "deny", "reason": "No target thread found."})
 
@@ -223,6 +225,7 @@ async def handle_approve_request(request):
                     return await prompt.send(target_thread)
 
                 await send_ordered(target_thread_id, _send_bash_prompt)
+                _set_tool_status("pending_approval_tool")
 
                 decision = await future
                 session_manager.clear_pending_approval(approval_key)
@@ -232,9 +235,14 @@ async def handle_approve_request(request):
                 if decision == "reject":
                     return web.json_response({"decision": "reject"})
 
+                _set_tool_status("current_tool")
+
             if target_thread and tool_msg_text and not prompted:
                 await send_ordered(target_thread_id, lambda: adapter.send_message(target_thread, tool_msg_formatted))
 
+            if not prompted:
+                _set_tool_status("current_tool")  # auto-allowed - runs immediately, no approval wait
+
             return allow_response(tool_name, tool_input)
 
         else:
@@ -250,6 +258,7 @@ async def handle_approve_request(request):
                     await send_ordered(
                         target_thread_id, lambda: adapter.send_message(target_thread, tool_msg_formatted)
                     )
+                _set_tool_status("current_tool")  # auto-allowed - runs immediately, no approval wait
                 return allow_response(tool_name, tool_input)
 
             approval_key = f"{conv_id}:{uuid.uuid4().hex}"
@@ -267,6 +276,7 @@ async def handle_approve_request(request):
                 return await prompt.send(target_thread)
 
             await send_ordered(target_thread_id, _send_prompt)
+            _set_tool_status("pending_approval_tool")
 
             decision = await future
             session_manager.clear_pending_approval(approval_key)
@@ -276,6 +286,7 @@ async def handle_approve_request(request):
             if decision == "reject":
                 return web.json_response({"decision": "reject"})
 
+            _set_tool_status("current_tool")
             return allow_response(tool_name, tool_input)
 
     except Exception as e:

package/src/cogs/voice/enrollment.py

@@ -263,7 +263,7 @@ class EnrollmentManager:
         session["pending_sample"] = audio_bytes
         session["awaiting_confirmation"] = True
 
-        await self._play_audio(session["guild_id"], audio_bytes, suppress_active_window=True)
+        await self._play_audio(session["guild_id"], self._trim_silence_wav(audio_bytes), suppress_active_window=True)
         await self._update_status(
             session,
             f"🔊 **{step}/{session['needed']}** captured - keep it, or re-record if it's noisy?",
@@ -337,7 +337,7 @@ class EnrollmentManager:
             except aiohttp.ClientError as e:
                 self.logger.warning(f"Failed to invalidate cached detector for {user_id}: {e}")
 
-        self.bot_settings["wake_words"] = session["word"]
+        self.bot_settings.setdefault("wake_words", {})[user_id] = session["word"]
         self.save_bot_settings(self.bot_settings)
 
         del self._enrollment[user_id]

package/src/cogs/voice_cog.py

@@ -7,6 +7,7 @@ from discord import app_commands
 from discord.ext import commands, tasks
 
 from config import allowed, logger
+from messengers.registry import get_adapter
 
 from .voice.enrollment import EnrollmentManager
 from .voice.stt_session import SttSessionTracker
@@ -174,22 +175,20 @@ class VoiceCog(commands.Cog):
         vc_chan = interaction.user.voice.channel
         guild_id = interaction.guild_id
 
-        has_wake_word = bool(self.bot_settings.get("wake_words"))
+        wake_word_map = self.bot_settings.get("wake_words") or {}
+        own_word = wake_word_map.get(str(interaction.user.id))
         active_timer = self.bot_settings.get("active_timer", 60)
 
-        if has_wake_word:
-            wake_words_raw = self.bot_settings["wake_words"]
-            ww_list = [f"`{w.strip()}`" for w in wake_words_raw.split(",") if w.strip()]
-            ww_str = ", ".join(ww_list[:-1]) + f", or {ww_list[-1]}" if len(ww_list) > 1 else ww_list[0]
+        if own_word:
             msg = (
                 f"🎤 Connected to `{vc_chan.name}`.\n"
-                f"💡 Say {ww_str} to activate me. Once awake, I'll keep listening for {active_timer} seconds after each interaction.\n"
+                f"💡 Say `{own_word}` to activate me. Once awake, I'll keep listening for {active_timer} seconds after each interaction.\n"
                 f"⚙️ You can customize settings using `/sound`."
             )
         else:
             msg = (
                 f"🎤 Connected to `{vc_chan.name}`.\n"
-                f"🎙️ No wake word is set up yet, so I can't hear you yet - run `/sound wake_word:<word>` "
+                f"🎙️ You haven't set up a wake word yet, so I can't hear you - run `/sound wake_word:<word>` "
                 f"and say your chosen word a few times to register it in your voice."
             )
         await interaction.response.send_message(msg)
@@ -210,17 +209,17 @@ class VoiceCog(commands.Cog):
                 if data.get("success"):
                     self._voice_state[str(guild_id)] = interaction.channel_id
 
-                    if has_wake_word:
+                    if own_word:
                         if self.bot_settings.get("tts_enabled", True):
-                            welcome_audio = await self.tts("Yes, I am listening.")
+                            welcome_audio = await self.tts("Voice connected.")
                             if welcome_audio:
-                                await self._play_audio(str(guild_id), 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."
                         )
                         if prompt_audio:
-                            await self._play_audio(str(guild_id), prompt_audio)
+                            await self._play_audio(str(guild_id), prompt_audio, suppress_active_window=True)
                 else:
                     await interaction.channel.send(f"⚠️ Node.js integration failed: {data.get('error')}")
         except aiohttp.ClientConnectorError:
@@ -274,7 +273,7 @@ class VoiceCog(commands.Cog):
             and tts_voice is None
             and tts_enabled is None
         ):
-            curr_wake = self.bot_settings.get("wake_words", "None")
+            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_thresh = self.bot_settings.get("voice_threshold", 3000)
             curr_tts = self.bot_settings.get("tts_voice", "en-US-AriaNeural")
@@ -451,9 +450,21 @@ class VoiceCog(commands.Cog):
 
             self.logger.debug(f"STT recognized: {text} -> AI: {text_to_ai}")
 
-            # A stale in-flight turn for this guild - cancel it, kill its agy process, stop playback.
+            sess = self.session_manager.get_session(str(thread_id))
+            if not sess:
+                sess = {"status": "pending", "user_id": str(user_id)}
+                self.session_manager.set_session(str(thread_id), sess)
+
+            conv_id = sess.get("conversation_id")
+            pa = self.session_manager.get_pending_approval_by_conv(conv_id) if conv_id else None
+            has_pending_approval = bool(conv_id and pa and not pa.done())
+
+            # A stale in-flight turn for this guild - cancel it, kill its agy process, stop
+            # playback. Skipped when a tool/question approval is pending: that turn is the one
+            # waiting on this very utterance as its answer, so cancelling here would kill the
+            # agy process before the "yes"/"no" below ever reaches it.
             prev_task = self._active_turns.get(str(guild_id))
-            if prev_task and not prev_task.done():
+            if prev_task and not prev_task.done() and not has_pending_approval:
                 prev_task.cancel()
 
                 from core.agy_runner import stop_active_process
@@ -492,15 +503,7 @@ class VoiceCog(commands.Cog):
                         await self._play_audio(str(guild_id), audio_reply)
                 return
 
-            sess = self.session_manager.get_session(str(thread_id))
-            if not sess:
-                sess = {"status": "pending", "user_id": str(user_id)}
-                self.session_manager.set_session(str(thread_id), sess)
-
-            conv_id = sess.get("conversation_id")
-            pa = self.session_manager.get_pending_approval_by_conv(conv_id) if conv_id else None
-
-            if conv_id and pa and not pa.done():
+            if has_pending_approval:
                 app_type = self.session_manager.get_pending_approval_type_by_conv(conv_id)
                 if app_type == "ask_question":
                     pa.set_result(text)
@@ -544,6 +547,12 @@ class VoiceCog(commands.Cog):
                         sess["status"] = "active"
                         self.session_manager.set_session(str(thread_id), sess)
                         conv_id = new_conv_id
+
+                        from utils.utils import generate_thread_title, update_agy_conversation_title
+
+                        new_title = await generate_thread_title(text_to_ai, raw_ans)
+                        await get_adapter().rename_conversation(thread, new_title)
+                        await update_agy_conversation_title(new_conv_id, new_title)
                     else:
                         logger.debug("Voice: calling agy_send...")
                         raw_ans = await self.agy_send(

package/src/config.py

@@ -7,6 +7,10 @@ WORKSPACE_DIR = Path.home() / ".gemini" / "linkgravity"
 WORKSPACE_DIR.mkdir(parents=True, exist_ok=True)
 DATA_DIR = WORKSPACE_DIR / "data"
 DATA_DIR.mkdir(parents=True, exist_ok=True)
+# Per-user wake-word recordings + built .rpw reference (see EnrollmentManager).
+# Defined early so load_bot_settings' migration below can read it.
+WAKE_REF_DIR = WORKSPACE_DIR / "wake_refs"
+WAKE_REF_DIR.mkdir(parents=True, exist_ok=True)
 
 LGY_CONFIG_FILE = WORKSPACE_DIR / "lgy.json"
 
@@ -14,7 +18,8 @@ DEFAULT_LGY_CONFIG = {
     "discord_token": "",
     "session_scopes": [],
     "allowed_user_ids": "",
-    "wake_words": "Jarvis",
+    # user_id (str) -> registered word, one per person (see EnrollmentManager._commit_enrollment).
+    "wake_words": {},
     "active_timer": 60,
     "voice_threshold": 3000,
     "tts_voice": "ko-KR-SunHiNeural",
@@ -33,10 +38,26 @@ class _PrintLogger:
         print(f"[config] {msg}")
 
 
+def _migrate_legacy_wake_words():
+    """Pre-1.3, wake_words was one global string shared by everyone and
+    overwritten by each /sound call. The .rpw files were always saved per
+    user_id though, so rebuild the real per-user mapping from those."""
+    migrated = {}
+    for user_dir in WAKE_REF_DIR.iterdir():
+        if not user_dir.is_dir():
+            continue
+        rpw = next(user_dir.glob("*.rpw"), None)
+        if rpw:
+            migrated[user_dir.name] = rpw.stem.replace("_", " ")
+    return migrated
+
+
 def load_bot_settings():
     data = safe_load_json(LGY_CONFIG_FILE, DEFAULT_LGY_CONFIG.copy(), logger=_PrintLogger())
     for k, v in DEFAULT_LGY_CONFIG.items():
         data.setdefault(k, v)
+    if isinstance(data.get("wake_words"), str):
+        data["wake_words"] = _migrate_legacy_wake_words()
     return data
 
 
@@ -93,12 +114,9 @@ def is_allowed_session_channel(channel) -> bool:
 
 TMP_FILE_DIR = WORKSPACE_DIR / "tmp-files"
 TMP_VOICE_DIR = WORKSPACE_DIR / "tmp-voice"
-# Per-user wake-word recordings + built .rpw reference (see EnrollmentManager).
-WAKE_REF_DIR = WORKSPACE_DIR / "wake_refs"
 
 TMP_FILE_DIR.mkdir(parents=True, exist_ok=True)
 TMP_VOICE_DIR.mkdir(parents=True, exist_ok=True)
-WAKE_REF_DIR.mkdir(parents=True, exist_ok=True)
 
 MAX_EMBED_LEN = 1900
 STREAM_RATE_LIMIT_SEC = 0.5

package/src/core/agy_runner.py

@@ -376,3 +376,36 @@ async def generate_thread_title(user_input: str, response: str) -> str:
     except Exception as e:
         logger.warning(f"AI thread-title generation failed, falling back to raw input: {e}")
         return fallback
+
+
+async def update_agy_conversation_title(conv_id: str, title: str) -> None:
+    """Antigravity CLI's own conversation list reads its display name from
+    conversation_summaries.db's `preview` column (the `title` column exists
+    but is unused/always empty - confirmed by inspecting the db directly).
+    Without this, agy shows its own auto-generated name while the Discord
+    thread shows ours, and the two drift apart for the same conversation."""
+    if not conv_id:
+        return
+
+    import sqlite3
+    from pathlib import Path
+
+    db_path = Path.home() / ".gemini/antigravity-cli/conversation_summaries.db"
+    if not db_path.exists():
+        return
+
+    def _update():
+        conn = sqlite3.connect(str(db_path), timeout=5)
+        try:
+            conn.execute(
+                "UPDATE conversation_summaries SET preview = ? WHERE conversation_id = ?",
+                (title, conv_id),
+            )
+            conn.commit()
+        finally:
+            conn.close()
+
+    try:
+        await asyncio.get_running_loop().run_in_executor(None, _update)
+    except Exception as e:
+        logger.warning(f"Failed to sync title into agy's conversation_summaries.db for {conv_id}: {e}")

package/src/handlers/thread_reply.py

@@ -16,6 +16,7 @@ from utils.utils import (
     generate_thread_title,
     handle_image_attachments,
     stt,
+    update_agy_conversation_title,
 )
 
 
@@ -68,6 +69,7 @@ async def handle_pending_session(
             response_text = result_text
             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)
 
             response_text = await render_thought_process(new_conv_id, ctx, response_text, thread)
 

package/src/main.py

@@ -71,6 +71,19 @@ def _status_text_for_tool(tool_name: str) -> str:
     return f"⚙️ Running {tool_name}..."
 
 
+def _voice_status_text() -> str | None:
+    """None if no guild is connected to voice right now. Otherwise reflects
+    whether any connected guild is in its post-wake-word "awake" window -
+    filling the gap between Idle and an active text session, since being
+    connected to voice and waiting for a wake word isn't really "Idle"."""
+    voice_cog = bot.get_cog("VoiceCog")
+    if not voice_cog or not voice_cog._voice_state:
+        return None
+    if any(voice_cog.stt_session.is_active(guild_id) for guild_id in voice_cog._voice_state):
+        return "👂 Awake"
+    return "💤 Asleep"
+
+
 intents = discord.Intents.default()
 intents.message_content = True
 intents.voice_states = True
@@ -87,12 +100,18 @@ async def status_updater_task():
 
             full_status = ""
             if not session_manager.has_active_queues():
-                full_status = "🟢 Idle"
+                full_status = _voice_status_text() or "🟢 Idle"
             else:
                 first_t_id = session_manager.get_active_queue_keys()[0]
                 sess = session_manager.get_session(first_t_id) or {}
+                pending_tool = sess.get("pending_approval_tool")
                 tool_name = sess.get("current_tool")
-                full_status = _status_text_for_tool(tool_name) if tool_name else "🧠 Thinking..."
+                if pending_tool:
+                    full_status = "⏳ Waiting for approval..."
+                elif tool_name:
+                    full_status = _status_text_for_tool(tool_name)
+                else:
+                    full_status = "🧠 Thinking..."
 
             if full_status != last_status:
                 logger.debug(f"Status updating to: {full_status}")
@@ -177,6 +196,18 @@ async def on_ready():
     logger.info(f"✅ Bot is fully online and ready! Logged in as {bot.user}")
 
 
+def _terminate_voice_process():
+    global _voice_shutting_down
+    _voice_shutting_down = True
+    if voice_process and voice_process.poll() is None:
+        logger.debug("Terminating child Node.js voice process...")
+        voice_process.terminate()  # Node now catches this and disconnects any active voice channel cleanly
+        try:
+            voice_process.wait(timeout=3)
+        except subprocess.TimeoutExpired:
+            voice_process.kill()
+
+
 @bot.event
 async def setup_hook():
     await bot.tree.sync()
@@ -201,18 +232,7 @@ async def setup_hook():
             asyncio.create_task(_wait_for_voice_service_ready())
             asyncio.create_task(_supervise_voice_process(voice_dir))
 
-            def cleanup_voice():
-                global _voice_shutting_down
-                _voice_shutting_down = True
-                if voice_process and voice_process.poll() is None:
-                    logger.debug("Zombie prevention: Terminating child Node.js process as Python exits...")
-                    voice_process.terminate()
-                    try:
-                        voice_process.wait(timeout=3)
-                    except subprocess.TimeoutExpired:
-                        voice_process.kill()
-
-            atexit.register(cleanup_voice)
+            atexit.register(_terminate_voice_process)
         else:
             logger.warning("Voice service (index.js) not found. Skipping auto-start.")
     except Exception as e:
@@ -275,6 +295,18 @@ async def main():
 
     discord.utils.setup_logging()
 
+    def _handle_sigterm():
+        logger.info("Received SIGTERM (lgy stop/restart) - disconnecting voice before exit...")
+        _terminate_voice_process()
+        asyncio.create_task(bot.close())
+
+    try:
+        import signal
+
+        asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, _handle_sigterm)
+    except NotImplementedError:
+        pass  # add_signal_handler isn't supported on this platform (e.g. Windows)
+
     from messengers.discord_adapter import DiscordAdapter
     from messengers.registry import set_adapter
 

package/src/services/streaming.py

@@ -11,12 +11,19 @@ from utils.utils import clean_ansi
 
 
 def _clear_current_tool(thread_id: str):
-    """Removes the "current_tool" marker set by api/ui_routes.py while a
-    tool call is being approved - without this, the bot's presence status
-    stays stuck on the last tool after the turn finishes."""
+    """Removes the "current_tool"/"pending_approval_tool" markers set by
+    api/ui_routes.py while a tool call is being approved/run - without
+    this, the bot's presence status stays stuck on the last tool after
+    the turn finishes."""
     session = session_manager.get_session(thread_id)
-    if session and "current_tool" in session:
-        del session["current_tool"]
+    if not session:
+        return
+    changed = False
+    for key in ("current_tool", "pending_approval_tool"):
+        if key in session:
+            del session[key]
+            changed = True
+    if changed:
         session_manager.set_session(thread_id, session)
 
 

package/src/utils/utils.py

@@ -7,6 +7,7 @@ from core.agy_runner import (
     generate_thread_title,
     get_current_model,
     run_agy,
+    update_agy_conversation_title,
 )
 from services.audio_service import stt, tts
 from services.discord_helpers import (
@@ -23,6 +24,7 @@ __all__ = [
     "agy_send_message",
     "get_current_model",
     "generate_thread_title",
+    "update_agy_conversation_title",
     "active_processes",
     "agy_start_lock",
     "tts",

package/voice-service/index.js

@@ -271,19 +271,8 @@ function loadRustpotterModule() {
 // userId -> { rustpotter, samplesPerFrame, residual: Int16Array }
 const detectorCache = new Map();
 
-// The real pass/fail cutoff for a wake-word match. This has to be a
-// genuine, meaningful threshold, not a tuning knob to set near-zero:
-// rustpotter's confirmation logic re-arms its countdown EVERY time a
-// new "candidate" clears the threshold (detector.rs's run_detection:
-// `self.detection_countdown = self.max_mfcc_frames / 2` runs again on
-// every qualifying frame). With this set to 0.05 during earlier
-// debugging, silence and noise cleared it just as easily as real
-// speech, so the countdown never ran out and nothing was ever
-// confirmed no matter how much silence padding was fed afterward.
-// Verified against a native Rust reproduction of this exact detector
-// before settling on 0.5 (matches rustpotter's own default, and what
-// rustpotter-cli scored real captured audio at: 0.55-0.73).
-const WAKE_MATCH_THRESHOLD = 0.5;
+// 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;
 
 async function getDetectorForUser(userId) {
     if (detectorCache.has(userId)) return detectorCache.get(userId);
@@ -661,20 +650,17 @@ function setupReceiver(connection, guildId) {
                     bestDiagScoreName = diagPaddingDetection.getName();
                 }
 
-                // The real pass/fail decision - see WAKE_MATCH_THRESHOLD's
-                // comment for why this has to be a meaningful cutoff.
-                // bestDiagScore comes from the separate diagnostic
-                // instance above (see its comment in getDetectorForUser)
-                // so a "no match" line still shows the real closest
-                // score instead of a meaningless flat 0.000.
+                // 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;
                 matchedWakeWord = wakeConfirmed ? bestWakeScoreName : null;
                 console.log(
                     wakeConfirmed
                         ? `[Wake] ${userId}: CONFIRMED (score ${bestWakeScore.toFixed(3)} for ` +
                               `"${bestWakeScoreName}", threshold ${WAKE_MATCH_THRESHOLD})`
-                        : `[Wake] ${userId}: no match (closest score ${bestDiagScore.toFixed(3)} for ` +
-                              `"${bestDiagScoreName ?? 'n/a'}", needed ${WAKE_MATCH_THRESHOLD})`,
+                        : `[Wake] ${userId}: no match (score ${bestWakeScore.toFixed(3)}, ` +
+                              `threshold ${WAKE_MATCH_THRESHOLD}; diagnostic-only closeness ` +
+                              `${bestDiagScore.toFixed(3)} for "${bestDiagScoreName ?? 'n/a'}" - ` +
+                              `different scoring config, not directly comparable to the threshold)`,
                 );
             }
 
@@ -702,7 +688,8 @@ function setupReceiver(connection, guildId) {
                 return;
             }
 
-            if (pcmBuffer.length < 24000) {
+            // Was 24000 (250ms) - cut off short Korean replies ("네"/"어"/"응"); noise is filtered upstream by isSpeaking's RMS/sustain check, not by duration.
+            if (pcmBuffer.length < 9600) {
                 if (partialSent) {
                     fetch('http://127.0.0.1:18080/stt_partial_cancel', {
                         method: 'POST',
@@ -1036,6 +1023,22 @@ process.on('uncaughtException', (err) => {
     process.exit(1);
 });
 
+// Without this, SIGTERM (lgy stop/restart) kills the process mid-connection and Discord never gets a clean leave.
+function shutdownGracefully() {
+    console.log(`[Shutdown] Disconnecting from ${connections.size} active voice connection(s)...`);
+    for (const connection of connections.values()) {
+        try {
+            connection.destroy();
+        } catch (e) {
+            // already destroyed/disconnected - fine
+        }
+    }
+    process.exit(0);
+}
+
+process.on('SIGTERM', shutdownGracefully);
+process.on('SIGINT', shutdownGracefully);
+
 const PORT = 18081;
 app.listen(PORT, '0.0.0.0', () => {
     console.log(`Node.js Voice API listening on port ${PORT}`);