linkgravity 1.2.2 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkgravity",
-  "version": "1.2.2",
+  "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?",

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
@@ -175,22 +176,19 @@ class VoiceCog(commands.Cog):
         guild_id = interaction.guild_id
 
         wake_word_map = self.bot_settings.get("wake_words") or {}
-        has_wake_word = bool(wake_word_map)
+        own_word = wake_word_map.get(str(interaction.user.id))
         active_timer = self.bot_settings.get("active_timer", 60)
 
-        if has_wake_word:
-            # dict.fromkeys dedupes while keeping first-registered order (each user has their own word).
-            ww_list = [f"`{w.strip()}`" for w in dict.fromkeys(wake_word_map.values()) 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)
@@ -211,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:
@@ -452,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
@@ -493,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)
@@ -545,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/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}`);