linkgravity 1.5.1 → 1.5.3

package/bin/cli.js

@@ -3,6 +3,7 @@
 const { spawn, spawnSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
+const os = require('os');
 const {
     PLATFORMS,
     getSettings,
@@ -236,20 +237,79 @@ function renderTable(headers, rows) {
     return lines.join('\n');
 }
 
+// Mirrors src/config.py's AGY_BIN resolution (AGY_BIN_PATH env var, else ~/.local/bin/agy), plus a PATH fallback for installs that don't use the default location.
+function findAgyBin() {
+    const envPath = process.env.AGY_BIN_PATH;
+    if (envPath && fs.existsSync(envPath)) return envPath;
+
+    const defaultPath = path.join(os.homedir(), '.local', 'bin', 'agy');
+    if (fs.existsSync(defaultPath)) return defaultPath;
+
+    const which = spawnSync(isWin ? 'where' : 'which', ['agy'], { stdio: 'pipe' });
+    if (which.status === 0) {
+        const out = which.stdout.toString().trim().split('\n')[0].trim();
+        if (out) return out;
+    }
+    return null;
+}
+
+function getPm2Proc() {
+    const jlist = spawnSync('npx', ['-y', 'pm2', 'jlist'], { stdio: 'pipe' });
+    if (jlist.status !== 0) return null;
+    try {
+        const procs = JSON.parse(jlist.stdout.toString());
+        return procs.find((p) => p.name === LGY_PM2_NAME) || null;
+    } catch (e) {
+        return null;
+    }
+}
+
 if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     const pkg = require('../package.json');
     console.log(`linkgravity v${pkg.version}`);
 } else if (cmd === 'start') {
+    const existing = getPm2Proc();
+    if (existing && existing.pm2_env.status === 'online') {
+        console.log(
+            `\n${color.yellow}⚠${color.reset} LinkGravity is already running. ` +
+                `Use ${color.cyan}lgy restart${color.reset} to apply changes, or ${color.cyan}lgy stop${color.reset} first.\n`,
+        );
+        process.exit(1);
+    }
+
+    const settings = getSettings();
+    const anyConfigured = Object.keys(PLATFORMS).some(
+        (key) => platformState(key, settings).configured,
+    );
+    if (!anyConfigured) {
+        console.log(
+            `\n${color.yellow}⚠${color.reset} No messenger is configured yet - ` +
+                `set up at least one of Discord, Telegram, or Slack first: ${color.cyan}lgy setup${color.reset}\n`,
+        );
+        process.exit(1);
+    }
+
+    if (!findAgyBin()) {
+        console.log(
+            `\n${color.yellow}⚠${color.reset} Couldn't find the agy CLI ` +
+                `(checked $AGY_BIN_PATH, ~/.local/bin/agy, and PATH). Install/configure agy first, ` +
+                `or set the AGY_BIN_PATH environment variable to its location.\n`,
+        );
+        process.exit(1);
+    }
+
     info('Starting LinkGravity daemon...');
     runPm2(['start', LGY_SCRIPT_PATH, '--interpreter', pythonExe, '--name', LGY_PM2_NAME]);
     verifyStartup().then((ok) => process.exit(ok ? 0 : 1));
 } else if (cmd === 'stop') {
     info('Stopping LinkGravity daemon...');
     runPm2(['stop', LGY_PM2_NAME]);
+    runPm2(['reset', LGY_PM2_NAME]);
     success('Daemon stopped successfully.\n');
 } else if (cmd === 'restart') {
     info('Restarting LinkGravity daemon...');
     runPm2(['restart', LGY_PM2_NAME, '--update-env']);
+    runPm2(['reset', LGY_PM2_NAME]);
     verifyStartup().then((ok) => process.exit(ok ? 0 : 1));
 } else if (cmd === 'logs') {
     const SHORT_FLAGS = ['-f', '-n', '-t'];
@@ -292,15 +352,7 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     const sessions = getSessions();
     const health = getPlatformHealth();
 
-    let pm2Procs = [];
-    const jlist = spawnSync('npx', ['-y', 'pm2', 'jlist'], { stdio: 'pipe' });
-    if (jlist.status === 0) {
-        try {
-            pm2Procs = JSON.parse(jlist.stdout.toString());
-        } catch (e) {}
-    }
-
-    const proc = pm2Procs.find((p) => p.name === LGY_PM2_NAME);
+    const proc = getPm2Proc();
     if (!proc) {
         console.log(`\n${color.cyan}▶${color.reset} daemon: not running\n`);
     } else {
@@ -310,9 +362,21 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
         const uptime =
             proc.pm2_env.status === 'online' ? formatUptime(proc.pm2_env.pm_uptime) : '-';
         const restarts = proc.pm2_env.restart_time;
+        const statusColor = proc.pm2_env.status === 'online' ? color.green : color.red;
+
         console.log(
-            `\n${color.cyan}▶${color.reset} daemon: ${proc.pm2_env.status} (uptime: ${uptime}, restarts: ${restarts}, cpu: ${cpu}, mem: ${mem})\n`,
+            `\n${color.cyan}▶${color.reset} daemon: ${statusColor}${proc.pm2_env.status}${color.reset}`,
         );
+        for (const [label, value] of [
+            ['uptime', uptime],
+            ['restarts', restarts],
+            ['cpu', cpu],
+            ['mem', mem],
+        ]) {
+            console.log(`    ${label.padEnd(9)} ${value}`);
+        }
+        console.log();
+
         // Flag "many restarts" only alongside a short current uptime - restart_time alone is cumulative, not live.
         if (
             proc.pm2_env.status === 'online' &&
@@ -331,16 +395,18 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
         const sessionCount = Object.values(sessions).filter((s) => s.platform === key).length;
         const h = health[key];
         let connection = '-';
+        let since = '-';
         if (enabled) {
             if (!h) connection = 'unknown';
             else if (h.status === 'running') connection = 'connected';
             else if (h.status === 'connecting') connection = 'connecting...';
             else if (h.status === 'error') connection = `error: ${h.detail || '?'}`;
             else if (h.status === 'stopped') connection = 'stopped';
+            if (h && h.at) since = formatUptime(new Date(h.at).getTime());
         }
-        return [def.label, enabled ? 'yes' : 'no', connection, String(sessionCount)];
+        return [def.label, enabled ? 'yes' : 'no', connection, since, String(sessionCount)];
     });
-    console.log(renderTable(['platform', 'enabled', 'connection', 'sessions'], rows));
+    console.log(renderTable(['platform', 'enabled', 'connection', 'since', 'sessions'], rows));
     console.log();
 } else if (cmd === 'enable') {
     if (isWin) {
@@ -409,6 +475,7 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     });
 
     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".

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkgravity",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "Discord/Telegram bot bridge for the Antigravity (agy) CLI, with voice interaction support",
   "scripts": {
     "postinstall": "node npm-scripts/postinstall.js",
@@ -40,7 +40,7 @@
     "npm-scripts",
     "hooks",
     "src",
-    "voice-service/index.js",
+    "voice-service/*.js",
     "voice-service/package.json",
     "voice-service/package-lock.json",
     "requirements.txt",

package/src/cogs/general_cog.py

@@ -242,7 +242,7 @@ class GeneralCog(commands.Cog):
         if not allowed(interaction.user.id):
             return await interaction.response.send_message("❌ Denied", ephemeral=True)
 
-        settings_path = Path(os.getenv("HOME", "/root")) / ".gemini/antigravity-cli/settings.json"
+        settings_path = Path.home() / ".gemini/antigravity-cli/settings.json"
         try:
             data = safe_load_json(settings_path, {}, logger=logger)
 

package/src/cogs/voice_cog.py

@@ -202,7 +202,7 @@ class VoiceCog(commands.Cog):
             await interaction.response.send_message("❌ Please join a voice channel first.", ephemeral=True)
             return
 
-        vc_chan = interaction.user.voice.channel
+        voice_channel = interaction.user.voice.channel
         guild_id = interaction.guild_id
 
         wake_word_map = self.bot_settings.get("wake_words") or {}
@@ -210,23 +210,26 @@ class VoiceCog(commands.Cog):
         active_timer = self.bot_settings.get("active_timer", 60)
         required = self._wake_word_required(interaction.user.id)
 
-        if own_word:
-            msg = (
-                f"🎤 Connected to `{vc_chan.name}`.\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`."
+        header = f"🎤 Connected to `{voice_channel.name}`."
+        sound_tip = "⚙️ You can customize settings using `/sound`."
+
+        if not required:
+            body = "💡 Wake word is off for you - just talk, I'm listening."
+        elif own_word:
+            body = (
+                f"💡 Say `{own_word}` to activate me. Once awake, "
+                f"I'll keep listening for {active_timer} seconds after each interaction."
             )
-        elif not required:
-            msg = f"🎤 Connected to `{vc_chan.name}`.\n💡 Wake word is off for you - just talk, I'm listening."
         else:
-            msg = (
-                f"🎤 Connected to `{vc_chan.name}`.\n"
-                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.\n"
-                f"💡 A wake word keeps everyone else's side conversation from triggering me by accident, and "
-                f"avoids running speech recognition on audio that isn't meant for me. If you use push-to-talk, "
-                f"turning it off with `/sound require_wake_word:off` is recommended instead."
+            body = (
+                "🎙️ You haven't set up a wake word yet, so I can't hear you - run `/sound wake_word:<word>` "
+                "and say your chosen word a few times to register it in your voice.\n"
+                "💡 A wake word keeps everyone else's side conversation from triggering me by accident, and "
+                "avoids running speech recognition on audio that isn't meant for me. If you use push-to-talk, "
+                "turning it off with `/sound require_wake_word:off` is recommended instead."
             )
+
+        msg = "\n".join([header, body, sound_tip])
         await interaction.response.send_message(msg)
 
         self.stt_session.clear_active_window(str(guild_id))  # don't inherit a window left open by a prior /join
@@ -239,7 +242,7 @@ class VoiceCog(commands.Cog):
                     self.logger.warning(f"Failed to call /leave before /join: {e}")
 
                 resp = await session.post(
-                    f"{NODE_VOICE_API}/join", json={"guild_id": str(guild_id), "channel_id": str(vc_chan.id)}
+                    f"{NODE_VOICE_API}/join", json={"guild_id": str(guild_id), "channel_id": str(voice_channel.id)}
                 )
                 if not required:
                     # Node's opt-out set is in-memory and won't survive a Node restart, unlike our own bot_settings.
@@ -554,15 +557,16 @@ class VoiceCog(commands.Cog):
                     self.logger.warning(f"Failed to interrupt playback for guild {guild_id}: {e}")
             self._active_turns[str(guild_id)] = asyncio.current_task()
 
-            user = self.bot.get_user(int(user_id))
-            if not user:
+            guild = self.bot.get_guild(int(guild_id))
+            member = guild.get_member(int(user_id)) if guild else None
+            if guild and not member:
                 try:
-                    user = await self.bot.fetch_user(int(user_id))
+                    member = await guild.fetch_member(int(user_id))
                 except discord.NotFound:
                     pass
                 except discord.HTTPException as e:
-                    self.logger.warning(f"fetch_user failed for {user_id}: {e}")
-            username = user.display_name if user else f"User {user_id}"
+                    self.logger.warning(f"fetch_member failed for {user_id}: {e}")
+            username = member.display_name if member else f"User {user_id}"
             await self.stt_session.finalize_partial_msg(str(guild_id), thread, f"🎤 **{username}**: {text}")
 
             if not text_to_ai:

package/src/core/agy_runner.py

@@ -3,70 +3,70 @@ import functools
 import os
 import re
 import signal
+import sys
 
 from config import logger
 
 active_processes = {}
 agy_start_lock = asyncio.Lock()
-# Threads killed intentionally - agy's SIGTERM exit code isn't reliable enough to tell otherwise.
 _intentionally_stopped = set()
 
-# Forced stdout buffer size (see _find_libstdbuf) - big enough for one write, small enough not to delay polling.
 _STDOUT_BUFFER_SIZE = 65536
 
 
 @functools.lru_cache(maxsize=1)
-def _find_libstdbuf() -> str | None:
-    """Find libstdbuf.so, the shared library `stdbuf` LD_PRELOADs. Linux-only
-    (no macOS/Windows equivalent implemented) - returns None there too.
-
-    agy runs commands under a PTY, so glibc line-buffers instead of
-    fully-buffering stdout - agy's completion-detection misreads the gap
-    between line writes as "done," truncating multi-line output to its
-    first line despite exit code 0. LD_PRELOADing this forces full
-    buffering instead. Returns None (no fix applied) if not found.
-    """
-    candidates = [
-        "/usr/lib/x86_64-linux-gnu/coreutils/libstdbuf.so",  # Debian/Ubuntu
-        "/usr/lib/aarch64-linux-gnu/coreutils/libstdbuf.so",
-        "/usr/libexec/coreutils/libstdbuf.so",  # Fedora/RHEL
-        "/usr/lib/coreutils/libstdbuf.so",  # Arch
-        "/usr/lib/libstdbuf.so",
-    ]
+def _find_preload_lib() -> tuple[str, str] | None:
+    if sys.platform == "darwin":
+        env_var = "DYLD_INSERT_LIBRARIES"
+        lib_name = "libstdbuf.dylib"
+        candidates = [
+            "/opt/homebrew/opt/coreutils/lib/libstdbuf.dylib",
+            "/usr/local/opt/coreutils/lib/libstdbuf.dylib",
+        ]
+        search_root = "/opt/homebrew" if os.path.isdir("/opt/homebrew") else "/usr/local"
+    elif os.name == "nt":
+        return None
+    else:
+        env_var = "LD_PRELOAD"
+        lib_name = "libstdbuf.so"
+        candidates = [
+            "/usr/lib/x86_64-linux-gnu/coreutils/libstdbuf.so",
+            "/usr/lib/aarch64-linux-gnu/coreutils/libstdbuf.so",
+            "/usr/libexec/coreutils/libstdbuf.so",
+            "/usr/lib/coreutils/libstdbuf.so",
+            "/usr/lib/libstdbuf.so",
+        ]
+        search_root = "/usr"
+
     for path in candidates:
         if os.path.isfile(path):
-            return path
+            return env_var, path
 
-    # lru_cache: only runs once per process.
     try:
         import subprocess
 
         result = subprocess.run(
-            ["find", "/usr", "-name", "libstdbuf.so"],
+            ["find", search_root, "-name", lib_name],
             capture_output=True,
             text=True,
             timeout=5,
         )
         found = [line for line in result.stdout.strip().splitlines() if line]
         if found:
-            return found[0]
+            return env_var, found[0]
     except Exception:
         pass
 
+    install_hint = "brew install coreutils" if sys.platform == "darwin" else "install coreutils"
     logger.warning(
-        "[AGY ENV] libstdbuf.so not found - run_command output for "
-        "multi-line commands may come back truncated. Add its path to "
-        "_find_libstdbuf()'s candidates list if coreutils is installed "
-        "somewhere nonstandard."
+        f"[AGY ENV] {lib_name} not found - run_command output for multi-line "
+        f"commands may come back truncated. Try `{install_hint}`, or add its path "
+        "to _find_preload_lib()'s candidates list if installed somewhere nonstandard."
     )
     return None
 
 
 def stop_active_process(thread_id: str) -> bool:
-    """Kill the agy subprocess for this thread, if any. Also used when a
-    new voice utterance interrupts a still-in-flight turn. Returns
-    whether a process was actually found and signaled.
-    """
     target_proc = active_processes.get(thread_id)
     if not target_proc:
         return False
@@ -100,6 +100,24 @@ async def _get_latest_conversation_id() -> str:
         return ""
 
 
+def _snapshot_conversation_dirs() -> set[str]:
+    from pathlib import Path
+
+    history_dir = Path.home() / ".gemini/antigravity-cli/brain"
+    if not history_dir.exists():
+        return set()
+    return {d.name for d in history_dir.iterdir() if d.is_dir()}
+
+
+async def _poll_new_conversation_id(before: set[str], attempts: int = 30, interval: float = 0.1) -> str:
+    for _ in range(attempts):
+        await asyncio.sleep(interval)
+        new_dirs = _snapshot_conversation_dirs() - before
+        if new_dirs:
+            return next(iter(new_dirs))
+    return ""
+
+
 async def run_agy(
     *args, timeout: int = 300, stream_queue: asyncio.Queue = None, thread_id: str = None, cwd: str = None
 ) -> str:
@@ -123,10 +141,11 @@ async def run_agy(
                 if thread_id:
                     env["LGY_THREAD_ID"] = thread_id
 
-                libstdbuf_path = _find_libstdbuf()  # works around agy's output-truncation bug
-                if libstdbuf_path:
-                    existing_preload = env.get("LD_PRELOAD", "")
-                    env["LD_PRELOAD"] = f"{libstdbuf_path}:{existing_preload}" if existing_preload else libstdbuf_path
+                preload = _find_preload_lib()  # works around agy's output-truncation bug
+                if preload:
+                    env_var, lib_path = preload
+                    existing_preload = env.get(env_var, "")
+                    env[env_var] = f"{lib_path}:{existing_preload}" if existing_preload else lib_path
                     env["_STDBUF_O"] = str(_STDOUT_BUFFER_SIZE)
 
                 kwargs = {
@@ -149,15 +168,15 @@ async def run_agy(
                 cmd = [AGY_BIN] + args_list
 
                 async with agy_start_lock:
+                    before_dirs = _snapshot_conversation_dirs()
                     proc = await asyncio.create_subprocess_exec(*cmd, **kwargs)
                     if thread_id:
                         active_processes[thread_id] = proc
 
                     if stream_queue and "--conversation" not in args:
-                        await asyncio.sleep(1.0)
-                        latest_conv_id = await _get_latest_conversation_id()
-                        if latest_conv_id:
-                            await stream_queue.put(("__CONV_ID__:" + latest_conv_id, False))
+                        new_conv_id = await _poll_new_conversation_id(before_dirs)
+                        if new_conv_id:
+                            await stream_queue.put(("__CONV_ID__:" + new_conv_id, False))
 
                 stdout_chunks = []
                 stderr_chunks = []
@@ -267,7 +286,6 @@ async def run_agy(
                         await stream_queue.put(("\n\n" + error_msg, True))
                     return error_msg
 
-                # DEBUG-only (LOG_LEVEL) raw stdout capture.
                 logger.debug(f"[AGY RAW STDOUT] {text!r}")
                 return text or "(Empty response)"
 
@@ -379,11 +397,6 @@ async def generate_thread_title(user_input: str, response: str) -> str:
 
 
 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
 

package/src/main_slack.py

@@ -139,12 +139,11 @@ async def cmd_credit(ack, body, respond, context) -> None:
         await respond("❌ Denied")
         return
 
-    import os
     from pathlib import Path
 
     from core.atomic_io import atomic_write_json, safe_load_json
 
-    settings_path = Path(os.getenv("HOME", "/root")) / ".gemini/antigravity-cli/settings.json"
+    settings_path = Path.home() / ".gemini/antigravity-cli/settings.json"
     current = bool(safe_load_json(settings_path, {}, logger=logger).get("useG1Credits", False))
 
     async def set_credit(use_credits: bool, action_body, client) -> None:

package/src/main_telegram.py

@@ -2,7 +2,6 @@
 which starts both concurrently when both platforms are enabled."""
 
 import asyncio
-import os
 import uuid
 from datetime import datetime
 from pathlib import Path
@@ -144,7 +143,7 @@ async def cmd_credit(update: Update, context) -> None:
         await update.message.reply_text("❌ Denied")
         return
 
-    settings_path = Path(os.getenv("HOME", "/root")) / ".gemini/antigravity-cli/settings.json"
+    settings_path = Path.home() / ".gemini/antigravity-cli/settings.json"
     current = bool(safe_load_json(settings_path, {}, logger=logger).get("useG1Credits", False))
 
     async def set_credit(use_credits: bool, query) -> None:
@@ -182,6 +181,10 @@ async def cmd_credit(update: Update, context) -> None:
 
 
 async def on_message(update: Update, context) -> None:
+    chat_id = update.effective_chat.id
+    user = update.effective_user
+    if user and allowed(user.id, "telegram") and not session_manager.get_session(str(chat_id)):
+        _start_session(chat_id, user.id)
     await handle_message(None, update, context.bot_data["adapter"])
 
 

package/voice-service/audioUtils.js

@@ -0,0 +1,31 @@
+function stereoToMono(buffer) {
+    // Discord voice receive is 48kHz stereo; everything downstream (WAV, Rustpotter) expects mono.
+    const samples = buffer.length >> 2; // 2 bytes/sample * 2 channels
+    const mono = Buffer.alloc(samples * 2);
+    for (let i = 0; i < samples; i++) {
+        const l = buffer.readInt16LE(i * 4);
+        const r = buffer.readInt16LE(i * 4 + 2);
+        mono.writeInt16LE((l + r) >> 1, i * 2);
+    }
+    return mono;
+}
+
+function createWavHeader(dataLength, sampleRate = 48000, channels = 1, bitDepth = 16) {
+    const buffer = Buffer.alloc(44);
+    buffer.write('RIFF', 0);
+    buffer.writeUInt32LE(36 + dataLength, 4);
+    buffer.write('WAVE', 8);
+    buffer.write('fmt ', 12);
+    buffer.writeUInt32LE(16, 16);
+    buffer.writeUInt16LE(1, 20);
+    buffer.writeUInt16LE(channels, 22);
+    buffer.writeUInt32LE(sampleRate, 24);
+    buffer.writeUInt32LE(sampleRate * channels * (bitDepth / 8), 28);
+    buffer.writeUInt16LE(channels * (bitDepth / 8), 32);
+    buffer.writeUInt16LE(bitDepth, 34);
+    buffer.write('data', 36);
+    buffer.writeUInt32LE(dataLength, 40);
+    return buffer;
+}
+
+module.exports = { stereoToMono, createWavHeader };

package/voice-service/config.js

@@ -0,0 +1,24 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const aglJsonPath = path.join(os.homedir(), '.gemini', 'linkgravity', 'lgy.json');
+let aglConfig = {};
+try {
+    if (fs.existsSync(aglJsonPath)) {
+        aglConfig = JSON.parse(fs.readFileSync(aglJsonPath, 'utf8'));
+    }
+} catch (e) {
+    console.error('Failed to load lgy.json:', e.message);
+}
+
+process.env.DISCORD_TOKEN =
+    aglConfig.discord_token || aglConfig.DISCORD_TOKEN || process.env.DISCORD_TOKEN;
+
+process.env.http_proxy = '';
+process.env.https_proxy = '';
+process.env.HTTP_PROXY = '';
+process.env.HTTPS_PROXY = '';
+process.env.PYTHON_HOST = '';
+
+module.exports = { aglConfig };

package/voice-service/index.js

@@ -1,10 +1,21 @@
-require('./logger'); // side-effect: timestamps console.log/error - must load before anything else logs
+require('./logger');
 
 const { Client, GatewayIntentBits, Events } = require('discord.js');
 const express = require('express');
 
 const { aglConfig } = require('./config');
 const state = require('./state');
+
+process.on('unhandledRejection', (reason) => {
+    console.error('Unhandled promise rejection (voice service stays alive):', reason);
+});
+
+process.on('uncaughtException', (err) => {
+    // Logs the cause before exiting - an unhandled sync error used to kill the process with no trace.
+    console.error('Uncaught exception - voice service is exiting:', err);
+    process.exit(1);
+});
+
 const { registerRoutes } = require('./routes');
 
 if (aglConfig.voice_threshold) {
@@ -24,16 +35,6 @@ client.once(Events.ClientReady, () => {
 
 registerRoutes(app, client);
 
-process.on('unhandledRejection', (reason) => {
-    console.error('Unhandled promise rejection (voice service stays alive):', reason);
-});
-
-process.on('uncaughtException', (err) => {
-    // Logs the cause before exiting - an unhandled sync error used to kill the process with no trace.
-    console.error('Uncaught exception - voice service is exiting:', 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(

package/voice-service/logger.js

@@ -0,0 +1,16 @@
+const originalLog = console.log;
+const originalError = console.error;
+
+function getTimestamp() {
+    const now = new Date();
+    const offset = now.getTimezoneOffset() * 60000;
+    const localTime = new Date(now.getTime() - offset);
+    return localTime.toISOString().replace('T', ' ').substring(0, 19);
+}
+
+console.log = function (...args) {
+    originalLog(`${getTimestamp()} INFO  Voice:`, ...args);
+};
+console.error = function (...args) {
+    originalError(`${getTimestamp()} ERROR Voice:`, ...args);
+};