linkgravity 1.5.2 → 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,10 +237,67 @@ 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));
@@ -294,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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkgravity",
-  "version": "1.5.2",
+  "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/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/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);
+};

package/voice-service/receiver.js

@@ -0,0 +1,310 @@
+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 { interruptTTS } = require('./tts');
+const state = require('./state');
+const { activeStreams, enrollingUsers, isPlaying, wakeWordOptedOut, runtime, isGuildActive } =
+    state;
+
+function setupReceiver(connection, guildId, client) {
+    const receiver = connection.receiver;
+
+    receiver.speaking.removeAllListeners('start');
+
+    receiver.speaking.on('start', (userId) => {
+        if (client.user.id === userId) return;
+
+        if (activeStreams.get(userId)) {
+            return;
+        }
+        activeStreams.set(userId, true);
+
+        let hasInterrupted = false;
+
+        const opusStream = receiver.subscribe(userId, {
+            end: {
+                behavior: EndBehaviorType.Manual,
+            },
+        });
+        const pcmStream = opusStream.pipe(
+            new prism.opus.Decoder({ rate: 48000, channels: 2, frameSize: 960 }),
+        );
+
+        // Without a listener, an unhandled 'error' event here crashes the ENTIRE process on one bad packet.
+        opusStream.on('error', (err) => {
+            console.error(`[Voice] Opus stream error for ${userId}:`, err.message);
+            forceEndStream();
+        });
+        pcmStream.on('error', (err) => {
+            console.error(
+                `[Voice] Opus decode error for ${userId} (bad/corrupted packet):`,
+                err.message,
+            );
+            forceEndStream();
+        });
+
+        const chunks = [];
+
+        let hasEnded = false;
+
+        const forceEndStream = () => {
+            if (hasEnded) return;
+            try {
+                opusStream.destroy();
+            } catch (e) {}
+            try {
+                pcmStream.destroy();
+            } catch (e) {}
+            pcmStream.emit('end');
+        };
+
+        const maxDurationTimer = setTimeout(forceEndStream, 30000);
+
+        // Rustpotter runs in-process here, no Python round trip - detectors cached per user.
+        let wakeConfirmed = false;
+        let matchedWakeWord = null;
+        let detectorEntry = null;
+        let bestWakeScore = 0;
+        let bestWakeScoreName = null;
+        let bestDiagScore = 0;
+        let bestDiagScoreName = null;
+
+        if (!enrollingUsers.has(userId) && !isGuildActive(guildId)) {
+            getDetectorForUser(userId)
+                .then((entry) => {
+                    if (entry) {
+                        entry.rustpotter.reset();
+                        entry.residual = new Int16Array(0);
+                        entry.diag.rustpotter.reset();
+                        entry.diag.residual = new Int16Array(0);
+                        detectorEntry = entry;
+                    }
+                })
+                .catch((err) =>
+                    console.error(`[Wake] Failed to load detector for ${userId}:`, err.message),
+                );
+        }
+
+        // Only during the active/awake window - reuses the same googleSTT() call for earlier live feedback.
+        const PARTIAL_INTERVAL_MS = 1500;
+        const PARTIAL_MIN_NEW_BYTES = 24000;
+        let lastPartialLength = 0;
+        let partialSent = false;
+        const partialTimer = setInterval(async () => {
+            if (hasEnded || !isSpeaking || enrollingUsers.has(userId)) return;
+            if (!isGuildActive(guildId)) return;
+
+            const currentLength = chunks.reduce((sum, c) => sum + c.length, 0);
+            if (currentLength - lastPartialLength < PARTIAL_MIN_NEW_BYTES) return;
+            lastPartialLength = currentLength;
+
+            const windowPcm = Buffer.concat(chunks);
+            const wavHeader = createWavHeader(windowPcm.length);
+            const wavBuffer = Buffer.concat([wavHeader, windowPcm]);
+
+            const text = await googleSTT(wavBuffer);
+            partialSent = true;
+            fetch('http://127.0.0.1:18080/stt_partial', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ guild_id: guildId, text }),
+            }).catch((err) =>
+                console.error(`[STT] Failed to send partial text to Python:`, err.message),
+            );
+        }, PARTIAL_INTERVAL_MS);
+
+        let bgNoiseRMS = 500;
+        let isSpeaking = false;
+        let silenceBytes = 0;
+        let silenceTimer = null;
+
+        pcmStream.on('data', (rawChunk) => {
+            if (hasEnded) return;
+            const chunk = stereoToMono(rawChunk); // see stereoToMono's comment - decoder gives real stereo now
+
+            let sumSquare = 0;
+            for (let i = 0; i < chunk.length; i += 2) {
+                const sample = chunk.readInt16LE(i);
+                sumSquare += sample * sample;
+            }
+            const rms = Math.sqrt(sumSquare / (chunk.length / 2));
+
+            const isBotPlaying = isPlaying.get(guildId) || false;
+
+            if (!hasInterrupted) {
+                const dynamicThreshold = isBotPlaying
+                    ? runtime.vadThreshold * 3
+                    : runtime.vadThreshold;
+                if (rms > dynamicThreshold) {
+                    if (interruptTTS(guildId)) {
+                        console.log(
+                            `[VAD] Loud voice detected (${Math.round(rms)}), interrupting TTS (Threshold: ${dynamicThreshold})`,
+                        );
+                        hasInterrupted = true;
+                    }
+                }
+            }
+
+            if (detectorEntry) {
+                const detection = feedPCMToDetector(detectorEntry, chunk);
+                if (detection && detection.getScore() > bestWakeScore) {
+                    bestWakeScore = detection.getScore();
+                    bestWakeScoreName = detection.getName();
+                }
+                const diagDetection = feedPCMToDetector(detectorEntry.diag, chunk);
+                if (diagDetection && diagDetection.getScore() > bestDiagScore) {
+                    bestDiagScore = diagDetection.getScore();
+                    bestDiagScoreName = diagDetection.getName();
+                }
+            }
+
+            if (isPlaying.get(guildId)) {
+                return;
+            }
+
+            chunks.push(chunk);
+
+            if (!isSpeaking) {
+                bgNoiseRMS = bgNoiseRMS * 0.98 + rms * 0.02;
+                bgNoiseRMS = Math.max(50, Math.min(bgNoiseRMS, 3000));
+            }
+
+            const threshold = Math.max(bgNoiseRMS * 2.0, 800);
+
+            if (rms > threshold) {
+                isSpeaking = true;
+                silenceBytes = 0;
+            } else {
+                if (isSpeaking) {
+                    silenceBytes += chunk.length;
+                    if (silenceBytes >= 76800) {
+                        forceEndStream();
+                        return;
+                    }
+                }
+            }
+
+            if (isSpeaking) {
+                if (silenceTimer) clearTimeout(silenceTimer);
+                silenceTimer = setTimeout(() => forceEndStream(), 800);
+            }
+        });
+
+        pcmStream.on('end', async () => {
+            if (hasEnded) return;
+            hasEnded = true;
+            clearTimeout(maxDurationTimer);
+            clearInterval(partialTimer);
+            if (silenceTimer) clearTimeout(silenceTimer);
+
+            activeStreams.delete(userId);
+
+            if (detectorEntry) {
+                // Live capture stops before rustpotter's confirm countdown finishes, so pad with
+                // silence to let a genuine match finalize instead of being silently discarded.
+                const paddingBuffer = Buffer.alloc(detectorEntry.samplesPerFrame * 100 * 2);
+                const paddingDetection = feedPCMToDetector(detectorEntry, paddingBuffer);
+                if (paddingDetection && paddingDetection.getScore() > bestWakeScore) {
+                    bestWakeScore = paddingDetection.getScore();
+                    bestWakeScoreName = paddingDetection.getName();
+                }
+                const diagPaddingBuffer = Buffer.alloc(
+                    detectorEntry.diag.samplesPerFrame * 100 * 2,
+                );
+                const diagPaddingDetection = feedPCMToDetector(
+                    detectorEntry.diag,
+                    diagPaddingBuffer,
+                );
+                if (diagPaddingDetection && diagPaddingDetection.getScore() > bestDiagScore) {
+                    bestDiagScore = diagPaddingDetection.getScore();
+                    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;
+                matchedWakeWord = wakeConfirmed ? bestWakeScoreName : null;
+                console.log(
+                    wakeConfirmed
+                        ? `[Wake] ${userId}: CONFIRMED (score ${bestWakeScore.toFixed(3)} for ` +
+                              `"${bestWakeScoreName}", threshold ${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)`,
+                );
+            }
+
+            const pcmBuffer = Buffer.concat(chunks);
+
+            // Enrollment mode: this is a reference sample, not a command - skip wake-check/STT.
+            if (enrollingUsers.has(userId)) {
+                if (pcmBuffer.length < 4000) return; // too short to be a real sample
+                const wavHeader = createWavHeader(pcmBuffer.length);
+                const wavBuffer = Buffer.concat([wavHeader, pcmBuffer]);
+                try {
+                    await fetch(
+                        `http://127.0.0.1:18080/enroll_sample?user_id=${encodeURIComponent(userId)}`,
+                        {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/octet-stream' },
+                            body: wavBuffer,
+                        },
+                    );
+                } catch (err) {
+                    console.error(`[Enroll] Failed to send sample to Python:`, err.message);
+                }
+                return;
+            }
+
+            // 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',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ guild_id: guildId }),
+                    }).catch(() => {});
+                }
+                return;
+            }
+
+            const shouldTranscribe =
+                isGuildActive(guildId) || wakeConfirmed || wakeWordOptedOut.has(userId);
+
+            if (!shouldTranscribe) {
+                if (partialSent) {
+                    fetch('http://127.0.0.1:18080/stt_partial_cancel', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ guild_id: guildId }),
+                    }).catch(() => {});
+                }
+                return;
+            }
+
+            const wavHeader = createWavHeader(pcmBuffer.length);
+            const wavBuffer = Buffer.concat([wavHeader, pcmBuffer]);
+            const text = await googleSTT(wavBuffer);
+
+            try {
+                await fetch('http://127.0.0.1:18080/stt_input', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        user_id: userId,
+                        guild_id: guildId,
+                        text,
+                        wake_confirmed: wakeConfirmed,
+                        matched_wake_word: matchedWakeWord,
+                    }),
+                });
+            } catch (err) {
+                console.error(`[STT] Failed to send recognized text to Python:`, err.message);
+            }
+        });
+    });
+}
+
+module.exports = { setupReceiver };

package/voice-service/routes.js

@@ -0,0 +1,182 @@
+const express = require('express');
+const { joinVoiceChannel, VoiceConnectionStatus } = require('@discordjs/voice');
+const state = require('./state');
+const { setupReceiver } = require('./receiver');
+const { interruptTTS, playNextInQueue } = require('./tts');
+const { loadRustpotterModule } = require('./wakeword');
+
+function registerRoutes(app, client) {
+    app.get('/health', (req, res) => {
+        res.json({ ready: client.isReady() });
+    });
+
+    app.post('/join', async (req, res) => {
+        const { guild_id, channel_id } = req.body;
+        try {
+            const guild = client.guilds.cache.get(guild_id);
+            if (!guild) return res.status(404).json({ error: 'Guild not found' });
+
+            let connection = joinVoiceChannel({
+                channelId: channel_id,
+                guildId: guild_id,
+                adapterCreator: guild.voiceAdapterCreator,
+                selfDeaf: false,
+                selfMute: false,
+            });
+
+            state.connections.set(guild_id, connection);
+
+            setupReceiver(connection, guild_id, client);
+
+            connection.removeAllListeners(VoiceConnectionStatus.Ready);
+            connection.on(VoiceConnectionStatus.Ready, () => {
+                console.log(`[Voice] Connected to ${channel_id} in ${guild_id}`);
+            });
+
+            res.json({ success: true });
+        } catch (e) {
+            console.error(e);
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    app.post('/leave', (req, res) => {
+        const { guild_id } = req.body;
+        const connection = state.connections.get(guild_id);
+        if (!connection) {
+            return res.status(404).json({ error: 'Not connected' });
+        }
+
+        const player = state.players.get(guild_id);
+        if (player) {
+            try {
+                player.stop(true);
+            } catch (e) {
+                // already stopped/destroyed - fine
+            }
+        }
+        connection.destroy();
+
+        // Without this, a stale isPlaying/players entry silently breaks STT/wake detection on the next /join.
+        state.connections.delete(guild_id);
+        state.players.delete(guild_id);
+        state.audioQueues.delete(guild_id);
+        state.isPlaying.delete(guild_id);
+        state.activeUntil.delete(guild_id);
+        state.suppressNotifyMap.delete(guild_id);
+
+        res.json({ success: true });
+    });
+
+    app.post(
+        '/play',
+        express.raw({ type: 'application/octet-stream', limit: '20mb' }),
+        (req, res) => {
+            const guild_id = req.query.guild_id;
+            const connection = state.connections.get(guild_id);
+            if (!connection) return res.status(404).json({ error: 'Not connected' });
+
+            if (!state.audioQueues.has(guild_id)) {
+                state.audioQueues.set(guild_id, []);
+            }
+
+            state.audioQueues.get(guild_id).push({
+                buffer: req.body, // req.body is a Buffer here
+                suppressActiveWindow: req.query.suppress_active_window === 'true',
+            });
+
+            if (!state.isPlaying.get(guild_id)) {
+                playNextInQueue(guild_id);
+            }
+
+            res.json({ success: true, queued: true });
+        },
+    );
+
+    app.post('/interrupt', (req, res) => {
+        const { guild_id } = req.body;
+        // Lets Python trigger the same cutoff the VAD loud-voice check uses, regardless of volume.
+        interruptTTS(guild_id);
+        res.json({ success: true });
+    });
+
+    app.post('/invalidate_detector', (req, res) => {
+        // Without this, detectorCache keeps serving the OLD .rpw after a user re-enrolls.
+        const { user_id } = req.body;
+        const deleted = state.detectorCache.delete(user_id);
+        console.log(`[Wake] Invalidated cached detector for ${user_id} (was cached: ${deleted})`);
+        res.json({ success: true, was_cached: deleted });
+    });
+
+    app.post('/build_wakeword', async (req, res) => {
+        // Builds a .rpw in-process via WakewordRefCreator, instead of shelling out to rustpotter-cli.
+        try {
+            const { name, samples } = req.body;
+            if (!name || !Array.isArray(samples) || samples.length === 0) {
+                return res
+                    .status(400)
+                    .json({ error: 'name and at least one sample (wav bytes) are required' });
+            }
+
+            const mod = await loadRustpotterModule();
+            const creator = mod.WakewordRefCreator.new(name);
+            try {
+                for (const sample of samples) {
+                    const buf = Buffer.from(sample.data_base64, 'base64');
+                    creator.addFile(sample.filename || `${name}.wav`, buf);
+                }
+                const rpwBytes = creator.saveToBytes();
+                console.log(
+                    `[Wake] Built .rpw for '${name}' from ${samples.length} sample(s) via WakewordRefCreator`,
+                );
+                res.json({ success: true, rpw_base64: Buffer.from(rpwBytes).toString('base64') });
+            } finally {
+                creator.free();
+            }
+        } catch (e) {
+            console.error(`[Wake] Failed to build wakeword reference:`, e);
+            res.status(500).json({ error: e.message || String(e) });
+        }
+    });
+
+    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}`);
+        }
+        res.json({ success: true });
+    });
+
+    app.post('/enroll_start', (req, res) => {
+        const { user_id } = req.body;
+        if (!user_id) return res.status(400).json({ error: 'user_id required' });
+        state.enrollingUsers.add(user_id);
+        res.json({ success: true });
+    });
+
+    app.post('/enroll_stop', (req, res) => {
+        const { user_id } = req.body;
+        if (!user_id) return res.status(400).json({ error: 'user_id required' });
+        state.enrollingUsers.delete(user_id);
+        res.json({ success: true });
+    });
+
+    app.post('/set_active', (req, res) => {
+        const { guild_id, active_until } = req.body;
+        if (!guild_id || !active_until)
+            return res.status(400).json({ error: 'guild_id and active_until required' });
+        state.activeUntil.set(guild_id, active_until);
+        res.json({ success: true });
+    });
+
+    app.post('/set_wake_word_required', (req, res) => {
+        const { user_id, required } = req.body;
+        if (!user_id) return res.status(400).json({ error: 'user_id required' });
+        if (required) state.wakeWordOptedOut.delete(user_id);
+        else state.wakeWordOptedOut.add(user_id);
+        res.json({ success: true });
+    });
+}
+
+module.exports = { registerRoutes };

package/voice-service/state.js

@@ -0,0 +1,42 @@
+const connections = new Map();
+const players = new Map();
+const audioQueues = new Map();
+const isPlaying = new Map();
+const activeStreams = new Map();
+
+// user_id -> recording wake-word samples right now; routes to /enroll_sample instead of STT.
+const enrollingUsers = new Set();
+
+// guild_id -> ms epoch until the "awake, skip wake word" window closes (set via /set_active).
+const activeUntil = new Map();
+
+// user_id -> opted out of wake-word gating via /sound - scoped per-user, unlike activeUntil.
+const wakeWordOptedOut = new Set();
+
+// Whether finished audio should extend the "stay awake" window (false for enrollment playback).
+const suppressNotifyMap = new Map();
+
+// userId -> { rustpotter, samplesPerFrame, residual: Int16Array }
+const detectorCache = new Map();
+
+// Object property, not a plain `let` - a `let` wouldn't propagate its reassignment across modules.
+const runtime = { vadThreshold: 3000 };
+
+function isGuildActive(guildId) {
+    return Date.now() < (activeUntil.get(guildId) || 0);
+}
+
+module.exports = {
+    connections,
+    players,
+    audioQueues,
+    isPlaying,
+    activeStreams,
+    enrollingUsers,
+    activeUntil,
+    wakeWordOptedOut,
+    suppressNotifyMap,
+    detectorCache,
+    runtime,
+    isGuildActive,
+};

package/voice-service/stt.js

@@ -0,0 +1,71 @@
+const { spawn } = require('child_process');
+const ffmpegPath = require('ffmpeg-static');
+
+// Unofficial Google STT key - same default Python's SpeechRecognition (recognize_google) ships with.
+const GOOGLE_STT_KEY = 'AIzaSyBOti4mM-6x9WDnZIjIeyEU21OpBXqWBgw';
+
+function flacEncode(wavBuffer) {
+    return new Promise((resolve, reject) => {
+        const ff = spawn(ffmpegPath, [
+            '-hide_banner',
+            '-loglevel',
+            'error',
+            '-i',
+            'pipe:0',
+            '-f',
+            'flac',
+            'pipe:1',
+        ]);
+        const out = [];
+        ff.stdout.on('data', (d) => out.push(d));
+        ff.stderr.on('data', () => {}); // -loglevel error already keeps this quiet in the normal case
+        ff.on('error', (err) => reject(new Error(`ffmpeg-static failed to run (${err.message})`)));
+        ff.on('close', (code) => {
+            if (code !== 0) return reject(new Error(`ffmpeg exited with code ${code}`));
+            resolve(Buffer.concat(out));
+        });
+        ff.stdin.write(wavBuffer);
+        ff.stdin.end();
+    });
+}
+
+async function googleSTT(wavBuffer, lang = 'ko-KR') {
+    let flacBuffer;
+    try {
+        flacBuffer = await flacEncode(wavBuffer);
+    } catch (err) {
+        console.error('[STT] FLAC encode failed:', err.message);
+        return null;
+    }
+
+    let res;
+    try {
+        res = await fetch(
+            `https://www.google.com/speech-api/v2/recognize?output=json&client=chromium&lang=${encodeURIComponent(lang)}&key=${GOOGLE_STT_KEY}`,
+            {
+                method: 'POST',
+                headers: { 'Content-Type': 'audio/x-flac; rate=48000' },
+                body: flacBuffer,
+            },
+        );
+    } catch (err) {
+        console.error('[STT] Request to Google STT failed:', err.message);
+        return null;
+    }
+
+    const raw = await res.text();
+    // Response is newline-delimited JSON, one object per line.
+    for (const line of raw.trim().split('\n')) {
+        if (!line) continue;
+        try {
+            const obj = JSON.parse(line);
+            const transcript = obj.result?.[0]?.alternative?.[0]?.transcript;
+            if (transcript) return transcript.trim();
+        } catch (e) {
+            // not JSON / partial line - ignore
+        }
+    }
+    return null;
+}
+
+module.exports = { googleSTT };

package/voice-service/tts.js

@@ -0,0 +1,81 @@
+const { Readable } = require('stream');
+const { createAudioPlayer, createAudioResource, AudioPlayerStatus } = require('@discordjs/voice');
+const { players, audioQueues, isPlaying, connections, suppressNotifyMap } = require('./state');
+
+function interruptTTS(guildId) {
+    const player = players.get(guildId);
+    let interrupted = false;
+
+    if (audioQueues.has(guildId)) {
+        // Queue holds in-memory Buffers (see /play), not filepaths - nothing on disk to clean up.
+        audioQueues.set(guildId, []);
+    }
+
+    if (player && player.state.status !== AudioPlayerStatus.Idle) {
+        player.stop();
+        console.log(`[VAD] Interrupted TTS in guild ${guildId}`);
+        interrupted = true;
+    }
+
+    isPlaying.set(guildId, false);
+    return interrupted;
+}
+
+async function notifyTtsFinished(guild_id) {
+    try {
+        await fetch('http://127.0.0.1:18080/tts_finished', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ guild_id }),
+        });
+    } catch (err) {
+        console.error(`[TTS] Failed to notify Python of playback completion:`, err.message);
+    }
+}
+
+function playNextInQueue(guild_id) {
+    const queue = audioQueues.get(guild_id) || [];
+    if (queue.length === 0) {
+        isPlaying.set(guild_id, false);
+        if (!suppressNotifyMap.get(guild_id)) {
+            notifyTtsFinished(guild_id);
+        }
+        return;
+    }
+
+    const connection = connections.get(guild_id);
+    if (!connection) {
+        isPlaying.set(guild_id, false);
+        return;
+    }
+
+    isPlaying.set(guild_id, true);
+    const item = queue.shift(); // { buffer, suppressActiveWindow }
+    suppressNotifyMap.set(guild_id, item.suppressActiveWindow);
+
+    try {
+        let player = players.get(guild_id);
+        if (!player) {
+            player = createAudioPlayer();
+            players.set(guild_id, player);
+            connection.subscribe(player);
+
+            player.on(AudioPlayerStatus.Idle, () => {
+                playNextInQueue(guild_id);
+            });
+
+            player.on('error', (error) => {
+                console.error(`[TTS] AudioPlayer Error:`, error.message);
+                playNextInQueue(guild_id);
+            });
+        }
+
+        const resource = createAudioResource(Readable.from(item.buffer));
+        player.play(resource);
+    } catch (e) {
+        console.error(`[TTS] Error playing queued audio:`, e);
+        playNextInQueue(guild_id);
+    }
+}
+
+module.exports = { interruptTTS, notifyTtsFinished, playNextInQueue };

package/voice-service/wakeword.js

@@ -0,0 +1,114 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { detectorCache } = 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');
+
+let rustpotterModPromise = null;
+function loadRustpotterModule() {
+    if (!rustpotterModPromise) {
+        rustpotterModPromise = (async () => {
+            // "rustpotter-web" (not "-slim") - also exposes WakewordRefCreator for /build_wakeword.
+            const mod = await import('rustpotter-web/rustpotter_wasm.js');
+            const wasmPath = require.resolve('rustpotter-web/rustpotter_wasm_bg.wasm');
+            mod.initSync(fs.readFileSync(wasmPath));
+            return mod;
+        })();
+    }
+    return rustpotterModPromise;
+}
+
+// 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);
+
+    const userDir = path.join(WAKE_REF_DIR, userId);
+    if (!fs.existsSync(userDir)) return null; // not enrolled
+
+    const rpwFile = fs.readdirSync(userDir).find((f) => f.endsWith('.rpw'));
+    if (!rpwFile) return null; // samples exist but .rpw build hasn't happened/failed - see _commit_enrollment
+
+    const mod = await loadRustpotterModule();
+    const config = mod.RustpotterConfig.new();
+    config.setSampleRate(48000);
+    config.setSampleFormat(mod.SampleFormat.i16);
+    config.setChannels(1);
+    config.setThreshold(WAKE_MATCH_THRESHOLD);
+    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.
+    config.setMinScores(2);
+    // Max (best of the 5 enrolled samples) beats Median here - real speech isn't consistent enough
+    // for Median's "middle sample must also score well" requirement; minScores compensates.
+    config.setScoreMode(mod.ScoreMode.max);
+    // Enrollment and live-call volume rarely match (distance, speaking softly); without this, that
+    // mismatch alone can push a genuine match below threshold.
+    config.setGainNormalizerEnabled(true);
+
+    const rustpotter = mod.Rustpotter.new(config);
+    rustpotter.addWakeword(rpwFile, fs.readFileSync(path.join(userDir, rpwFile)));
+
+    // Diagnostic-only twin (same audio) so "no match" logs show a closeness score - never gates wake behavior.
+    const diagConfig = mod.RustpotterConfig.new();
+    diagConfig.setSampleRate(48000);
+    diagConfig.setSampleFormat(mod.SampleFormat.i16);
+    diagConfig.setChannels(1);
+    diagConfig.setThreshold(0.01);
+    diagConfig.setAveragedThreshold(0);
+    diagConfig.setMinScores(1);
+    diagConfig.setEager(true);
+    diagConfig.setScoreMode(mod.ScoreMode.max);
+    diagConfig.setGainNormalizerEnabled(true);
+    const diagRustpotter = mod.Rustpotter.new(diagConfig);
+    diagRustpotter.addWakeword(rpwFile, fs.readFileSync(path.join(userDir, rpwFile)));
+
+    const entry = {
+        rustpotter,
+        samplesPerFrame: rustpotter.getSamplesPerFrame(),
+        residual: new Int16Array(0),
+        diag: {
+            rustpotter: diagRustpotter,
+            samplesPerFrame: diagRustpotter.getSamplesPerFrame(),
+            residual: new Int16Array(0),
+        },
+    };
+    console.log(
+        `[Wake] Loaded detector for ${userId} from ${rpwFile}: samplesPerFrame=${entry.samplesPerFrame}`,
+    );
+    detectorCache.set(userId, entry);
+    return entry;
+}
+
+// Frame-aligns via residual carryover (Rustpotter needs a continuous stream); returns a detection if any.
+function feedPCMToDetector(entry, chunk) {
+    const incoming = new Int16Array(chunk.buffer, chunk.byteOffset, chunk.length / 2);
+    let combined = incoming;
+    if (entry.residual.length) {
+        combined = new Int16Array(entry.residual.length + incoming.length);
+        combined.set(entry.residual, 0);
+        combined.set(incoming, entry.residual.length);
+    }
+
+    let offset = 0;
+    let detection = null;
+    while (combined.length - offset >= entry.samplesPerFrame) {
+        const frame = combined.subarray(offset, offset + entry.samplesPerFrame);
+        const result = entry.rustpotter.processI16(frame);
+        if (result) detection = result;
+        offset += entry.samplesPerFrame;
+    }
+    entry.residual = combined.subarray(offset);
+    return detection;
+}
+
+module.exports = {
+    WAKE_REF_DIR,
+    WAKE_MATCH_THRESHOLD,
+    loadRustpotterModule,
+    getDetectorForUser,
+    feedPCMToDetector,
+};