feat: play the Nth YouTube result in browseAndPlay via an index arg

agents/llm.md promises "play the Nth video from the top", but browseAndPlay
only ever clicked the first result. Add an optional 1-based index argument
(default 1, backward-compatible) threaded to the Node helper, which now clicks
the Nth a#video-title and clamps to the number of results returned so asking
beyond the list plays the last available video instead of failing.

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

.env.example

@@ -34,18 +34,18 @@ WHISPER_DEVICE=cuda
 WHISPER_COMPUTE_TYPE=float16
 # Optional explicit Piper voice model (.onnx). If empty, the jarvis default is used.
 TTS_PIPER_MODEL_PATH=
-# TTS engine: "melo" (default) uses the MeloTTS Korean voice served by the warm
+# TTS engine: "edge" (default) uses Microsoft Edge TTS, a natural Korean neural
-# melo-worker (Korean speaker, speed 1.5). Set to "piper" to use Piper directly.
+# voice. Set to "piper" for the offline English voice. NOTE: edge is ONLINE —
-TTS_ENGINE=melo
+# reply text is sent to Microsoft's servers and needs internet.
-# Melo-only by default: if MeloTTS synthesis fails the bridge returns no audio
+TTS_ENGINE=edge
-# rather than speaking Korean through the English Piper voice (which mangles it).
+# Edge voice + speaking rate. Rate is a percentage (+45% ≈ 1.45×). Korean voices:
-# Set to 1 only if you explicitly want the Piper fallback.
+# ko-KR-HyunsuMultilingualNeural (M), ko-KR-InJoonNeural (M), ko-KR-SunHiNeural (F).
+EDGE_TTS_VOICE=ko-KR-HyunsuMultilingualNeural
+EDGE_TTS_RATE=+45%
+# Neural-only by default: if synthesis fails the bridge returns no audio rather
+# than speaking Korean through the English Piper voice. Set to 1 to allow the
+# Piper fallback.
 MELO_FALLBACK_PIPER=0
-# Where the bridge reaches the in-container MeloTTS worker, and how long it
-# waits for a synthesis. Speaking rate is set on the worker via MELO_SPEED.
-MELO_WORKER_URL=http://127.0.0.1:8770
-MELO_TIMEOUT=30
-MELO_SPEED=1.5
 
 # ---------------------------------------------------------------------------
 # Jarvis brain (Ollama-backed). In Docker these populate the rendered

CLAUDE.md

@@ -1,6 +1,6 @@
 Data privacy comes first, always.
 
-All user-facing command line output should make use of emojis. Especially an initial emoji to start off the lines that depict what the line is about. Output should make use of indentation spacing to establish a visual hierarchy and aim to make output as easy to sift through as possible. Exception: Windows .bat scripts cannot use emojis (cmd.exe doesn't render Unicode properly).
+This assistant is used through a Discord bot with voice (TTS) replies, not a CLI. Do not add emojis to user-facing assistant output. Keep output plain and readable. (Runtime assistant behaviour lives in `agents/*.md`, which is injected into the reply LLM's prompt.)
 
 Any important point in our logical flows should have debug logs using the `debug_log` method from `src/jarvis/debug.py`. Avoid excessive logging to keep the logs easily readable and actionable.
 

Dockerfile

@@ -65,20 +65,14 @@ RUN ls -d /opt/venv/lib/python*/site-packages/nvidia/cublas/lib \
         > /etc/ld.so.conf.d/nvidia-cu12.conf 2>/dev/null \
     && /sbin/ldconfig || true
 
-# --- MeloTTS Korean voice (separate /opt/melo py3.11 venv; see setup-melo.sh).
+# --- Korean voice: Microsoft Edge TTS (online neural). No model is baked — the
-#     Heavy layer (torch CPU + transformers + MeCab); placed before the app
+#     `edge-tts` pip package (in requirements-bridge.txt) calls the MS service at
-#     COPY so it stays cached across source-only changes. ---
+#     runtime and the bridge transcodes the MP3 to PCM16 with ffmpeg. No heavy
-COPY docker/setup-melo.sh /app/docker/setup-melo.sh
+#     TTS build layer is needed. ---
-# Strip CR before running: a Windows checkout (autocrlf) yields CRLF, which makes
-# bash read line 18 as `set -euxo pipefail\r` and abort with
-# "set: pipefail: invalid option name". .gitattributes pins *.sh to LF, but this
-# keeps the build working even on a not-yet-renormalised working tree.
-RUN sed -i 's/\r$//' /app/docker/setup-melo.sh && bash /app/docker/setup-melo.sh
 
 # --- Human input + window management for the on-screen Chrome control tool.
-#     Placed AFTER the heavy melo layer so it doesn't bust that cache. xdotool
+#     xdotool injects real X pointer/keyboard events (visible cursor,
-#     injects real X pointer/keyboard events (visible cursor, char-by-char
+#     char-by-char typing) into the broadcast; wmctrl lists/moves windows. ---
-#     typing) into the broadcast; wmctrl lists/moves windows. ---
 RUN apt-get update && apt-get install -y --no-install-recommends \
       xdotool wmctrl \
     && rm -rf /var/lib/apt/lists/*

README.md

@@ -69,7 +69,7 @@ docker compose -f docker-compose.yml -f docker-compose.gpu-linux.yml up -d --bui
 docker compose -f docker-compose.yml -f docker-compose.gpu-windows.yml up -d --build
 
 # ── GPU 없이 (CPU 전용 호스트) ──
-#   .env 에 WHISPER_DEVICE=cpu, MELO_DEVICE=cpu 를 넣고 베이스만 사용
+#   .env 에 WHISPER_DEVICE=cpu 를 넣고 베이스만 사용
 docker compose up -d --build
 ```
 
@@ -113,7 +113,7 @@ docker compose up -d          # 유저봇이 로그인해 지정 음성채널에
 
 ### GPU 가속 (OS별)
 
-LLM(Ollama), Whisper STT, MeloTTS가 GPU에서 돕니다(env 기본 `WHISPER_DEVICE=cuda`, `MELO_DEVICE=cuda`). NVIDIA Blackwell(sm_120, 예: RTX 5050/5070Ti)에서 검증: 컨테이너 내 torch cu128 CUDA 동작, Ollama GPU 오프로드, faster-whisper float16, MeloTTS GPU 합성 모두 확인.
+LLM(Ollama)과 Whisper STT가 GPU에서 돕니다(env 기본 `WHISPER_DEVICE=cuda`). TTS는 기본값이 Edge TTS(온라인 한국어 음성)라 GPU를 쓰지 않습니다. NVIDIA Blackwell(sm_120, 예: RTX 5050/5070Ti)에서 검증: 컨테이너 내 torch cu128 CUDA 동작, Ollama GPU 오프로드, faster-whisper float16 모두 확인.
 
 GPU는 위 "실행 — Docker"의 OS별 override 파일로 켜집니다. 호스트 사전 준비는 OS마다 다릅니다:
 
@@ -137,7 +137,7 @@ docker run --rm --device nvidia.com/gpu=all ubuntu nvidia-smi -L   # GPU 보이
 **공통:**
 
 - 모델: 베이스 compose 기본은 `qwen2.5:3b`(8GB VRAM에서 도구호출 안정적). 더 무겁게(`qwen2.5:7b`, `qwen3:8b` 등) 쓰려면 `.env`의 `OLLAMA_CHAT_MODEL` 변경.
-- **GPU가 없거나 인식 실패 시 자동으로 CPU 폴백**(Whisper)하므로 안전합니다. 명시적으로 CPU만 쓰려면 override 파일 없이 베이스만 올리고 `.env`에 `WHISPER_DEVICE=cpu`, `MELO_DEVICE=cpu`를 두세요.
+- **GPU가 없거나 인식 실패 시 자동으로 CPU 폴백**(Whisper)하므로 안전합니다. 명시적으로 CPU만 쓰려면 override 파일 없이 베이스만 올리고 `.env`에 `WHISPER_DEVICE=cpu`를 두세요.
 
 - 데이터(메모리 DB), Whisper 캐시, Piper 음성은 named volume에 영속됩니다.
 - 셀프봇 영상 송출 의존성은 이미지에 기본 포함하지 않습니다. 쓰려면 컨테이너에서 `cd /app/bot && bun add discord.js-selfbot-v13 @dank074/discord-video-stream` 후 재시작(또는 Dockerfile에 추가).
@@ -243,7 +243,7 @@ cd bot; bun run register; bun run start   # 창 2: (일반 봇이면) 슬래시
 - `BRIDGE_URL` — 봇이 호출할 브릿지 주소 (기본 `http://127.0.0.1:8765`)
 - `STREAM_BACKEND`, `DISCORD_SELFBOT_TOKEN`, `NOVNC_URL` — 화면 송출
 - `VNC_DISPLAY=:1`, `VNC_RESOLUTION`, `VNC_FRAMERATE`, `VNC_BITRATE_KBPS` — 캡처
-- `WHISPER_DEVICE/COMPUTE_TYPE`, `MELO_DEVICE` — GPU 호스트면 `cuda`/`float16`, CPU 전용이면 `cpu`(GPU 자체는 OS별 override compose 파일로 켬)
+- `WHISPER_DEVICE/COMPUTE_TYPE` — GPU 호스트면 `cuda`/`float16`, CPU 전용이면 `cpu`(GPU 자체는 OS별 override compose 파일로 켬)
 - `OLLAMA_CHAT_MODEL` — 두뇌 LLM (기본 `qwen2.5:3b`)
 - `COMPOSE_FILE` — OS별 GPU override를 매번 `-f`로 안 치고 자동 적용 (위 "실행 — Docker" 참고)
 - `output_language` — 출력 언어 고정(비우면 사용자 언어). 설정 웹 UI(`/settings`)에서 바꾸면 env 기본값보다 우선하며 컨테이너 재생성 후에도 유지됩니다.

agents/llm.md

@@ -0,0 +1,13 @@
+# 자비스 운영자 지시
+
+- 너의 이름은 자비스다.
+- 모든 답변은 음성(TTS)으로 읽혀 나간다. 그러니 최대한 간결하게, 한두 문장으로 답한다. 목록, 마크다운, 이모지, 그리고 소리 내어 읽기 어려운 특수문자는 쓰지 않는다.
+- 정해진 문구에만 반응하지 말고, 실제 사람처럼 말의 뉘앙스와 맥락으로 의도를 알아듣고 처리한다.
+
+화면 속 크롬(방송 화면)에서 유튜브를 다룰 때 (화면에 보여야 하므로 반드시 on-screen 브라우저 제어 도구로 수행한다):
+
+- "유튜브 켜줘" → 방송 크롬에서 유튜브를 연다.
+- "유튜브에서 OO 검색해줘" → 유튜브로 가서 검색창에 OO를 사람이 직접 타이핑하듯 입력하고 검색한다.
+- "위에서 N번째 영상 재생해줘" 또는 "왼쪽에서 N번째 영상 재생해줘" → 검색 결과 목록에서 그 위치의 영상을 재생한다.
+- "일시정지해줘" → 현재 영상을 일시정지한다. "다시 재생해줘" → 이어서 재생한다.
+- "영상 종료" 또는 "그만 보여줘" → 뒤로 가서 직전 화면으로 돌아간다.

bot/scripts/stream-test/browse-search.mjs

@@ -2,10 +2,11 @@
 // 9222) so the action is visible on the Go-Live broadcast, and prints a JSON
 // result on stdout for the Python `browseAndSearch` tool to wrap.
 //
-//   node browse-search.mjs "<query>" [search|youtube]
+//   node browse-search.mjs "<query>" [search|youtube] [index]
 //
 // - search  : Google-search the query, return the top organic results.
-// - youtube : search YouTube and play the first result.
+// - youtube : search YouTube and play a result. `index` is the 1-based position
+//             from the top of the result list (default 1 = first result).
 //
 // Backend selection for `search`:
 //   1. The broadcast Chrome over CDP (visible on the Go-Live stream).
@@ -29,6 +30,9 @@ const UA =
   '(KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36';
 const query = process.argv[2] || '';
 const mode = (process.argv[3] || 'search').toLowerCase();
+// 1-based position of the YouTube result to play, counted from the top of the
+// list. Defaults to 1 (first result). Anything <1 or non-numeric falls back to 1.
+const playIndex = Math.max(1, parseInt(process.argv[4], 10) || 1);
 const out = (o) => { process.stdout.write(JSON.stringify(o)); };
 
 if (!query) { out({ ok: false, error: 'no query' }); process.exit(1); }
@@ -105,15 +109,21 @@ try {
   await page.bringToFront().catch(() => {});
 
   if (mode === 'youtube') {
-    // Type into YouTube's search box like a person, then play the first result.
+    // Type into YouTube's search box like a person, then play the requested
+    // result (the Nth from the top of the list; default the first).
     await typeSearch('https://www.youtube.com/?hl=ko', 'input#search, input[name="search_query"]', query);
     await page.waitForSelector('ytd-video-renderer a#video-title, a#video-title', { timeout: 20000 });
-    const first = page.locator('ytd-video-renderer a#video-title, a#video-title').first();
+    const results = page.locator('ytd-video-renderer a#video-title, a#video-title');
-    const title = (await first.getAttribute('title').catch(() => '')) || (await first.innerText().catch(() => ''));
+    // Clamp to what's actually on the page so "play the 5th" still plays the
-    await first.click();
+    // last available result rather than failing when fewer were returned.
+    const available = await results.count();
+    const targetIdx = Math.min(playIndex, Math.max(available, 1)) - 1;
+    const target = results.nth(targetIdx);
+    const title = (await target.getAttribute('title').catch(() => '')) || (await target.innerText().catch(() => ''));
+    await target.click();
     await page.waitForSelector('#movie_player', { timeout: 20000 });
     await page.evaluate(() => { const v = document.querySelector('video'); if (v && v.paused) v.play(); });
-    out({ ok: true, mode, title: (title || '').trim(), url: page.url() });
+    out({ ok: true, mode, index: targetIdx + 1, title: (title || '').trim(), url: page.url() });
   } else {
     // Type into Google's search box like a person, then read the results.
     await typeSearch('https://www.google.com/?hl=ko', 'textarea[name="q"], input[name="q"]', query);

bridge/requirements-bridge.txt

@@ -21,7 +21,11 @@ nvidia-cudnn-cu12
 # --- Bridge HTTP service ---
 flask>=3.0.0
 
-# --- Text-to-speech (Piper) ---
+# --- Text-to-speech ---
+# Edge TTS: the primary Korean voice (online MS neural). Lightweight (httpx);
+# emits MP3, transcoded to PCM16 by the system ffmpeg in the bridge.
+edge-tts>=6.1.0
+# Piper: offline English fallback.
 piper-tts>=1.3.0
 
 # --- Built-in tools (lazily imported; needed for full functionality) ---

bridge/server.py

@@ -87,12 +87,11 @@ VAD_MIN_SPEECH_MS = int(os.environ.get("VAD_MIN_SPEECH_MS", "200"))
 # Korean phrase decoded as Chinese) and shaves a little latency. Empty = auto.
 STT_LANGUAGE = os.environ.get("STT_LANGUAGE", "ko").strip() or None
 
-# TTS engine: "melo" (MeloTTS Korean speaker, the warm worker) is the primary
+# TTS engine: "edge" (Microsoft Edge TTS, natural Korean neural voice) is the
-# voice; Piper is kept as a fallback if the worker is unreachable. Set
+# primary voice. "melo" (a warm MeloTTS worker) and "piper" remain selectable.
-# TTS_ENGINE=piper to disable MeloTTS entirely.
 def _tts_engine_setting() -> str:
     """TTS engine: settings-UI value (runtime config JSON) wins, else env, else
-    melo. Read at startup; the settings UI restarts the bridge on apply."""
+    edge. Read at startup; the settings UI restarts the bridge on apply."""
     try:
         _cp = os.environ.get("JARVIS_CONFIG_PATH", "/app/config/jarvis.json")
         _v = json.loads(open(_cp, encoding="utf-8").read()).get("tts_engine")
@@ -100,16 +99,22 @@ def _tts_engine_setting() -> str:
             return str(_v).strip().lower()
     except Exception:
         pass
-    return os.environ.get("TTS_ENGINE", "melo").strip().lower()
+    return os.environ.get("TTS_ENGINE", "edge").strip().lower()
 
 
 TTS_ENGINE = _tts_engine_setting()
+# Edge TTS (online MS neural voice). Voice + rate are env-driven so they can be
+# changed without code. Default: Korean "Hyunsu" multilingual voice at +45%
+# (≈1.45×), the chosen settings. NOTE: edge synthesis sends the reply TEXT to
+# Microsoft's servers and needs internet — an intentional privacy trade-off for
+# the more natural voice.
+EDGE_TTS_VOICE = os.environ.get("EDGE_TTS_VOICE", "ko-KR-HyunsuMultilingualNeural").strip()
+EDGE_TTS_RATE = os.environ.get("EDGE_TTS_RATE", "+45%").strip()
 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
+# Do NOT silently fall back to the English Piper voice on a neural-voice failure:
-# voice on failure: speaking Korean text through an English voice produces
+# speaking Korean through an English voice produces mangled audio. Default is
-# mangled audio. Default is melo-only (return no audio on failure); set
+# neural-only (return no audio on failure); set MELO_FALLBACK_PIPER=1 to opt in.
-# 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")
 
 # ---------------------------------------------------------------------------
@@ -302,6 +307,54 @@ def _coerce_bool(value) -> Optional[bool]:
     return str(value).strip().lower() in ("1", "true", "yes", "on")
 
 
+def _edge_synthesize(text: str) -> Optional[bytes]:
+    """Synthesise via Microsoft Edge TTS (online neural voice) and return a
+    16-bit PCM WAV, or None on any failure. Edge emits MP3; we transcode to
+    PCM16 mono with the system ffmpeg, writing to a temp file (seekable) so the
+    WAV header carries a correct length. Needs internet."""
+    import asyncio
+    import subprocess
+    import tempfile
+
+    try:
+        import edge_tts  # type: ignore
+
+        async def _gen() -> bytes:
+            comm = edge_tts.Communicate(text, EDGE_TTS_VOICE, rate=EDGE_TTS_RATE)
+            buf = bytearray()
+            async for chunk in comm.stream():
+                if chunk.get("type") == "audio":
+                    buf.extend(chunk["data"])
+            return bytes(buf)
+
+        mp3 = asyncio.run(_gen())
+        if not mp3:
+            print("[bridge] edge TTS returned no audio", flush=True)
+            return None
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as t:
+            out_path = t.name
+        try:
+            proc = subprocess.run(
+                ["ffmpeg", "-hide_banner", "-loglevel", "error", "-y",
+                 "-i", "pipe:0", "-ac", "1", "-ar", "24000",
+                 "-acodec", "pcm_s16le", out_path],
+                input=mp3, capture_output=True,
+            )
+            if proc.returncode != 0:
+                print(f"[bridge] edge ffmpeg transcode failed: {proc.stderr.decode('utf-8','ignore')[:200]}", flush=True)
+                return None
+            with open(out_path, "rb") as f:
+                return f.read()
+        finally:
+            try:
+                os.unlink(out_path)
+            except OSError:
+                pass
+    except Exception as e:  # pragma: no cover - network / dep dependent
+        print(f"[bridge] edge synth failed: {e}", flush=True)
+    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
@@ -361,20 +414,22 @@ def _tts_ready() -> bool:
 
 
 def synthesize(text: str) -> Optional[bytes]:
-    """Synthesize text to a 16-bit PCM WAV. The primary voice is MeloTTS
+    """Synthesize text to a 16-bit PCM WAV. The primary voice is Edge TTS (a
-    (Korean speaker, speed 1.5) served by the warm melo worker; Piper is a
+    natural Korean neural voice); "melo" uses the warm MeloTTS worker. For a
-    fallback if the worker is unavailable. Returns None if TTS is off."""
+    neural engine, Piper (English) is only used if explicitly enabled, since
+    speaking Korean through an English voice mangles it. Returns None if off."""
     if not TTS_ENABLED or not text.strip():
         return None
-    if TTS_ENGINE == "melo":
+    _neural = {"edge": _edge_synthesize, "melo": _melo_synthesize}.get(TTS_ENGINE)
-        audio = _melo_synthesize(text)
+    if _neural is not None:
+        audio = _neural(text)
         if audio:
             return audio
         if not MELO_FALLBACK_PIPER:
-            # Melo-only: better silent than mangled English for Korean text.
+            # Neural-only: better silent than mangled English for Korean text.
-            print("[bridge] melo synth failed; no audio (Piper fallback disabled)", flush=True)
+            print(f"[bridge] {TTS_ENGINE} synth failed; no audio (Piper fallback disabled)", flush=True)
             return None
-        print("[bridge] melo synth failed; falling back to Piper", flush=True)
+        print(f"[bridge] {TTS_ENGINE} synth failed; falling back to Piper", flush=True)
     return _piper_synthesize(text)
 
 

bridge/settings_web.py

@@ -22,8 +22,7 @@ from typing import Any, Dict
 FIELDS = [
     ("ollama_chat_model", "LLM 모델", "model"),
     ("whisper_model", "STT(Whisper) 모델", "select:tiny,base,small,medium,large,large-v3"),
-    ("tts_engine", "TTS 엔진", "select:melo,piper"),
+    ("tts_engine", "TTS 엔진", "select:edge,piper"),
-    ("melo_speed", "TTS 속도 (MeloTTS)", "number:0.5:2.5:0.1"),
     ("output_language", "출력 언어 (비우면 사용자 언어)", "text"),
     ("llm_thinking_enabled", "LLM 사고(thinking) 모드", "bool"),
     ("agentic_max_turns", "에이전트 최대 반복", "number:1:12:1"),
@@ -54,9 +53,7 @@ def _current() -> Dict[str, Any]:
     cfg = _read_config()
     out: Dict[str, Any] = {}
     for k in _KEYS:
-        if k == "melo_speed":
+        if k == "output_language":
-            out[k] = cfg.get("melo_speed", os.environ.get("MELO_SPEED", "1.5"))
-        elif k == "output_language":
             out[k] = cfg.get("output_language", os.environ.get("OUTPUT_LANGUAGE", ""))
         else:
             out[k] = cfg.get(k, "")
@@ -78,12 +75,7 @@ def _coerce(updates: Dict[str, Any]) -> Dict[str, Any]:
     for k, v in updates.items():
         if k not in _KEYS:
             continue
-        if k == "melo_speed":
+        if k == "agentic_max_turns":
-            try:
-                v = float(v)
-            except (TypeError, ValueError):
-                continue
-        elif k == "agentic_max_turns":
             try:
                 v = int(v)
             except (TypeError, ValueError):
@@ -114,15 +106,15 @@ def _save(updates: Dict[str, Any]) -> None:
 
 
 def _apply() -> str:
-    # Restart melo + bridge AFTER this response is sent. Detached (new session)
+    # Restart the bridge AFTER this response is sent. Detached (new session) so
-    # so the bridge being killed mid-restart doesn't drop the restart itself,
+    # the bridge being killed mid-restart doesn't drop the restart itself, and
-    # and the HTTP client still receives this response.
+    # the HTTP client still receives this response. (Edge TTS has no worker.)
     try:
         subprocess.Popen(
-            ["sh", "-c", "sleep 1; supervisorctl restart melo-worker bridge"],
+            ["sh", "-c", "sleep 1; supervisorctl restart bridge"],
             start_new_session=True,
         )
-        return "1초 후 브리지/TTS 워커가 재시작되어 반영됩니다."
+        return "1초 후 브리지가 재시작되어 반영됩니다."
     except Exception as e:  # pragma: no cover
         return str(e)
 

docker-compose.yml

@@ -66,9 +66,15 @@ services:
       WHISPER_MODEL: ${WHISPER_MODEL:-medium}
       WHISPER_DEVICE: ${WHISPER_DEVICE:-cuda}
       WHISPER_COMPUTE_TYPE: ${WHISPER_COMPUTE_TYPE:-float16}
-      # MeloTTS on the GPU (cu128 torch baked by docker/setup-melo.sh). CPU synth
+      # TTS engine. Rendered into /app/config/jarvis.json via envsubst (the
-      # serialised under load and pushed TTS to 7-8s; GPU does ~0.3s/sentence.
+      # bridge reads that JSON BEFORE the env, so it must carry the real engine,
-      MELO_DEVICE: ${MELO_DEVICE:-cuda}
+      # not a hardcoded one — otherwise Korean text is read by the English Piper
+      # voice). Default edge; .env can override (e.g. piper for offline).
+      TTS_ENGINE: ${TTS_ENGINE:-edge}
+      # Edge TTS voice + rate (the chosen natural Korean voice). NOTE: edge is an
+      # ONLINE engine — reply text is sent to Microsoft and needs internet.
+      EDGE_TTS_VOICE: ${EDGE_TTS_VOICE:-ko-KR-HyunsuMultilingualNeural}
+      EDGE_TTS_RATE: ${EDGE_TTS_RATE:-+45%}
       # Optional single-language lock for replies (empty = user's own language).
       OUTPUT_LANGUAGE: ${OUTPUT_LANGUAGE:-ko}
       # Drop the pre-loop planner LLM call to cut voice-reply latency on small

docker/entrypoint.sh

@@ -16,6 +16,9 @@ set -euo pipefail
 # by default so everything runs on one resident model; override if you pull a
 # dedicated small model.
 : "${OLLAMA_INTENT_MODEL:=${OLLAMA_CHAT_MODEL}}"
+# Cap chat-model output tokens per turn (worst-case latency guard). Spoken
+# answers are 1-2 sentences; 512 is safe headroom above tool-call JSON. 0 = off.
+: "${OLLAMA_NUM_PREDICT:=512}"
 : "${OLLAMA_EMBED_MODEL:=nomic-embed-text}"
 : "${WHISPER_MODEL:=small}"
 : "${WHISPER_DEVICE:=cuda}"
@@ -32,7 +35,7 @@ set -euo pipefail
 : "${XDG_RUNTIME_DIR:=/run/user/0}"
 : "${PULSE_SERVER:=unix:${XDG_RUNTIME_DIR}/pulse/native}"
 
-export VNC_RESOLUTION OLLAMA_BASE_URL OLLAMA_CHAT_MODEL OLLAMA_INTENT_MODEL OLLAMA_EMBED_MODEL \
+export VNC_RESOLUTION OLLAMA_BASE_URL OLLAMA_CHAT_MODEL OLLAMA_NUM_PREDICT OLLAMA_INTENT_MODEL OLLAMA_EMBED_MODEL \
        WHISPER_MODEL WHISPER_DEVICE WHISPER_COMPUTE_TYPE JARVIS_DB_PATH \
        PIPER_VOICE PIPER_VOICE_DIR TTS_PIPER_MODEL_PATH BRIDGE_HOST BRIDGE_PORT \
        XDG_RUNTIME_DIR PULSE_SERVER
@@ -51,12 +54,18 @@ export JARVIS_CONFIG_PATH=/app/config/jarvis.json
 # the env-rendered config, so changes survive container recreate.
 if [ -f /data/jarvis-settings.json ]; then
   python3 - <<'PY' || true
-import json
+import json, os
 try:
     base = json.load(open("/app/config/jarvis.json"))
     ov = json.load(open("/data/jarvis-settings.json"))
     if isinstance(base, dict) and isinstance(ov, dict):
         base.update(ov)
+        # A stale persisted tts_engine from an earlier voice (melo/xtts, no
+        # longer built into the image) would override the configured engine and
+        # leave the bot silent. Reset those to the env-configured engine.
+        if base.get("tts_engine") in ("melo", "xtts"):
+            base["tts_engine"] = os.environ.get("TTS_ENGINE", "edge")
+            print(f"[entrypoint] reset stale tts_engine -> {base['tts_engine']}")
         json.dump(base, open("/app/config/jarvis.json", "w"), ensure_ascii=False, indent=2)
         print("[entrypoint] merged persistent settings overrides")
 except Exception as e:

docker/jarvis-config.template.json

@@ -4,9 +4,10 @@
   "ollama_base_url": "${OLLAMA_BASE_URL}",
   "ollama_embed_model": "${OLLAMA_EMBED_MODEL}",
   "ollama_chat_model": "${OLLAMA_CHAT_MODEL}",
+  "ollama_num_predict": "${OLLAMA_NUM_PREDICT}",
   "intent_judge_model": "${OLLAMA_INTENT_MODEL}",
   "tts_enabled": true,
-  "tts_engine": "piper",
+  "tts_engine": "${TTS_ENGINE}",
   "tts_piper_model_path": "${TTS_PIPER_MODEL_PATH}",
   "whisper_model": "${WHISPER_MODEL}",
   "whisper_backend": "faster-whisper",

docker/run-chrome.sh

@@ -18,6 +18,27 @@ cat > /etc/opt/chrome/policies/managed/jarvis.json <<'JSON'
 { "CommandLineFlagSecurityWarningsEnabled": false }
 JSON
 
+# Seed the profile's web-content language to Korean so sites (YouTube, Google,
+# Naver) render in Korean. --lang sets Chrome's own UI, but the Accept-Language
+# sent to sites comes from the profile's intl.accept_languages, which a persisted
+# user-data-dir would otherwise keep at en-US regardless of --accept-lang.
+PREFS_DIR="${CHROME_PROFILE_DIR:-/root/chrome-profile}/Default"
+PREFS="${PREFS_DIR}/Preferences"
+mkdir -p "$PREFS_DIR"
+if [ -f "$PREFS" ]; then
+  python3 - "$PREFS" <<'PY' 2>/dev/null || true
+import json, sys
+p = sys.argv[1]
+d = json.load(open(p))
+d.setdefault("intl", {})
+d["intl"]["accept_languages"] = "ko-KR,ko"
+d["intl"]["selected_languages"] = "ko-KR,ko"
+json.dump(d, open(p, "w"), ensure_ascii=False)
+PY
+else
+  printf '%s' '{"intl":{"accept_languages":"ko-KR,ko","selected_languages":"ko-KR,ko"}}' > "$PREFS"
+fi
+
 # Minimal, non-automation flags. --remote-debugging exposes CDP so the brain can
 # drive this on-screen Chrome (Google/YouTube/Naver), --disable-features=Translate
 # hides the translate popup. NO --test-type / --disable-blink-features.
@@ -26,6 +47,7 @@ exec google-chrome \
   --no-default-browser-check \
   --disable-features=Translate,TranslateUI \
   --lang=ko-KR \
+  --accept-lang=ko-KR,ko \
   --remote-debugging-port="${CDP_PORT:-9222}" \
   --remote-debugging-address="${CDP_BIND:-127.0.0.1}" \
   --user-data-dir="${CHROME_PROFILE_DIR:-/root/chrome-profile}" \

docker/supervisord.conf

@@ -49,28 +49,8 @@ stdout_logfile_maxbytes=0
 stderr_logfile=/dev/stderr
 stderr_logfile_maxbytes=0
 
-[program:melo-worker]
+# (No TTS worker program: the default Edge TTS engine synthesises in-process in
-; Warm MeloTTS Korean voice (speed 1.5) in its own py3.11 venv. The bridge's
+# the bridge via the `edge-tts` package — no warm model/worker is needed.)
-; synthesize() POSTs here; if this is down the bridge falls back to Piper.
-command=/app/docker/run-if-role.sh full,bot /opt/melo/bin/python /app/bridge/melo_worker.py
-directory=/app
-; HF_HOME points at the dedicated, image-baked melo cache (warmed in
-; setup-melo.sh). The brain's whisper_cache volume is mounted over
-; /root/.cache/huggingface, so without this the pre-cached BERT + KR checkpoint
-; would be shadowed and re-downloaded (and would fail if the host is offline).
-; HF_HUB_OFFLINE/TRANSFORMERS_OFFLINE force pure-cache reads: the pinned old
-; transformers/huggingface_hub otherwise retry the network on every load and
-; error out instead of falling back to the (complete) baked cache.
-; MELO_DEVICE inherits from the container env (compose sets it; default cuda)
-; so the worker runs MeloTTS on the GPU. supervisord interpolates %(ENV_x)s
-; from its own environment, which is the container's.
-environment=MELO_LANGUAGE="KR",MELO_SPEED="1.5",MELO_DEVICE="%(ENV_MELO_DEVICE)s",MELO_WORKER_HOST="127.0.0.1",MELO_WORKER_PORT="8770",HF_HOME="/opt/melo-cache",HF_HUB_OFFLINE="1",TRANSFORMERS_OFFLINE="1"
-priority=280
-autorestart=true
-stdout_logfile=/dev/stdout
-stdout_logfile_maxbytes=0
-stderr_logfile=/dev/stderr
-stderr_logfile_maxbytes=0
 
 [program:bridge]
 command=/app/docker/run-if-role.sh full,bot /opt/venv/bin/python -m bridge.server

docs/llm_contexts.md

@@ -20,7 +20,7 @@ Every distinct LLM call in Jarvis, what feeds it, what consumes it, and how it i
   - Tool schema: native via `generate_tools_json_schema()` ([src/jarvis/tools/registry.py](src/jarvis/tools/registry.py)) or text fallback via `_text_tool_call_guidance()` ([engine.py:68](src/jarvis/reply/engine.py:68))
   - Tool results from prior turns (raw or digested — see #5)
 - **Output**: OpenAI-style `{content, tool_calls, thinking}`. Consumed by the tool orchestrator and TTS pipeline. Natural-language content is delivered immediately; no post-turn evaluator runs.
-- **Limits**: `num_ctx: 8192` (explicit). Timeout `llm_chat_timeout_sec` (45s). Auto-fallback from native to text tool-calls on HTTP 400 (`ToolsNotSupportedError`), sticky for the session. Risk: `fetch_web_page` truncates at 50,000 chars (~37k tokens) — mitigated for SMALL models by tool-result digest (#5) which compresses the payload before it enters the messages history. LARGE models receive the raw payload and may silently see a truncated context.
+- **Limits**: `num_ctx: 8192` (explicit). Output `num_predict: cfg.ollama_num_predict` (default 512, `0`/negative disables) caps generated tokens per turn — a worst-case latency guard for short spoken answers; the headroom stays above tool-call JSON so it does not truncate tool calls (both native and text tool-call paths). Timeout `llm_chat_timeout_sec` (45s). Auto-fallback from native to text tool-calls on HTTP 400 (`ToolsNotSupportedError`), sticky for the session. Risk: `fetch_web_page` truncates at 50,000 chars (~37k tokens) — mitigated for SMALL models by tool-result digest (#5) which compresses the payload before it enters the messages history. LARGE models receive the raw payload and may silently see a truncated context.
 
 ## 2. Intent Judge
 

src/jarvis/config.py

@@ -85,6 +85,12 @@ class Settings:
     llm_digest_timeout_sec: float
     llm_embedding_timeout_sec: float
     llm_profile_select_timeout_sec: float
+    # Upper bound on tokens the chat model may generate per reply turn. Spoken
+    # (TTS) answers are 1-2 sentences, so a cap bounds the worst-case latency of
+    # a model that occasionally rambles or loops without changing normal answers.
+    # The headroom (default 512) sits well above this app's short tool-call JSON,
+    # so capping never truncates a tool call. 0 (or negative) disables the cap.
+    ollama_num_predict: int
 
     # Profiles & Behavior
     active_profiles: list[str]
@@ -394,6 +400,9 @@ def get_default_config() -> Dict[str, Any]:
         "llm_digest_timeout_sec": 8.0,
         "llm_embedding_timeout_sec": 60.0,
         "llm_profile_select_timeout_sec": 30.0,
+        # Cap on chat-model output tokens per turn (worst-case latency guard).
+        # 512 is safe headroom above short TTS answers and tool-call JSON; 0 off.
+        "ollama_num_predict": 512,
 
         # Profiles & Behavior
         "active_profiles": ["developer", "business", "life"],
@@ -608,7 +617,11 @@ def load_settings() -> Settings:
     active_profiles = _ensure_list(merged.get("active_profiles"))
     tts_enabled = bool(merged.get("tts_enabled", True))
     tts_engine = str(merged.get("tts_engine", "piper")).lower()
-    if tts_engine not in ("piper", "chatterbox"):
+    # "edge" (Microsoft Edge TTS) is the containerized bridge's Korean voice;
+    # "melo" is the legacy warm-worker voice. Both are multilingual, so they must
+    # be preserved here — coercing them to "piper" would mislabel the engine as
+    # English-only in reply_language_directive().
+    if tts_engine not in ("piper", "chatterbox", "edge", "melo"):
         tts_engine = "piper"  # Default to piper if invalid value
     tts_voice_val = merged.get("tts_voice")
     tts_voice = None if tts_voice_val in (None, "", "null") else str(tts_voice_val)
@@ -759,6 +772,10 @@ def load_settings() -> Settings:
     llm_digest_timeout_sec = float(merged.get("llm_digest_timeout_sec", 8.0))
     llm_embedding_timeout_sec = float(merged.get("llm_embedding_timeout_sec", 60.0))
     llm_profile_select_timeout_sec = float(merged.get("llm_profile_select_timeout_sec", 30.0))
+    try:
+        ollama_num_predict = int(merged.get("ollama_num_predict", 512))
+    except (TypeError, ValueError):
+        ollama_num_predict = 512
 
     return Settings(
         # Database & Storage
@@ -774,6 +791,7 @@ def load_settings() -> Settings:
         llm_digest_timeout_sec=llm_digest_timeout_sec,
         llm_embedding_timeout_sec=llm_embedding_timeout_sec,
         llm_profile_select_timeout_sec=llm_profile_select_timeout_sec,
+        ollama_num_predict=ollama_num_predict,
 
         # Profiles & Behavior
         active_profiles=active_profiles,

src/jarvis/reply/engine.py

@@ -2233,6 +2233,16 @@ def run_reply_engine(db: "Database", cfg, tts: Optional[Any],
                 has_tool_calls = " (has tool_calls)" if msg.get("tool_calls") else ""
                 debug_log(f"    [{i}] {role}: {content}{has_tool_calls}", "planning")
 
+        # Bound worst-case generation latency: spoken answers are 1-2 sentences,
+        # so cap the chat model's output tokens. The default headroom sits well
+        # above this app's tool-call JSON, so capping never truncates a tool
+        # call. 0/negative disables it. See config.ollama_num_predict.
+        try:
+            _num_predict = int(getattr(cfg, 'ollama_num_predict', 0) or 0)
+        except (TypeError, ValueError):
+            _num_predict = 0
+        _chat_extra_options = {"num_predict": _num_predict} if _num_predict > 0 else None
+
         # Send messages to Ollama — try native tool calling first, fall back to text-based
         # if the model returns HTTP 400 (native tools API not supported).
         _dump_tools_schema = None if use_text_tools else tools_json_schema
@@ -2242,7 +2252,7 @@ def run_reply_engine(db: "Database", cfg, tts: Optional[Any],
                 chat_model=cfg.ollama_chat_model,
                 messages=messages,
                 timeout_sec=float(getattr(cfg, 'llm_chat_timeout_sec', 45.0)),
-                extra_options=None,
+                extra_options=_chat_extra_options,
                 tools=_dump_tools_schema,
                 thinking=getattr(cfg, 'llm_thinking_enabled', False),
             )
@@ -2273,7 +2283,7 @@ def run_reply_engine(db: "Database", cfg, tts: Optional[Any],
                 chat_model=cfg.ollama_chat_model,
                 messages=messages,
                 timeout_sec=float(getattr(cfg, 'llm_chat_timeout_sec', 45.0)),
-                extra_options=None,
+                extra_options=_chat_extra_options,
                 tools=None,
                 thinking=getattr(cfg, 'llm_thinking_enabled', False),
             )

src/jarvis/reply/reply.spec.md

@@ -287,6 +287,8 @@ Turn 4: LLM → {content: "Here's a comprehensive comparison of the iPhone 15 mo
   - `llm_tools_timeout_sec` (enrichment extraction)
   - `llm_embed_timeout_sec` (vector search)
   - `llm_chat_timeout_sec` (messages loop turn)
+- Output bound:
+  - `ollama_num_predict` (default `512`, `0`/negative disables) caps the chat model's generated tokens per turn via the Ollama `num_predict` option on the messages-loop call. Spoken (TTS) answers are 1-2 sentences, so this never clips a normal answer; it bounds the worst-case latency of a model that occasionally rambles or loops. The default headroom sits well above this app's short tool-call JSON, so it does not truncate tool calls. Applied uniformly to the reply loop's chat call (both native-tools and text-tools paths); the small classification passes (intent judge, digests) keep their own caps. Note: this is a worst-case guard, not the primary latency lever, which is model size and GPU residency.
 - Memory enrichment:
   - `memory_enrichment_max_results` limits recalled snippets.
   - `memory_digest_enabled` (default `null` = auto-on for SMALL models ≤7B, off for LARGE) distils the combined diary + graph dump into a short relevance-filtered note via a cheap LLM pass before injecting into the system prompt. See **Memory Digest for Small Models** below.

src/jarvis/tools/builtin/browse_and_play.py

@@ -30,8 +30,10 @@ class BrowseAndPlayTool(Tool):
     def description(self) -> str:
         return (
             "Play a song / music video / clip on the shared screen by searching YouTube "
-            "and playing the first result. Use when the user asks you to play or watch "
+            "and playing a result. Use when the user asks you to play or watch "
-            "something. Only available in screen-share mode."
+            "something. Plays the first result by default; pass 'index' to play the "
+            "Nth result from the top of the search list (e.g. 'play the 3rd video' -> "
+            "index=3). Only available in screen-share mode."
         )
 
     @property
@@ -42,7 +44,16 @@ class BrowseAndPlayTool(Tool):
                 "query": {
                     "type": "string",
                     "description": "What to play, e.g. 'IU Good Day' or 'lofi hip hop'.",
-                }
+                },
+                "index": {
+                    "type": "integer",
+                    "description": (
+                        "1-based position of the video to play in the search results, "
+                        "counted from the top of the list. Defaults to 1 (first result). "
+                        "Use for 'play the Nth video' / 'play the second one'."
+                    ),
+                    "minimum": 1,
+                },
             },
             "required": ["query"],
         }
@@ -55,18 +66,25 @@ class BrowseAndPlayTool(Tool):
                 reply_text="화면 공유 모드(STREAM_BROWSER=true)에서만 영상을 재생할 수 있습니다.",
             )
         query = ""
+        index = 1
         if args and isinstance(args, dict):
             query = str(args.get("query", "")).strip()
+            try:
+                index = int(args.get("index", 1) or 1)
+            except (TypeError, ValueError):
+                index = 1
+            if index < 1:
+                index = 1
         if not query:
             return ToolExecutionResult(success=False, reply_text="재생할 내용을 알려주세요.")
         if not _NODE_SCRIPT.exists():
             return ToolExecutionResult(success=False, reply_text="브라우저 재생 도구를 찾을 수 없습니다.")
 
-        context.user_print(f"▶️ 화면에서 '{query}' 재생 중…")
+        context.user_print(f"▶️ 화면에서 '{query}' 재생 중… (#{index})")
-        debug_log(f"    ▶️ browseAndPlay '{query}'", "tools")
+        debug_log(f"    ▶️ browseAndPlay '{query}' index={index}", "tools")
         try:
             proc = subprocess.run(
-                ["node", str(_NODE_SCRIPT), query, "youtube"],
+                ["node", str(_NODE_SCRIPT), query, "youtube", str(index)],
                 capture_output=True,
                 text=True,
                 timeout=40,

src/jarvis/tools/builtin/browse_and_play.spec.md

@@ -6,16 +6,24 @@ video, or clip.
 
 ### Behaviour
 
-- Public schema is a single required `query` string (what to play).
+- Public schema is a required `query` string (what to play) plus an optional
+  `index` integer (1-based position in the search results, counted from the top
+  of the list). `index` defaults to `1` (first result), so existing callers and
+  "play X" requests are unchanged; "play the 3rd video" / "play the second one"
+  map to `index=3` / `index=2`.
 - **Mode-gated**: only acts when `STREAM_BROWSER` is true (`cfg.stream_browser`).
   In voice-only mode (false) there is no screen to show, so it returns a short
   message and does nothing.
 - Drives the on-screen Chrome by subprocessing the Node CDP helper
-  `bot/scripts/stream-test/browse-search.mjs <query> youtube`, which searches
+  `bot/scripts/stream-test/browse-search.mjs <query> youtube <index>`, which
-  YouTube and plays the first result on display `:1`. The broadcast captures
+  searches YouTube and plays the chosen result on display `:1`. The broadcast
-  that display, so the playback is what viewers see.
+  captures that display, so the playback is what viewers see.
-- Returns `success` with the played video's title, or a failure message if the
+  - The helper clicks the `index`-th `a#video-title` in the results list. The
-  helper/Chrome is unavailable. It does NOT make an LLM call.
+    index is clamped to the number of results actually returned, so asking for a
+    position beyond the list plays the last available result rather than failing.
+- Returns `success` with the played video's title (and the resolved `index`), or
+  a failure message if the helper/Chrome is unavailable. It does NOT make an LLM
+  call.
 
 ### Principles
 

tests/test_browse_and_play_index.py

@@ -0,0 +1,79 @@
+"""Tests for browseAndPlay's ``index`` argument (play the Nth search result).
+
+Behaviour verified:
+- default plays the first result (index 1) and stays backward-compatible,
+- an explicit index is forwarded to the Node helper as the 4th argv,
+- bad / sub-1 index values clamp to 1,
+- the index is advertised in the tool schema.
+"""
+
+import json
+from unittest.mock import Mock, patch
+
+import pytest
+
+from src.jarvis.tools.builtin.browse_and_play import BrowseAndPlayTool, _NODE_SCRIPT
+
+
+def _ctx():
+    cfg = Mock()
+    cfg.stream_browser = True
+    return Mock(cfg=cfg, user_print=Mock())
+
+
+def _run(args):
+    tool = BrowseAndPlayTool()
+    with patch("src.jarvis.tools.builtin.browse_and_play.subprocess.run") as mock_run:
+        mock_run.return_value = Mock(
+            stdout=json.dumps({"ok": True, "title": "Some Video"}),
+            stderr="",
+        )
+        result = tool.run(args, _ctx())
+        return mock_run, result
+
+
+def _argv(mock_run):
+    return list(mock_run.call_args[0][0])
+
+
+@pytest.mark.unit
+def test_schema_exposes_index():
+    schema = BrowseAndPlayTool().inputSchema
+    assert "index" in schema["properties"]
+    assert schema["properties"]["index"]["type"] == "integer"
+    assert "query" in schema["required"]
+    assert "index" not in schema["required"]  # optional
+
+
+@pytest.mark.unit
+def test_default_index_is_first():
+    mock_run, result = _run({"query": "IU Good Day"})
+    argv = _argv(mock_run)
+    assert argv[:4] == ["node", str(_NODE_SCRIPT), "IU Good Day", "youtube"]
+    assert argv[4] == "1"
+    assert result.success is True
+
+
+@pytest.mark.unit
+def test_explicit_index_forwarded():
+    mock_run, _ = _run({"query": "lofi", "index": 3})
+    assert _argv(mock_run)[4] == "3"
+
+
+@pytest.mark.unit
+@pytest.mark.parametrize("bad", [0, -2, "nope", None])
+def test_bad_index_clamps_to_one(bad):
+    mock_run, _ = _run({"query": "lofi", "index": bad})
+    assert _argv(mock_run)[4] == "1"
+
+
+@pytest.mark.unit
+def test_voice_only_mode_does_not_play():
+    tool = BrowseAndPlayTool()
+    cfg = Mock()
+    cfg.stream_browser = False
+    ctx = Mock(cfg=cfg, user_print=Mock())
+    with patch("src.jarvis.tools.builtin.browse_and_play.subprocess.run") as mock_run:
+        result = tool.run({"query": "x", "index": 2}, ctx)
+    assert result.success is False
+    mock_run.assert_not_called()

tests/test_ollama_num_predict.py

@@ -0,0 +1,112 @@
+"""Tests for the ``ollama_num_predict`` chat-output cap.
+
+The cap bounds worst-case reply latency by limiting how many tokens the chat
+model may generate per turn. Spoken (TTS) answers are 1-2 sentences, so the
+default headroom never clips a normal answer and stays above tool-call JSON.
+
+These tests verify behaviour:
+- the config default is present,
+- the value is threaded into the Ollama request as the ``num_predict`` option,
+- the reply loop forwards it to the chat call (and disables it at 0).
+"""
+
+from unittest.mock import Mock, patch
+
+import pytest
+
+from src.jarvis.config import get_default_config
+from src.jarvis.memory.conversation import DialogueMemory
+from src.jarvis.reply.engine import run_reply_engine
+
+
+# ---------------------------------------------------------------------------
+# Config default
+# ---------------------------------------------------------------------------
+
+def test_default_config_has_num_predict_cap():
+    config = get_default_config()
+    assert config["ollama_num_predict"] == 512
+
+
+# ---------------------------------------------------------------------------
+# Transport: extra_options.num_predict reaches the Ollama payload options
+# ---------------------------------------------------------------------------
+
+@patch("jarvis.llm.requests.post")
+def test_chat_with_messages_forwards_num_predict(mock_post):
+    from jarvis.llm import chat_with_messages
+
+    mock_resp = Mock()
+    mock_resp.status_code = 200
+    mock_resp.json.return_value = {"message": {"content": "ok"}}
+    mock_resp.raise_for_status = Mock()
+    mock_post.return_value = mock_resp
+
+    chat_with_messages(
+        "http://localhost:11434",
+        "test-large",
+        [{"role": "user", "content": "hi"}],
+        extra_options={"num_predict": 512},
+    )
+    _, kwargs = mock_post.call_args
+    options = (kwargs.get("json") or {}).get("options") or {}
+    assert options.get("num_predict") == 512
+
+
+# ---------------------------------------------------------------------------
+# Reply loop wiring
+# ---------------------------------------------------------------------------
+
+def _mock_cfg(num_predict):
+    cfg = Mock()
+    cfg.ollama_base_url = "http://localhost:11434"
+    cfg.ollama_chat_model = "test-large"  # avoid SMALL-model text-tool path
+    cfg.ollama_num_predict = num_predict
+    cfg.voice_debug = False
+    cfg.llm_tools_timeout_sec = 8.0
+    cfg.llm_embed_timeout_sec = 10.0
+    cfg.llm_chat_timeout_sec = 45.0
+    cfg.llm_digest_timeout_sec = 8.0
+    cfg.memory_enrichment_max_results = 5
+    cfg.memory_enrichment_source = "diary"
+    cfg.memory_digest_enabled = False
+    cfg.tool_result_digest_enabled = False
+    cfg.location_ip_address = None
+    cfg.location_auto_detect = False
+    cfg.location_enabled = False
+    cfg.agentic_max_turns = 8
+    cfg.tool_search_max_calls = 3
+    cfg.tool_selection_strategy = "all"
+    cfg.tool_carryover_max_turns = 2
+    cfg.tool_carryover_per_entry_chars = 1200
+    cfg.mcps = {}
+    cfg.llm_thinking_enabled = False
+    cfg.tts_engine = "none"
+    cfg.ollama_embed_model = "test-embed"
+    return cfg
+
+
+def _run_single_turn(cfg):
+    """Drive one reply turn that answers in plain text and capture the
+    chat call's extra_options."""
+    with patch("src.jarvis.reply.engine.plan_query", return_value=[]), \
+         patch("src.jarvis.reply.engine.extract_search_params_for_memory", return_value={}), \
+         patch("src.jarvis.reply.engine.extract_text_from_response", return_value="Hello."), \
+         patch("src.jarvis.reply.engine.chat_with_messages") as mock_chat:
+        mock_chat.return_value = {"message": {"content": "Hello."}}
+        run_reply_engine(db=Mock(), cfg=cfg, tts=None,
+                         text="hi", dialogue_memory=DialogueMemory())
+        assert mock_chat.called
+        return mock_chat.call_args.kwargs.get("extra_options")
+
+
+@pytest.mark.unit
+def test_reply_loop_caps_output_when_enabled():
+    extra = _run_single_turn(_mock_cfg(512))
+    assert extra == {"num_predict": 512}
+
+
+@pytest.mark.unit
+def test_reply_loop_no_cap_when_zero():
+    extra = _run_single_turn(_mock_cfg(0))
+    assert extra is None

tests/test_system_prompt.py

@@ -110,6 +110,14 @@ class TestReplyLanguageDirective:
         directive = reply_language_directive("Korean", "melo")
         assert directive is not None and "Korean" in directive
 
+    def test_edge_is_multilingual(self):
+        # Edge TTS (the default Korean voice) is not English-only: no lock → the
+        # user's own language, and a lock is honoured (not forced to English).
+        assert reply_language_directive(None, "edge") is None
+        directive = reply_language_directive("Korean", "edge")
+        assert directive is not None and "Korean" in directive
+        assert directive != ENGLISH_ONLY_DIRECTIVE
+
 
 class TestLoadAgentInstructions:
     """Operator can extend the reply LLM's system prompt by dropping *.md files

tests/test_tts_engine_config.py

@@ -0,0 +1,35 @@
+"""The container's TTS engine must be env-driven, not hardcoded.
+
+Regression for a bug where docker/jarvis-config.template.json hardcoded
+`"tts_engine": "piper"`. The bridge reads the rendered /app/config/jarvis.json
+*before* the environment, so a hardcoded "piper" overrode `TTS_ENGINE=melo` in
+.env and the bot read Korean text with the English Piper voice ("foreign
+accent"). The template must carry `${TTS_ENGINE}` so envsubst (entrypoint.sh)
+renders whatever engine the deployment configured.
+"""
+
+import json
+import string
+from pathlib import Path
+
+TEMPLATE = Path(__file__).resolve().parent.parent / "docker" / "jarvis-config.template.json"
+
+
+def _render(**env) -> dict:
+    """Mimic entrypoint.sh `envsubst < template`: substitute env vars, leaving
+    any unset ones as literal text (valid JSON string values)."""
+    raw = TEMPLATE.read_text(encoding="utf-8")
+    return json.loads(string.Template(raw).safe_substitute(**env))
+
+
+def test_template_does_not_hardcode_an_engine():
+    raw = TEMPLATE.read_text(encoding="utf-8")
+    assert '"tts_engine": "${TTS_ENGINE}"' in raw
+    assert '"tts_engine": "piper"' not in raw
+    assert '"tts_engine": "melo"' not in raw
+
+
+def test_rendered_engine_follows_env():
+    assert _render(TTS_ENGINE="melo")["tts_engine"] == "melo"
+    assert _render(TTS_ENGINE="piper")["tts_engine"] == "piper"
+    assert _render(TTS_ENGINE="xtts")["tts_engine"] == "xtts"