feat(tts): add MeloTTS Korean voice via warm worker with offline-baked cache

Adds a dedicated MeloTTS Korean voice (speed 1.5) as the primary TTS engine,
served by a long-lived in-container worker so each Discord turn pays only
inference cost, not model-load cost.

- bridge/melo_worker.py: tiny HTTP service in its own /opt/melo py3.11 venv,
  keeps the KR model warm, returns PCM16 WAV on POST /synth.
- bridge/server.py: synthesize() routes to the melo worker first; Piper stays
  as an opt-in fallback (MELO_FALLBACK_PIPER, default off so Korean is never
  mangled through the English voice). /health reports tts_engine.
- docker/setup-melo.sh: builds the isolated venv (pinned torch 2.12.0 /
  torchaudio 2.11.0 CPU, MeloTTS pinned to a commit for reproducible rebuilds),
  pre-fetches mecab-ko, and warms a dedicated HF cache (/opt/melo-cache) with a
  real KR synth so all BERT + KR checkpoint assets are baked into the image.
- docker/supervisord.conf: runs melo-worker before the bridge with
  HF_HOME=/opt/melo-cache (the whisper_cache volume shadows the default HF
  cache) plus HF_HUB_OFFLINE/TRANSFORMERS_OFFLINE so it reads the baked cache
  and never retries the network on load.
- Dockerfile/.env.example: wire the melo build layer and config knobs.

Verified: offline synth passes with --network none and the prod volume mounted;
prod container recreated, all supervisord services up, bot logged in, and an
end-to-end /tts call returns a 44.1kHz mono PCM16 WAV.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

bridge/server.py

@@ -29,6 +29,7 @@ from __future__ import annotations
 
 import base64
 import io
+import json
 import os
 import sys
 import threading
@@ -54,6 +55,18 @@ BRIDGE_PORT = int(os.environ.get("BRIDGE_PORT", "8765"))
 BRAIN_ENABLED = os.environ.get("JARVIS_BRAIN_ENABLED", "1") not in ("0", "false", "False")
 TTS_ENABLED = os.environ.get("JARVIS_TTS_ENABLED", "1") not in ("0", "false", "False")
 
+# TTS engine: "melo" (MeloTTS Korean speaker, the warm worker) is the primary
+# voice; Piper is kept as a fallback if the worker is unreachable. Set
+# TTS_ENGINE=piper to disable MeloTTS entirely.
+TTS_ENGINE = os.environ.get("TTS_ENGINE", "melo").strip().lower()
+MELO_WORKER_URL = os.environ.get("MELO_WORKER_URL", "http://127.0.0.1:8770")
+MELO_TIMEOUT = float(os.environ.get("MELO_TIMEOUT", "30"))
+# When MeloTTS is the engine, do NOT silently fall back to the English Piper
+# voice on failure: speaking Korean text through an English voice produces
+# mangled audio. Default is melo-only (return no audio on failure); set
+# MELO_FALLBACK_PIPER=1 to opt into the Piper fallback.
+MELO_FALLBACK_PIPER = os.environ.get("MELO_FALLBACK_PIPER", "0") in ("1", "true", "True", "yes", "on")
+
 # ---------------------------------------------------------------------------
 # Lazy singletons. The first request pays the model-load cost; afterwards the
 # brain stays warm. A lock guards initialization so concurrent Discord events
@@ -207,10 +220,29 @@ def _coerce_bool(value) -> Optional[bool]:
     return str(value).strip().lower() in ("1", "true", "yes", "on")
 
 
-def synthesize(text: str) -> Optional[bytes]:
-    """Synthesize text to a 16-bit PCM WAV using Piper. Returns None if TTS off."""
-    if not TTS_ENABLED or not text.strip():
-        return None
+def _melo_synthesize(text: str) -> Optional[bytes]:
+    """Synthesise via the warm MeloTTS worker (separate /opt/melo venv, Korean
+    speaker @ speed 1.5). Returns a 16-bit PCM WAV, or None on any failure so
+    the caller can fall back to Piper."""
+    import urllib.request
+
+    try:
+        req = urllib.request.Request(
+            f"{MELO_WORKER_URL}/synth",
+            data=json.dumps({"text": text}).encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+        )
+        with urllib.request.urlopen(req, timeout=MELO_TIMEOUT) as resp:
+            if resp.status == 200:
+                return resp.read()
+            print(f"[bridge] melo worker HTTP {resp.status}", flush=True)
+    except Exception as e:  # pragma: no cover - worker may be down
+        print(f"[bridge] melo worker unreachable: {e}", flush=True)
+    return None
+
+
+def _piper_synthesize(text: str) -> Optional[bytes]:
+    """Fallback: synthesise with Piper (English voice). Returns WAV bytes."""
     _ensure_piper()
     if _piper_voice is None:
         return None
@@ -223,6 +255,24 @@ def synthesize(text: str) -> Optional[bytes]:
     return buf.getvalue()
 
 
+def synthesize(text: str) -> Optional[bytes]:
+    """Synthesize text to a 16-bit PCM WAV. The primary voice is MeloTTS
+    (Korean speaker, speed 1.5) served by the warm melo worker; Piper is a
+    fallback if the worker is unavailable. Returns None if TTS is off."""
+    if not TTS_ENABLED or not text.strip():
+        return None
+    if TTS_ENGINE == "melo":
+        audio = _melo_synthesize(text)
+        if audio:
+            return audio
+        if not MELO_FALLBACK_PIPER:
+            # Melo-only: better silent than mangled English for Korean text.
+            print("[bridge] melo synth failed; no audio (Piper fallback disabled)", flush=True)
+            return None
+        print("[bridge] melo synth failed; falling back to Piper", flush=True)
+    return _piper_synthesize(text)
+
+
 # ---------------------------------------------------------------------------
 # HTTP endpoints
 # ---------------------------------------------------------------------------
@@ -235,6 +285,7 @@ def health():
             "brain_ready": _cfg is not None,
             "brain_error": _brain_error,
             "tts_enabled": TTS_ENABLED,
+            "tts_engine": TTS_ENGINE,
         }
     )