diff --git a/.env.example b/.env.example
index 0e0f312..fcdf77c 100644
--- a/.env.example
+++ b/.env.example
@@ -20,6 +20,25 @@ TTS_REFERENCE_AUDIO=/root/pipecat-voice/voice_profiles/solis.wav
 # otherwise the raw string is used. Leave empty to auto-load <audio>.txt.
 TTS_REFERENCE_TEXT=/root/pipecat-voice/voice_profiles/solis.txt
 
+# --- Drama 3 de-emphasis (TTS_ENGINE=fish) ---
+# Drama 3 can sound overly theatrical/recitative. Two knobs trim that register
+# without changing the voice reference. Leave a sampling variable EMPTY to omit
+# the field and fall back to the server default.
+# Sampling temperature sent to SGLang. Lower values reduce over-articulation;
+# the recitative "radio drama" register lives in the distribution tails, so a
+# lower value makes the delivery flatter. Tunable range: 0.3–0.6.
+TTS_TEMPERATURE=0.45
+# Nucleus sampling top-p: trims the tail of the acoustic token distribution
+# (exaggerated intonations). 0.7–0.8 is the useful range.
+TTS_TOP_P=0.75
+# Optional top-k. Leave empty to omit the field (server default).
+TTS_TOP_K=
+# Neutral style tag prepended to every synthesis request that does not already
+# start with a "[...]" tag. LLM replies carry no tag (the system prompt forbids
+# stage directions), so they get this register; clip banks with their own tag
+# are left untouched. Empty disables the prefix.
+TTS_STYLE_TAG="[conversational, casual]"
+
 # --- Kokoro (TTS_ENGINE=kokoro) ---
 KOKORO_URL=http://localhost:8880
 KOKORO_VOICE=af_heart
@@ -71,15 +90,50 @@ FILLER_ENABLED=true
 FILLER_DELAY_MS=2500
 FILLER_GAIN_IDLE=1.0
 FILLER_GAIN_DUCK=0.15
+# --- Start filler (turn-start acknowledgment when the reply is late) ---
+# A second latency mask, on its own mixer channel: if the first audio chunk of
+# the reply has not reached the mixer within START_FILLER_GO_DELAY ms, one of the
+# phrases below (picked at random) is played so the agent acknowledges the turn
+# while the LLM/TTS are still working. If audio arrives in time the cue is
+# dropped. It shares the filler gain, so it ducks out of the way once the reply
+# starts.
+START_FILLER_ENABLED=true
+# How long (ms) to wait for the first audio chunk of the reply before playing the
+# start filler (default 1200). Measured from chunk ARRIVAL (not from playback
+# start, which would also include the TTS_PREBUFFER_MS jitter buffer). Same idea
+# as FILLER_DELAY_MS, but shorter.
+START_FILLER_GO_DELAY=500
+# Phrases spoken by the start filler, ONE PER LINE (a single line with "|"
+# separators also works). One clip is synthesized per phrase and a RANDOM one is
+# played when the reply is late, so the cue varies turn to turn. The bank follows
+# this list: editing it triggers a full re-synthesis at the next restart (no
+# manual deletion needed), phrases dropped here are deleted on disk, and a
+# failed synthesis keeps the previous clip. An unchanged list is skipped, so
+# startup stays fast. Drama-3 style tags ([calm], [sigh], ...) are passed
+# through to the TTS.
+START_FILLER_TEXTS="[calm] Un momento...
+[thoughtful] A ver, veamos...
+[hesitant] Entonces... echemos un vistazo...
+[sigh] Vale, ya voy..."
+# Directory holding the start-filler clips (kept separate from FILLERS_DIR so
+# they are not added to the round-robin filler bank).
+START_FILLER_DIR=assets/start_filler
 # TTS jitter buffer (ms): how much synthesized audio the mixer buffers before it
 # starts playing the reply. Lower values start speaking sooner; higher values
 # absorb uneven TTS chunk arrival at the cost of added latency. Drama-3's vocoder
-# emits audio in windows of `stream_followup_stride` codec frames (2048 samples =
-# 46.4 ms each); with the recommended server setting (stride 16, ramp
-# "[10,12,16]") the first window is 10 frames = 0.464 s, so 450 ms starts
-# playback on that very first window. Mid-reply underruns resume as soon as any
-# audio is queued again (no full refill).
-TTS_PREBUFFER_MS=450
+# emits audio in windows of codec frames (2048 samples = 46.4 ms each); with the
+# recommended server setting (stride 4, followup 8, overlap 16, crossfade 512)
+# the first window is 4 frames = 185.8 ms and the steady windows are 8 frames =
+# 371.6 ms. The first arrives at the server TTFB (~0.38 s) and the second ~350 ms
+# later, so ANY value in (186, 557] ms primes on the same second window (TTFA
+# ~0.73 s); 550 ms takes the whole ~557 ms cushion for free. That cushion absorbs
+# the drain when several TTS requests share one GPU and produce slower than real
+# time (measured ~1.5x concurrent vs ~0.94x alone); without it every chunk seam
+# starves the queue and pauses playback (a micro-gap at each sentence start).
+# Below ~186 ms playback starts on the first window (TTFA ~= server TTFB) but
+# leaves almost no cushion. Mid-reply underruns resume as soon as any audio is
+# queued again (no refill).
+TTS_PREBUFFER_MS=550
 # Number of TTS requests kept in flight at once. Reply chunks are synthesized
 # ahead of playback (and replayed in order) so each request's start-up latency
 # hides behind the previous chunk's audio instead of leaving an audible gap.
@@ -89,18 +143,98 @@ TTS_PIPELINE_DEPTH=3
 # --- Backchannel (short acknowledgments while the user speaks) ---
 # Master switch. When disabled, no during-utterance acknowledgment is played.
 BACKCHANNEL_ENABLED=true
-# Directory of preloaded "*.raw" PCM clips (16-bit LE mono, 44.1 kHz), e.g.
-# mmhmm / ajá / claro. Played round-robin.
+# Directory of the generated "*.raw" PCM clips (16-bit LE mono, 44.1 kHz). One
+# clip is synthesized per phrase of BACKCHANNEL_TEXTS at startup.
 BACKCHANNEL_DIR=assets/backchannel
+# Phrases spoken by the backchannel, ONE PER LINE (a single line with "|"
+# separators also works). One clip is synthesized per phrase and a RANDOM one is
+# played, so the cue varies from turn to turn. The bank follows this list:
+# editing it triggers a full re-synthesis at the next restart (no manual
+# deletion needed), phrases dropped here are deleted on disk, and a failed
+# synthesis keeps the previous clip. An unchanged list is skipped, so startup
+# stays fast. Drama-3 style tags ([calm], ...) are passed through to the TTS.
+#
+# A line may start with an optional "category::" prefix (e.g. "agree::..."); the
+# scheduler uses it to progress through the turn (an acknowledgment first,
+# agreement later) and to avoid chaining two cues of the same kind. Lines
+# without a prefix belong to the default "ack" category.
+BACKCHANNEL_TEXTS="ack::[calm] Mm-hmm...
+ack::[attentive] Ajá...
+agree::[agreeing] Claro...
+ack::[listening] Ya veo..."
 # Mix gain applied to the backchannel channel (0..1). Kept low so the cue stays
 # in the background.
-BACKCHANNEL_GAIN=0.35
-# Continuous speech required (ms) before the first backchannel of a turn.
+BACKCHANNEL_GAIN=0.55
+# Confirmed speech required (ms) before the first cue may be considered.
 BACKCHANNEL_MIN_SPEECH_MS=1500
-# Minimum spacing (ms) between two backchannels. Clamped to >= MIN_SPEECH_MS.
+# Base spacing (ms) between two cues of the same turn; randomized by ±JITTER/2.
 BACKCHANNEL_INTERVAL_MS=3000
-# Maximum backchannels emitted per user turn.
-BACKCHANNEL_MAX_PER_TURN=2
+# Timing jitter (ms): delays the first cue by 0..JITTER after MIN_SPEECH_MS and
+# spreads the spacing, so cues don't land on a fixed cadence.
+BACKCHANNEL_JITTER_MS=1200
+# Micro-pause window (ms): the cue lands only while the user is in a short
+# pause. The reaction DEPTH is drawn at random inside [MIN, MAX] per pause, so
+# cues don't all land at exactly MIN. Below MIN the user is likely still
+# mid-word; above MAX (capped below VAD_MIN_SILENCE_MS) the utterance is about
+# to close.
+BACKCHANNEL_PAUSE_MIN_MS=96
+BACKCHANNEL_PAUSE_MAX_MS=260
+# Probability (0..1) of cueing when a qualifying micro-pause occurs.
+BACKCHANNEL_PROB=0.65
+# Random per-cue volume scaling (± fraction) so cues don't sit at a fixed level.
+BACKCHANNEL_VOLUME_JITTER=0.2
+# Maximum cues emitted per user turn.
+BACKCHANNEL_MAX_PER_TURN=3
+
+# --- Multilingual clip banks (backchannel + filler + start filler) ---
+# Every clip bank lives in a per-language subdirectory `<dir>/<lang>` named after
+# the ISO 639-1 code (<dir>/<lang>/, e.g. assets/backchannel/es/), including the
+# default language LANG_DEFAULT. When the user is detected speaking a different
+# language, that language's banks are generated on demand into their own
+# subdirectory and the session switches to them. Each language has its own
+# directory, so regenerating one never removes the clips of another.
+LANG_DEFAULT=es
+# Detect the user's language with a dedicated LLM call (a short auxiliary
+# request that returns only the ISO code) and switch the banks when it differs
+# from the active one. Requires the LLM (LLM_ENABLED=true).
+LANG_DETECT_ENABLED=true
+# Minimum transcript length (chars) before a sample is sent to the LLM.
+LANG_MIN_CHARS=12
+# The first user turn is always checked; afterwards the language is re-checked
+# once every N turns, so a mid-conversation switch is picked up without paying
+# for a detection call on every turn.
+LANG_REDETECT_EVERY=5
+# Built-in phrase tables cover es/en/it/fr/de/pt. For any other language the
+# phrase list is generated by the LLM; set false to keep only the tables.
+LANG_LLM_FALLBACK_ENABLED=true
+
+# --- Per-session audit log ---
+# Writes one structured JSONL file per WebSocket session: a configuration
+# snapshot at the start, every inbound control message and outbound event, the
+# cue emissions, the language switches, the barge-ins / interrupts and an
+# event-count summary at the end. Useful for post-mortem analysis and for
+# tuning latency knobs (FILLER_DELAY_MS, START_FILLER_GO_DELAY, ...). One
+# <id>.jsonl file per session, written under SESSION_AUDIT_DIR.
+SESSION_AUDIT_ENABLED=true
+SESSION_AUDIT_DIR=logs/sessions
+
+# --- External audio source (URL / radio / YouTube) ---
+# Injects an audio stream — a direct media URL, an Icecast/Shoutcast radio or a
+# YouTube link — into the mixer's own "external" channel, mixed under the
+# agent's voice. Demonstrated in the /mivocero client (URL box + Play/Stop +
+# volume slider). Decoding is delegated to external tools:
+#   * ffmpeg  — decodes direct URLs, radio and HLS streams (required);
+#   * yt-dlp  — resolves YouTube URLs to a decodable stream (YouTube only).
+# A barge-in (interrupt) stops the agent but leaves this background source
+# playing; the external channel does not count as the agent speaking.
+# Gain applied to the external channel (kept below 1 so it sits under the voice).
+EXTERNAL_AUDIO_GAIN=0.6
+# Override the decoder binaries if they are not on PATH.
+MEDIA_FFMPEG_BIN=ffmpeg
+MEDIA_YTDLP_BIN=yt-dlp
+# Extra yt-dlp arguments (space-separated), e.g. to pass cookies or a JS
+# runtime: "--cookies /path/cookies.txt". Leave empty normally.
+MEDIA_YTDLP_ARGS=
 
 # --- LLM reasoning (OpenAI-compatible chat-completions endpoint) ---
 # When enabled, the user transcript is sent to the model and the reply is
@@ -143,12 +277,35 @@ LLM_DIRECT_ANSWERS=true
 # word-boundary flush (chunks then end on sentence punctuation only).
 LLM_STREAM_FIRST_CHUNK_CHARS=20
 # Same threshold for every chunk after the first. Larger chunks give better
-# prosody; smaller ones keep the audio flowing while the model is generating.
-LLM_STREAM_CHUNK_CHARS=120
+# prosody and fewer TTS requests: each chunk is a separate request with its own
+# start-up and its own audio seam, so a larger value cuts the number of seams
+# (where the TTS queue can starve) per reply.
+LLM_STREAM_CHUNK_CHARS=240
 # Optional system prompt override. Leave unset for the built-in voice-assistant
 # prompt (see `DEFAULT_LLM_SYSTEM_PROMPT` in src/config.rs).
 #LLM_SYSTEM_PROMPT=
 
+# --- Tool calling (configurable HTTP tools) ---
+# Lets the model call external HTTP services (weather, home automation, a
+# webhook, …) before answering. The deployment's vLLM server runs without a
+# tool parser, so it returns the call as text in the Qwen native
+# `<tool_call>` format: the engine parses it client-side, executes the HTTP
+# request and hands the result back to the model (see src/tools.rs). The
+# tool-call block is never spoken nor shown in the chat box.
+# Enabled automatically when LLM_TOOLS_FILE points to a valid tool file.
+LLM_TOOLS_ENABLED=false
+# JSON file with the tool definitions (name, description, JSON schema, url,
+# method, headers). See tools.example.json.
+LLM_TOOLS_FILE=
+# Maximum tool-call rounds per turn (call → execute → re-prompt). Bounds
+# runaway loops; the first round is the model's initial reply.
+LLM_TOOL_MAX_ITERATIONS=4
+# Timeout of a single tool HTTP request, in seconds.
+LLM_TOOL_TIMEOUT_SECS=15
+# Tool responses are truncated to this many characters before being handed
+# back to the model (keeps the context small).
+LLM_TOOL_RESULT_MAX_CHARS=2000
+
 # --- HTTPS (optional) ---
 # Set BOTH to serve HTTPS/WSS instead of plain HTTP. A secure context is
 # required by browsers to grant microphone access (getUserMedia) when the page
diff --git a/.gitignore b/.gitignore
index 29adf1c..484742d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,6 +15,8 @@ Cargo.lock.temp
 *.log
 *.tmp
 *.bak
+# Per-session audit logs (SESSION_AUDIT_DIR)
+/logs/
 
 # --- Variabili d'ambiente e credenziali ---
 .env
diff --git a/README.md b/README.md
index 6a1c51a..cc24301 100644
--- a/README.md
+++ b/README.md
@@ -36,9 +36,27 @@ Browser mic ──► WebSocket PCM ──► STT (Parakeet/ONNX) + VAD/EOU
   the reply is late*: it is scheduled `FILLER_DELAY_MS` (default 2500 ms) after
   the turn starts and dropped if the response audio has already begun. Clips are
   played round-robin from `FILLERS_DIR`; `FILLER_ENABLED=false` disables it.
+- **Start filler** — a second latency mask on its own mixer channel: if the first
+  audio chunk of the reply has not reached the mixer within
+  `START_FILLER_GO_DELAY` (default 1200 ms) the agent plays a short
+  acknowledgment ("Un momento...") while the LLM/TTS are still working, and drops
+  it as soon as audio arrives in time. One phrase is picked **at random** from
+  `START_FILLER_TEXTS`, so the cue varies turn to turn. Independent of the delayed
+  latency filler above; `START_FILLER_ENABLED=false` disables it. See
+  [Fillers](#fillers--end-of-utterance-acknowledgments).
 - **During-utterance backchannel** — short acknowledgments ("mm-hmm", "ajá")
   are mixed in at a reduced gain *while the user is speaking*, so the agent
-  signals it is listening without taking the turn. Plugin-style `.env` config.
+  signals it is listening without taking the turn. Like the start filler the
+  bank is a phrase list (`BACKCHANNEL_TEXTS`) with Drama-3 tags, one clip per
+  phrase synthesized at startup. To sound natural the scheduler cues only on a
+  VAD **micro-pause**, randomizes the timing, gates each pause probabilistically,
+  avoids repeating the recent clips, drifts the volume slightly and follows a
+  **category** progression through the turn (`category::phrase` lines).
+- **External audio injection** — a dedicated mixer channel can play a background
+  source (direct audio URL, Icecast/Shoutcast radio, HLS, or a YouTube link)
+  alongside the agent's voice, with an independent runtime volume and its own
+  decoder process (`ffmpeg` for URLs/radio, `yt-dlp` for YouTube). See
+  [External audio injection](#external-audio-injection).
 - **Barge-in / interrupt** — cancels in-flight synthesis and flushes audio,
   triggered client-side or server-side by the VAD.
 - **Voice cloning** — reference audio + transcript (Fish Audio `references`).
@@ -55,10 +73,20 @@ Browser mic ──► WebSocket PCM ──► STT (Parakeet/ONNX) + VAD/EOU
   (first chunk after a few words, tunable) for the lowest time-to-first-audio;
   chain-of-thought (`reasoning_content` / ` thinking`) is stripped from both the
   audio and the chat box.
+- **Tool calling** — the model can call external HTTP tools described in a JSON
+  file (`LLM_TOOLS_FILE`) before answering. Calls are parsed client-side from
+  the model's native `<tool_call>` format, executed over HTTP and fed back to
+  the model; the tool-call block is never spoken. See
+  [Tool calling](#tool-calling).
 - **Embedded playground** — a single-page HTML client served at `/`.
 - **Mivocero speech-to-speech client** — an example agent client at `/mivocero`
   with a microphone, a live chat box (user transcript + streaming assistant
   reply) and a text composer, useful to drive a full STT → LLM → TTS turn.
+- **Per-session audit log** — each WebSocket session can be recorded to a
+  structured JSONL file: the configuration snapshot, every inbound control
+  message and outbound event, the cue emissions, the language switches, the
+  barge-ins and an end-of-session summary. Best-effort and off the audio hot
+  path. See [Session audit log](#session-audit-log).
 
 ---
 
@@ -72,6 +100,9 @@ Browser mic ──► WebSocket PCM ──► STT (Parakeet/ONNX) + VAD/EOU
 - *(Optional)* An OpenAI-compatible chat-completions endpoint (e.g. a local
   vLLM / SGLang server) for the LLM reasoning stage. Without it the pipeline is
   a plain STT → TTS echo.
+- *(Optional)* `ffmpeg` on `PATH` (or `MEDIA_FFMPEG_BIN`) to inject external
+  audio from a URL / radio stream, and `yt-dlp` (or `MEDIA_YTDLP_BIN`) to inject
+  a YouTube link. Both are only needed for the external audio channel.
 
 ---
 
@@ -152,6 +183,10 @@ See [`.env.example`](.env.example) for a copy-paste template.
 | `TTS_VOICE` | `default` | Voice identifier. |
 | `TTS_REFERENCE_AUDIO` | `…/voice_profiles/solis.wav` | Voice-cloning reference WAV (path on the TTS server). |
 | `TTS_REFERENCE_TEXT` | *(empty)* | Reference transcript. If it names an existing `.txt`, its contents are loaded; otherwise the raw string is used. Empty → auto-load `<audio-stem>.txt`. |
+| `TTS_TEMPERATURE` | `0.45` | Sampling temperature sent to the SGLang speech endpoint (`fish` engine). Lower values flatten the delivery — the recitative "radio drama" register lives in the distribution tails. Empty omits the field (server default). |
+| `TTS_TOP_P` | `0.75` | Nucleus sampling `top_p` sent to SGLang. Trims the tail of the acoustic token distribution, where exaggerated intonations live. Empty omits the field. |
+| `TTS_TOP_K` | *(unset)* | Optional `top_k` sampling. Unset/empty omits the field (server default). |
+| `TTS_STYLE_TAG` | `[conversational, casual]` | Neutral style tag prepended to every synthesis request that does not already start with a `[...]` tag. LLM replies carry no tag (the system prompt forbids stage directions), so they get this register; clip banks with their own tag are left untouched. Empty disables the prefix. **Quote the value in `.env`** (it contains a space). |
 | `KOKORO_URL` | `http://localhost:8880` | Kokoro HTTP endpoint (`kokoro` engine). |
 | `KOKORO_VOICE` | `af_heart` | Kokoro voice name. |
 | `STT_MODEL_PATH` | `models/parakeet` | Directory of the Parakeet TDT ONNX pipeline (see below). |
@@ -167,19 +202,38 @@ See [`.env.example`](.env.example) for a copy-paste template.
 | `VAD_SEGMENT_STT` | `true` | Feed the STT engine with VAD-segmented utterances instead of the worker's RMS segmentation. |
 | `VAD_BARGE_IN` | `true` | Interrupt the agent when the user starts speaking over it. |
 | `VAD_DEBUG` | `false` | Log the speech probability of every analysis window. |
-| `FILLERS_DIR` | `assets/fillers` | Directory of `*.raw` filler PCM files (16-bit LE mono, 44.1 kHz), played round-robin, at most once per turn. |
+| `FILLERS_DIR` | `assets/fillers` | Directory of `*.raw` filler PCM files (16-bit LE mono, 44.1 kHz), played round-robin, at most once per turn. Clips live in a per-language subdirectory `<dir>/<lang>` (e.g. `assets/fillers/es/`). |
 | `FILLER_ENABLED` | `true` | Master switch for the end-of-turn filler. `false` => no filler is ever queued. |
 | `FILLER_DELAY_MS` | `2500` | How long (ms) to wait for the response audio to start before playing the filler. If the reply starts earlier, the filler is dropped instead of talking over the beginning of the answer. |
 | `FILLER_GAIN_IDLE` | `1.0` | Filler gain when TTS is idle. |
-| `FILLER_GAIN_DUCK` | `0.15` | Filler gain while TTS is active (ducking). |
-| `TTS_PREBUFFER_MS` | `450` | Synthesized audio (ms) buffered on the TTS channel before the reply starts playing. Lower = the agent speaks sooner; higher = fewer drop-outs on uneven TTS chunk arrival. Only awaited at the start of a reply; mid-reply underruns resume as soon as any audio is queued again. |
+| `FILLER_GAIN_DUCK` | `0.15` | Filler gain while TTS is active (ducking). Also applies to the start-filler channel. |
+| `START_FILLER_ENABLED` | `true` | Master switch for the **start filler** — a turn-start acknowledgment queued on its own mixer channel when the reply audio is late, independently of the delayed filler above. `false` => no cue is ever queued. |
+| `START_FILLER_GO_DELAY` | `1200` | How long (ms) the agent waits for the **first audio chunk of the reply** to reach the mixer before queueing the start filler. If audio arrives within this window the cue is dropped instead of talking over the beginning of the answer. The gate is latched on chunk *arrival* (`AudioMixer::tts_audio_arrived`), not on playback start, so it does not wait for the `TTS_PREBUFFER_MS` jitter buffer. Same idea as `FILLER_DELAY_MS`, but shorter — the start filler only covers the gap before the reply begins, not the whole generation. |
+| `START_FILLER_TEXTS` | `[calm] Un momento...` | Phrases spoken by the start filler, **one per line** (a `\|` separator also works). One clip is synthesized per phrase and a **random** one is played when the reply is late, so the acknowledgment varies. Editing the list re-synthesizes the whole bank at the next restart (no manual deletion); an unchanged list is skipped to keep startup fast, and a failed synthesis keeps the previous clip. Drama-3 style tags (`[calm]`, `[sigh]`, …) are passed through to the TTS. |
+| `START_FILLER_DIR` | `assets/start_filler` | Directory holding the start-filler clips (`sf01.raw`, `sf02.raw`, …, plus a `texts.txt` list index). Clips live in a per-language subdirectory `<dir>/<lang>` (e.g. `assets/start_filler/es/`). Kept out of `FILLERS_DIR` so the clips are not part of the round-robin filler bank. |
+| `TTS_PREBUFFER_MS` | `550` | Synthesized audio (ms) buffered on the TTS channel before the reply starts playing. Lower = the agent speaks sooner; higher = fewer drop-outs on uneven TTS chunk arrival. With the deployment's vocoder windows (first `185.8` ms, then `371.6` ms), any value in `(186, 557]` ms primes on the *same* second window, so `550` takes the whole cushion at no extra TTFA (~`0.73 s`). Below the first window (~`186` ms) playback starts on that window (TTFA ≈ server TTFB, ~`0.38 s`) but leaves almost no margin and exposes chunk seams. Only awaited at the start of a reply; mid-reply underruns resume as soon as any audio is queued again. |
 | `TTS_PIPELINE_DEPTH` | `3` | How many TTS requests may be in flight at once. Chunks are synthesized ahead of playback and replayed in order, so each request's start-up latency hides behind the previous chunk's audio. `1` restores strictly serial synthesis. |
 | `BACKCHANNEL_ENABLED` | `true` | Master switch for during-utterance acknowledgments. |
-| `BACKCHANNEL_DIR` | `assets/backchannel` | Directory of `*.raw` backchannel PCM clips (16-bit LE mono, 44.1 kHz). |
+| `BACKCHANNEL_DIR` | `assets/backchannel` | Directory of the generated `*.raw` backchannel PCM clips (16-bit LE mono, 44.1 kHz; `bc01.raw`, `bc02.raw`, …, plus a `texts.txt` list index). Clips live in a per-language subdirectory `<dir>/<lang>` (e.g. `assets/backchannel/es/`). |
+| `BACKCHANNEL_TEXTS` | `ack::[calm] Mm-hmm...` … | Phrases spoken by the backchannel, **one per line** (a `\|` separator also works). One clip is synthesized per phrase and one is played per cue. Editing the list re-synthesizes the whole bank at the next restart (no manual deletion); an unchanged list is skipped to keep startup fast, and a failed synthesis keeps the previous clip. Drama-3 style tags (`[calm]`, …) are passed through to the TTS. A line may carry an optional **`category::`** prefix (e.g. `agree::[agreeing] Claro...`) used to progress through the turn; a line without it belongs to the default `ack` category. |
 | `BACKCHANNEL_GAIN` | `0.35` | Mix gain applied to the backchannel channel (0..1). |
-| `BACKCHANNEL_MIN_SPEECH_MS` | `1500` | Continuous speech required before the first backchannel of a turn. |
-| `BACKCHANNEL_INTERVAL_MS` | `3000` | Minimum spacing between two backchannels (clamped to ≥ `BACKCHANNEL_MIN_SPEECH_MS`). |
-| `BACKCHANNEL_MAX_PER_TURN` | `2` | Maximum backchannels emitted per user turn. |
+| `BACKCHANNEL_MIN_SPEECH_MS` | `1500` | Confirmed speech required before the first cue may be considered. |
+| `BACKCHANNEL_INTERVAL_MS` | `3000` | Base spacing between two cues of the same turn; randomized by ±`BACKCHANNEL_JITTER_MS`/2. |
+| `BACKCHANNEL_JITTER_MS` | `1200` | Timing jitter: delays the first cue by `0..JITTER` after `BACKCHANNEL_MIN_SPEECH_MS` and spreads the spacing. |
+| `BACKCHANNEL_PAUSE_MIN_MS` | `96` | Lower bound of the VAD micro-pause window (ms). The reaction **depth** inside a pause is drawn at random in `[MIN, MAX]`, so cues don't all land at exactly `MIN`. Below this the user is likely still mid-word. |
+| `BACKCHANNEL_PAUSE_MAX_MS` | `260` | Upper bound of the micro-pause window, capped below `VAD_MIN_SILENCE_MS` so a cue never lands on the pause that closes the turn. |
+| `BACKCHANNEL_PROB` | `0.65` | Probability (0..1) of cueing on a qualifying micro-pause — keeps the agent from acknowledging every pause. |
+| `BACKCHANNEL_VOLUME_JITTER` | `0.2` | Random per-cue volume scaling (± fraction), so cues don't sit at a fixed level. |
+| `BACKCHANNEL_MAX_PER_TURN` | `3` | Maximum backchannels emitted per user turn. |
+| `LANG_DEFAULT` | `es` | Base language of the **filler, start-filler and backchannel** banks — its clips live in the `<dir>/<lang>` subdirectory (e.g. `assets/backchannel/es/`). Other languages are generated on demand into their own per-language subdirectories. See [Multilingual clip banks](#multilingual-clip-banks). |
+| `LANG_DETECT_ENABLED` | `true` | Master switch for LLM-based language detection. Requires the LLM (`LLM_ENABLED=true`). |
+| `LANG_MIN_CHARS` | `12` | Minimum transcript length (chars) before a sample is sent to the detector. |
+| `LANG_REDETECT_EVERY` | `5` | The first user turn is always checked; afterwards the language is re-checked once every N turns. |
+| `LANG_LLM_FALLBACK_ENABLED` | `true` | Phrase tables cover `es/en/it/fr/de/pt`; for any other language the phrase list is generated with the LLM. `false` keeps only the tables. |
+| `EXTERNAL_AUDIO_GAIN` | `0.6` | Mix gain applied to the external audio channel (0..1) at session start. Overridable at runtime from the Mivocero volume slider. |
+| `MEDIA_FFMPEG_BIN` | `ffmpeg` | `ffmpeg` binary used to decode a URL / radio / HLS stream into PCM. |
+| `MEDIA_YTDLP_BIN` | `yt-dlp` | `yt-dlp` binary used to resolve a YouTube link to a direct stream URL. |
+| `MEDIA_YTDLP_ARGS` | *(empty)* | Extra whitespace-separated args appended to the `yt-dlp` invocation (e.g. `--cookies /path/cookies.txt` when YouTube asks for bot verification, or a custom `--extractor-args`). |
 | `LLM_ENABLED` | *(auto)* | Master switch for the LLM reasoning stage. Default: enabled when `LLM_BASE_URL` and `LLM_MODEL` are both set. When `false`, the pipeline is a plain STT → TTS echo. |
 | `LLM_BASE_URL` | *(empty)* | Base URL of the OpenAI-compatible endpoint; the client posts to `{LLM_BASE_URL}/chat/completions`. |
 | `LLM_API_KEY` | `EMPTY` | Bearer token sent in the `Authorization` header (local servers usually ignore it). |
@@ -188,14 +242,21 @@ See [`.env.example`](.env.example) for a copy-paste template.
 | `LLM_TEMPERATURE` | `0.7` | Sampling temperature. |
 | `LLM_STREAM` | `true` | `true` → SSE token streaming, TTS starts on the first words; `false` → one blocking request, the whole reply is synthesized at once. |
 | `LLM_STREAM_FIRST_CHUNK_CHARS` | `20` | Characters buffered before the **first** chunk is sent to the TTS, cut on a word boundary. Small = the agent starts speaking on the first few words. `0` disables the early flush. |
-| `LLM_STREAM_CHUNK_CHARS` | `120` | Same threshold for every following chunk (larger chunks give better prosody). `0` disables. |
+| `LLM_STREAM_CHUNK_CHARS` | `240` | Same threshold for every following chunk (larger chunks give better prosody and fewer TTS seams). `0` disables. |
 | `LLM_HISTORY_MESSAGES` | `16` | Rolling conversation window (user+assistant messages) kept across turns. |
 | `LLM_ENABLE_THINKING` | *(unset)* | `false` sends `chat_template_kwargs: {"enable_thinking": false}` — turns Qwen3-style thinking off on vLLM/SGLang so the model answers directly. Unset omits the vendor-specific field entirely (safe for strict OpenAI-compatible servers). |
 | `LLM_STRIP_REASONING` | `true` | Drop the chain-of-thought from the reply before it reaches the chat box / TTS: ignores `reasoning_content` deltas and removes inline think blocks. `false` passes the raw output through. |
 | `LLM_DIRECT_ANSWERS` | `true` | Append an "answer directly, never narrate your reasoning" directive to the system prompt. |
 | `LLM_SYSTEM_PROMPT` | *(built-in)* | Overrides the system prompt. The default asks for short, spoken-friendly replies (no markdown / bullet points). |
+| `LLM_TOOLS_ENABLED` | *(auto)* | Master switch for tool calling. Default: enabled when `LLM_TOOLS_FILE` is a non-empty path. |
+| `LLM_TOOLS_FILE` | *(empty)* | JSON file with the tool definitions (`name`, `description`, `parameters` JSON schema, `url`, `method`, `headers`). See [Tool calling](#tool-calling) and [`tools.example.json`](tools.example.json). |
+| `LLM_TOOL_MAX_ITERATIONS` | `4` | Maximum tool-call rounds per turn (call → execute → re-prompt). Bounds runaway loops. |
+| `LLM_TOOL_TIMEOUT_SECS` | `15` | Timeout of a single tool HTTP request. |
+| `LLM_TOOL_RESULT_MAX_CHARS` | `2000` | Tool responses are truncated to this many characters before being handed back to the model. |
 | `TLS_CERT` | *(empty)* | PEM certificate chain. Set together with `TLS_KEY` to serve HTTPS/WSS. |
 | `TLS_KEY` | *(empty)* | PEM private key matching `TLS_CERT`. |
+| `SESSION_AUDIT_ENABLED` | `true` | Write a structured JSONL audit file per WebSocket session (config snapshot, inbound control messages, every outbound event, cues, language switches, barge-ins, end-of-session summary). Best-effort — a write failure never affects the session. See [Session audit log](#session-audit-log). |
+| `SESSION_AUDIT_DIR` | `logs/sessions` | Directory holding the per-session audit files (`<id>.jsonl`). Relative to the process working directory; git-ignored. |
 
 ---
 
@@ -268,9 +329,10 @@ An unknown value panics at startup with a clear message.
 
 ##### Starting the Drama 3 backend (SGLang-Omni)
 
-The `fish` engine talks to an **SGLang-Omni** server running Drama 3. Start it
-with the vocoder streaming window narrowed, otherwise the vocoder emits ~3 s
-bursts and the client is forced into a large pre-buffer:
+The `fish` engine talks to an **SGLang-Omni** server running Drama 3. The
+vocoder emits audio in **windows** of codec frames (2048 samples = 46.4 ms each);
+the window sizes are the single biggest lever on latency, so the server must be
+started with them tuned:
 
 ```bash
 sgl-omni serve \
@@ -278,8 +340,12 @@ sgl-omni serve \
     --host 0.0.0.0 --port 8000 \
     --tts_engine.gpu_memory_fraction 0.45 \
     --tts_engine.factory.max_running_requests 4 \
-    --vocoder.factory.stream_followup_stride 16 \
-    --vocoder.factory.stream_followup_stride_ramp "[10,12,16]"
+    --tts_engine.factory.enable_async_decode true \
+    --vocoder.factory.stream_stride 4 \
+    --vocoder.factory.stream_followup_stride_ramp "[8,8,8]" \
+    --vocoder.factory.stream_followup_stride 8 \
+    --vocoder.factory.stream_overlap_tokens 16 \
+    --vocoder.factory.stream_crossfade_samples 512
 ```
 
 In this deployment the launcher is `/root/drama3/start-drama3.sh` and the server
@@ -290,26 +356,71 @@ pm2 restart start-drama3 --update-env   # after editing the launcher
 pm2 logs start-drama3 --lines 100       # CUDA-graph rebuild takes ~2 min at start
 ```
 
-The two `--vocoder.factory.*` overrides are the key part:
+| Flag | Value | Meaning |
+|---|---|---|
+| `stream_stride` | `4` | **First** window, in codec frames (decoded with *no* overlap context). Sets the server TTFB floor: at `4` it is ~`0.38 s`, at `16` it is ~`1.2 s`, because the TTS engine must emit that many codec tokens before the vocoder can decode anything. |
+| `stream_followup_stride` | `8` | Steady-state window: `8` frames = `0.372 s`, arriving ~`0.35 s` apart (the server runs at ~`0.95×` real time), so the client queue grows and never starves. Larger windows mean **fewer seams** per second, which is what removes the audible artifacts. Upstream default `64` ⇒ `2.97 s` bursts. |
+| `stream_followup_stride_ramp` | `"[8,8,8]"` | Windows 2..4, as a JSON tuple. Keep it flat: a *rising* ramp (e.g. `[4,6,10]`, or the upstream `(10,12,32)`) makes later windows arrive after the small ones have drained, which gaps playback at the start of a reply. |
+| `stream_overlap_tokens` | `16` | Decoder warm-up context. It is decoded and **discarded** on output, so it only costs compute. This is the seam-quality lever: with too little context the streaming decoder wobbles in timbre/pitch at each seam (an audible "detune"/falsetto on long replies). `16` with stride `8` is a `(16+8)/8 = 3×` real-time decode load and stays sustainable (~`0.95×` ratio); the same `16` with stride `4` would be 5× and is **not** sustainable. Upstream default `32`. |
+| `stream_crossfade_samples` | `512` | ~`11.6 ms` blend at each window seam, smoothing the hand-off between windows. |
 
-| Flag | Meaning |
-|---|---|
-| `stream_followup_stride` | Steady-state window, in codec frames (`2048` samples = `46.4 ms` each). `16` ⇒ `0.743 s` bursts; the upstream default `64` ⇒ `2.97 s`. |
-| `stream_followup_stride_ramp` | Window sizes for the first windows, as a JSON tuple. `[10,12,16]` emits a `0.464 s` then a `0.557 s` window first, so playback can start sooner. Upstream default `(10,12,32)`. |
+Measured on this deployment (with the voice-cloning reference), server-side:
+
+| Config | TTFB | Real-time ratio |
+|---|---|---|
+| `stream_stride 4`, followup `8`, overlap `16`, crossfade `512` *(this deployment)* | **~0.38 s** | ~`0.94–0.98×` |
+| `stream_stride 4`, followup `4`, overlap `8`, crossfade `256` | ~`0.38 s` | ~`0.95×` (but audible detune / micro-gaps on long replies) |
+| `stream_stride 16`, overlap `16` | ~`1.2 s` | ~`1.0×` |
+
+The engine's Time-to-First-Audio is essentially `TTFB + (TTS_PREBUFFER_MS − first
+window)`, quantized to the window the pre-buffer lands on. With this config the
+first window is `185.8` ms and the second `371.6` ms, so any `TTS_PREBUFFER_MS`
+in `(186, 557]` ms primes on the **same** second window → TTFA ≈ `0.73 s`. The
+deployment ships `550 ms`: the whole cushion, no extra latency. Dropping to a
+value below the first window (~`186` ms) starts playback on the first window
+(TTFA ≈ `0.38 s`) but leaves little margin, and under concurrent TTS requests the
+per-request throughput dips below real time (measured ~`1.5×` vs ~`0.94×` alone),
+so each chunk seam starves the queue and pauses playback — an audible micro-gap at
+the start of each sentence.
 
 Two gotchas when writing the command:
 
 - The flags are **dotted keys into the pydantic config**, so they go *without* a
   `stages.` prefix — `--vocoder.factory.stream_followup_stride`, not
   `--stages.vocoder.factory.stream_followup_stride` (the latter is rejected).
-- The ramp tuple must be passed as a **JSON string** — `"[10,12,16]"` — because
+- The ramp tuple must be passed as a **JSON string** — `"[8,8,8]"` — because
   the config manager parses non-scalar paths with JSON.
 
-Smaller stride = finer delivery granularity but more compute: each window
-re-decodes `stream_overlap_tokens` (default `32`) of context, so `stride 16`
-decodes 48 frames per 16 emitted. Keep the stride at or below the client's
-`TTS_PREBUFFER_MS` budget (see *Mixer & jitter buffering*) — with the defaults
-above, `TTS_PREBUFFER_MS=450` starts playback on the first window.
+##### De-emphasis — reducing Drama 3's recitative register
+
+Drama 3 tends to over-articulate: an LLM reply can come back with a theatrical,
+radio-drama cadence rather than a conversational tone. The engine applies two
+configurable mitigations, both in [`src/tts/fish_audio.rs`](src/tts/fish_audio.rs):
+
+1. **Sampling knobs** — `temperature` / `top_p` / `top_k` are sent in the
+   `/v1/audio/speech` payload (`TTS_TEMPERATURE` default `0.45`, `TTS_TOP_P`
+   default `0.75`). Exaggerated intonations live in the tails of the acoustic
+   token distribution, so trimming them flattens the delivery. Lowering
+   `temperature` toward `0.3` flattens it further; `0.8+` makes it unstable and
+   theatrical again. An empty value omits the field (server default). Note that
+   this server **rejects `repetition_penalty`** with anything other than `1.0`,
+   so that knob cannot be used.
+2. **Neutral style tag** — `TTS_STYLE_TAG` (default `[conversational, casual]`)
+   is prepended to every request whose text does not already start with a `[...]`
+   tag. LLM replies carry no tag (the system prompt forbids stage directions), so
+   they get this register; the filler/backchannel banks carry their own tags and
+   are left untouched. Empty disables the prefix. Quote the value in `.env`, as
+   it contains a space.
+
+> **`.env` parsing note.** The file is read with `dotenvy`, which **fails on
+> unquoted values containing spaces** — and a single bad line makes it discard the
+> *entire* file (the process then silently falls back to built-in defaults: no
+> LLM, plain HTTP). Always quote values that contain spaces, e.g.
+> `TTS_STYLE_TAG="[conversational, casual]"`.
+
+The remaining lever — replacing the voice-cloning reference with a more
+conversational one — is not applied here: the default `solis.wav` is a
+"locutor profesional" reading, whose prosody is part of the recitative tone.
 
 #### `kokoro` — Kokoro TTS *(stub)*
 
@@ -494,27 +605,60 @@ All VAD logs live under the `audio_agent_engine::vad` target;
 
 ## Startup clip bootstrap
 
-The filler and backchannel banks are plain `*.raw` PCM files. At startup
-[`assets::ensure_clips`](src/assets.rs) checks each expected clip and, **if a
-clip is missing, synthesizes it with the configured TTS engine** and writes it
-to disk (the directory is created if needed). Existing clips are never
-overwritten, so a fresh checkout works without a manual generation step and a
-partial/customized bank is left untouched.
+The filler, start-filler and backchannel banks are plain `*.raw` PCM files
+(16-bit LE mono PCM at 44.1 kHz). At startup the clip banks are bootstrapped with
+the configured TTS engine and the files are written to disk (the directory is
+created if needed), so a fresh checkout works without a manual generation step.
+Every bank lives in a per-language subdirectory `<dir>/<lang>` (see
+[Multilingual clip banks](#multilingual-clip-banks)); the startup bootstrap
+targets the `LANG_DEFAULT` subdirectory (e.g. `assets/fillers/es/`).
 
-- Defaults live in [`assets::FILLER_CLIPS`](src/assets.rs) (7 clips: `uhm`,
-  `eh`, `mmm`, `aver`, `bueno`, `pues`, `vaya`) and
-  [`assets::BACKCHANNEL_CLIPS`](src/assets.rs) (4 clips: `mmhmm`, `aja`, `claro`,
-  `yaveo`). The generated voice matches the configured TTS voice-cloning
-  reference.
-- Backchannel clips are only generated when `BACKCHANNEL_ENABLED=true`.
+- Filler uses [`assets::ensure_clips`](src/assets.rs): each expected clip is
+  checked and **synthesized only if missing**, so an existing bank is left
+  untouched. Defaults live in [`assets::FILLER_CLIPS`](src/assets.rs) (7 clips:
+  `uhm`, `eh`, `mmm`, `aver`, `bueno`, `pues`, `vaya`). The generated voice
+  matches the configured TTS voice-cloning reference.
+- The **start filler** and the **backchannel** use the generic
+  [`assets::ensure_text_bank_clips`](src/assets.rs) (through
+  [`ensure_start_filler_clips`](src/assets.rs) / [`ensure_backchannel_clips`](src/assets.rs)):
+  both are driven by their phrase list (`START_FILLER_TEXTS` /
+  `BACKCHANNEL_TEXTS`) instead of a fixed clip set, so editing the list from
+  `.env` is enough to change what is spoken. The list the current clips were made
+  from is recorded in `<dir>/texts.txt`; when it is unchanged and every clip is
+  still on disk the synthesis is **skipped** (startup stays at ~2 s). Editing,
+  adding or dropping a phrase — or deleting a clip — triggers a **full refresh**
+  at the next restart, and clips left over from a previous list are removed.
+  Clips are named by position (`sf01`, `sf02`, … for the start filler; `bc01`,
+  `bc02`, … for the backchannel) and generated a few at a time
+  (`TEXT_BANK_CONCURRENCY`); a failed synthesis keeps the previous clip of that
+  position, and the index is only written once every clip succeeded, so a partial
+  failure is retried next time.
+- Backchannel clips are only generated when `BACKCHANNEL_ENABLED=true`; its
+  default phrase list lives in
+  [`DEFAULT_BACKCHANNEL_TEXTS`](src/orchestrator/backchannel.rs).
 - Generation is best-effort: if the TTS backend is unreachable each clip logs a
   warning and the server still starts (that bank simply stays silent).
 
 ```text
-INFO audio_agent_engine::assets: generating missing clips at startup label="filler" dir=assets/fillers missing=7 engine="fish-audio"
-INFO audio_agent_engine::assets: generated clip label="filler" name="uhm" samples=32768 path=assets/fillers/uhm.raw
+INFO audio_agent_engine::assets: generating clips at startup label="filler" dir=assets/fillers/es clips=7 engine="fish-audio"
+INFO audio_agent_engine::assets: generated clip label="filler" name="uhm" samples=32768 path=assets/fillers/es/uhm.raw
 ...
-INFO audio_agent_engine: clip banks bootstrapped generated=11
+INFO audio_agent_engine::assets: refreshing backchannel clips at startup label="backchannel" dir=assets/backchannel/es clips=8 engine="fish-audio"
+INFO audio_agent_engine::assets: generated backchannel clip label="backchannel" name="bc01" samples=28672 path=assets/backchannel/es/bc01.raw
+...
+INFO audio_agent_engine::assets: removed stale backchannel clip label="backchannel" path=assets/backchannel/es/mmhmm.raw
+INFO audio_agent_engine::assets: refreshing start-filler clips at startup label="start-filler" dir=assets/start_filler/es clips=22 engine="fish-audio"
+INFO audio_agent_engine::assets: generated start-filler clip label="start-filler" name="sf01" samples=36864 path=assets/start_filler/es/sf01.raw
+...
+INFO audio_agent_engine::assets: removed stale start-filler clip label="start-filler" path=assets/start_filler/es/start_filler.raw
+INFO audio_agent_engine: clip banks bootstrapped generated=30
+```
+
+On a later startup with unchanged lists:
+
+```text
+INFO audio_agent_engine::assets: backchannel clips up to date — skipping synthesis label="backchannel" dir=assets/backchannel/es clips=8
+INFO audio_agent_engine::assets: start-filler clips up to date — skipping synthesis label="start-filler" dir=assets/start_filler/es clips=22
 ```
 
 ---
@@ -546,25 +690,73 @@ PCM at 44.1 kHz** — selected **round-robin** (`TurnManager::next_filler` →
 different fillers. With a single clip the behaviour is unchanged. Missing clips
 are synthesized at startup ([Startup clip bootstrap](#startup-clip-bootstrap)).
 
+### Start filler (turn-start acknowledgment when the reply is late)
+
+A second latency mask, on its own mixer channel. It works exactly like the filler
+above, but with its own — shorter — delay
+([`TurnManager::schedule_start_filler`](src/orchestrator/turn_manager.rs)):
+`START_FILLER_GO_DELAY` (default **1200 ms**) after the turn is dispatched, if the
+first audio chunk of the reply has **not** reached the mixer yet
+(`AudioMixer::tts_audio_arrived` is still `false`) the cue is queued; if audio
+arrived within that window, the cue is dropped instead of talking over the
+beginning of the answer.
+
+The gate is latched on chunk *arrival* (at the moment anything is pushed on the
+TTS queue, checked on the 20 ms ticker), not on playback start: unlike
+`tts_playback_started`, which only flips once the `TTS_PREBUFFER_MS` jitter buffer
+is full, it does not wait out the pre-buffer. With the reference deployment the
+first chunk lands ~`0.7`–`1.0 s` after the dispatch while playback starts
+~`1.9 s` later, so gating on playback made the cue fire on every turn; gating on
+arrival lets a reply that produces audio within `START_FILLER_GO_DELAY` suppress
+it. A pending cue is also dropped on barge-in / new turn via the turn's
+`CancellationToken`. This means a fast reply is never preceded by an
+acknowledgment — only a late one is masked.
+
+It lives on its own mixer channel (`start_filler_queue`), so it plays
+independently of the round-robin latency filler above, but it shares the filler
+gain, so it ducks to `FILLER_GAIN_DUCK` once the reply starts. Disabled by
+`START_FILLER_ENABLED=false`.
+
+Its clips live in `START_FILLER_DIR` (default `assets/start_filler`) and are
+**not** part of the round-robin `FILLERS_DIR` bank. One clip is synthesized per
+phrase of `START_FILLER_TEXTS` (default `"[calm] Un momento..."`) with the
+configured voice, and [`FillerBank::random`](src/orchestrator/turn_manager.rs)
+picks one **uniformly at random**, so the acknowledgment varies instead of
+repeating the same sentence. Editing the phrase list re-synthesizes the bank at
+the next restart (see
+[Startup clip bootstrap](#startup-clip-bootstrap)); a failed synthesis leaves the
+previous clip in place.
+
+```text
+START_FILLER_TEXTS="[calm] Un momento...
+[thoughtful] A ver, veamos...
+[sigh] Vale, ya voy..."
+```
+
 ---
 
 ## Backchannel — during-utterance acknowledgments
 
 A **backchannel** is a short acknowledgment ("mm-hmm", "ajá", "claro") played
 *while the user is still speaking*, at a low gain, to signal that the agent is
-listening — without taking the turn. It is distinct from the **filler** — the
-instant acknowledgment injected at end-of-utterance by the
-[`TurnManager`](src/orchestrator/turn_manager.rs) from `FILLERS_DIR` (played
-round-robin; see [Fillers](#fillers--end-of-utterance-acknowledgments)).
+listening — without taking the turn. It is distinct from the **filler** and the
+**start filler** injected around end-of-utterance by the
+[`TurnManager`](src/orchestrator/turn_manager.rs) (delayed mask from
+`FILLERS_DIR` played round-robin, and a shorter-delay cue from `START_FILLER_DIR`;
+see [Fillers](#fillers--end-of-utterance-acknowledgments)).
 
 It is implemented in [`src/orchestrator/backchannel.rs`](src/orchestrator/backchannel.rs).
 
 ### Clips
 
-`BACKCHANNEL_DIR` (default `assets/backchannel`) holds `*.raw` clips — **16-bit
-LE mono PCM at 44.1 kHz** — played round-robin. The bundled set is synthesized
-with the same cloned voice as the TTS (`mmhmm`, `aja`, `claro`, `yaveo`). The
-clips are loaded once at startup into a
+`BACKCHANNEL_DIR` (default `assets/backchannel`) holds the generated `*.raw`
+clips — **16-bit LE mono PCM at 44.1 kHz** — one per phrase of
+`BACKCHANNEL_TEXTS`, named by position (`bc01`, `bc02`, …). Each phrase may carry
+an optional `category::` prefix; clips keep the list order, so the i-th clip
+inherits the i-th phrase's category. The default list
+([`DEFAULT_BACKCHANNEL_TEXTS`](src/orchestrator/backchannel.rs), Spanish with
+Drama-3 tags) is synthesized with the same cloned voice as the TTS. The clips are
+loaded once at startup into a
 [`FillerBank`](src/orchestrator/turn_manager.rs) and shared across sessions.
 Missing clips are synthesized at startup
 ([Startup clip bootstrap](#startup-clip-bootstrap)).
@@ -575,18 +767,46 @@ Missing clips are synthesized at startup
 
 | Signal | Action |
 |---|---|
-| `VadEvent::SpeechStart` | begin a turn (`on_speech_start`) |
+| `VadEvent::SpeechStart` | begin a turn (`on_speech_start`, randomizes the first-cue instant) |
 | `VadEvent::SpeechEnd` | close the turn, reset counters (`on_speech_end`) |
-| every frame while speaking | `maybe_emit()` attempts a cue |
+| every frame while speaking | `maybe_emit(pause_ms)` attempts a cue |
 
 `maybe_emit()` emits a clip **only when all** of the following hold:
 
 - `BACKCHANNEL_ENABLED=true` and the clip bank is non-empty;
-- the user has been speaking for at least `BACKCHANNEL_MIN_SPEECH_MS`;
-- at least `BACKCHANNEL_INTERVAL_MS` elapsed since the previous cue;
-- fewer than `BACKCHANNEL_MAX_PER_TURN` cues were emitted this turn;
 - the agent is **not** speaking (`!TurnManager::is_speaking()`) — cuing over the
-  agent's own TTS would be an interruption, not a backchannel.
+  agent's own TTS would be an interruption, not a backchannel (checked by the
+  caller);
+- the user is in a **micro-pause**: `VadDetector::silence_ms()` reached the
+  per-pause reaction depth, a random value drawn in `[BACKCHANNEL_PAUSE_MIN_MS,
+  BACKCHANNEL_PAUSE_MAX_MS]`, so the cue never lands mid-word *and* doesn't
+  always react at the same depth. A zero-length pause (voice ongoing) re-arms
+  the gate;
+- the first cue is due (a per-turn randomized instant,
+  `BACKCHANNEL_MIN_SPEECH_MS + 0..BACKCHANNEL_JITTER_MS` after the speech start);
+- a randomized `BACKCHANNEL_INTERVAL_MS ± JITTER/2` gap elapsed since the
+  previous cue;
+- fewer than `BACKCHANNEL_MAX_PER_TURN` cues were emitted this turn;
+- the **probabilistic gate** (`BACKCHANNEL_PROB`) does not skip this pause — so
+  the agent acknowledges some pauses but not all.
+
+### Naturalness
+
+Six mechanisms keep the cues from sounding like a metronome:
+
+| Mechanism | How |
+|---|---|
+| Cue on micro-pauses | gated on the VAD `silence_ms()` (a `PAUSE_MIN..PAUSE_MAX` window, 32 ms steps, capped below `VAD_MIN_SILENCE_MS`), not on a timer |
+| Randomized reaction depth | per pause, the depth to react at is drawn at random in `[PAUSE_MIN, PAUSE_MAX]`, so the cue doesn't always land at exactly `PAUSE_MIN` |
+| Randomized timing | the first cue and every following gap are jittered by `BACKCHANNEL_JITTER_MS` |
+| Probabilistic gate | `BACKCHANNEL_PROB` skips a share of the qualifying pauses |
+| Anti-repetition | the last two clip names are excluded from the pick, across turns |
+| Volume drift | each cue is scaled by a random ±`BACKCHANNEL_VOLUME_JITTER` factor |
+
+The phrase list is further grouped in **categories**: the scheduler prefers a
+category other than the previous cue's, then a category not yet used this turn,
+so a turn tends to start with an acknowledgment (`ack`) and drift toward
+agreement (`agree`) instead of repeating the same kind of nod.
 
 ### Mixing
 
@@ -594,13 +814,90 @@ The cue is pushed into the mixer's dedicated `backchannel_queue` and summed at a
 fixed low gain (`BACKCHANNEL_GAIN`, default `0.35`):
 
 ```text
-mixed = tts + (filler × filler_gain) + (backchannel × BACKCHANNEL_GAIN)
+mixed = tts + ((filler + start_filler) × filler_gain) + (backchannel × BACKCHANNEL_GAIN)
 ```
 
 The queue is included in `AudioMixer::flush()`, so a barge-in clears any pending
-cue along with the TTS and filler audio. Logs live under the
-`audio_agent_engine::orchestrator::backchannel` target (`INFO` when a cue is
-emitted).
+cue along with the TTS and filler audio. At session start the effective policy is
+logged under `audio_agent_engine::orchestrator::backchannel`
+(`backchannel scheduler ready …`, with the parsed categories), and every emitted
+cue is logged under `audio_agent_engine::ws::session`
+(`backchannel emitted during user speech`, with the clip name and the pause
+length).
+
+---
+
+## Multilingual clip banks
+
+The filler, start-filler and backchannel banks are pre-synthesized in a single
+language — the base language `LANG_DEFAULT` (default `es`). When the user is
+detected speaking a different language, the engine generates that language's
+banks on demand and switches the session to them, **without touching** the clips
+of any other language.
+
+### Layout
+
+Every language — **including the base `LANG_DEFAULT`** — lives in its own
+subdirectory named after its ISO 639-1 code under `FILLERS_DIR` /
+`START_FILLER_DIR` / `BACKCHANNEL_DIR`:
+
+```text
+assets/backchannel/es/     <- base language (LANG_DEFAULT), pre-synthesized
+assets/fillers/es/
+assets/start_filler/es/
+assets/backchannel/en/     <- English, generated on demand
+assets/backchannel/it/     <- Italian, generated on demand
+assets/fillers/en/
+assets/start_filler/en/
+```
+
+Because the refresh pass (`remove_stale_clips`) only prunes `*.raw` files inside
+the directory it is given, scoping each language — base included — to its own
+subdirectory is what guarantees a regeneration never deletes another language's
+clips. No language is special-cased to the top level.
+
+### Phrase source
+
+Phrases come from built-in tables (Spanish, English, Italian, French, German and
+Portuguese) in [`src/lang.rs`](src/lang.rs) — one table for the backchannel, one
+for the end-of-turn filler and one for the start filler; for any other language
+they are generated with the LLM (`LANG_LLM_FALLBACK_ENABLED=true`). Each
+language's list is then synthesized through the same
+[`ensure_text_bank_clips`](src/assets.rs) pipeline used at startup, so an
+already-generated language is only reloaded (its `texts.txt` index matches) and
+never re-synthesized.
+
+### Detection & switching
+
+- A dedicated, short LLM call returns only the ISO 639-1 code
+  ([`lang::detect_language`](src/lang.rs)); it runs on the first user turn and
+  then once every `LANG_REDETECT_EVERY` turns (default `5`), so a
+  mid-conversation switch is picked up without paying for a detection call on
+  every turn.
+- Detection only runs when `LANG_DETECT_ENABLED=true`, the LLM is present, at
+  least one language-aware cue (backchannel / filler / start filler) is enabled
+  and the transcript is at least `LANG_MIN_CHARS` long (shorter samples are too
+  noisy to classify).
+- If the detected code equals the base language the session falls back to the
+  startup banks; otherwise the language's clips are ensured/loaded into a new
+  bank and the session switches to it.
+- The active language is shared between the consumers through an
+  `Arc<LanguageState>` ([`src/lang.rs`](src/lang.rs)): the end-of-turn and start
+  fillers ([`TurnManager`](src/orchestrator/turn_manager.rs)) read the active
+  bank per turn, while the backchannel scheduler is re-pointed via
+  [`BackchannelScheduler::retarget`](src/orchestrator/backchannel.rs) whenever
+  the language generation counter changes. Detection runs in the background, so
+  it never blocks the reply — it takes effect from the following turn.
+
+### Configuration
+
+| Variable | Default | Purpose |
+|---|---|---|
+| `LANG_DEFAULT` | `es` | Language of the startup filler / start-filler / backchannel banks (each in its own `<dir>/<lang>` subdirectory) |
+| `LANG_DETECT_ENABLED` | `true` | Master switch for LLM language detection |
+| `LANG_MIN_CHARS` | `12` | Minimum transcript length before detecting |
+| `LANG_REDETECT_EVERY` | `5` | Re-check the language every N user turns |
+| `LANG_LLM_FALLBACK_ENABLED` | `true` | Generate phrases via LLM for languages absent from the tables |
 
 ---
 
@@ -645,8 +942,9 @@ chat box  ──────────────┘
   the **first** chunk is cut once `LLM_STREAM_FIRST_CHUNK_CHARS` (default `20`)
   characters are buffered — so the agent starts speaking on the first few words
   instead of waiting for a whole sentence — and every following chunk at
-  `LLM_STREAM_CHUNK_CHARS` (default `120`). Set either to `0` to disable that
-  flush (chunks then end on sentence punctuation only).
+  `LLM_STREAM_CHUNK_CHARS` (default `240`). Set either to `0` to disable that
+  flush (chunks then end on sentence punctuation only). Larger follow-up chunks
+  mean fewer TTS requests, hence fewer chunk seams to starve the queue.
 - **Pipelined synthesis** — chunks are *not* synthesized one after another. Each
   chunk is requested as soon as the LLM produces it (up to `TTS_PIPELINE_DEPTH`,
   default `3`, in flight at once) and streams into its own staging buffer; a
@@ -666,6 +964,145 @@ chat box  ──────────────┘
 
 ---
 
+## Tool calling
+
+With `LLM_TOOLS_FILE` pointing at a JSON file, the model can call external HTTP
+services before answering. Tools are plain descriptions of an HTTP request, so
+any service (weather API, webhook, home automation, internal REST endpoint) can
+be exposed without touching the code:
+
+```json
+[
+  {
+    "name": "get_weather",
+    "description": "Current weather and temperature for a city.",
+    "parameters": {
+      "type": "object",
+      "properties": { "city": { "type": "string" } },
+      "required": ["city"]
+    },
+    "url": "https://wttr.in/{city}?format=3",
+    "method": "GET",
+    "headers": { "X-Api-Key": "…" }
+  }
+]
+```
+
+- `url` may contain `{arg}` placeholders substituted from the call arguments.
+- `GET` sends the arguments that were **not** consumed by a placeholder as query
+  parameters; `POST` (the default) sends them as a JSON body.
+- `headers` are optional and sent verbatim (API keys, etc.).
+
+See [`tools.example.json`](tools.example.json) for a ready-to-use file.
+
+### Why a client-side parser
+
+The deployment's OpenAI-compatible server (vLLM) runs **without** a tool parser
+(`--enable-auto-tool-choice --tool-call-parser …`), so it never returns
+structured `tool_calls` or `finish_reason: "tool_calls"`. The tools are still
+advertised in every request (`tools` + `tool_choice: "auto"`), so the Qwen model
+knows about them and emits the call **as text** in its native format:
+
+```text
+<tool_call>
+<function=get_weather>
+<parameter=city>
+Paris
+</parameter>
+</function>
+</tool_call>
+```
+
+[`src/tools.rs`](src/tools.rs) parses that format client-side and works with any
+server, no server-side reconfiguration needed.
+
+### Turn loop
+
+Each turn runs a bounded loop (`LLM_TOOL_MAX_ITERATIONS`, default `4`):
+
+1. Stream one reply. A `ToolCallStripper` removes `<tool_call>` blocks from the
+   streamed text — a block that is still incomplete is **held back**, so it is
+   never spoken by the TTS nor shown in the chat box even when split across
+   deltas. The visible text is spoken as usual, so the assistant can say
+   something short ("Let me check…") before calling.
+2. If the round produced no tool call, the turn ends.
+3. Otherwise the assistant message (with its native call) plus one `tool` role
+   message per result are appended, and the loop re-prompts the model, which can
+   then answer using the results.
+
+Tool errors (unknown tool, transport failure, non-2xx status) are returned to
+the model as text, so it can recover and still produce an answer; the turn never
+fails because of a tool. Only the *spoken* text is written to the rolling
+history — the tool exchange stays local to the turn.
+
+The `tool_call` event is also forwarded to the client for observability:
+
+```json
+{ "type": "tool_call", "name": "get_weather", "arguments": { "city": "Paris" } }
+```
+
+---
+
+## External audio injection
+
+The mixer has a dedicated **external channel** (`external_queue`) that plays an
+audio source injected from the client — a direct audio URL, an Icecast/Shoutcast
+radio stream, an HLS playlist, or a YouTube link — mixed together with the
+agent's voice. It is implemented by [`src/media.rs`](src/media.rs)
+(`MediaSource`) and driven over the WebSocket by the `audio_source` message
+(see [WebSocket Protocol](#websocket-protocol)). The Mivocero client exposes it
+in its footer bar.
+
+### Why `ffmpeg` / `yt-dlp`
+
+The channel does not decode audio itself: it spawns an external decoder process
+whose raw PCM output feeds the ring buffer.
+
+- **`ffmpeg`** (URL / radio / HLS) — reads the source and writes
+  `-f s16le -acodec pcm_s16le -ac 1 -ar 44100 pipe:1`, i.e. exactly the mixer's
+  format (44.1 kHz, 16-bit LE, mono). URL inputs use `-reconnect 1
+  -reconnect_streamed 1 -reconnect_delay_max 5` so a dropped radio connection is
+  retried instead of ending the stream.
+- **`yt-dlp`** (YouTube) — used only to *resolve* a YouTube page to a direct
+  media URL (`-f bestaudio/best -g --no-playlist`); that URL is then handed to
+  `ffmpeg`. YouTube-specific cookies/extractor tweaks go in `MEDIA_YTDLP_ARGS`
+  (e.g. `--cookies /path/cookies.txt` if the media server asks to "confirm
+  you're not a bot").
+
+Both binaries are configurable (`MEDIA_FFMPEG_BIN`, `MEDIA_YTDLP_BIN`) and are
+only required when the external channel is actually used.
+
+### Backpressure
+
+A live radio always produces audio at real time, but a bounded VOD source (a
+YouTube video, a file) decodes far faster than real time. The decode task
+respects the channel's `remaining_capacity()` and sleeps 20 ms whenever the
+queue is full, so a fast source is throttled to the mixer's drain rate instead
+of overflowing the ring buffer (which would drop the oldest samples).
+
+### Independence from the agent
+
+The external channel is deliberately **not** cleared by `AudioMixer::flush()`:
+a barge-in stops the *agent* (TTS + fillers), not the background music. It also
+does not count towards `AudioMixer::is_active()` — the agent is not considered
+to be "speaking" because the music is playing. Its volume is a runtime atomic
+(`AudioMixer::set_external_gain`) so the client slider takes effect on the next
+mixed frame.
+
+### Lifecycle
+
+| Step | What happens |
+|---|---|
+| `play` | Any current source is stopped; state `loading` is emitted. For a YouTube URL `yt-dlp` resolves the direct URL first. |
+| ready | `ffmpeg` is spawned and reading begins; state `playing` is emitted. |
+| streaming | Decoded PCM is pushed into `external_queue` under backpressure. |
+| `stop` / new `play` / disconnect | The `CancellationToken` is cancelled and the child processes are killed (`kill_on_drop(true)`); `stopped` (or `error`) is emitted. |
+
+A monotonic generation counter guards against a stale task clearing the state of
+a newer source.
+
+---
+
 ## Mivocero chat client
 
 A ready-to-use speech-to-speech example client is served at **`/mivocero`**
@@ -685,12 +1122,77 @@ A ready-to-use speech-to-speech example client is served at **`/mivocero`**
   without using the microphone (`{"type":"user_text","text":…}`).
 - **Interrupt button** — flushes audio and cancels the in-flight reply
   (`{"type":"interrupt"}`).
+- **External audio bar** — footer controls to inject a background source by URL
+  (direct audio / radio / YouTube), with **Play** / **Stop** buttons, a volume
+  slider (0–150 %, sent as `EXTERNAL_AUDIO_GAIN` × slider) and a live state
+  label driven by the server's `audio_source` events. Demonstrates the
+  [external audio channel](#external-audio-injection).
+- **Cue indicators** — a row of three tiles (**Filler**, **Start filler**,
+  **Backchannel**) that flash and bump a session counter each time the server
+  emits the matching cue, driven by the `{"type":"cue"}` events. The detail line
+  shows the backchannel category (or the clip name), so the emission cadence of
+  the latency masks is visible live. Counters reset on each connect.
+- **Cue methods panel** — a collapsible **Cue methods** section below the tiles
+  that documents the method used by each cue (when it fires, how a clip is
+  chosen) and shows the **live parameters** reported by the server in the
+  `{"type":"cues"}` event sent at session start: filler delay / gains / clip
+  count, start-filler go-delay, and the backchannel gain, min-speech, interval,
+  jitter, pause window, probability, volume jitter, per-turn cap and categories
+  — all read from the effective runtime configuration (no hard-coded values).
+- **Idle auto-disconnect** — the session closes itself after **2 minutes**
+  (`IDLE_TIMEOUT_MS`) without any traffic in either direction. The timer is
+  reset by every server event *and* audio frame received, and by every user
+  action sent (typed message, Stop, media controls) — so an ongoing reply or a
+  playing external source counts as activity. On expiry the WebSocket is closed,
+  the microphone is released, an explanatory message is appended to the chat and
+  the **Connect** button becomes available again.
 
 Open `http://localhost:8787/mivocero` (or `https://…` for remote microphone
 access — see [HTTPS](#https-microphone-access)).
 
 ---
 
+## Session audit log
+
+Every WebSocket session can be recorded to its own structured **JSONL** file —
+one JSON object per line — under `SESSION_AUDIT_DIR` (default `logs/sessions`),
+named `s-<epoch_ms>-<seq>.jsonl`. It is meant for post-mortem analysis and for
+tuning the latency knobs (why a filler fired, when a cue landed, how long the
+first audio took).
+
+Each record carries a wall-clock timestamp, the elapsed time since the session
+started, an event discriminator and a payload:
+
+```json
+{"ts":1729170000000,"elapsed_ms":12,"event":"session_start","data":{"config":{…},"runtime":{…}}}
+{"ts":1729170000123,"elapsed_ms":135,"event":"control","data":{"type":"user_text","text":"…"}}
+{"ts":1729170000456,"elapsed_ms":468,"event":"out","data":{"type":"assistant_delta","text":"Hola,"}}
+{"ts":1729170000500,"elapsed_ms":512,"event":"out","data":{"type":"cue","kind":"start_filler","name":"sf02"}}
+{"ts":1729170009000,"elapsed_ms":9012,"event":"session_end","data":{"reason":"client_disconnected","counts":{…}}}
+```
+
+| `event` | When | `data` |
+|---|---|---|
+| `session_start` | Session opens | `config` — the full non-secret configuration snapshot; `runtime` — which of STT / VAD / tokenizer / LLM are actually active (plus the LLM model). |
+| `control` | `user_text` control message received | The text turn. |
+| `out` | **Every** event sent to the client | The exact WS payload — `user`, `assistant_delta`, `assistant_end`, `tool_call`, `cue`, `error`, `audio_source` state, … Recorded at the single sender tap, so nothing sent to the browser is missed. |
+| `interrupt` | Client barge-in (`interrupt` JSON or legacy `INTERRUPT`) | `source` (`client` / `client_legacy`). |
+| `barge_in` | VAD-driven barge-in | `prob` (onset speech probability). |
+| `vad_speech_start` / `vad_speech_end` | Utterance boundaries | `prob`; `duration_ms`, `avg_prob`. |
+| `media` | External audio control | `action` (`play`/`stop`/`volume`) with `url` / `gain`. |
+| `reference` | Voice-cloning reference change | `action` (`set`/`clear`) and the audio path. |
+| `speak` | Direct TTS request (playground / fallback text) | `text`. |
+| `language_switch` | Detected language changed | `from`, `to`, `generated` (whether clip banks were synthesized). |
+| `error` | Transport / receiver error | `where`, `text`. |
+| `session_end` | Session closes | `reason`, `duration_ms`, `session_id`, `file`, `counts` (per-event totals). |
+
+The sink is **best-effort**: if the file cannot be opened, or a write fails, the
+session runs unchanged (the failure is logged once in the tracing output and the
+sink then goes quiet). Files are appended and flushed after every record, so the
+log survives a crash or a `pm2 restart`. The directory is git-ignored.
+
+---
+
 ## WebSocket Protocol
 
 Connect to `ws://<host>:8787/ws`.
@@ -702,6 +1204,9 @@ Connect to `ws://<host>:8787/ws`.
 | **Binary** | Raw 16-bit LE mono PCM microphone frames (44.1 kHz). Resampled to 16 kHz server-side for STT. |
 | **Text — `{"type":"user_text","text":"…"}`** | Text turn from the chat box: runs the same LLM → TTS path as a spoken utterance (no STT). |
 | **Text — `{"type":"interrupt"}`** | Barge-in: cancel the in-flight LLM reply / TTS and flush all queued audio. |
+| **Text — `{"type":"audio_source","action":"play","url":"…"}`** | Inject an external audio source (direct URL / radio / HLS / YouTube) into the mixer's external channel, replacing any current one. |
+| **Text — `{"type":"audio_source","action":"stop"}`** | Stop the external source and clear the channel. |
+| **Text — `{"type":"audio_source","action":"volume","gain":0.6}`** | Set the external channel gain (0..1) at runtime. |
 | **Text — `INTERRUPT`** *(also `interrupt`, `BAARGEIN`, `bargein`)* | Legacy barge-in form (kept for the playground). |
 | **Text — `SET_REFERENCE:<path>\|<text>`** | Set/change the voice-cloning reference. `<text>` may be omitted to re-use the sibling `.txt`. |
 | **Text — `CLEAR_REFERENCE`** | Disable voice cloning. |
@@ -715,7 +1220,11 @@ Connect to `ws://<host>:8787/ws`.
 | **Text — `{"type":"user","text":"…"}`** | The user's turn (STT transcript or chat-box message) — rendered in the chat box. |
 | **Text — `{"type":"assistant_delta","text":"…"}`** | Streaming chunk of the assistant reply (chain-of-thought already removed). |
 | **Text — `{"type":"assistant_end"}`** | The assistant turn is complete. |
+| **Text — `{"type":"tool_call","name":"…","arguments":{…}}`** | The model called a tool; the call has been executed (result is not echoed in the chat box, only in the model's next round). Purely informational. |
 | **Text — `{"type":"error","text":"…"}`** | LLM request failed; the turn was aborted. |
+| **Text — `{"type":"audio_source","state":"…","url":"…"}`** | External audio channel state change: `loading` (decoding is being set up / YouTube URL resolving), `playing` (PCM is streaming), `stopped`, or `error` (with a `text` message). |
+| **Text — `{"type":"cue","kind":"…","name":"…","category":"…"}`** | A latency-mask / backchannel cue was actually emitted into the mixer: `kind` is `filler` (end-of-turn), `start_filler` (turn start) or `backchannel` (during user speech); `name` is the clip name and `category` (backchannel only) its category. Fired only when the cue really plays — a skipped cue sends nothing. Drives the demo's cue indicators. |
+| **Text — `{"type":"cues","lang":"…","config":{…}}`** | Sent once at session start: the effective policy of the three cues for the active language — the filler parameters (`delay_ms`, gains, clip count), the start-filler `go_delay_ms` and the full backchannel configuration (gain, min-speech, interval, jitter, pause window, probability, volume jitter, per-turn cap, categories). Purely informational; drives the demo's **Cue methods** panel so it shows the live values instead of hard-coded ones. |
 
 ---
 
@@ -736,23 +1245,32 @@ Constants are defined in [`src/config.rs`](src/config.rs):
 ### Mixer & jitter buffering ([`src/audio/mixer.rs`](src/audio/mixer.rs))
 
 - Mixing formula:
-  `mixed = tts + (filler × filler_gain) + (backchannel × BACKCHANNEL_GAIN)`.
+  `mixed = tts + ((filler + start_filler) × filler_gain) + (backchannel × BACKCHANNEL_GAIN) + (external × external_gain)`.
   The filler gain is `1.0` when TTS is idle, else `filler_gain_duck` (default
   `0.15`); the backchannel gain is fixed (`BACKCHANNEL_GAIN`, default `0.35`).
-  Output is clamped to `i16`.
+  The start-filler channel is summed with the filler, so it shares the same gain.
+  The external channel gain starts at `EXTERNAL_AUDIO_GAIN` (default `0.6`) and
+  is adjustable at runtime (`AudioMixer::set_external_gain`). Output is clamped
+  to `i16`.
 - **Pre-buffer:** TTS playback does not start until the queue holds
-  ≥ `TTS_PREBUFFER_MS` (default **450 ms**) of synthesized audio. It absorbs
+  ≥ `TTS_PREBUFFER_MS` (default **550 ms**) of synthesized audio. It absorbs
   uneven TTS chunk arrival; lower it to start speaking sooner, raise it for fewer
-  drop-outs. With pipelined synthesis (above) the pre-buffer only has to cover
-  arrival jitter, not the TTS engine's per-request start-up, so it can stay
-  small. Note: Drama-3 delivers ~1.04× real time, and its *granularity* is set by
-  the server's vocoder window
-  (`--vocoder.factory.stream_followup_stride`, in codec frames of 2048 samples =
-  46.4 ms). With stride `16` and ramp `"[10,12,16]"` the first window is 10
-  frames = 0.464 s, so `450 ms` starts playback on that very first window (the
-  steady state then delivers a 0.743 s burst every ~0.69 s). With the upstream
-  default (`64`, a 2.97 s burst every ~2.7 s) gapless playback would instead
-  require a ~3 s pre-buffer.
+  drop-outs. Note: Drama-3's *granularity* is set by the server's vocoder window
+  (`--vocoder.factory.stream_stride` / `stream_followup_stride`, in codec frames
+  of 2048 samples = 46.4 ms). With the deployment used here (stride `4`, followup
+  `8`, overlap `16`) the first window is 4 frames = 0.186 s and the steady windows
+  are 8 frames = 0.372 s, delivered ~0.35 s apart (the server runs at ~0.95× real
+  time). Because `TTFA ≈ TTFB + (prebuffer − window)`, any pre-buffer in
+  `(186, 557]` ms primes on the **same** second window → TTFA ≈ `0.73 s`; the
+  default `550 ms` takes that whole cushion at no extra latency. A pre-buffer
+  below ~`186 ms` starts playback on the first window (TTFA ≈ `0.38 s`) but leaves
+  almost no margin: under concurrent TTS requests one GPU serves several requests
+  and the per-request throughput dips below real time (~`1.5×` vs ~`0.94×` alone),
+  so every chunk seam starves the queue and pauses playback → an audible
+  micro-gap at the start of each sentence. With the upstream default (`64`, a
+  2.97 s burst every ~2.7 s) gapless playback would instead require a ~3 s
+  pre-buffer; a large constant stride (`16`) both raises the TTFB (~1.2 s) and
+  bursts, and a growing ramp gaps the tail while the small early windows drain.
 - **Resilient resume:** the full pre-buffer is only required at the *first*
   playback of a reply. If the queue empties mid-reply (after the 200 ms drain
   grace) playback pauses, but resumes as soon as *any* audio is queued again —
@@ -774,13 +1292,15 @@ audio-agent-engine/
 ├── server.sh                 # start / stop / restart / status / logs / cert
 ├── certs/                    # self-signed TLS cert+key (generated)
 ├── UPDATES.md                # changelog (English, newest-first)
-├── assets/fillers/           # *.raw filler PCM (16-bit LE mono, 44.1 kHz; round-robin)
-├── assets/backchannel/       # *.raw backchannel PCM (16-bit LE mono, 44.1 kHz)
+├── tools.example.json        # tool definitions for LLM tool calling (copy/edit)
+├── assets/fillers/<lang>/    # *.raw filler PCM (16-bit LE mono, 44.1 kHz; round-robin), one dir per language
+├── assets/start_filler/<lang>/  # sf01.raw … turn-start start-filler clips + texts.txt index
+├── assets/backchannel/<lang>/   # bc01.raw … backchannel clips + texts.txt index
 ├── models/                   # Parakeet ONNX + Silero VAD + tokenizer
 └── src/
     ├── main.rs               # Axum server, routes, graceful shutdown
     ├── config.rs             # env-var config + audio constants
-    ├── assets.rs             # startup clip bootstrap (auto-generate fillers/backchannel)
+    ├── assets.rs             # startup clip bootstrap (auto-generate fillers/backchannel/start filler)
     ├── tls.rs                # optional HTTPS/WSS termination (rustls)
     ├── onnx.rs               # shared process-wide ONNX Runtime environment
     ├── audio/                # ring_buffer, mixer
@@ -791,6 +1311,9 @@ audio-agent-engine/
     ├── stt/                  # Parakeet ONNX + tokenizer + worker
     ├── vad/                  # Silero VAD v5 + onset/offset state machine
     ├── llm.rs                # OpenAI-compatible chat-completions client (streaming + think stripping)
+    ├── tools.rs              # configurable HTTP tool calling (native <tool_call> parser + executor)
+    ├── media.rs              # external audio source (URL / radio / YouTube) via ffmpeg + yt-dlp
+    ├── audit.rs              # per-session JSONL audit log (config snapshot, events, summary)
     ├── orchestrator/         # turn_manager (EOU/STT → LLM → filler → TTS) + backchannel
     ├── ws/                   # handler, session (per-connection audio loop)
     └── web/                  # embedded playground.html + mivocero.html
diff --git a/UPDATES.md b/UPDATES.md
index e67333a..9dfbac3 100644
--- a/UPDATES.md
+++ b/UPDATES.md
@@ -5,6 +5,813 @@ Entries are written in English and ordered newest-first.
 
 ---
 
+## 2026-10-17 — Cue methods panel in the Mivocero client (live cue policy)
+
+### Added
+
+- **`cues` WebSocket event** — sent once at session start by
+  `src/ws/session.rs`, it reports the **effective policy** of the three cues for
+  the active language: the filler (`delay_ms`, `gain_idle`, `gain_duck`, clip
+  count, bank dir), the start filler (`go_delay_ms`, clip count, bank dir) and
+  the backchannel (gain, min-speech, interval, jitter, pause window,
+  probability, volume jitter, per-turn cap, categories, clip count). The
+  backchannel `pause_max_ms` is capped to the VAD EOU window exactly like
+  `BackchannelScheduler::pause_max`; the bank paths are the language
+  subdirectories (`assets/fillers/<lang>`). Purely informational.
+- **Cue methods panel** in `src/web/mivocero.html` — a collapsible
+  `<details>` section under the cue tiles with one card per cue: the **method**
+  used (when it fires, how a clip is chosen) and the **live parameters** from
+  the `cues` event, so the panel always matches the running configuration
+  instead of hard-coded values.
+
+### Notes
+
+- The panel is display-only; it changes no behaviour. Values reflect the
+  process configuration at session start (env-derived), so a `.env` change is
+  visible after the next session.
+
+---
+
+## 2026-10-17 — Per-session audit log (structured JSONL)
+
+### Added
+
+- **`src/audit.rs`** — a best-effort per-session audit sink. Each WebSocket
+  session is recorded to its own JSONL file
+  (`SESSION_AUDIT_DIR/<id>.jsonl`, id `s-<epoch_ms>-<seq>`), one record per line:
+  `{"ts":…,"elapsed_ms":…,"event":…,"data":…}`. Records are flushed as they are
+  written, and any failure (directory/file creation, write) only disables the
+  sink for that session — the session itself is never affected.
+- **Event coverage (complete)**:
+  - `session_start` — full non-secret configuration snapshot plus the active
+    runtime capabilities (STT / VAD / tokenizer / LLM + model);
+  - `control` — inbound `user_text` turns;
+  - `out` — **every** event sent to the client, tapped at the single sender
+    point in `src/ws/session.rs` so nothing is missed (`user`,
+    `assistant_delta`, `assistant_end`, `tool_call`, `cue`, `error`,
+    `audio_source` state, …);
+  - `interrupt` — client barge-in (JSON or legacy text form);
+  - `barge_in` — VAD-driven barge-in (with the onset probability);
+  - `vad_speech_start` / `vad_speech_end` — utterance boundaries;
+  - `media` / `reference` / `speak` — external-audio control, voice-reference
+    changes and direct TTS requests;
+  - `language_switch` — detected language change (`from`, `to`, `generated`) —
+    `src/orchestrator/turn_manager.rs`;
+  - `error` — transport/receiver errors;
+  - `session_end` — reason, duration, session id, file and per-event counts.
+- **Config** — `SESSION_AUDIT_ENABLED` (default `true`) and
+  `SESSION_AUDIT_DIR` (default `logs/sessions`); documented in `.env`,
+  `.env.example` and the README. `logs/` is git-ignored.
+
+### Changed
+
+- `TurnManager::new` takes an `Arc<SessionAudit>` (used for the language-switch
+  record); every other event reaches the log through the sender tap.
+
+### Notes
+
+- The audit path is off the audio hot path (the sink only touches the outbound
+  text events, not the 20 ms frames) and is disabled cleanly when the LLM/VAD/…
+  are off. Intended for post-mortem analysis and for tuning the latency knobs.
+
+---
+
+## 2026-10-17 — Cue emission indicators in the Mivocero demo
+
+### Added
+
+- **`{"type":"cue"}` WebSocket event** — the server now tells the client each
+  time a latency-mask / backchannel cue is **actually emitted** into the mixer:
+  - **filler** (end-of-turn) — `src/orchestrator/turn_manager.rs`
+    (`schedule_filler`),
+  - **start_filler** (turn start) — `src/orchestrator/turn_manager.rs`
+    (`schedule_start_filler`),
+  - **backchannel** (during user speech) — `src/ws/session.rs` (mic task).
+  The payload is `{"type":"cue","kind":…,"name":…}` and, for backchannel, also
+  `"category":…`. A cue that is skipped (audio already arrived / playing, or a
+  barge-in) sends nothing.
+- **`BackchannelScheduler::maybe_emit`** now returns `(name, category)` instead
+  of just the name, so the backchannel cue carries its category.
+- **Mivocero cue indicators** — `src/web/mivocero.html` gained a row of three
+  tiles (**Filler**, **Start filler**, **Backchannel**) that flash (colour-coded
+  dot + border glow) and bump a per-session counter on every `cue` event, with a
+  detail line showing the backchannel category (or the clip name). Counters reset
+  on each connect.
+
+### Notes
+
+- Only real emissions are reported, so the panel is a faithful view of what the
+  user actually hears — useful for tuning `FILLER_DELAY_MS` /
+  `START_FILLER_GO_DELAY` and the backchannel cadence.
+
+---
+
+## 2026-10-17 — Per-language subdirectory for every clip bank (base included)
+
+### Changed
+
+- **`src/main.rs`** — the startup bootstrap now generates and loads the three
+  base banks (filler, start-filler, backchannel) from
+  `<dir>/<LANG_DEFAULT>/` via [`assets::lang_dir`](src/assets.rs) instead of the
+  top-level directory. Every language — **including the default one** — now
+  lives in its own subdirectory, so the filler, start-filler and backchannel
+  share the exact same layout for every language and no language is special-cased
+  to the top level.
+- **`src/assets.rs`** — [`lang_dir`](src/assets.rs) doc updated accordingly.
+
+### Notes
+
+- On the first start after this change the base clips are re-synthesized into
+  `assets/<bank>/<lang>/`. To avoid the re-synthesis, move the existing
+  top-level `*.raw` files (and `texts.txt`) into the matching language
+  subdirectory by hand — this was done for the `es` deployment.
+- No other language's clips are touched: the per-language subdirectory remains
+  what isolates each language's refresh (`remove_stale_clips`).
+
+---
+
+## 2026-10-17 — Multilingual clip banks (backchannel, filler & start filler)
+
+### Added
+
+- **`src/lang.rs`** — new multilingual module. It holds built-in phrase tables
+  for **backchannel** (category + phrase), **filler** (interjections) and
+  **start filler** (turn-start acknowledgments, with Drama-3 style tags) in
+  Spanish, English, Italian, French, German and Portuguese, exposes accessors
+  for them, and implements the auxiliary LLM calls: `detect_language` (returns
+  only the ISO 639-1 code, or `und`) and `generate_backchannel_texts` /
+  `generate_filler_texts` / `generate_start_filler_texts` (LLM fallback for
+  languages absent from the tables).
+  It also defines `LangBanks` (a language's loaded clip banks, including its
+  start-filler bank) and `LanguageState` (the session's active language plus a
+  generation counter, kept in a parking-lot `RwLock`).
+- **On-demand per-language generation** — when the user's language differs from
+  the active one, that language's backchannel/filler/start-filler clips are
+  synthesized into a **per-language subdirectory** (`assets/backchannel/<lang>/`,
+  `assets/fillers/<lang>/`, `assets/start_filler/<lang>/`) and the session
+  switches to them. Because the refresh pass only prunes clips inside the
+  directory it is given, **no other language's clips are ever removed**; the
+  base language keeps living in the top-level directories, so no migration is
+  needed.
+- **New env vars** — `LANG_DEFAULT` (default `es`), `LANG_DETECT_ENABLED`
+  (default `true`), `LANG_MIN_CHARS` (default `12`), `LANG_REDETECT_EVERY`
+  (default `5`) and `LANG_LLM_FALLBACK_ENABLED` (default `true`).
+
+### Changed
+
+- **`src/llm.rs`** — new `LlmClient::simple_chat` for short, non-streaming
+  auxiliary requests (explicit system + user message, **no** tools), used by the
+  language detection and phrase-generation calls.
+- **`src/config.rs`** — five new `LANG_*` fields, parsed in `from_env`.
+- **`src/assets.rs`** — `lang_dir` helper plus `ensure_lang_backchannel_clips` /
+  `ensure_lang_filler_clips` / `ensure_lang_start_filler_clips`, which scope the
+  text-bank refresh to `<base>/<lang>/` so each language is refreshed
+  independently.
+- **`src/orchestrator/backchannel.rs`** — the clip/category mapping is extracted
+  into `map_clips`, and `BackchannelScheduler::retarget` re-points a live
+  scheduler to a new bank when the language changes. `DEFAULT_CATEGORY` is now
+  `pub(crate)` so `lang.rs` can reuse it.
+- **`src/orchestrator/turn_manager.rs`** — `TurnManager` now holds an
+  `Arc<LanguageState>` instead of a single filler bank; `next_filler` and the
+  start filler read from the active language (`schedule_start_filler` picks from
+  `langs.current().start_filler`). A new `maybe_detect_language` runs on each
+  user turn (first turn + every `LANG_REDETECT_EVERY`) and spawns
+  `switch_language_if_needed`, which detects, generates/loads the target
+  language's banks (start filler optional: a missing table just leaves that cue
+  silent) and swaps the active state — in the background, so the reply is never
+  blocked.
+- **`src/ws/session.rs`** — builds the shared `LanguageState`; the mic task polls
+  the language generation counter each frame and calls `retarget` on the
+  backchannel scheduler only when it changes.
+- **`.env` / `.env.example`** — new "Multilingual clip banks" section;
+  **`README.md`** — new "Multilingual clip banks" section.
+
+### Why
+
+- The banks were pre-synthesized in a single language, so a user speaking any
+  other language heard Spanish cues — including the start filler. Generating the
+  matching language on demand keeps the acknowledgment natural in a multilingual
+  deployment, while the per-language directory layout guarantees that adding a
+  language never destroys the clips already generated for the others.
+
+### Notes
+
+- Detection needs the LLM (`LANG_DETECT_ENABLED` is a no-op without it); the LLM
+  phrase fallback is used only for languages outside the built-in tables.
+- Generating a new language's bank calls the TTS backend once per phrase, which
+  can take a few seconds on the first switch; it is idempotent (an
+  already-generated language is only reloaded).
+
+---
+
+## 2026-10-16 — Mivocero: auto-disconnect an idle session after 2 minutes
+
+### Added
+
+- **Idle guard in the Mivocero client** ([`src/web/mivocero.html`](src/web/mivocero.html)) —
+  the session closes itself after `IDLE_TIMEOUT_MS` (2 minutes) without any
+  activity. `touchActivity()` re-arms the timer and is called on every server
+  event, on every received audio frame and on every user action sent
+  (`sendJson`), so an ongoing reply or a playing external source keeps the
+  session alive. On expiry it logs the reason, appends an explanatory message to
+  the chat and calls `disconnect()`, which closes the WebSocket and releases the
+  microphone.
+
+### Changed
+
+- **Reconnect after close** — `ws.onclose` now clears the `ws` reference.
+  Without it the Connect button stayed bound to the stale socket, so a session
+  closed by the idle guard (or by any disconnect) could not be reopened without
+  reloading the page.
+
+### Why
+
+- A microphone-backed session left open keeps the device busy and the server
+  streaming silent 20 ms frames forever. An inactivity timeout releases both
+  without user action, while still allowing a long reply or a background radio
+  to run uninterrupted.
+
+### Notes
+
+- The timer counts *any* traffic in either direction: TTS audio is sent as
+  binary frames, so speaking does not trip the timeout.
+- The timeout is a client-side constant (`IDLE_TIMEOUT_MS` in the HTML); change
+  it there and rebuild (the page is embedded with `include_str!`).
+
+---
+
+## 2026-10-16 — Tool calling: configurable HTTP tools for the LLM
+
+### Added
+
+- **`src/tools.rs`** — new tool-calling module. It loads tool definitions from a
+  JSON file and provides: a `ToolRegistry` (builds the OpenAI `tools` array,
+  executes a call over HTTP), a client-side parser for the model's **native**
+  `<tool_call>` format, and a `ToolCallStripper` that removes tool-call blocks
+  from the streamed reply — holding back a block that is still incomplete, so it
+  is never spoken by the TTS nor shown in the chat box even when split across
+  deltas (same hold-back pattern as the chain-of-thought stripper).
+- **`tools.example.json`** — ready-to-use definitions: `get_weather` (GET with a
+  `{city}` URL placeholder, wttr.in) and `send_webhook` (POST with a custom
+  header), covering both request shapes.
+- **New env vars** — `LLM_TOOLS_ENABLED` (auto: on when `LLM_TOOLS_FILE` is set),
+  `LLM_TOOLS_FILE`, `LLM_TOOL_MAX_ITERATIONS` (default `4`),
+  `LLM_TOOL_TIMEOUT_SECS` (default `15`) and `LLM_TOOL_RESULT_MAX_CHARS`
+  (default `2000`).
+- **`ChatMessage::tool`** — `role: "tool"` message used to hand a tool result
+  back to the model.
+- **WebSocket protocol** — informational
+  `{"type":"tool_call","name":"…","arguments":{…}}` event emitted when the model
+  calls a tool.
+
+### Changed
+
+- **`LlmClient`** carries an optional `Arc<ToolRegistry>`
+  ([`src/llm.rs`](src/llm.rs)); when present, every request advertises
+  `tools` + `tool_choice:"auto"`, so the model knows which functions it may
+  call. The registry is built by `load_tools(config)`; a missing or invalid file
+  logs a warning and leaves tool calling disabled without breaking the pipeline.
+- **[`TurnManager::run_llm_turn`](src/orchestrator/turn_manager.rs)** now runs a
+  bounded tool loop: each round streams a reply through the `ToolCallStripper`;
+  if a call was emitted, the assistant message (with its native call) plus one
+  `tool` message per result are appended and the model is re-prompted, up to
+  `LLM_TOOL_MAX_ITERATIONS`. The TTS pipeline is created once and every round's
+  visible text flows into it, so the assistant can say something short before
+  calling. Only the spoken text is written to the rolling history.
+
+### Why
+
+- The deployment's vLLM server runs **without** a tool parser
+  (`--enable-auto-tool-choice --tool-call-parser …`), so it never returns
+  structured `tool_calls` / `finish_reason:"tool_calls"`. Tools are still
+  advertised in the request and the Qwen model emits the call as text in its
+  native format; parsing it client-side keeps the feature working with any
+  server and requires no server-side reconfiguration.
+- Tool definitions live in a JSON file rather than `.env` so the verbose JSON
+  schemas stay readable and editable.
+
+### Notes
+
+- Tool errors (unknown tool, transport failure, non-2xx status) are returned to
+  the model as text so it can recover; a tool never fails the turn.
+- `GET` sends arguments not consumed by a `{arg}` placeholder as query
+  parameters; `POST` sends them as a JSON body. `headers` are sent verbatim.
+
+---
+
+## 2026-10-16 — External audio channel: inject a URL / radio / YouTube source
+
+### Added
+
+- **`src/media.rs`** — new [`MediaSource`](src/media.rs) module implementing an
+  external audio source for a WebSocket session. A source is decoded by an
+  external process and its raw PCM is pushed into the mixer's new external ring
+  buffer. `ffmpeg` decodes direct URLs / radio / HLS
+  (`-f s16le -acodec pcm_s16le -ac 1 -ar 44100 pipe:1`, with
+  `-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5`); YouTube links are
+  first resolved to a direct URL with `yt-dlp` (`-f bestaudio/best -g
+  --no-playlist`). Child processes are killed on stop / replacement /
+  disconnection (`kill_on_drop(true)` + `CancellationToken`), and a monotonic
+  generation counter prevents a stale task from clearing a newer source.
+- **Mixer external channel** — `AudioMixer` gains `external_queue` and a runtime
+  gain ([`src/audio/mixer.rs`](src/audio/mixer.rs)). The mixing formula becomes
+  `… + (external × external_gain)`; `set_external_gain` updates the gain (an
+  atomic, so it takes effect on the next frame without rebuilding the mixer).
+  The external queue is **not** cleared by `flush()` and does not count towards
+  `is_active()`: a barge-in stops the agent, not the background audio.
+- **New env vars** — `EXTERNAL_AUDIO_GAIN` (default `0.6`),
+  `MEDIA_FFMPEG_BIN` (default `ffmpeg`), `MEDIA_YTDLP_BIN` (default `yt-dlp`) and
+  `MEDIA_YTDLP_ARGS` (extra `yt-dlp` args, e.g. `--cookies …`).
+- **WebSocket protocol** — new `audio_source` message:
+  `{"type":"audio_source","action":"play","url":"…"}`,
+  `{"type":"audio_source","action":"stop"}` and
+  `{"type":"audio_source","action":"volume","gain":0.6}`. The server reports
+  state back with `{"type":"audio_source","state":"loading|playing|stopped|error","url":"…"}`
+  ([`src/ws/session.rs`](src/ws/session.rs)).
+- **Mivocero client** — footer bar with a URL input, **Play** / **Stop**
+  buttons, a volume slider (0–150 %) and a live state label, driving the external
+  channel ([`src/web/mivocero.html`](src/web/mivocero.html)).
+
+### Changed
+
+- [`TurnManager::set_external_gain`](src/orchestrator/turn_manager.rs) forwards
+  the client volume to the mixer.
+- New module declared in [`src/main.rs`](src/main.rs) (`mod media;`).
+
+### Why
+
+- Lets the agent play a music/radio/YouTube bed under the voice — useful for
+  demos (radio, background music) — while keeping the channel fully independent
+  of the speech pipeline so it survives barge-in.
+
+### Notes
+
+- Only needed when the external channel is used: `ffmpeg` for URL/radio/HLS and
+  `yt-dlp` for YouTube. YouTube may require cookies in some environments; pass
+  them via `MEDIA_YTDLP_ARGS=--cookies /path/cookies.txt`.
+- A bounded source (VOD) is throttled to the mixer's drain rate via backpressure
+  (`remaining_capacity()` + 20 ms sleeps), so a fast decoder cannot overflow the
+  ring buffer.
+
+---
+
+## 2026-10-16 — Drama 3 de-emphasis: sampling knobs + neutral style tag
+
+### Added
+
+- **`TTS_TEMPERATURE`** (default `0.45`), **`TTS_TOP_P`** (default `0.75`) and
+  **`TTS_TOP_K`** (unset) — optional sampling overrides forwarded in the
+  `/v1/audio/speech` payload by the `fish` engine. An empty value omits the field
+  so the server default applies. New `env_opt_f32` / `env_opt_u32` helpers in
+  [`src/config.rs`](src/config.rs) implement the "unset → fallback, empty →
+  `None`" semantics.
+- **`TTS_STYLE_TAG`** (default `[conversational, casual]`) — a neutral style tag
+  prepended to every synthesis request whose text does not already start with a
+  `[...]` tag ([`FishAudioTts::styled`](src/tts/fish_audio.rs)). Empty disables
+  the prefix.
+
+### Changed
+
+- [`SpeechRequest`](src/tts/fish_audio.rs) gains optional `temperature`, `top_p`
+  and `top_k` fields (serialized only when set); the request body now uses the
+  styled text as `input`. Startup logs `TTS de-emphasis settings …`, and the
+  per-request debug log shows the sampling values and whether the text was
+  prefixed (`styled=`).
+
+### Why
+
+- Drama 3 over-articulates: LLM replies could come back with a theatrical,
+  radio-drama cadence. Exaggerated intonations live in the tails of the acoustic
+  token distribution, so trimming the sampling tails (`temperature` / `top_p`)
+  flattens the delivery, and a neutral style tag steers untagged (LLM) prose into
+  a conversational register. Clip banks carry their own tags and are untouched.
+
+### Notes
+
+- `repetition_penalty` is deliberately **not** exposed: this server rejects any
+  value other than `1.0` (`Drama 3 request: repetition_penalty must be 1.0`).
+  `min_p`, `seed` and a nested `sampling_params` are rejected too.
+- The voice-cloning reference (`solis.wav`) is left unchanged for now — its
+  "locutor profesional" prosody is a further, separate lever.
+- **`.env` gotcha surfaced during this change.** `dotenvy` fails on unquoted
+  values containing spaces, and a single bad line makes it discard the whole
+  file: the process then silently starts with built-in defaults (no LLM, plain
+  HTTP) while `server.sh` still reports the scheme from its own `.env` grep. The
+  style tag is therefore quoted (`TTS_STYLE_TAG="[conversational, casual]"`).
+
+---
+
+## 2026-10-16 — Backchannel: random reaction depth inside the micro-pause
+
+### Changed
+
+- [`BackchannelScheduler::maybe_emit`](src/orchestrator/backchannel.rs) now draws
+  the depth at which it reacts **per pause**: the first time a micro-pause is
+  seen, a target is picked uniformly in `[BACKCHANNEL_PAUSE_MIN_MS,
+  BACKCHANNEL_PAUSE_MAX_MS]` and the cue fires only once `silence_ms()` reaches
+  it (new `pause_target_ms` field, cleared when the pause ends or the turn
+  resets). Previously the cue fired at the *first* analysis window inside the
+  window, so with a 32 ms VAD step every cue landed at exactly
+  `BACKCHANNEL_PAUSE_MIN_MS`.
+- A pause that grows past the upper bound (on its way to end-of-utterance) is
+  abandoned without firing.
+
+### Why
+
+- Verification on a live session showed every cue at `pause_ms=96`, i.e. all cues
+  reacting at exactly the minimum — a residual regularity in an otherwise
+  naturalized feature. Randomizing the depth removes it: cues now land anywhere
+  in the window (observed `pause_ms` of `96`, `128`, `192`, …).
+
+### Notes
+
+- No new environment variables: the behaviour is driven by the existing
+  `BACKCHANNEL_PAUSE_MIN_MS` / `BACKCHANNEL_PAUSE_MAX_MS` window.
+- Because the VAD advances in 32 ms windows, the emitted `pause_ms` is a multiple
+  of 32 ms; the randomly drawn target is what varies.
+
+---
+
+## 2026-10-16 — Backchannel sounds more natural (micro-pause cues, jittered timing, categories)
+
+### Added
+
+- **`BACKCHANNEL_JITTER_MS`** (default `1200`), **`BACKCHANNEL_PAUSE_MIN_MS`**
+  (default `96`), **`BACKCHANNEL_PAUSE_MAX_MS`** (default `260`),
+  **`BACKCHANNEL_PROB`** (default `0.65`) and **`BACKCHANNEL_VOLUME_JITTER`**
+  (default `0.2`) — new `.env` knobs (`.env`, `.env.example`,
+  [`BackchannelSettings`](src/orchestrator/backchannel.rs)) that shape the cue
+  timing, spacing, hit rate and loudness drift.
+- **Category prefix** in `BACKCHANNEL_TEXTS`: a line may be written
+  `category::phrase` (e.g. `ack::[calm] Mm-hmm...`, `agree::[agreeing] Claro...`);
+  [`parse_texts`](src/orchestrator/backchannel.rs) stores the category alongside
+  the phrase and defaults to `ack` when the prefix is absent.
+- [`VadDetector::silence_ms`](src/vad/silero.rs) — exposes the running silence
+  inside the current utterance (multiples of the 32 ms analysis window), i.e. the
+  length of the micro-pause the speaker is currently in.
+- [`FillerBank::names`](src/orchestrator/turn_manager.rs) — read accessor for the
+  clip names, used to map the bank order onto the phrase/category list.
+
+### Changed
+
+- [`BackchannelScheduler::maybe_emit`](src/orchestrator/backchannel.rs) now takes
+  the VAD micro-pause length and fires a cue **only inside a
+  `PAUSE_MIN_MS..PAUSE_MAX_MS` window** (the upper bound is capped just below
+  `VAD_MIN_SILENCE_MS` so it never collides with end-of-utterance), **at most once
+  per pause** (latched with `pause_settled`).
+- Cue timing is **randomized**: the first cue of a turn waits
+  `MIN_SPEECH_MS + rand(0..JITTER_MS)`, and the gap to the next cue is
+  `INTERVAL_MS ± JITTER_MS/2` — instead of a fixed interval.
+- Each qualifying pause passes a **probabilistic gate** (`PROB`); a miss does not
+  retry on the same pause.
+- The clip is chosen with an **anti-repetition** rule (skips the last two clips)
+  and its samples are scaled by **±`VOLUME_JITTER`** before being pushed to
+  `backchannel_queue`.
+- Selection follows a **category progression** through the turn — it prefers a
+  category other than the last one used and favours categories not yet used this
+  turn (e.g. `ack` then `agree`), falling back to a random clip.
+- `BACKCHANNEL_MAX_PER_TURN` default lowered **8 → 3**, so the agent emits a
+  couple of cues per turn rather than chattering.
+
+### Why
+
+- A fixed interval with a fixed clip made the backchannel feel mechanical and
+  detached from the speaker. Real listeners react to *pauses*, not to a metronome:
+  cueing inside the speaker's own micro-pauses, with jittered spacing, an
+  occasional deliberate skip, mild volume drift and a little progression
+  (acknowledge → agree) reads as attentive listening instead of a loop.
+
+### Notes
+
+- The naturalness knobs are all optional; omitting them keeps the previous
+  behaviour except for the `MAX_PER_TURN` default (now `3`).
+- Nested clamps in `from_env`: `interval_ms >= 500`, `pause_max >= pause_min`,
+  and `gain`/`prob`/`volume_jitter` are clamped to sane ranges.
+- A debug line is logged only when a cue is actually emitted:
+  `backchannel emitted during user speech … pause_ms=…` (enable
+  `audio_agent_engine::orchestrator=debug` in `RUST_LOG`).
+
+---
+
+## 2026-10-16 — Backchannel becomes a random phrase bank driven by `BACKCHANNEL_TEXTS`
+
+### Added
+
+- **`BACKCHANNEL_TEXTS`** (`.env`, `.env.example`,
+  [`BackchannelSettings`](src/orchestrator/backchannel.rs)): the backchannel bank
+  is now a list of phrases, **one per line** (a `|` separator is also accepted),
+  with Drama-3 style tags passed straight through to the TTS. `.env` ships 8
+  Spanish phrases (`[calm] Mm-hmm...`, `[attentive] Ajá...`, …); the Rust default
+  is [`DEFAULT_BACKCHANNEL_TEXTS`](src/orchestrator/backchannel.rs).
+- [`assets::ensure_backchannel_clips`](src/assets.rs), implemented on top of the
+  new generic [`assets::ensure_text_bank_clips`](src/assets.rs): synthesizes **one
+  clip per phrase** at startup (`bc01`, `bc02`, …, `TEXT_BANK_CONCURRENCY = 4` at
+  a time) and removes clips left over from a previous list. The list the current
+  clips were made from is stored in `BACKCHANNEL_DIR/texts.txt`; when it is
+  unchanged and every clip is present the whole synthesis is **skipped**, so a
+  restart costs ~2 s instead of ~1 s per phrase. The index is only written once
+  every clip succeeded, so a partial failure is retried at the next startup.
+
+### Changed
+
+- [`BackchannelScheduler::maybe_emit`](src/orchestrator/backchannel.rs) picks the
+  clip **at random** ([`FillerBank::random`](src/orchestrator/turn_manager.rs),
+  xorshift64 seeded from the clock) instead of round-robin, so the acknowledgment
+  varies from turn to turn — the same behaviour the start filler already had. The
+  `next_index` cursor was dropped.
+- `assets::ensure_start_filler_clips` is now a thin wrapper over
+  `ensure_text_bank_clips`, so the start filler and the backchannel share one
+  implementation. Its logs gained a `label` field
+  (`refreshing backchannel clips at startup …`).
+- The backchannel no longer uses the fixed `assets::BACKCHANNEL_CLIPS` list
+  (removed); its defaults moved to `DEFAULT_BACKCHANNEL_TEXTS`.
+
+### Why
+
+- A fixed 4-clip bank repeated the same "mm-hmm / ajá" over and over; a curated
+  list with tags keeps the agent sounding natural and is editable straight from
+  `.env`, exactly like the start filler.
+- The old bootstrap (`ensure_clips`) only generated *missing* clips, so changing
+  the phrases required deleting files by hand; the phrase list is now the source
+  of truth.
+
+### Notes
+
+- Clips are named by position, so switching from the old names (`mmhmm`, `aja`,
+  `claro`, `yaveo`) to `bc01`…**removes** the four legacy files on the first
+  restart after this change (logged as `removed stale backchannel clip`).
+- `BACKCHANNEL_GAIN`, `BACKCHANNEL_MIN_SPEECH_MS`, `BACKCHANNEL_INTERVAL_MS` and
+  `BACKCHANNEL_MAX_PER_TURN` are unchanged.
+
+---
+
+## 2026-10-16 — Fix: start filler fired on every turn (gate on chunk arrival, not playback)
+
+### Fixed
+
+- [`TurnManager::schedule_start_filler`](src/orchestrator/turn_manager.rs) gated the
+  cue on `AudioMixer::tts_playback_started`, which only flips once the **TTS
+  pre-buffer** (`TTS_PREBUFFER_MS`) is full — i.e. when playback starts, ~1.9 s
+  after the dispatch in the reference deployment. The first response chunk
+  actually arrives at ~0.7–1.0 s, so a `START_FILLER_GO_DELAY` of 1200 ms was
+  almost always *shorter* than the gate's own signal and the acknowledgment was
+  queued on essentially every turn.
+- The gate now uses the new
+  [`AudioMixer::tts_audio_arrived`](src/audio/mixer.rs), latched as soon as the
+  first TTS samples are queued for the turn (checked on the 20 ms ticker),
+  **before** the pre-buffer is reached. Both `tts_audio_arrived` and
+  `tts_playback_started` are reset by `mark_stream_start` / `flush`.
+  A fast reply that produces audio within `START_FILLER_GO_DELAY` therefore
+  suppresses the cue, as intended.
+
+### Changed
+
+- The skip log line is now `first response audio already arrived — start filler
+  skipped` (was `response audio already playing — start filler skipped`).
+- The end-of-turn filler is unchanged: it still keys off
+  `tts_playback_started` (its 2500 ms delay is long enough that playback start is
+  the right signal).
+
+### Notes
+
+- No configuration change; `START_FILLER_GO_DELAY=1200` now means what the `.env`
+  comment always said ("first audio chunk of the reply"). Verified in the log: a
+  text turn in which the first chunk reached the mixer ~0.4 s after the TTS
+  request logged `first response audio already arrived — start filler skipped`
+  with no `queued start filler` for the turn.
+
+---
+
+## 2026-10-16 — Start filler becomes conditional: `START_FILLER_GO_DELAY` (1200 ms)
+
+### Changed
+
+- The start filler is no longer played on **every** turn: it is now a *latency
+  mask*, scheduled exactly like the end-of-turn filler but on its own channel and
+  with its own, shorter delay.
+  [`TurnManager::schedule_start_filler`](src/orchestrator/turn_manager.rs)
+  (replacing `play_start_filler`) sleeps `START_FILLER_GO_DELAY` after the turn is
+  dispatched and queues a random phrase **only if the first response audio has not
+  started playing** (`AudioMixer::tts_playback_started` still `false`); otherwise
+  the cue is dropped. *(The gate was later changed to `tts_audio_arrived` — see
+  the entry above, which fixes this cue firing on every turn.)* A pending cue is
+  cancelled on barge-in / new turn through the turn's `CancellationToken`, and
+  `mixer.flush` clears it once queued.
+- The scheduling now happens in `run_llm_turn` / `dispatch_tts` next to
+  `schedule_filler` (where the turn's cancellation token and `mark_stream_start`
+  live) instead of at the top of `handle_user_turn`, because the delay must be
+  measured from the dispatch of the reply and be cancellable with it.
+
+### Added
+
+- **`START_FILLER_GO_DELAY`** (`.env`, `.env.example`, default `1200` ms): how long
+  to wait for the first response audio before falling back to the start filler.
+
+### Why
+
+- The cue is only useful when the reply is *late*; a fast reply (LLM + TTS first
+  chunk under 1200 ms) is now answered directly, without an unnecessary
+  "Un momento…" in front of it.
+
+### Notes
+
+- The 22-clip bank, the random pick and the startup refresh are unchanged.
+
+---
+
+## 2026-10-16 — Start filler: random phrase bank driven by `START_FILLER_TEXTS`
+
+### Added
+
+- **`START_FILLER_TEXTS`** (`.env`, `.env.example`,
+  [`src/config.rs`](src/config.rs)) replaces the single `START_FILLER_TEXT`: a
+  list of phrases, **one per line** (a `|` separator is also accepted), e.g. the
+  Spanish set `"[calm] Un momento..."`, `"[thoughtful] A ver, veamos..."`, … with
+  Drama-3 style tags passed straight through to the TTS. `.env` ships 22 phrases.
+- [`assets::ensure_start_filler_clips`](src/assets.rs): synthesizes **one clip per
+  phrase** at startup (`sf01`, `sf02`, …, generated
+  `START_FILLER_CONCURRENCY = 4` at a time) and removes clips left over from a
+  previous list. The list the current clips were made from is stored in
+  `START_FILLER_DIR/texts.txt`; when it is unchanged and every clip is present the
+  whole synthesis is **skipped**, so a restart costs ~2 s instead of ~1 s per
+  phrase. The index is only written once every clip succeeded, so a partial
+  failure is retried at the next startup.
+- [`FillerBank::random`](src/orchestrator/turn_manager.rs): uniform pick over the
+  bank using a per-bank xorshift64 state seeded from the clock;
+  [`TurnManager::play_start_filler`](src/orchestrator/turn_manager.rs) now uses it,
+  so the acknowledgment differs from turn to turn instead of always repeating the
+  same sentence. *(Caller renamed to `schedule_start_filler` by the entry above,
+  which also made the cue conditional.)*
+
+### Why
+
+- A single fixed acknowledgment ("Un momento…") becomes annoying across a long
+  conversation; a random phrase from a curated list keeps the agent sounding
+  natural, and the phrase list is editable straight from `.env`.
+- Re-synthesizing 22 clips on *every* startup added ~21 s to the boot time
+  (measured), so the bootstrap now tracks the phrase list and only re-synthesizes
+  when it changed (or a clip is missing).
+
+### Notes
+
+- `force` was dropped from [`assets::ensure_clips`](src/assets.rs): the filler /
+  backchannel banks keep the "generate only if missing" behaviour, and the start
+  filler has its own list-driven bootstrap.
+- [`server.sh`](server.sh) startup wait raised from ~20 s to ~60 s: the first
+  startup after a list change synthesizes the whole bank before the socket is
+  bound.
+- A failed synthesis keeps the previous clip of that position; a barge-in still
+  clears the start-filler channel (`AudioMixer::flush`), and
+  `START_FILLER_ENABLED=false` disables it entirely.
+
+---
+
+## 2026-10-16 — Start filler: immediate turn-start acknowledgment on its own mixer channel
+
+### Added
+
+- **`START_FILLER_ENABLED` / `START_FILLER_TEXT` / `START_FILLER_DIR`** (`.env`,
+  `.env.example`, [`src/config.rs`](src/config.rs)). The *start filler* is a
+  pre-generated clip queued the moment a user turn begins — no delay — on a
+  **dedicated mixer channel**, so it acknowledges the turn while the LLM/TTS are
+  still working, independently of the delayed latency filler. *(Superseded by the
+  entry above: `START_FILLER_TEXT` became the `START_FILLER_TEXTS` list and the
+  clip is now picked at random.)*
+- [`AudioMixer`](src/audio/mixer.rs): new `start_filler_queue` channel, mixed as
+  `mixed = tts + ((filler + start_filler) × filler_gain) + (backchannel ×
+  BACKCHANNEL_GAIN)`, so the start filler shares the filler gain (idle `1.0`,
+  ducked `0.15` under TTS). Included in `is_active()` and cleared by `flush()`.
+- [`TurnManager::play_start_filler`](src/orchestrator/turn_manager.rs), called
+  from `handle_user_turn` right after the in-flight reply is cancelled.
+- Startup bootstrap synthesizes `START_FILLER_DIR/start_filler.raw` with the
+  configured voice if it is missing ([`src/assets.rs`](src/assets.rs)); the clip
+  is preloaded into its own [`FillerBank`](src/orchestrator/turn_manager.rs),
+  kept out of the round-robin `FILLERS_DIR` bank.
+
+### Why
+
+- The delayed latency filler only fires after `FILLER_DELAY_MS` (and only if the
+  reply is still silent), so with the current fast TTFB (~`0.73 s`) the agent can
+  stay silent for a moment after the user stops speaking. The start filler
+  provides an immediate acknowledgment instead, without touching the existing
+  delayed filler.
+
+### Notes
+
+- *(Superseded — see the entry above.)* The clip was re-synthesized on every
+  startup (`ensure_clips(..., force = true)`), so editing `START_FILLER_TEXT` took
+  effect at the next restart with no manual deletion. A new clip was written only
+  on success, so a failed synthesis left the previous clip in place; the filler /
+  backchannel banks kept the "generate only if missing" behaviour.
+- A barge-in clears the start filler along with every other channel
+  (`AudioMixer::flush`); `START_FILLER_ENABLED=false` disables it entirely.
+
+---
+
+## 2026-10-16 — Fixed micro-gaps at the start of each sentence → `TTS_PREBUFFER_MS` 170 → 550 ms, `LLM_STREAM_CHUNK_CHARS` 120 → 240
+
+### Changed
+
+- **`TTS_PREBUFFER_MS` raised `170` → `550`** (`.env`, `.env.example`). With the
+  current vocoder windows (first `185.8` ms, steady `371.6` ms) any pre-buffer in
+  `(186, 557]` ms primes playback on the *same* second window, so `550 ms` takes
+  the entire ~557 ms cushion **at no extra TTFA** (~`0.73 s`).
+- **`LLM_STREAM_CHUNK_CHARS` raised `120` → `240`** (`.env`, `.env.example`). The
+  first-chunk threshold stays at `20` (early flush preserved), but every following
+  chunk is now twice as long → **fewer TTS requests, hence fewer chunk seams**.
+- **README** (`Mixer & jitter buffering`, the `TTS_PREBUFFER_MS` /
+  `LLM_STREAM_CHUNK_CHARS` tables and the TTFA note) updated to the new defaults
+  and rationale. No Rust code changed — both values are read from `.env` at
+  runtime.
+
+### Why
+
+- After the seam-quality retune left the **audible micro-interruptions at the
+  start of sentences**. Diagnosis from `run/server.log`: the defect is a **TTS
+  queue underrun at the chunk seams**, not a timbre artifact. Each sentence /
+  fragment is a *separate* HTTP request whose PCM is concatenated with no
+  crossfade; the relay advances chunk-by-chunk, so the first dip in production
+  empties the queue and the mixer logs
+  `TTS queue underrun — pausing playback until audio resumes` (94 occurrences in
+  the sampled log; 0 `running low` warnings), then restarts with `need = 1` → an
+  audible micro-gap at the start of the next sentence.
+- **Why the queue empties:** with `TTS_PIPELINE_DEPTH = 3` on a single GPU the
+  measured per-window cadence under concurrency is **552–613 ms (~1.5×)** versus
+  **~350 ms (~0.94×)** for a lone request. A `170 ms` cushion has no margin
+  against that; `550 ms` does, and it is latency-free because the pre-buffer
+  already lands on the second window.
+- Measured in the log at the seam (12:56:36–38): chunks of `16384` samples
+  (`queue_len=16384`, `prebuffer=7497` = 170 ms) with two concurrent requests
+  (`text_len=119` and `19`), each followed by an underrun-pause line.
+
+### Notes
+
+- Both levers are pure configuration; the binary is unchanged, so `./server.sh
+  restart` (no rebuild) is enough to apply them.
+- The `550 ms` cushion is the ~557 ms gap to the third window start, so raising
+  it further only adds latency (it would wait for the *next* window).
+
+---
+
+## 2026-10-16 — Drama-3 vocoder retuned for seam quality → stride `4` / followup `8` / overlap `16`; `TTS_PREBUFFER_MS` 450 → 170 ms
+
+### Changed
+
+- **The Drama-3 launcher (`/root/drama3/start-drama3.sh`, pm2 `start-drama3`) now
+  carries more decoder context per window.** The previous config (stride `4`,
+  flat ramp `"[4,4,4]"`, overlap `8`, crossfade `256`) was replaced by:
+  ```
+  --vocoder.factory.stream_stride 4
+  --vocoder.factory.stream_followup_stride_ramp "[8,8,8]"
+  --vocoder.factory.stream_followup_stride 8
+  --vocoder.factory.stream_overlap_tokens 16
+  --vocoder.factory.stream_crossfade_samples 512
+  --tts_engine.factory.enable_async_decode true
+  ```
+- **`TTS_PREBUFFER_MS` lowered `450` → `170`** (`.env`, `.env.example`,
+  [`src/config.rs`](src/config.rs)). With stride `4` the *first* vocoder window is
+  4 codec frames = **0.186 s**, so `170 ms` starts playback on that first window
+  and **TTFA collapses to the server's own TTFB (~0.38 s)**.
+- **README:** the *"Starting the Drama 3 backend (SGLang-Omni)"* subsection and
+  the *"Mixer & jitter buffering"* pre-buffer note were rewritten around the new
+  stride/overlap values and the ~0.186 s first / ~0.372 s steady window cadence.
+
+### Why
+
+- The previous latency-first config (stride `4`, overlap `8`) produced **audible
+  micro-gaps and a slight detune / falsetto on long replies**. Root cause: with
+  only `8` tokens of decoder warm-up context *per window*, and one TTS request
+  per reply chunk (PCM concatenated without crossfade at the request seams), the
+  streaming decoder's state was too shallow and its timbre/pitch wobbled at each
+  window and request boundary.
+- **Seam context restored without breaking real-time:** raising the overlap to
+  `16` at stride `4` pushes decode to 5× real time, which the box **cannot**
+  sustain (ratio rose to 1.18–1.98×). Raising *strides and overlap together* —
+  stride `4` (first window) / followup `8` (steady) with overlap `16` — keeps the
+  decode load at a sustainable **`(16+8)/8 = 3×`** (~0.95× ratio) while giving
+  each steady window twice the context, and `crossfade 512` smooths the seams
+  further.
+- A/B measurements on the live endpoint (`measure_tts.py`, warm server, voice
+  cloning, single request vs sentence-chunked like the engine) on a long
+  multi-sentence reply: **the amplitude jump at the seam boundaries dropped from
+  the 99.5+ percentile of the signal to 96–98**, i.e. the seams no longer stand
+  out. TTFB stays **~0.38 s** (the first window is unchanged) and the real-time
+  ratio stays **~0.94–0.98×**.
+
+### Notes
+
+- The first window is unchanged (4 frames), so the residual latency is still
+  dominated by the server's **fixed ~0.38 s TTFB**; the steady window grew from
+  0.186 s to **0.372 s** (8 frames) and arrives ~350 ms apart, so the pre-buffer
+  of `170 ms` still starts playback on the very first window. Further latency
+  gains would need a faster first token (model / preprocessing), not a smaller
+  stride.
+- `measure_tts.py` was added to the repo: it streams `/v1/audio/speech` and prints
+  the per-window arrival schedule, TTFB and real-time ratio (plus a seam-jump
+  summary), so future A/B runs are one command.
+
+---
+
 ## 2026-10-16 — Mivocero: karaoke word highlighting on the assistant reply
 
 ### Changed
diff --git a/assets/backchannel/aja.raw b/assets/backchannel/aja.raw
deleted file mode 100644
index 5ee7a3c..0000000
Binary files a/assets/backchannel/aja.raw and /dev/null differ
diff --git a/assets/backchannel/claro.raw b/assets/backchannel/claro.raw
deleted file mode 100644
index e0e5b7c..0000000
Binary files a/assets/backchannel/claro.raw and /dev/null differ
diff --git a/assets/backchannel/en/bc01.raw b/assets/backchannel/en/bc01.raw
new file mode 100644
index 0000000..a4167c9
Binary files /dev/null and b/assets/backchannel/en/bc01.raw differ
diff --git a/assets/backchannel/en/bc02.raw b/assets/backchannel/en/bc02.raw
new file mode 100644
index 0000000..2959878
Binary files /dev/null and b/assets/backchannel/en/bc02.raw differ
diff --git a/assets/backchannel/en/bc03.raw b/assets/backchannel/en/bc03.raw
new file mode 100644
index 0000000..7e10291
Binary files /dev/null and b/assets/backchannel/en/bc03.raw differ
diff --git a/assets/backchannel/en/bc04.raw b/assets/backchannel/en/bc04.raw
new file mode 100644
index 0000000..be15687
Binary files /dev/null and b/assets/backchannel/en/bc04.raw differ
diff --git a/assets/backchannel/en/bc05.raw b/assets/backchannel/en/bc05.raw
new file mode 100644
index 0000000..8345843
Binary files /dev/null and b/assets/backchannel/en/bc05.raw differ
diff --git a/assets/backchannel/en/bc06.raw b/assets/backchannel/en/bc06.raw
new file mode 100644
index 0000000..d5e39b9
Binary files /dev/null and b/assets/backchannel/en/bc06.raw differ
diff --git a/assets/backchannel/en/bc07.raw b/assets/backchannel/en/bc07.raw
new file mode 100644
index 0000000..154b748
Binary files /dev/null and b/assets/backchannel/en/bc07.raw differ
diff --git a/assets/backchannel/en/bc08.raw b/assets/backchannel/en/bc08.raw
new file mode 100644
index 0000000..80d3df3
Binary files /dev/null and b/assets/backchannel/en/bc08.raw differ
diff --git a/assets/backchannel/en/texts.txt b/assets/backchannel/en/texts.txt
new file mode 100644
index 0000000..23f5977
--- /dev/null
+++ b/assets/backchannel/en/texts.txt
@@ -0,0 +1,8 @@
+[calm] Mm-hmm...
+[attentive] Uh-huh...
+[agreeing] Right...
+[listening] I see...
+[attentive] Yeah, yeah...
+[calm] Got it...
+[relaxed] Okay...
+[thoughtful] Oh, I see...
\ No newline at end of file
diff --git a/assets/backchannel/es/bc01.raw b/assets/backchannel/es/bc01.raw
new file mode 100644
index 0000000..e6c19c3
Binary files /dev/null and b/assets/backchannel/es/bc01.raw differ
diff --git a/assets/backchannel/es/bc02.raw b/assets/backchannel/es/bc02.raw
new file mode 100644
index 0000000..41efc90
Binary files /dev/null and b/assets/backchannel/es/bc02.raw differ
diff --git a/assets/backchannel/es/bc03.raw b/assets/backchannel/es/bc03.raw
new file mode 100644
index 0000000..8d9d621
Binary files /dev/null and b/assets/backchannel/es/bc03.raw differ
diff --git a/assets/backchannel/es/bc04.raw b/assets/backchannel/es/bc04.raw
new file mode 100644
index 0000000..b999b3e
Binary files /dev/null and b/assets/backchannel/es/bc04.raw differ
diff --git a/assets/backchannel/es/bc05.raw b/assets/backchannel/es/bc05.raw
new file mode 100644
index 0000000..3e48b6f
Binary files /dev/null and b/assets/backchannel/es/bc05.raw differ
diff --git a/assets/backchannel/es/bc06.raw b/assets/backchannel/es/bc06.raw
new file mode 100644
index 0000000..52f3a34
Binary files /dev/null and b/assets/backchannel/es/bc06.raw differ
diff --git a/assets/backchannel/es/bc07.raw b/assets/backchannel/es/bc07.raw
new file mode 100644
index 0000000..c3c7eee
Binary files /dev/null and b/assets/backchannel/es/bc07.raw differ
diff --git a/assets/backchannel/es/bc08.raw b/assets/backchannel/es/bc08.raw
new file mode 100644
index 0000000..6e90ae5
Binary files /dev/null and b/assets/backchannel/es/bc08.raw differ
diff --git a/assets/backchannel/es/texts.txt b/assets/backchannel/es/texts.txt
new file mode 100644
index 0000000..769253f
--- /dev/null
+++ b/assets/backchannel/es/texts.txt
@@ -0,0 +1,8 @@
+[calm] Mm-hmm...
+[attentive] Ajá...
+[agreeing] Claro...
+[listening] Ya veo...
+[attentive] Sí, sí...
+[calm] Entiendo...
+[relaxed] Vale...
+[thoughtful] Ah, ya...
\ No newline at end of file
diff --git a/assets/backchannel/it/bc01.raw b/assets/backchannel/it/bc01.raw
new file mode 100644
index 0000000..bc7da6c
Binary files /dev/null and b/assets/backchannel/it/bc01.raw differ
diff --git a/assets/backchannel/it/bc02.raw b/assets/backchannel/it/bc02.raw
new file mode 100644
index 0000000..9822047
Binary files /dev/null and b/assets/backchannel/it/bc02.raw differ
diff --git a/assets/backchannel/it/bc03.raw b/assets/backchannel/it/bc03.raw
new file mode 100644
index 0000000..0bb8be0
Binary files /dev/null and b/assets/backchannel/it/bc03.raw differ
diff --git a/assets/backchannel/it/bc04.raw b/assets/backchannel/it/bc04.raw
new file mode 100644
index 0000000..8215632
Binary files /dev/null and b/assets/backchannel/it/bc04.raw differ
diff --git a/assets/backchannel/it/bc05.raw b/assets/backchannel/it/bc05.raw
new file mode 100644
index 0000000..b9130f5
Binary files /dev/null and b/assets/backchannel/it/bc05.raw differ
diff --git a/assets/backchannel/it/bc06.raw b/assets/backchannel/it/bc06.raw
new file mode 100644
index 0000000..1e78446
Binary files /dev/null and b/assets/backchannel/it/bc06.raw differ
diff --git a/assets/backchannel/it/bc07.raw b/assets/backchannel/it/bc07.raw
new file mode 100644
index 0000000..bafc9b0
Binary files /dev/null and b/assets/backchannel/it/bc07.raw differ
diff --git a/assets/backchannel/it/bc08.raw b/assets/backchannel/it/bc08.raw
new file mode 100644
index 0000000..474ca4e
Binary files /dev/null and b/assets/backchannel/it/bc08.raw differ
diff --git a/assets/backchannel/it/texts.txt b/assets/backchannel/it/texts.txt
new file mode 100644
index 0000000..d94d676
--- /dev/null
+++ b/assets/backchannel/it/texts.txt
@@ -0,0 +1,8 @@
+[calm] Mmm...
+[attentive] Eh già...
+[agreeing] Certo...
+[listening] Capisco...
+[attentive] Sì, sì...
+[calm] Ho capito...
+[relaxed] Va bene...
+[thoughtful] Ah, ecco...
\ No newline at end of file
diff --git a/assets/backchannel/mmhmm.raw b/assets/backchannel/mmhmm.raw
deleted file mode 100644
index f494836..0000000
Binary files a/assets/backchannel/mmhmm.raw and /dev/null differ
diff --git a/assets/backchannel/yaveo.raw b/assets/backchannel/yaveo.raw
deleted file mode 100644
index 7fd383e..0000000
Binary files a/assets/backchannel/yaveo.raw and /dev/null differ
diff --git a/assets/fillers/aver.raw b/assets/fillers/aver.raw
deleted file mode 100644
index 9468fc2..0000000
Binary files a/assets/fillers/aver.raw and /dev/null differ
diff --git a/assets/fillers/bueno.raw b/assets/fillers/bueno.raw
deleted file mode 100644
index f6e40a8..0000000
Binary files a/assets/fillers/bueno.raw and /dev/null differ
diff --git a/assets/fillers/eh.raw b/assets/fillers/eh.raw
deleted file mode 100644
index 42e252f..0000000
Binary files a/assets/fillers/eh.raw and /dev/null differ
diff --git a/assets/fillers/en/fl01.raw b/assets/fillers/en/fl01.raw
new file mode 100644
index 0000000..295a109
Binary files /dev/null and b/assets/fillers/en/fl01.raw differ
diff --git a/assets/fillers/en/fl02.raw b/assets/fillers/en/fl02.raw
new file mode 100644
index 0000000..39c6c4f
Binary files /dev/null and b/assets/fillers/en/fl02.raw differ
diff --git a/assets/fillers/en/fl03.raw b/assets/fillers/en/fl03.raw
new file mode 100644
index 0000000..4fe624f
Binary files /dev/null and b/assets/fillers/en/fl03.raw differ
diff --git a/assets/fillers/en/fl04.raw b/assets/fillers/en/fl04.raw
new file mode 100644
index 0000000..4270961
Binary files /dev/null and b/assets/fillers/en/fl04.raw differ
diff --git a/assets/fillers/en/fl05.raw b/assets/fillers/en/fl05.raw
new file mode 100644
index 0000000..170da77
Binary files /dev/null and b/assets/fillers/en/fl05.raw differ
diff --git a/assets/fillers/en/fl06.raw b/assets/fillers/en/fl06.raw
new file mode 100644
index 0000000..9f5189c
Binary files /dev/null and b/assets/fillers/en/fl06.raw differ
diff --git a/assets/fillers/en/fl07.raw b/assets/fillers/en/fl07.raw
new file mode 100644
index 0000000..6702bb1
Binary files /dev/null and b/assets/fillers/en/fl07.raw differ
diff --git a/assets/fillers/en/texts.txt b/assets/fillers/en/texts.txt
new file mode 100644
index 0000000..5d6b033
--- /dev/null
+++ b/assets/fillers/en/texts.txt
@@ -0,0 +1,7 @@
+Uhm...
+Hmm...
+Mmm...
+Well...
+Uh, let's see...
+Okay...
+Right...
\ No newline at end of file
diff --git a/assets/fillers/es/aver.raw b/assets/fillers/es/aver.raw
new file mode 100644
index 0000000..9c8a710
Binary files /dev/null and b/assets/fillers/es/aver.raw differ
diff --git a/assets/fillers/es/bueno.raw b/assets/fillers/es/bueno.raw
new file mode 100644
index 0000000..1ca90c8
Binary files /dev/null and b/assets/fillers/es/bueno.raw differ
diff --git a/assets/fillers/es/eh.raw b/assets/fillers/es/eh.raw
new file mode 100644
index 0000000..727c0d8
Binary files /dev/null and b/assets/fillers/es/eh.raw differ
diff --git a/assets/fillers/es/mmm.raw b/assets/fillers/es/mmm.raw
new file mode 100644
index 0000000..9ad0497
Binary files /dev/null and b/assets/fillers/es/mmm.raw differ
diff --git a/assets/fillers/es/pues.raw b/assets/fillers/es/pues.raw
new file mode 100644
index 0000000..e3a6a69
Binary files /dev/null and b/assets/fillers/es/pues.raw differ
diff --git a/assets/fillers/es/uhm.raw b/assets/fillers/es/uhm.raw
new file mode 100644
index 0000000..6447d70
Binary files /dev/null and b/assets/fillers/es/uhm.raw differ
diff --git a/assets/fillers/es/vaya.raw b/assets/fillers/es/vaya.raw
new file mode 100644
index 0000000..3f9921a
Binary files /dev/null and b/assets/fillers/es/vaya.raw differ
diff --git a/assets/fillers/it/fl01.raw b/assets/fillers/it/fl01.raw
new file mode 100644
index 0000000..65ceb25
Binary files /dev/null and b/assets/fillers/it/fl01.raw differ
diff --git a/assets/fillers/it/fl02.raw b/assets/fillers/it/fl02.raw
new file mode 100644
index 0000000..98a9985
Binary files /dev/null and b/assets/fillers/it/fl02.raw differ
diff --git a/assets/fillers/it/fl03.raw b/assets/fillers/it/fl03.raw
new file mode 100644
index 0000000..25b34b9
Binary files /dev/null and b/assets/fillers/it/fl03.raw differ
diff --git a/assets/fillers/it/fl04.raw b/assets/fillers/it/fl04.raw
new file mode 100644
index 0000000..537d582
Binary files /dev/null and b/assets/fillers/it/fl04.raw differ
diff --git a/assets/fillers/it/fl05.raw b/assets/fillers/it/fl05.raw
new file mode 100644
index 0000000..58b7c8b
Binary files /dev/null and b/assets/fillers/it/fl05.raw differ
diff --git a/assets/fillers/it/fl06.raw b/assets/fillers/it/fl06.raw
new file mode 100644
index 0000000..a64297c
Binary files /dev/null and b/assets/fillers/it/fl06.raw differ
diff --git a/assets/fillers/it/fl07.raw b/assets/fillers/it/fl07.raw
new file mode 100644
index 0000000..edafa28
Binary files /dev/null and b/assets/fillers/it/fl07.raw differ
diff --git a/assets/fillers/it/texts.txt b/assets/fillers/it/texts.txt
new file mode 100644
index 0000000..858870a
--- /dev/null
+++ b/assets/fillers/it/texts.txt
@@ -0,0 +1,7 @@
+Uhm...
+Eh...
+Mmm...
+Vediamo...
+Allora...
+Beh...
+Dunque...
\ No newline at end of file
diff --git a/assets/fillers/mmm.raw b/assets/fillers/mmm.raw
deleted file mode 100644
index d5c3002..0000000
Binary files a/assets/fillers/mmm.raw and /dev/null differ
diff --git a/assets/fillers/pues.raw b/assets/fillers/pues.raw
deleted file mode 100644
index 59e86c0..0000000
Binary files a/assets/fillers/pues.raw and /dev/null differ
diff --git a/assets/fillers/uhm.raw b/assets/fillers/uhm.raw
deleted file mode 100644
index 9511900..0000000
Binary files a/assets/fillers/uhm.raw and /dev/null differ
diff --git a/assets/fillers/vaya.raw b/assets/fillers/vaya.raw
deleted file mode 100644
index d74079b..0000000
Binary files a/assets/fillers/vaya.raw and /dev/null differ
diff --git a/assets/start_filler/en/sf01.raw b/assets/start_filler/en/sf01.raw
new file mode 100644
index 0000000..77c4bcc
Binary files /dev/null and b/assets/start_filler/en/sf01.raw differ
diff --git a/assets/start_filler/en/sf02.raw b/assets/start_filler/en/sf02.raw
new file mode 100644
index 0000000..7e6e641
Binary files /dev/null and b/assets/start_filler/en/sf02.raw differ
diff --git a/assets/start_filler/en/sf03.raw b/assets/start_filler/en/sf03.raw
new file mode 100644
index 0000000..164f395
Binary files /dev/null and b/assets/start_filler/en/sf03.raw differ
diff --git a/assets/start_filler/en/texts.txt b/assets/start_filler/en/texts.txt
new file mode 100644
index 0000000..c563f5f
--- /dev/null
+++ b/assets/start_filler/en/texts.txt
@@ -0,0 +1,3 @@
+[calm] One moment...
+[thoughtful] Let me see...
+[sigh] Okay, coming up...
\ No newline at end of file
diff --git a/assets/start_filler/es/sf01.raw b/assets/start_filler/es/sf01.raw
new file mode 100644
index 0000000..d0a5ae8
Binary files /dev/null and b/assets/start_filler/es/sf01.raw differ
diff --git a/assets/start_filler/es/sf02.raw b/assets/start_filler/es/sf02.raw
new file mode 100644
index 0000000..0ff4a36
Binary files /dev/null and b/assets/start_filler/es/sf02.raw differ
diff --git a/assets/start_filler/es/sf03.raw b/assets/start_filler/es/sf03.raw
new file mode 100644
index 0000000..89e4c15
Binary files /dev/null and b/assets/start_filler/es/sf03.raw differ
diff --git a/assets/start_filler/es/sf04.raw b/assets/start_filler/es/sf04.raw
new file mode 100644
index 0000000..a390b9c
Binary files /dev/null and b/assets/start_filler/es/sf04.raw differ
diff --git a/assets/start_filler/es/sf05.raw b/assets/start_filler/es/sf05.raw
new file mode 100644
index 0000000..b7bbea2
Binary files /dev/null and b/assets/start_filler/es/sf05.raw differ
diff --git a/assets/start_filler/es/sf06.raw b/assets/start_filler/es/sf06.raw
new file mode 100644
index 0000000..6a98e8a
Binary files /dev/null and b/assets/start_filler/es/sf06.raw differ
diff --git a/assets/start_filler/es/sf07.raw b/assets/start_filler/es/sf07.raw
new file mode 100644
index 0000000..3d9f5c7
Binary files /dev/null and b/assets/start_filler/es/sf07.raw differ
diff --git a/assets/start_filler/es/sf08.raw b/assets/start_filler/es/sf08.raw
new file mode 100644
index 0000000..8324ef1
Binary files /dev/null and b/assets/start_filler/es/sf08.raw differ
diff --git a/assets/start_filler/es/sf09.raw b/assets/start_filler/es/sf09.raw
new file mode 100644
index 0000000..20c1826
Binary files /dev/null and b/assets/start_filler/es/sf09.raw differ
diff --git a/assets/start_filler/es/sf10.raw b/assets/start_filler/es/sf10.raw
new file mode 100644
index 0000000..bd50aa3
Binary files /dev/null and b/assets/start_filler/es/sf10.raw differ
diff --git a/assets/start_filler/es/sf11.raw b/assets/start_filler/es/sf11.raw
new file mode 100644
index 0000000..af1955f
Binary files /dev/null and b/assets/start_filler/es/sf11.raw differ
diff --git a/assets/start_filler/es/sf12.raw b/assets/start_filler/es/sf12.raw
new file mode 100644
index 0000000..eeac82d
Binary files /dev/null and b/assets/start_filler/es/sf12.raw differ
diff --git a/assets/start_filler/es/sf13.raw b/assets/start_filler/es/sf13.raw
new file mode 100644
index 0000000..d88e011
Binary files /dev/null and b/assets/start_filler/es/sf13.raw differ
diff --git a/assets/start_filler/es/sf14.raw b/assets/start_filler/es/sf14.raw
new file mode 100644
index 0000000..3787f27
Binary files /dev/null and b/assets/start_filler/es/sf14.raw differ
diff --git a/assets/start_filler/es/sf15.raw b/assets/start_filler/es/sf15.raw
new file mode 100644
index 0000000..419219b
Binary files /dev/null and b/assets/start_filler/es/sf15.raw differ
diff --git a/assets/start_filler/es/sf16.raw b/assets/start_filler/es/sf16.raw
new file mode 100644
index 0000000..3fd693c
Binary files /dev/null and b/assets/start_filler/es/sf16.raw differ
diff --git a/assets/start_filler/es/sf17.raw b/assets/start_filler/es/sf17.raw
new file mode 100644
index 0000000..3806159
Binary files /dev/null and b/assets/start_filler/es/sf17.raw differ
diff --git a/assets/start_filler/es/sf18.raw b/assets/start_filler/es/sf18.raw
new file mode 100644
index 0000000..66e1e13
Binary files /dev/null and b/assets/start_filler/es/sf18.raw differ
diff --git a/assets/start_filler/es/sf19.raw b/assets/start_filler/es/sf19.raw
new file mode 100644
index 0000000..9ddc1b4
Binary files /dev/null and b/assets/start_filler/es/sf19.raw differ
diff --git a/assets/start_filler/es/sf20.raw b/assets/start_filler/es/sf20.raw
new file mode 100644
index 0000000..e2e3da0
Binary files /dev/null and b/assets/start_filler/es/sf20.raw differ
diff --git a/assets/start_filler/es/sf21.raw b/assets/start_filler/es/sf21.raw
new file mode 100644
index 0000000..7116a82
Binary files /dev/null and b/assets/start_filler/es/sf21.raw differ
diff --git a/assets/start_filler/es/sf22.raw b/assets/start_filler/es/sf22.raw
new file mode 100644
index 0000000..b1f4154
Binary files /dev/null and b/assets/start_filler/es/sf22.raw differ
diff --git a/assets/start_filler/es/texts.txt b/assets/start_filler/es/texts.txt
new file mode 100644
index 0000000..2412c82
--- /dev/null
+++ b/assets/start_filler/es/texts.txt
@@ -0,0 +1,22 @@
+[calm] Un momento...
+[thoughtful] A ver, veamos...
+[calm][thinking] Déjame revisar...
+[serious] A ver, déjame entender bien esto...
+[hesitant] Entonces... echemos un vistazo...
+[calm] Dame solo un segundo...
+[sigh] Vale, ya voy...
+[laughs] Buena pregunta... déjame ver...
+[chuckle] De acuerdo, a ver qué encontramos...
+[inhale] Bueno, vamos por partes...
+[casual] Sí, espera un instante...
+[confident] Recibido, me pongo a ello ahora mismo...
+[excited] Perfecto, mira esto...
+[enthusiastic] ¡Genial! Vamos a comprobarlo de inmediato...
+[determined] Sin problema, me encargo ya...
+[hesitant] Mmm... espera un segundo...
+[confused] Déjame comprobarlo otra vez...
+[curious] Curioso... a ver un momento...
+[whispering] Shh, solo un instante...
+[speaking softly, thinking out loud] Déjame echar un vistazo rápido...
+[sighing gently, reassuring] Tranquilo, enseguida tengo la respuesta...
+[focused, typing on a keyboard] Solo un momento, lo compruebo ya mismo...
\ No newline at end of file
diff --git a/assets/start_filler/it/sf01.raw b/assets/start_filler/it/sf01.raw
new file mode 100644
index 0000000..6fabd4a
Binary files /dev/null and b/assets/start_filler/it/sf01.raw differ
diff --git a/assets/start_filler/it/sf02.raw b/assets/start_filler/it/sf02.raw
new file mode 100644
index 0000000..8b5eb89
Binary files /dev/null and b/assets/start_filler/it/sf02.raw differ
diff --git a/assets/start_filler/it/sf03.raw b/assets/start_filler/it/sf03.raw
new file mode 100644
index 0000000..16bf384
Binary files /dev/null and b/assets/start_filler/it/sf03.raw differ
diff --git a/assets/start_filler/it/texts.txt b/assets/start_filler/it/texts.txt
new file mode 100644
index 0000000..7f3046d
--- /dev/null
+++ b/assets/start_filler/it/texts.txt
@@ -0,0 +1,3 @@
+[calm] Un momento...
+[thoughtful] Vediamo un po'...
+[sigh] Va bene, arrivo...
\ No newline at end of file
diff --git a/measure_tts.py b/measure_tts.py
new file mode 100644
index 0000000..fc2b037
--- /dev/null
+++ b/measure_tts.py
@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+"""Measure Drama 3 / SGLang TTS streaming: TTFB, burst sizes, real-time ratio.
+
+Streams /v1/audio/speech as raw PCM and reports how the audio arrives, so the
+vocoder window schedule (stream_stride / ramp / followup) and the real-time
+ratio can be checked. Run against the local SGLang-Omni server.
+
+Two modes:
+  (default)    one request for the whole text -> only the server's own vocoder
+               window seams are present.
+  --chunked    split the text on sentence boundaries and issue one request per
+               sentence, concatenating the raw PCM like the engine does -> adds
+               the engine's per-chunk request boundaries on top of the seams.
+               Comparing the two WAVs tells whether an artifact comes from the
+               vocoder (present in both) or from the engine's chunking (only in
+               the chunked one).
+"""
+import array
+import re
+import sys
+import time
+import wave
+
+import requests
+
+URL = "http://localhost:8000/v1/audio/speech"
+MODEL = "fishaudio/drama-3"
+SR = 44100
+BYTES_PER_SAMPLE = 2
+
+# Voice-cloning reference (matches the engine's .env defaults).
+REF_AUDIO = "/root/piperust/audio-agent-engine/voice_profiles/solis.wav"
+REF_TEXT = "/root/piperust/audio-agent-engine/voice_profiles/solis.txt"
+
+
+def load_ref_text(path: str) -> str:
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return f.read().strip()
+    except OSError:
+        return ""
+
+
+def save_wav(path: str, pcm: bytes, sr: int) -> None:
+    with wave.open(path, "wb") as w:
+        w.setnchannels(1)
+        w.setsampwidth(BYTES_PER_SAMPLE)
+        w.setframerate(sr)
+        w.writeframes(pcm)
+
+
+def analyze_seams(pcm: bytes, boundaries: list[int]) -> None:
+    """Compare the sample-to-sample jump exactly at each boundary against the
+    jumps inside the windows. A boundary jump no larger than the interior
+    distribution means no amplitude discontinuity there (the vocoder crossfade /
+    the engine's crossfade are doing their job)."""
+    s = array.array("h")
+    s.frombytes(pcm[: len(pcm) // BYTES_PER_SAMPLE * BYTES_PER_SAMPLE])
+    n = len(s)
+    if n < 2:
+        return
+    deltas = sorted(abs(s[i] - s[i - 1]) for i in range(1, n))
+    p999 = deltas[int(len(deltas) * 0.999)]
+    global_max = deltas[-1]
+    bounds = [b for b in boundaries[:-1] if 0 < b < n]
+    bj = [abs(s[b] - s[b - 1]) for b in bounds]
+    max_b = max(bj) if bj else 0
+    rank = deltas.index(max_b) / len(deltas) * 100 if bj else 0
+    print(f"seam analysis: boundaries={len(bounds)} max_boundary_jump={max_b} "
+          f"global_max_jump={global_max} global_p99.9={p999} "
+          f"max_boundary_percentile={rank:.2f}")
+
+
+def stream_pcm(text: str, use_ref: bool, t0: float):
+    """POST one text and return (pcm_bytes, events, sample_rate).
+    events = list of (t_seconds, bytes_cumulative, chunk_bytes)."""
+    body = {
+        "model": MODEL,
+        "input": text,
+        "voice": "default",
+        "response_format": "pcm",
+        "stream": True,
+    }
+    if use_ref:
+        body["references"] = [
+            {"audio_path": REF_AUDIO, "text": load_ref_text(REF_TEXT)}
+        ]
+    resp = requests.post(URL, json=body, stream=True, timeout=120)
+    resp.raise_for_status()
+    sr = int(resp.headers.get("x-sample-rate") or SR)
+    pcm = bytearray()
+    events = []
+    total = 0
+    with resp:
+        for chunk in resp.iter_content(chunk_size=None):
+            if not chunk:
+                continue
+            total += len(chunk)
+            pcm += chunk
+            events.append((time.perf_counter() - t0, total, len(chunk)))
+    return bytes(pcm), events, sr
+
+
+def summarise_events(events) -> None:
+    ttfb = events[0][0]
+    tlast = events[-1][0]
+    audio_s = (events[-1][1] // BYTES_PER_SAMPLE) / SR
+    print(f"chunks={len(events)} ttfb={ttfb*1000:.0f}ms "
+          f"last={tlast*1000:.0f}ms audio={audio_s:.2f}s "
+          f"wall={tlast:.2f}s ratio={tlast/audio_s:.3f}x")
+
+
+def measure(text: str, use_ref: bool = True, out: str | None = None) -> None:
+    print(f"[single] text={text!r} ref={use_ref}")
+    t0 = time.perf_counter()
+    pcm, events, sr = stream_pcm(text, use_ref, t0)
+    print("x-sample-rate:", sr)
+    summarise_events(events)
+    boundaries = [cum // BYTES_PER_SAMPLE for _, cum, _ in events]
+    analyze_seams(pcm, boundaries)
+    if out:
+        save_wav(out, pcm, sr)
+        print(f"saved WAV -> {out}")
+
+
+def measure_chunked(text: str, use_ref: bool = True, out: str | None = None) -> None:
+    parts = [p for p in re.split(r"(?<=[.!?;])\s+", text.strip()) if p]
+    print(f"[chunked] parts={len(parts)} ref={use_ref}")
+    t0 = time.perf_counter()
+    pcm = bytearray()
+    events = []
+    sr = SR
+    total = 0
+    for i, part in enumerate(parts):
+        t_req = time.perf_counter()
+        p, ev, sr = stream_pcm(part, use_ref, t0)
+        ttfb = ev[0][0] - (t_req - t0)
+        print(f"  part {i}: {len(part):3d} chars ttfb={ttfb*1000:4.0f}ms "
+              f"audio={(len(p)//BYTES_PER_SAMPLE)/sr:.2f}s part={part[:40]!r}")
+        pcm += p
+        for t, cum, cb in ev:
+            total += cb
+            events.append((t, total, cb))
+    print("x-sample-rate:", sr)
+    summarise_events(events)
+    boundaries = [cum // BYTES_PER_SAMPLE for _, cum, _ in events]
+    analyze_seams(bytes(pcm), boundaries)
+    if out:
+        save_wav(out, bytes(pcm), sr)
+        print(f"saved WAV -> {out}")
+
+
+if __name__ == "__main__":
+    args = sys.argv[1:]
+    use_ref = "--no-ref" not in args
+
+    def arg_value(flag):
+        return args[args.index(flag) + 1] if flag in args else None
+
+    out = arg_value("--out")
+    text = arg_value("--text") or (
+        "Ciao, questa e' una prova per misurare la latenza del motore vocale. "
+        "Contiamo insieme da uno fino a venti: uno, due, tre, quattro, cinque, "
+        "sei, sette, otto, nove, dieci, undici, dodici, tredici, quattordici, "
+        "quindici, sedici, diciassette, diciotto, diciannove, venti.")
+    if "--chunked" in args:
+        measure_chunked(text, use_ref=use_ref, out=out)
+    else:
+        measure(text, use_ref=use_ref, out=out)
diff --git a/piperust-start.sh b/piperust-start.sh
new file mode 100755
index 0000000..62f0721
--- /dev/null
+++ b/piperust-start.sh
@@ -0,0 +1,4 @@
+./server.sh restart
+tail -f run/server.log
+
+
diff --git a/pm2-piperust.sh b/pm2-piperust.sh
new file mode 100755
index 0000000..f68f629
--- /dev/null
+++ b/pm2-piperust.sh
@@ -0,0 +1,2 @@
+cargo r
+
diff --git a/run/listen_test.wav b/run/listen_test.wav
new file mode 100644
index 0000000..5500422
Binary files /dev/null and b/run/listen_test.wav differ
diff --git a/run/long_chunked.wav b/run/long_chunked.wav
new file mode 100644
index 0000000..09a2d64
Binary files /dev/null and b/run/long_chunked.wav differ
diff --git a/run/long_probe.wav b/run/long_probe.wav
new file mode 100644
index 0000000..654a09a
Binary files /dev/null and b/run/long_probe.wav differ
diff --git a/run/long_single.wav b/run/long_single.wav
new file mode 100644
index 0000000..0ed7d01
Binary files /dev/null and b/run/long_single.wav differ
diff --git a/run/ov16_chunked.wav b/run/ov16_chunked.wav
new file mode 100644
index 0000000..d0c27bf
Binary files /dev/null and b/run/ov16_chunked.wav differ
diff --git a/run/ov16_single.wav b/run/ov16_single.wav
new file mode 100644
index 0000000..93f2117
Binary files /dev/null and b/run/ov16_single.wav differ
diff --git a/run/server.pid b/run/server.pid
deleted file mode 100644
index 460fc28..0000000
--- a/run/server.pid
+++ /dev/null
@@ -1 +0,0 @@
-3212397
diff --git a/server.sh b/server.sh
index 69c457a..8897801 100755
--- a/server.sh
+++ b/server.sh
@@ -148,8 +148,11 @@ start() {
   echo $! > "$PID_FILE"
   local pid=$!
 
-  # Wait for the port to accept connections (model load ~1.5 s).
-  for _ in $(seq 1 40); do
+  # Wait for the port to accept connections. Apart from the model load (~1.5 s)
+  # startup also re-synthesizes the start-filler clip bank (one clip per
+  # START_FILLER_TEXTS phrase, generated before the socket is bound), which can
+  # take a while with a long phrase list — hence the generous timeout.
+  for _ in $(seq 1 120); do
     if [ -n "$(listening_pid)" ]; then
       ok "started (pid $pid) — $sch://localhost:$PORT/"
       return 0
@@ -157,7 +160,7 @@ start() {
     sleep 0.5
   done
 
-  err "failed to start within ~20 s. Last log lines:"
+  err "failed to start within ~60 s. Last log lines:"
   tail -n 20 "$LOG_FILE" || true
   rm -f "$PID_FILE"
   return 1
diff --git a/src/assets.rs b/src/assets.rs
index e23e8b8..b9a3240 100644
--- a/src/assets.rs
+++ b/src/assets.rs
@@ -1,15 +1,19 @@
 //! Startup asset bootstrap.
 //!
-//! The filler (end-of-utterance) and backchannel (during-utterance) clip banks
-//! are plain `*.raw` PCM files. If a clip is missing at startup it is
-//! synthesized with the configured TTS engine and written to disk, so a fresh
-//! checkout works without a manual generation step. Existing clips are never
-//! overwritten.
+//! The filler (end-of-utterance), start-filler (turn-start) and backchannel
+//! (during-utterance) clip banks are plain `*.raw` PCM files. If a clip is
+//! missing at startup it is synthesized with the configured TTS engine and
+//! written to disk, so a fresh checkout works without a manual generation step.
+//! Existing filler clips are kept, while the user-editable start-filler and
+//! backchannel banks are refreshed from their phrase lists (`START_FILLER_TEXTS`
+//! / `BACKCHANNEL_TEXTS`) whenever those change (see
+//! [`ensure_text_bank_clips`]).
 
 use crate::audio::SampleRingBuffer;
 use crate::tts::TtsEngine;
 use anyhow::{Context, Result};
-use std::path::Path;
+use futures_util::StreamExt;
+use std::path::{Path, PathBuf};
 use tokio_util::sync::CancellationToken;
 use tracing::{info, warn};
 
@@ -24,21 +28,24 @@ pub const FILLER_CLIPS: &[(&str, &str)] = &[
     ("vaya", "Vaya..."),
 ];
 
-/// Default during-utterance backchannel clips: `(name, text)`.
-pub const BACKCHANNEL_CLIPS: &[(&str, &str)] = &[
-    ("mmhmm", "Mm-hmm."),
-    ("aja", "Ajá."),
-    ("claro", "Claro."),
-    ("yaveo", "Ya veo."),
-];
-
 /// Capacity (in samples) of the scratch buffer used to capture one synthesized
 /// clip. 30 s at 44.1 kHz is far beyond any filler / backchannel length.
 const SYNTH_BUFFER_SAMPLES: usize = 30 * 44_100;
 
+/// Number of text-bank clips synthesized concurrently at startup. The lists can
+/// hold dozens of phrases; a few parallel requests keep the bootstrap short
+/// without flooding the TTS backend.
+const TEXT_BANK_CONCURRENCY: usize = 4;
+
+/// Name of the file inside a text-driven clip directory that records the phrase
+/// list the current clips were synthesized from (one phrase per line). Used to
+/// skip the re-synthesis when the list did not change.
+const TEXTS_INDEX_FILE: &str = "texts.txt";
+
 /// Ensure every clip in `clips` exists as `<dir>/<name>.raw`, synthesizing the
-/// missing ones with `tts`. Creates `dir` if needed. Returns the number of
-/// clips generated. Never fails the caller: individual errors are logged.
+/// missing ones with `tts`. Creates `dir` if needed. Existing clips are kept.
+/// Returns the number of clips generated. Never fails the caller: individual
+/// errors are logged.
 pub async fn ensure_clips(
     dir: &Path,
     clips: &[(&str, &str)],
@@ -66,9 +73,9 @@ pub async fn ensure_clips(
     info!(
         label,
         dir = %dir.display(),
-        missing = missing.len(),
+        clips = missing.len(),
         engine = tts.name(),
-        "generating missing clips at startup"
+        "generating clips at startup"
     );
 
     let mut generated = 0usize;
@@ -91,6 +98,187 @@ pub async fn ensure_clips(
     generated
 }
 
+/// Refresh the *start filler* clip bank so it matches `START_FILLER_TEXTS`.
+pub async fn ensure_start_filler_clips(
+    dir: &Path,
+    texts: &[String],
+    tts: &dyn TtsEngine,
+) -> usize {
+    ensure_text_bank_clips(dir, texts, "sf", "start-filler", tts).await
+}
+
+/// Refresh the *backchannel* clip bank so it matches `BACKCHANNEL_TEXTS`.
+pub async fn ensure_backchannel_clips(
+    dir: &Path,
+    texts: &[String],
+    tts: &dyn TtsEngine,
+) -> usize {
+    ensure_text_bank_clips(dir, texts, "bc", "backchannel", tts).await
+}
+
+/// Directory of the clip bank for `lang` under `base` (`<base>/<lang>`, ISO
+/// 639-1), see [`crate::lang`].
+///
+/// Every language — including the configured default — lives in its own
+/// subdirectory, so regenerating a language writes and prunes only within that
+/// subdirectory and therefore never removes the clips of another language.
+pub fn lang_dir(base: &Path, lang: &str) -> PathBuf {
+    base.join(lang)
+}
+
+/// Refresh the *backchannel* clip bank of `lang` (`<base>/<lang>`).
+pub async fn ensure_lang_backchannel_clips(
+    base: &Path,
+    lang: &str,
+    texts: &[String],
+    tts: &dyn TtsEngine,
+) -> usize {
+    ensure_text_bank_clips(&lang_dir(base, lang), texts, "bc", "backchannel", tts).await
+}
+
+/// Refresh the end-of-turn *filler* clip bank of `lang` (`<base>/<lang>`).
+///
+/// Unlike the default filler bank (fixed names, see [`ensure_clips`]) a
+/// language bank is driven by its phrase list, so the round-robin order follows
+/// the list order.
+pub async fn ensure_lang_filler_clips(
+    base: &Path,
+    lang: &str,
+    texts: &[String],
+    tts: &dyn TtsEngine,
+) -> usize {
+    ensure_text_bank_clips(&lang_dir(base, lang), texts, "fl", "filler", tts).await
+}
+
+/// Refresh the *start-filler* clip bank of `lang` (`<base>/<lang>`).
+pub async fn ensure_lang_start_filler_clips(
+    base: &Path,
+    lang: &str,
+    texts: &[String],
+    tts: &dyn TtsEngine,
+) -> usize {
+    ensure_text_bank_clips(&lang_dir(base, lang), texts, "sf", "start-filler", tts).await
+}
+
+/// Refresh a *text-driven* clip bank so it matches `texts` exactly.
+///
+/// The start filler (`START_FILLER_TEXTS`) and the backchannel
+/// (`BACKCHANNEL_TEXTS`) are user-editable, so unlike the filler bank they are
+/// re-synthesized from their phrase list rather than only when a clip is
+/// missing. The list is remembered in [`TEXTS_INDEX_FILE`], so the synthesis is
+/// skipped when nothing changed; editing a phrase, adding or dropping one, or
+/// losing a clip triggers a full refresh at the next startup, and clips left
+/// over from a previous list are removed. Clips are named by position
+/// (`<prefix>01`, `<prefix>02`, …); a failed synthesis keeps the previous clip
+/// of that position. `label` is only used in log messages (e.g. "start-filler",
+/// "backchannel"). Returns the number of clips generated.
+async fn ensure_text_bank_clips(
+    dir: &Path,
+    texts: &[String],
+    prefix: &str,
+    label: &str,
+    tts: &dyn TtsEngine,
+) -> usize {
+    if texts.is_empty() {
+        warn!(label, "no {label} texts configured — the cue stays silent");
+        return 0;
+    }
+    if let Err(e) = std::fs::create_dir_all(dir) {
+        warn!(
+            label,
+            dir = %dir.display(),
+            error = %e,
+            "cannot create {label} directory — skipping auto-generation"
+        );
+        return 0;
+    }
+
+    let names: Vec<String> = (1..=texts.len()).map(|i| format!("{prefix}{i:02}")).collect();
+    let index = dir.join(TEXTS_INDEX_FILE);
+    let index_content = texts.join("\n");
+
+    // Skip the re-synthesis when the phrase list is unchanged and every clip is
+    // still on disk — otherwise a long list would add ~1 s per phrase to every
+    // restart.
+    let unchanged = std::fs::read_to_string(&index)
+        .map(|s| s == index_content)
+        .unwrap_or(false)
+        && names.iter().all(|n| dir.join(format!("{n}.raw")).exists());
+    if unchanged {
+        info!(
+            label,
+            dir = %dir.display(),
+            clips = texts.len(),
+            "{label} clips up to date — skipping synthesis"
+        );
+        return 0;
+    }
+
+    info!(
+        label,
+        dir = %dir.display(),
+        clips = texts.len(),
+        engine = tts.name(),
+        "refreshing {label} clips at startup"
+    );
+
+    // A handful of concurrent requests keeps startup short without flooding the
+    // TTS backend. Each clip is written to its own file, so order is irrelevant.
+    let generated = futures_util::stream::iter(names.iter().cloned().zip(texts.iter().cloned()))
+        .map(|(name, text)| {
+            let path = dir.join(format!("{name}.raw"));
+            async move {
+                match synthesize_to_file(tts, &text, &path).await {
+                    Ok(samples) => {
+                        info!(label, name, samples, path = %path.display(), "generated {label} clip");
+                        true
+                    }
+                    Err(e) => {
+                        warn!(label, name, error = %e, "failed to generate {label} clip");
+                        false
+                    }
+                }
+            }
+        })
+        .buffer_unordered(TEXT_BANK_CONCURRENCY)
+        .filter(|ok| std::future::ready(*ok))
+        .count()
+        .await;
+
+    remove_stale_clips(dir, &names, label);
+
+    // Only record the list once every clip was produced: a partial failure
+    // leaves the index stale so the next startup retries.
+    if generated == texts.len() {
+        if let Err(e) = std::fs::write(&index, &index_content) {
+            warn!(label, path = %index.display(), error = %e, "failed to write {label} list index");
+        }
+    }
+    generated
+}
+
+/// Delete every `*.raw` clip in `dir` whose name is not in `keep`, so the bank
+/// matches the current phrase list (e.g. after shortening a phrase list).
+fn remove_stale_clips(dir: &Path, keep: &[String], label: &str) {
+    let Ok(entries) = std::fs::read_dir(dir) else {
+        return;
+    };
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if path.extension().and_then(|e| e.to_str()) != Some("raw") {
+            continue;
+        }
+        let stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or_default();
+        if keep.iter().any(|k| k == stem) {
+            continue;
+        }
+        match std::fs::remove_file(&path) {
+            Ok(()) => info!(label, path = %path.display(), "removed stale {label} clip"),
+            Err(e) => warn!(label, path = %path.display(), error = %e, "failed to remove stale {label} clip"),
+        }
+    }
+}
+
 /// Synthesize `text` and write the raw 16-bit LE mono PCM to `path`.
 async fn synthesize_to_file(tts: &dyn TtsEngine, text: &str, path: &Path) -> Result<usize> {
     let buf = SampleRingBuffer::new(SYNTH_BUFFER_SAMPLES);
diff --git a/src/audio/mixer.rs b/src/audio/mixer.rs
index 0b281bc..b6b33bd 100644
--- a/src/audio/mixer.rs
+++ b/src/audio/mixer.rs
@@ -1,9 +1,11 @@
 //! 20 ms audio frame mixer.
 //!
-//! Combines the TTS channel, the filler (end-of-utterance backchannel) channel
-//! and the backchannel (during-utterance acknowledgment) channel into a single
-//! mono PCM stream at 44.1 kHz / 16-bit. The mixer runs on a strict 20 ms ticker
-//! and must never block on network or model I/O.
+//! Combines the TTS channel, the filler (end-of-utterance latency mask)
+//! channel, the start-filler (immediate turn-start acknowledgment) channel, the
+//! backchannel (during-utterance acknowledgment) channel and the external
+//! (URL / radio / YouTube) channel into a single mono PCM stream at 44.1 kHz /
+//! 16-bit. The mixer runs on a strict 20 ms ticker and must never block on
+//! network or model I/O.
 //!
 //! To absorb the uneven arrival of Fish Audio TTS chunks, the mixer applies a
 //! pre-buffer (jitter buffer) on the TTS channel: playback of TTS samples does
@@ -18,7 +20,7 @@
 
 use crate::audio::ring_buffer::SampleRingBuffer;
 use crate::config::{OUTPUT_FRAME_BYTES, OUTPUT_FRAME_SAMPLES};
-use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU32, AtomicUsize, Ordering};
 use std::sync::Arc;
 use tracing::{debug, info};
 
@@ -32,16 +34,26 @@ use tracing::{debug, info};
 /// re-introduces the pre-buffer latency mid-reply.
 const TTS_DRAIN_GRACE_FRAMES: usize = 10;
 
-/// Shared audio mixer holding the TTS, filler and backchannel sample queues.
+/// Shared audio mixer holding the TTS, filler, start-filler and backchannel
+/// sample queues.
 #[derive(Clone)]
 pub struct AudioMixer {
     /// Samples coming from the SGLang Drama 3 TTS stream.
     pub tts_queue: SampleRingBuffer,
     /// Samples coming from preloaded filler PCM (played at end-of-utterance).
     pub filler_queue: SampleRingBuffer,
+    /// Samples coming from the preloaded start-filler clip (played on its own
+    /// channel as soon as a user turn begins).
+    pub start_filler_queue: SampleRingBuffer,
     /// Samples coming from preloaded backchannel PCM (played while the user is
     /// speaking, so the agent signals it is listening).
     pub backchannel_queue: SampleRingBuffer,
+    /// Samples coming from an external audio source — a direct URL, an
+    /// Icecast/Shoutcast radio or a YouTube stream (see [`crate::media`]). This
+    /// is background audio the user injects into the mix; it is *not* cleared by
+    /// `flush` (a barge-in stops the agent, not the music) and does not count as
+    /// the agent speaking.
+    pub external_queue: SampleRingBuffer,
     /// Filler gain when TTS is idle.
     filler_gain_idle: f32,
     /// Filler gain when TTS is active (ducking).
@@ -49,6 +61,10 @@ pub struct AudioMixer {
     /// Fixed, low gain applied to the backchannel channel so the cue stays in
     /// the background.
     backchannel_gain: f32,
+    /// Gain applied to the external audio channel. Atomic (f32 bits) so the
+    /// client can adjust the background level at runtime without rebuilding the
+    /// mixer.
+    external_gain: Arc<AtomicU32>,
     /// Whether the TTS pre-buffer has been reached and TTS is being played out.
     tts_primed: Arc<AtomicBool>,
     /// Count of consecutive frames where the TTS queue was empty while primed.
@@ -66,33 +82,45 @@ pub struct AudioMixer {
     tts_stream_active: Arc<AtomicBool>,
     /// Set the first time the pre-buffer is reached in a turn, i.e. when the
     /// response audio actually starts playing. Reset by `mark_stream_start`
-    /// and `flush`. Used to decide whether a latency filler is still useful.
+    /// and `flush`. Only used to bypass the pre-buffer on subsequent
+    /// playbacks within the same turn.
     tts_playback_started: Arc<AtomicBool>,
+    /// Set as soon as the first TTS samples of the turn are queued, i.e. when
+    /// the response's first audio chunk has *arrived* — possibly still inside
+    /// the pre-buffer window, before playback starts. Reset by
+    /// `mark_stream_start` and `flush`. Used to decide whether a turn-start
+    /// filler is still useful.
+    tts_first_chunk: Arc<AtomicBool>,
 }
 
 impl AudioMixer {
     /// Create a new mixer with the given queue capacities (in samples), filler
-    /// gain parameters and backchannel gain.
+    /// gain parameters, backchannel gain and external-audio gain.
     pub fn new(
         queue_capacity: usize,
         tts_prebuffer_samples: usize,
         filler_gain_idle: f32,
         filler_gain_duck: f32,
         backchannel_gain: f32,
+        external_gain: f32,
     ) -> Self {
         Self {
             tts_queue: SampleRingBuffer::new(queue_capacity),
             filler_queue: SampleRingBuffer::new(queue_capacity),
+            start_filler_queue: SampleRingBuffer::new(queue_capacity),
             backchannel_queue: SampleRingBuffer::new(queue_capacity),
+            external_queue: SampleRingBuffer::new(queue_capacity),
             filler_gain_idle,
             filler_gain_duck,
             backchannel_gain,
+            external_gain: Arc::new(AtomicU32::new(external_gain.to_bits())),
             tts_prebuffer_samples,
             tts_primed: Arc::new(AtomicBool::new(false)),
             tts_drain_frames: Arc::new(AtomicUsize::new(0)),
             tts_stream_end: Arc::new(AtomicBool::new(false)),
             tts_stream_active: Arc::new(AtomicBool::new(false)),
             tts_playback_started: Arc::new(AtomicBool::new(false)),
+            tts_first_chunk: Arc::new(AtomicBool::new(false)),
         }
     }
 
@@ -103,14 +131,26 @@ impl AudioMixer {
     /// bytes long and contains little-endian 16-bit mono PCM.
     ///
     /// Mixing formula:
-    /// `mixed = tts + filler * filler_gain + backchannel * backchannel_gain`.
+    /// `mixed = tts + (filler + start_filler) * filler_gain
+    /// + backchannel * backchannel_gain + external * external_gain`.
     /// The filler gain is dynamically attenuated to `filler_gain_duck` while
     /// TTS is being played out, otherwise it stays at `filler_gain_idle`; the
     /// backchannel gain is fixed and low so the cue stays in the background.
+    /// The start-filler channel shares the filler gain, so the immediate
+    /// acknowledgment ducks out of the way once the reply starts. The external
+    /// channel is a user-injected background source with its own (runtime
+    /// adjustable) gain.
     pub fn pull_frame(&self) -> Option<Vec<u8>> {
         // TTS pre-buffer / priming logic.
         let primed = self.tts_primed.load(Ordering::Relaxed);
         let tts_len = self.tts_queue.len();
+        // The first audio chunk of the turn has arrived as soon as anything is
+        // queued, even if the pre-buffer is not full yet and playback has not
+        // started. Latched here (20 ms ticker) so callers can tell "no audio
+        // yet" apart from "audio arrived but still buffering".
+        if tts_len > 0 {
+            self.tts_first_chunk.store(true, Ordering::Relaxed);
+        }
         if !primed {
             // Prime when the pre-buffer is reached, or when the TTS stream has
             // already ended and anything is queued. The latter handles short
@@ -171,7 +211,9 @@ impl AudioMixer {
         // Scratch buffers for one frame — allocation-free hot path.
         let mut tts_buf = [0i16; OUTPUT_FRAME_SAMPLES];
         let mut filler_buf = [0i16; OUTPUT_FRAME_SAMPLES];
+        let mut start_filler_buf = [0i16; OUTPUT_FRAME_SAMPLES];
         let mut backchannel_buf = [0i16; OUTPUT_FRAME_SAMPLES];
+        let mut external_buf = [0i16; OUTPUT_FRAME_SAMPLES];
 
         // Only consume TTS when primed (pre-buffer reached). This prevents
         // partial frames that cause audible drop-outs.
@@ -181,13 +223,21 @@ impl AudioMixer {
             0
         };
         let filler_n = self.filler_queue.pop_into(&mut filler_buf);
+        let start_filler_n = self.start_filler_queue.pop_into(&mut start_filler_buf);
         let backchannel_n = self.backchannel_queue.pop_into(&mut backchannel_buf);
+        let external_n = self.external_queue.pop_into(&mut external_buf);
 
         // If no channel produced anything, skip sending a frame.
-        if tts_n == 0 && filler_n == 0 && backchannel_n == 0 {
+        if tts_n == 0
+            && filler_n == 0
+            && start_filler_n == 0
+            && backchannel_n == 0
+            && external_n == 0
+        {
             return None;
         }
 
+        let external_gain = f32::from_bits(self.external_gain.load(Ordering::Relaxed));
         let mut out = vec![0u8; OUTPUT_FRAME_BYTES];
         // Mix into the output byte buffer directly to avoid an extra copy.
         let bytes = out.as_mut_slice();
@@ -195,9 +245,13 @@ impl AudioMixer {
             let tts = tts_buf[i] as i32;
             // Apply filler / backchannel gains in floating point then round back.
             let filler_scaled = (filler_buf[i] as f32 * filler_gain).round() as i32;
+            let start_filler_scaled =
+                (start_filler_buf[i] as f32 * filler_gain).round() as i32;
             let backchannel_scaled =
                 (backchannel_buf[i] as f32 * self.backchannel_gain).round() as i32;
-            let mixed = tts + filler_scaled + backchannel_scaled;
+            let external_scaled = (external_buf[i] as f32 * external_gain).round() as i32;
+            let mixed =
+                tts + filler_scaled + start_filler_scaled + backchannel_scaled + external_scaled;
             // Clamp to i16 range to prevent overflow / audible pops.
             let clamped = mixed.clamp(i16::MIN as i32, i16::MAX as i32) as i16;
             let lo = (clamped & 0xFF) as u8;
@@ -215,6 +269,7 @@ impl AudioMixer {
         self.tts_stream_end.store(false, Ordering::Relaxed);
         self.tts_stream_active.store(true, Ordering::Relaxed);
         self.tts_playback_started.store(false, Ordering::Relaxed);
+        self.tts_first_chunk.store(false, Ordering::Relaxed);
         self.tts_primed.store(false, Ordering::Relaxed);
         self.tts_drain_frames.store(0, Ordering::Relaxed);
     }
@@ -228,14 +283,15 @@ impl AudioMixer {
     }
 
     /// Whether the agent is producing or playing audio: a TTS request is in
-    /// flight, TTS samples are queued (or being played out), or a filler is
-    /// still queued. Used to gate VAD-driven barge-in, so silence from the user
-    /// does not flush an idle mixer.
+    /// flight, TTS samples are queued (or being played out), or a filler /
+    /// start-filler is still queued. Used to gate VAD-driven barge-in, so
+    /// silence from the user does not flush an idle mixer.
     pub fn is_active(&self) -> bool {
         self.tts_stream_active.load(Ordering::Relaxed)
             || self.tts_primed.load(Ordering::Relaxed)
             || self.tts_queue.len() > 0
             || self.filler_queue.len() > 0
+            || self.start_filler_queue.len() > 0
     }
 
     /// Whether the response audio has started playing since the last
@@ -246,17 +302,38 @@ impl AudioMixer {
         self.tts_playback_started.load(Ordering::Relaxed)
     }
 
-    /// Instantly clear all queues. Used for barge-in / interruption so that
-    /// stale TTS, filler and backchannel audio is not played after the user
-    /// speaks.
+    /// Whether the first response audio chunk has reached the mixer since the
+    /// last `mark_stream_start`. Unlike [`Self::tts_playback_started`] this is
+    /// latched on *arrival*, so it is already `true` while the first samples
+    /// are still sitting in the pre-buffer. `false` means no response audio has
+    /// been produced yet, i.e. a turn-start filler is still worth playing.
+    pub fn tts_audio_arrived(&self) -> bool {
+        self.tts_first_chunk.load(Ordering::Relaxed)
+    }
+
+    /// Instantly clear all *agent* queues. Used for barge-in / interruption so
+    /// that stale TTS, filler, start-filler and backchannel audio is not played
+    /// after the user speaks.
+    ///
+    /// The [`Self::external_queue`] is deliberately left untouched: a barge-in
+    /// stops the agent, not the background audio the user injected.
     pub fn flush(&self) {
         self.tts_queue.clear();
         self.filler_queue.clear();
+        self.start_filler_queue.clear();
         self.backchannel_queue.clear();
         self.tts_primed.store(false, Ordering::Relaxed);
         self.tts_drain_frames.store(0, Ordering::Relaxed);
         self.tts_stream_end.store(false, Ordering::Relaxed);
         self.tts_stream_active.store(false, Ordering::Relaxed);
         self.tts_playback_started.store(false, Ordering::Relaxed);
+        self.tts_first_chunk.store(false, Ordering::Relaxed);
+    }
+
+    /// Set the gain applied to the external audio channel. Used by the client's
+    /// volume control; takes effect on the next mixed frame.
+    pub fn set_external_gain(&self, gain: f32) {
+        self.external_gain
+            .store(gain.max(0.0).to_bits(), Ordering::Relaxed);
     }
 }
diff --git a/src/audit.rs b/src/audit.rs
new file mode 100644
index 0000000..c86222e
--- /dev/null
+++ b/src/audit.rs
@@ -0,0 +1,295 @@
+//! Per-session audit log: a structured JSONL record of a whole WebSocket
+//! session.
+//!
+//! Each session can be written to its own file (`<dir>/<id>.jsonl`), one JSON
+//! object per line. Every record carries a wall-clock timestamp, the elapsed
+//! time since the session started, an event discriminator and a payload:
+//!
+//! ```text
+//! {"ts":1729170000000,"elapsed_ms":12,"event":"session_start","data":{…}}
+//! {"ts":1729170000123,"elapsed_ms":135,"event":"control","data":{"type":"user_text",…}}
+//! {"ts":1729170000456,"elapsed_ms":468,"event":"out","data":{"type":"assistant_delta",…}}
+//! {"ts":1729170009000,"elapsed_ms":9012,"event":"session_end","data":{…}}
+//! ```
+//!
+//! The log captures what the client sent (control messages), what the agent
+//! sent back (every WebSocket event, tapped on the sender path), the cue
+//! emissions, the language switches, the barge-ins and interrupts, plus a
+//! configuration snapshot at the start and an event-count summary at the end.
+//! It is meant for post-mortem analysis and for tuning latency knobs
+//! (`FILLER_DELAY_MS`, `START_FILLER_GO_DELAY`, …).
+//!
+//! Recording is **best-effort**: when the sink is disabled, or the file cannot
+//! be created, or a write fails, the session runs unchanged (failures are
+//! logged at most once and then the sink goes quiet). Nothing on this path ever
+//! aborts or delays a session.
+
+use crate::config::Config;
+use parking_lot::Mutex;
+use serde_json::{json, Value};
+use std::collections::BTreeMap;
+use std::fs::{File, OpenOptions};
+use std::io::{BufWriter, Write};
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{Instant, SystemTime, UNIX_EPOCH};
+use tracing::{info, warn};
+
+/// Process-wide sequence number, so two sessions that start in the same
+/// millisecond still get distinct ids.
+static SESSION_SEQ: AtomicU64 = AtomicU64::new(0);
+
+/// Wall-clock milliseconds since the Unix epoch (0 if the clock predates it).
+fn now_ms() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_millis() as u64)
+        .unwrap_or(0)
+}
+
+/// Mutable state behind the sink's lock.
+struct Inner {
+    /// Buffered file writer; flushed after every record so the log survives a
+    /// crash or a `pm2 restart`.
+    writer: BufWriter<File>,
+    /// Event counts by discriminator, for the end-of-session summary.
+    counts: BTreeMap<String, u64>,
+    /// Set after a write error, so we stop retrying on every event.
+    failed: bool,
+}
+
+/// A per-session JSONL audit sink. Shared across the session tasks through an
+/// `Arc`; safe to call from any task. A disabled sink makes every method a
+/// no-op.
+pub struct SessionAudit {
+    /// Unique session id (also the file stem), e.g. `s-1729170000000-0001`.
+    id: String,
+    /// The file being written (for logging and the summary).
+    path: Option<PathBuf>,
+    /// `None` when disabled or when the file could not be opened.
+    inner: Option<Mutex<Inner>>,
+    /// Session start instant, the origin of every `elapsed_ms`.
+    start: Instant,
+}
+
+impl SessionAudit {
+    /// Create the sink for a new session. `SESSION_AUDIT_ENABLED=false`
+    /// disables it; a failure to create the directory or the file (logged as a
+    /// warning) also yields a disabled sink.
+    pub fn new(config: &Config) -> Self {
+        let start = Instant::now();
+        if !config.session_audit_enabled {
+            return Self::disabled(start);
+        }
+
+        let seq = SESSION_SEQ.fetch_add(1, Ordering::Relaxed);
+        let id = format!("s-{}-{:04}", now_ms(), seq);
+        let path = config.session_audit_dir.join(format!("{id}.jsonl"));
+
+        if let Err(e) = std::fs::create_dir_all(&config.session_audit_dir) {
+            warn!(
+                dir = %config.session_audit_dir.display(),
+                error = %e,
+                "session audit: cannot create directory — logging disabled"
+            );
+            return Self::disabled(start);
+        }
+        let file = match OpenOptions::new().create(true).append(true).open(&path) {
+            Ok(f) => f,
+            Err(e) => {
+                warn!(
+                    path = %path.display(),
+                    error = %e,
+                    "session audit: cannot open file — logging disabled"
+                );
+                return Self::disabled(start);
+            }
+        };
+
+        info!(id = %id, path = %path.display(), "session audit log opened");
+        Self {
+            id,
+            path: Some(path),
+            inner: Some(Mutex::new(Inner {
+                writer: BufWriter::new(file),
+                counts: BTreeMap::new(),
+                failed: false,
+            })),
+            start,
+        }
+    }
+
+    /// An inert sink (nothing is written).
+    fn disabled(start: Instant) -> Self {
+        Self {
+            id: String::new(),
+            path: None,
+            inner: None,
+            start,
+        }
+    }
+
+    /// Append one record. `kind` is the discriminator (e.g. `session_start`,
+    /// `control`, `out`, `barge_in`); `data` is the payload. Best-effort: a
+    /// write failure disables the sink for the rest of the session.
+    pub fn event(&self, kind: &str, data: Value) {
+        let Some(inner) = &self.inner else {
+            return;
+        };
+        let mut inner = inner.lock();
+        if inner.failed {
+            return;
+        }
+        let record = json!({
+            "ts": now_ms(),
+            "elapsed_ms": self.start.elapsed().as_millis() as u64,
+            "event": kind,
+            "data": data,
+        });
+        let mut line = record.to_string();
+        line.push('\n');
+        if let Err(e) = inner
+            .writer
+            .write_all(line.as_bytes())
+            .and_then(|_| inner.writer.flush())
+        {
+            warn!(
+                error = %e,
+                "session audit: write failed — logging disabled for this session"
+            );
+            inner.failed = true;
+            return;
+        }
+        *inner.counts.entry(kind.to_string()).or_insert(0) += 1;
+    }
+
+    /// Write the opening record: the full configuration snapshot plus the
+    /// runtime capabilities that are not part of [`Config`] (whether STT, VAD,
+    /// tokenizer and LLM are actually active for this process).
+    pub fn log_start(&self, config: &Config, runtime: Value) {
+        self.event(
+            "session_start",
+            json!({ "config": config_snapshot(config), "runtime": runtime }),
+        );
+    }
+
+    /// Write the closing record with the event counts and the session duration.
+    pub fn summary(&self, reason: &str) {
+        let Some(inner) = &self.inner else {
+            return;
+        };
+        let counts = inner.lock().counts.clone();
+        self.event(
+            "session_end",
+            json!({
+                "reason": reason,
+                "duration_ms": self.start.elapsed().as_millis() as u64,
+                "session_id": self.id,
+                "file": self.path.as_ref().map(|p| p.display().to_string()),
+                "counts": counts,
+            }),
+        );
+    }
+}
+
+/// A compact, serializable view of everything that shapes a session's
+/// observable behaviour. Secrets (API keys) are deliberately omitted.
+fn config_snapshot(c: &Config) -> Value {
+    json!({
+        "server_port": c.server_port,
+        "tls": c.tls_cert.is_some() && c.tls_key.is_some(),
+        "tts": {
+            "engine": c.tts_engine,
+            "sglang_url": c.sglang_url,
+            "model": c.tts_model,
+            "voice": c.tts_voice,
+            "reference_audio": c.tts_reference_audio.as_ref().map(|p| p.display().to_string()),
+            "temperature": c.tts_temperature,
+            "top_p": c.tts_top_p,
+            "top_k": c.tts_top_k,
+            "style_tag": c.tts_style_tag,
+            "prebuffer_ms": c.tts_prebuffer_ms,
+            "pipeline_depth": c.tts_pipeline_depth,
+        },
+        "stt": {
+            "model_path": c.stt_model_path.display().to_string(),
+            "tokenizer_path": c.stt_tokenizer_path.as_ref().map(|p| p.display().to_string()),
+        },
+        "filler": {
+            "enabled": c.filler_enabled,
+            "dir": c.fillers_dir.display().to_string(),
+            "delay_ms": c.filler_delay_ms,
+            "gain_idle": c.filler_gain_idle,
+            "gain_duck": c.filler_gain_duck,
+        },
+        "start_filler": {
+            "enabled": c.start_filler_enabled,
+            "dir": c.start_filler_dir.display().to_string(),
+            "go_delay_ms": c.start_filler_go_delay_ms,
+            "texts": c.start_filler_texts,
+        },
+        "backchannel": {
+            "enabled": c.backchannel.enabled,
+            "dir": c.backchannel.dir.display().to_string(),
+            "gain": c.backchannel.gain,
+            "min_speech_ms": c.backchannel.min_speech_ms,
+            "interval_ms": c.backchannel.interval_ms,
+            "jitter_ms": c.backchannel.jitter_ms,
+            "pause_min_ms": c.backchannel.pause_min_ms,
+            "pause_max_ms": c.backchannel.pause_max_ms,
+            "prob": c.backchannel.prob,
+            "volume_jitter": c.backchannel.volume_jitter,
+            "max_per_turn": c.backchannel.max_per_turn,
+            "texts": c.backchannel.texts,
+            "categories": c.backchannel.categories,
+        },
+        "external_audio": {
+            "gain": c.external_audio_gain,
+            "ffmpeg_bin": c.media_ffmpeg_bin,
+            "ytdlp_bin": c.media_ytdlp_bin,
+            "ytdlp_args": c.media_ytdlp_args,
+        },
+        "vad": {
+            "enabled": c.vad.enabled,
+            "model_path": c.vad.model_path.display().to_string(),
+            "threshold": c.vad.threshold,
+            "neg_threshold": c.vad.neg_threshold,
+            "min_speech_ms": c.vad.min_speech_ms,
+            "min_silence_ms": c.vad.min_silence_ms,
+            "speech_pad_ms": c.vad.speech_pad_ms,
+            "barge_in_min_speech_ms": c.vad.barge_in_min_speech_ms,
+            "segment_stt": c.vad.segment_stt,
+            "barge_in": c.vad.barge_in,
+            "debug": c.vad.debug,
+        },
+        "lang": {
+            "default": c.lang_default,
+            "detect_enabled": c.lang_detect_enabled,
+            "min_chars": c.lang_min_chars,
+            "redetect_every": c.lang_redetect_every,
+            "llm_fallback": c.lang_llm_fallback_enabled,
+        },
+        "llm": {
+            "enabled": c.llm_enabled,
+            "base_url": c.llm_base_url,
+            "model": c.llm_model,
+            "max_tokens": c.llm_max_tokens,
+            "temperature": c.llm_temperature,
+            "stream": c.llm_stream,
+            "history_messages": c.llm_history_messages,
+            "enable_thinking": c.llm_enable_thinking,
+            "strip_reasoning": c.llm_strip_reasoning,
+            "direct_answers": c.llm_direct_answers,
+            "stream_first_chunk_chars": c.llm_stream_first_chunk_chars,
+            "stream_chunk_chars": c.llm_stream_chunk_chars,
+            "system_prompt": c.llm_system_prompt,
+            "tools": {
+                "enabled": c.llm_tools_enabled,
+                "file": c.llm_tools_file,
+                "max_iterations": c.llm_tool_max_iterations,
+                "timeout_secs": c.llm_tool_timeout_secs,
+                "result_max_chars": c.llm_tool_result_max_chars,
+            },
+        },
+    })
+}
diff --git a/src/config.rs b/src/config.rs
index 361182f..7928707 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -64,6 +64,26 @@ pub struct Config {
     /// Optional reference transcript. If this looks like a path to a `.txt`
     /// file, its contents are loaded; otherwise the string itself is used.
     pub tts_reference_text: Option<String>,
+    /// Sampling temperature sent to the SGLang speech endpoint
+    /// (`TTS_TEMPERATURE`, default `0.45`). `None` omits the field, falling
+    /// back to the server default. Lower values reduce the "theatrical"
+    /// over-articulation of Drama 3.
+    pub tts_temperature: Option<f32>,
+    /// Nucleus sampling top-p sent to SGLang (`TTS_TOP_P`, default `0.75`).
+    /// `None` omits the field. Trims the tail of the acoustic token
+    /// distribution, where exaggerated intonations live.
+    pub tts_top_p: Option<f32>,
+    /// Top-k sampling sent to SGLang (`TTS_TOP_K`, default unset/omitted).
+    pub tts_top_k: Option<u32>,
+    /// Neutral style tag prepended to every synthesis request that does not
+    /// already start with one (`TTS_STYLE_TAG`, default
+    /// `[conversational, casual]`). Empty disables it.
+    ///
+    /// Drama 3 replies are plain LLM prose (the system prompt forbids stage
+    /// directions), so this is the only way to steer the *reply* away from a
+    /// recitative register; clip banks that carry their own tag are left
+    /// untouched.
+    pub tts_style_tag: String,
     /// Filesystem directory containing the Parakeet TDT ONNX pipeline
     /// (`nemo128.onnx`, `encoder-model*.onnx`, `decoder_joint-model.onnx`,
     /// `vocab.txt`, `config.json`).
@@ -84,7 +104,7 @@ pub struct Config {
     /// per turn.
     pub filler_delay_ms: u64,
     /// TTS jitter buffer (ms) the mixer must fill before the response audio
-    /// starts playing (`TTS_PREBUFFER_MS`, default `450`). Larger values absorb
+    /// starts playing (`TTS_PREBUFFER_MS`, default `170`). Larger values absorb
     /// uneven TTS chunk arrival (fewer drop-outs) at the cost of added
     /// time-to-first-audio. The full buffer is only required at the start of a
     /// reply; after a mid-reply underrun the mixer resumes as soon as any audio
@@ -105,6 +125,45 @@ pub struct Config {
     pub filler_gain_idle: f32,
     /// Filler gain applied while TTS is active (ducking).
     pub filler_gain_duck: f32,
+    /// Fixed gain applied to the external audio channel (`EXTERNAL_AUDIO_GAIN`,
+    /// default `0.6`) — the mixer channel used to inject an audio stream coming
+    /// from a URL / radio / YouTube source (see [`crate::media`]). Kept below
+    /// `1.0` so background audio sits under the agent's voice.
+    pub external_audio_gain: f32,
+    /// Binary used to fetch and decode external audio sources
+    /// (`MEDIA_FFMPEG_BIN`, default `ffmpeg`). ffmpeg handles direct media URLs,
+    /// Icecast/Shoutcast radio and HLS streams.
+    pub media_ffmpeg_bin: String,
+    /// Binary used to resolve YouTube URLs to a decodable stream
+    /// (`MEDIA_YTDLP_BIN`, default `yt-dlp`). Only needed for YouTube sources.
+    pub media_ytdlp_bin: String,
+    /// Extra arguments appended to the yt-dlp invocation
+    /// (`MEDIA_YTDLP_ARGS`, space-separated). Useful to pass cookies or a
+    /// JavaScript runtime, e.g. `--cookies /path/cookies.txt`.
+    pub media_ytdlp_args: Vec<String>,
+    /// Whether the immediate *start filler* acknowledgment is used at all
+    /// (`START_FILLER_ENABLED`). The cue is queued on its own mixer channel
+    /// whenever the response audio is late, so the agent acknowledges the turn
+    /// while the reply is still being generated (see
+    /// [`Config::start_filler_go_delay_ms`]).
+    pub start_filler_enabled: bool,
+    /// How long (ms) the agent waits for the response audio to start before
+    /// playing the start filler (`START_FILLER_GO_DELAY`, default `1200`). Same
+    /// idea as [`Config::filler_delay_ms`] — a late reply is masked with a
+    /// short acknowledgment, an on-time one is not — but on the dedicated
+    /// start-filler channel and with its own (shorter) delay. If playback has
+    /// already begun within this window the cue is dropped.
+    pub start_filler_go_delay_ms: u64,
+    /// Directory holding the pre-generated start-filler clips
+    /// (`START_FILLER_DIR`). One clip per entry in
+    /// [`Config::start_filler_texts`] is synthesized at startup.
+    pub start_filler_dir: PathBuf,
+    /// Phrases spoken by the start filler (`START_FILLER_TEXTS`), one per line
+    /// (a `|` separator also works), e.g. `"[calm] Un momento..."`. One clip is
+    /// synthesized per phrase and a random one is played at each turn start, so
+    /// the agent's acknowledgment varies. The clips are re-synthesized on every
+    /// startup, so editing this list takes effect at the next restart.
+    pub start_filler_texts: Vec<String>,
     /// Optional TLS certificate (PEM) for serving HTTPS. Set `TLS_CERT` and
     /// `TLS_KEY` together to enable HTTPS; when unset the server speaks plain
     /// HTTP. HTTPS is required for browser microphone access from a non-
@@ -116,6 +175,29 @@ pub struct Config {
     pub vad: VadSettings,
     /// Backchannel settings (see [`crate::orchestrator::backchannel`]).
     pub backchannel: BackchannelSettings,
+    /// Language of the shipped clip banks (`LANG_DEFAULT`, default `es`).
+    ///
+    /// The base directories (`BACKCHANNEL_DIR`, `FILLERS_DIR`) hold the clips
+    /// of this language; the clips of any other language are generated on
+    /// demand into a subdirectory named after the ISO 639-1 code. See
+    /// [`crate::lang`].
+    pub lang_default: String,
+    /// Detect the user's language with a dedicated LLM call and switch the
+    /// backchannel / end-of-turn filler clip banks to it when it differs from
+    /// the active one (`LANG_DETECT_ENABLED`, default `true`).
+    pub lang_detect_enabled: bool,
+    /// Minimum transcript length (chars) before a sample is sent to the LLM
+    /// (`LANG_MIN_CHARS`, default `12`): a shorter text is not a reliable
+    /// language sample.
+    pub lang_min_chars: usize,
+    /// Re-detect the language every N user turns (`LANG_REDETECT_EVERY`,
+    /// default `5`). The first turn is always checked, so a language switch
+    /// mid-conversation is picked up without a detection call on every turn.
+    pub lang_redetect_every: u64,
+    /// Generate the phrase list with the LLM for languages without a built-in
+    /// table (`LANG_LLM_FALLBACK_ENABLED`, default `true`). See
+    /// [`crate::lang::BACKCHANNEL_TEXTS`].
+    pub lang_llm_fallback_enabled: bool,
     /// Master switch for the reasoning LLM (`LLM_ENABLED`). When off the
     /// pipeline runs STT → TTS with no reasoning step.
     pub llm_enabled: bool,
@@ -164,6 +246,31 @@ pub struct Config {
     /// default `120`). Larger chunks give better prosody; smaller ones keep the
     /// audio flowing while the model is still generating. `0` disables.
     pub llm_stream_chunk_chars: usize,
+    /// Master switch for LLM tool calling (`LLM_TOOLS_ENABLED`). Defaults to
+    /// enabled when `LLM_TOOLS_FILE` points to a loadable file.
+    pub llm_tools_enabled: bool,
+    /// Path to the JSON file listing the HTTP tools
+    /// (`LLM_TOOLS_FILE`, see [`crate::tools`]). Empty disables tool calling.
+    pub llm_tools_file: String,
+    /// Maximum tool-call round trips per user turn
+    /// (`LLM_TOOL_MAX_ITERATIONS`, default `4`). Bounds a runaway loop.
+    pub llm_tool_max_iterations: usize,
+    /// Per-request timeout (seconds) for a tool HTTP call
+    /// (`LLM_TOOL_TIMEOUT_SECS`, default `15`).
+    pub llm_tool_timeout_secs: u64,
+    /// Maximum characters of a tool response handed back to the model
+    /// (`LLM_TOOL_RESULT_MAX_CHARS`, default `2000`); longer responses are
+    /// truncated to protect the context window.
+    pub llm_tool_result_max_chars: usize,
+    /// Write a structured per-session audit log to disk
+    /// (`SESSION_AUDIT_ENABLED`, default `true`). One JSONL file per session,
+    /// holding the configuration snapshot, the control messages, every outbound
+    /// event, the cues, the language switches, the barge-ins and a summary — see
+    /// [`crate::audit`].
+    pub session_audit_enabled: bool,
+    /// Directory holding the per-session audit files (`SESSION_AUDIT_DIR`,
+    /// default `logs/sessions`).
+    pub session_audit_dir: PathBuf,
 }
 
 impl Default for Config {
@@ -179,19 +286,36 @@ impl Default for Config {
             // left unset. Overridable at runtime from the playground.
             tts_reference_audio: Some(PathBuf::from("/root/pipecat-voice/voice_profiles/solis.wav")),
             tts_reference_text: None,
+            tts_temperature: Some(0.45),
+            tts_top_p: Some(0.75),
+            tts_top_k: None,
+            tts_style_tag: "[conversational, casual]".to_string(),
             stt_model_path: PathBuf::from("models/parakeet"),
             stt_tokenizer_path: None,
             fillers_dir: PathBuf::from("assets/fillers"),
             filler_enabled: true,
             filler_delay_ms: 2500,
-            tts_prebuffer_ms: 450,
+            tts_prebuffer_ms: 170,
             tts_pipeline_depth: 3,
             filler_gain_idle: 1.0,
             filler_gain_duck: 0.15,
+            external_audio_gain: 0.6,
+            media_ffmpeg_bin: "ffmpeg".to_string(),
+            media_ytdlp_bin: "yt-dlp".to_string(),
+            media_ytdlp_args: Vec::new(),
+            start_filler_enabled: true,
+            start_filler_go_delay_ms: 1200,
+            start_filler_dir: PathBuf::from("assets/start_filler"),
+            start_filler_texts: vec!["[calm] Un momento...".to_string()],
             tls_cert: None,
             tls_key: None,
             vad: VadSettings::default(),
             backchannel: BackchannelSettings::default(),
+            lang_default: "es".to_string(),
+            lang_detect_enabled: true,
+            lang_min_chars: 12,
+            lang_redetect_every: 5,
+            lang_llm_fallback_enabled: true,
             llm_enabled: false,
             llm_base_url: String::new(),
             llm_api_key: "EMPTY".to_string(),
@@ -206,6 +330,13 @@ impl Default for Config {
             llm_direct_answers: true,
             llm_stream_first_chunk_chars: 20,
             llm_stream_chunk_chars: 120,
+            llm_tools_enabled: false,
+            llm_tools_file: String::new(),
+            llm_tool_max_iterations: 4,
+            llm_tool_timeout_secs: 15,
+            llm_tool_result_max_chars: 2000,
+            session_audit_enabled: true,
+            session_audit_dir: PathBuf::from("logs/sessions"),
         }
     }
 }
@@ -243,6 +374,15 @@ impl Config {
                 cfg.tts_reference_text = Some(t);
             }
         }
+        // Optional sampling overrides. Setting a variable to an empty value
+        // disables the field (the server default then applies), so the
+        // de-emphasis can be turned off without editing code.
+        cfg.tts_temperature = env_opt_f32("TTS_TEMPERATURE", cfg.tts_temperature);
+        cfg.tts_top_p = env_opt_f32("TTS_TOP_P", cfg.tts_top_p);
+        cfg.tts_top_k = env_opt_u32("TTS_TOP_K", cfg.tts_top_k);
+        if let Ok(v) = std::env::var("TTS_STYLE_TAG") {
+            cfg.tts_style_tag = v.trim().to_string();
+        }
         if let Ok(p) = std::env::var("STT_MODEL_PATH") {
             cfg.stt_model_path = PathBuf::from(p);
         }
@@ -256,6 +396,26 @@ impl Config {
         }
         cfg.filler_enabled = env_bool("FILLER_ENABLED", cfg.filler_enabled);
         cfg.filler_delay_ms = env_u32("FILLER_DELAY_MS", cfg.filler_delay_ms as u32) as u64;
+        cfg.start_filler_enabled = env_bool("START_FILLER_ENABLED", cfg.start_filler_enabled);
+        cfg.start_filler_go_delay_ms =
+            env_u32("START_FILLER_GO_DELAY", cfg.start_filler_go_delay_ms as u32) as u64;
+        if let Ok(d) = std::env::var("START_FILLER_DIR") {
+            if !d.is_empty() {
+                cfg.start_filler_dir = PathBuf::from(d);
+            }
+        }
+        if let Ok(t) = std::env::var("START_FILLER_TEXTS") {
+            // One phrase per line; a `|` separator is also accepted so the list
+            // can live on a single line. Blank entries are dropped.
+            let texts: Vec<String> = t
+                .split(['\n', '|'])
+                .map(|s| s.trim().to_string())
+                .filter(|s| !s.is_empty())
+                .collect();
+            if !texts.is_empty() {
+                cfg.start_filler_texts = texts;
+            }
+        }
         cfg.tts_prebuffer_ms = env_u32("TTS_PREBUFFER_MS", cfg.tts_prebuffer_ms as u32) as u64;
         cfg.tts_pipeline_depth =
             env_u32("TTS_PIPELINE_DEPTH", cfg.tts_pipeline_depth as u32).max(1) as usize;
@@ -269,8 +429,42 @@ impl Config {
                 cfg.tls_key = Some(PathBuf::from(p));
             }
         }
+        // External audio source (URL / radio / YouTube) — see `crate::media`.
+        cfg.external_audio_gain = env_f32("EXTERNAL_AUDIO_GAIN", cfg.external_audio_gain);
+        if let Ok(v) = std::env::var("MEDIA_FFMPEG_BIN") {
+            if !v.trim().is_empty() {
+                cfg.media_ffmpeg_bin = v.trim().to_string();
+            }
+        }
+        if let Ok(v) = std::env::var("MEDIA_YTDLP_BIN") {
+            if !v.trim().is_empty() {
+                cfg.media_ytdlp_bin = v.trim().to_string();
+            }
+        }
+        if let Ok(v) = std::env::var("MEDIA_YTDLP_ARGS") {
+            cfg.media_ytdlp_args = v.split_whitespace().map(str::to_string).collect();
+        }
         cfg.vad = VadSettings::from_env();
         cfg.backchannel = BackchannelSettings::from_env();
+        // Multilingual clip banks (see `crate::lang`): the language of the
+        // shipped banks plus the runtime detection / regeneration knobs.
+        if let Ok(v) = std::env::var("LANG_DEFAULT") {
+            if !v.trim().is_empty() {
+                cfg.lang_default = v.trim().to_lowercase();
+            }
+        }
+        cfg.lang_detect_enabled = env_bool("LANG_DETECT_ENABLED", cfg.lang_detect_enabled);
+        cfg.lang_min_chars = env_u32("LANG_MIN_CHARS", cfg.lang_min_chars as u32) as usize;
+        cfg.lang_redetect_every = env_u64("LANG_REDETECT_EVERY", cfg.lang_redetect_every).max(1);
+        cfg.lang_llm_fallback_enabled =
+            env_bool("LANG_LLM_FALLBACK_ENABLED", cfg.lang_llm_fallback_enabled);
+        // Per-session audit log (see `crate::audit`).
+        if let Ok(d) = std::env::var("SESSION_AUDIT_DIR") {
+            if !d.trim().is_empty() {
+                cfg.session_audit_dir = PathBuf::from(d.trim());
+            }
+        }
+        cfg.session_audit_enabled = env_bool("SESSION_AUDIT_ENABLED", cfg.session_audit_enabled);
         cfg.read_llm_env();
         cfg
     }
@@ -310,6 +504,21 @@ impl Config {
         self.llm_stream_chunk_chars =
             env_u32("LLM_STREAM_CHUNK_CHARS", self.llm_stream_chunk_chars as u32) as usize;
 
+        // Tool calling (configurable HTTP tools). Enabled by default as soon as
+        // a tools file is configured; see `crate::tools`.
+        if let Ok(v) = std::env::var("LLM_TOOLS_FILE") {
+            if !v.trim().is_empty() {
+                self.llm_tools_file = v.trim().to_string();
+            }
+        }
+        self.llm_tool_max_iterations =
+            env_u32("LLM_TOOL_MAX_ITERATIONS", self.llm_tool_max_iterations as u32).max(1) as usize;
+        self.llm_tool_timeout_secs = env_u64("LLM_TOOL_TIMEOUT_SECS", self.llm_tool_timeout_secs);
+        self.llm_tool_result_max_chars =
+            env_u32("LLM_TOOL_RESULT_MAX_CHARS", self.llm_tool_result_max_chars as u32) as usize;
+        self.llm_tools_enabled =
+            env_bool("LLM_TOOLS_ENABLED", !self.llm_tools_file.is_empty());
+
         // Direct-answer instruction: appended to whichever system prompt is in
         // use (built-in default or `LLM_SYSTEM_PROMPT` override).
         self.llm_direct_answers = env_bool("LLM_DIRECT_ANSWERS", self.llm_direct_answers);
@@ -407,6 +616,25 @@ pub(crate) fn env_f32(name: &str, default: f32) -> f32 {
         .unwrap_or(default)
 }
 
+/// Parse an optional `f32` sampling knob: `fallback` when unset or malformed,
+/// `None` when set but empty (disables the field), `Some(v)` otherwise.
+pub(crate) fn env_opt_f32(name: &str, fallback: Option<f32>) -> Option<f32> {
+    match std::env::var(name) {
+        Ok(v) if v.trim().is_empty() => None,
+        Ok(v) => v.trim().parse().ok().or(fallback),
+        Err(_) => fallback,
+    }
+}
+
+/// Parse an optional `u32` sampling knob (see [`env_opt_f32`]).
+pub(crate) fn env_opt_u32(name: &str, fallback: Option<u32>) -> Option<u32> {
+    match std::env::var(name) {
+        Ok(v) if v.trim().is_empty() => None,
+        Ok(v) => v.trim().parse().ok().or(fallback),
+        Err(_) => fallback,
+    }
+}
+
 /// Parse a `u32` env var, falling back to `default` when unset or malformed.
 pub(crate) fn env_u32(name: &str, default: u32) -> u32 {
     std::env::var(name)
diff --git a/src/lang.rs b/src/lang.rs
new file mode 100644
index 0000000..fe6950d
--- /dev/null
+++ b/src/lang.rs
@@ -0,0 +1,433 @@
+//! Multilingual clip banks: language detection and per-language phrase tables.
+//!
+//! The shipped clip banks (backchannel, end-of-turn filler and start filler,
+//! built in [`crate::assets`]) are pre-synthesized in a single language — the
+//! one configured by `LANG_DEFAULT` (Spanish by default), which lives in the
+//! base directories (`BACKCHANNEL_DIR`, `FILLERS_DIR`, `START_FILLER_DIR`).
+//! When the user is detected speaking a different language, the banks for that
+//! language are generated on demand into a per-language subdirectory
+//! (`<base>/<lang>/`, ISO 639-1) and the session switches to them. Every
+//! language has its own directory, so regenerating one never removes the clips
+//! of another.
+//!
+//! Detection is a dedicated LLM call (`LANG_DETECT_ENABLED`) returning the ISO
+//! 639-1 code of the transcript. The phrase lists come from the built-in tables
+//! below for the common languages, and from the LLM
+//! (`LANG_LLM_FALLBACK_ENABLED`) for any other language.
+
+use crate::llm::LlmClient;
+use crate::orchestrator::FillerBank;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
+use tokio_util::sync::CancellationToken;
+use tracing::{info, warn};
+
+/// Maximum number of phrases accepted from an LLM-generated list.
+const LLM_TEXT_LIMIT: usize = 12;
+
+/// Backchannel phrases per language, as `(category, phrase)` pairs.
+///
+/// The category drives the progression through a turn (an acknowledgment first,
+/// agreement later — see [`crate::orchestrator::backchannel`]); the Drama-3
+/// style tag steers the delivery and is passed straight to the TTS. Spanish
+/// matches [`DEFAULT_BACKCHANNEL_TEXTS`](crate::orchestrator::backchannel::DEFAULT_BACKCHANNEL_TEXTS),
+/// the language of the shipped clip bank.
+pub const BACKCHANNEL_TEXTS: &[(&str, &[(&str, &str)])] = &[
+    (
+        "es",
+        &[
+            ("ack", "[calm] Mm-hmm..."),
+            ("ack", "[attentive] Ajá..."),
+            ("agree", "[agreeing] Claro..."),
+            ("ack", "[listening] Ya veo..."),
+            ("ack", "[attentive] Sí, sí..."),
+            ("ack", "[calm] Entiendo..."),
+            ("agree", "[relaxed] Vale..."),
+            ("ack", "[thoughtful] Ah, ya..."),
+        ],
+    ),
+    (
+        "en",
+        &[
+            ("ack", "[calm] Mm-hmm..."),
+            ("ack", "[attentive] Uh-huh..."),
+            ("agree", "[agreeing] Right..."),
+            ("ack", "[listening] I see..."),
+            ("ack", "[attentive] Yeah, yeah..."),
+            ("ack", "[calm] Got it..."),
+            ("agree", "[relaxed] Okay..."),
+            ("ack", "[thoughtful] Oh, I see..."),
+        ],
+    ),
+    (
+        "it",
+        &[
+            ("ack", "[calm] Mmm..."),
+            ("ack", "[attentive] Eh già..."),
+            ("agree", "[agreeing] Certo..."),
+            ("ack", "[listening] Capisco..."),
+            ("ack", "[attentive] Sì, sì..."),
+            ("ack", "[calm] Ho capito..."),
+            ("agree", "[relaxed] Va bene..."),
+            ("ack", "[thoughtful] Ah, ecco..."),
+        ],
+    ),
+    (
+        "fr",
+        &[
+            ("ack", "[calm] Mm-hmm..."),
+            ("ack", "[attentive] Hum, oui..."),
+            ("agree", "[agreeing] Bien sûr..."),
+            ("ack", "[listening] Je vois..."),
+            ("ack", "[attentive] Oui, oui..."),
+            ("ack", "[calm] D'accord..."),
+            ("agree", "[relaxed] Très bien..."),
+            ("ack", "[thoughtful] Ah, je vois..."),
+        ],
+    ),
+    (
+        "de",
+        &[
+            ("ack", "[calm] Mhm..."),
+            ("ack", "[attentive] Aha..."),
+            ("agree", "[agreeing] Genau..."),
+            ("ack", "[listening] Ich verstehe..."),
+            ("ack", "[attentive] Ja, ja..."),
+            ("ack", "[calm] Verstehe..."),
+            ("agree", "[relaxed] In Ordnung..."),
+            ("ack", "[thoughtful] Ach so..."),
+        ],
+    ),
+    (
+        "pt",
+        &[
+            ("ack", "[calm] Mm-hmm..."),
+            ("ack", "[attentive] Aham..."),
+            ("agree", "[agreeing] Claro..."),
+            ("ack", "[listening] Entendo..."),
+            ("ack", "[attentive] Sim, sim..."),
+            ("ack", "[calm] Entendi..."),
+            ("agree", "[relaxed] Tá bom..."),
+            ("ack", "[thoughtful] Ah, entendi..."),
+        ],
+    ),
+];
+
+/// End-of-turn filler interjections per language, played round-robin. Spanish
+/// matches [`FILLER_CLIPS`](crate::assets::FILLER_CLIPS), the language of the
+/// shipped filler bank.
+pub const FILLER_TEXTS: &[(&str, &[&str])] = &[
+    ("es", &["Uhm...", "Eh...", "Mmm...", "A ver...", "Bueno...", "Pues...", "Vaya..."]),
+    ("en", &["Uhm...", "Hmm...", "Mmm...", "Well...", "Uh, let's see...", "Okay...", "Right..."]),
+    ("it", &["Uhm...", "Eh...", "Mmm...", "Vediamo...", "Allora...", "Beh...", "Dunque..."]),
+    ("fr", &["Hum...", "Euh...", "Mmm...", "Voyons...", "Alors...", "Ben...", "Bref..."]),
+    ("de", &["Ähm...", "Hm...", "Mmm...", "Mal sehen...", "Also...", "Naja...", "Tja..."]),
+    ("pt", &["Hã...", "É...", "Mmm...", "Vejamos...", "Então...", "Bom...", "Pois..."]),
+];
+
+/// Start-filler phrases per language: the turn-start acknowledgment played when
+/// the reply audio is late (see
+/// [`TurnManager::schedule_start_filler`](crate::orchestrator::turn_manager::TurnManager)).
+/// Each phrase carries a Drama-3 style tag. Spanish matches the shipped default
+/// `START_FILLER_TEXTS`, the language of the base clip bank.
+pub const START_FILLER_TEXTS: &[(&str, &[&str])] = &[
+    (
+        "es",
+        &["[calm] Un momento...", "[thoughtful] A ver, veamos...", "[sigh] Vale, ya voy..."],
+    ),
+    (
+        "en",
+        &["[calm] One moment...", "[thoughtful] Let me see...", "[sigh] Okay, coming up..."],
+    ),
+    (
+        "it",
+        &["[calm] Un momento...", "[thoughtful] Vediamo un po'...", "[sigh] Va bene, arrivo..."],
+    ),
+    (
+        "fr",
+        &["[calm] Un instant...", "[thoughtful] Voyons voir...", "[sigh] Bon, voilà..."],
+    ),
+    (
+        "de",
+        &["[calm] Einen Moment...", "[thoughtful] Mal sehen...", "[sigh] Okay, gleich..."],
+    ),
+    (
+        "pt",
+        &["[calm] Um momento...", "[thoughtful] Vejamos...", "[sigh] Tá bom, já vai..."],
+    ),
+];
+
+/// Backchannel phrases of `lang` as `(category, phrase)` pairs, or `None` when
+/// the language is not in the built-in table.
+pub fn backchannel_texts(lang: &str) -> Option<Vec<(String, String)>> {
+    BACKCHANNEL_TEXTS
+        .iter()
+        .find(|(l, _)| *l == lang)
+        .map(|(_, list)| {
+            list.iter()
+                .map(|(c, p)| (c.to_string(), p.to_string()))
+                .collect()
+        })
+}
+
+/// End-of-turn filler phrases of `lang`, or `None` when the language is not in
+/// the built-in table.
+pub fn filler_texts(lang: &str) -> Option<Vec<String>> {
+    FILLER_TEXTS
+        .iter()
+        .find(|(l, _)| *l == lang)
+        .map(|(_, list)| list.iter().map(|s| s.to_string()).collect())
+}
+
+/// Start-filler phrases of `lang`, or `None` when the language is not in the
+/// built-in table.
+pub fn start_filler_texts(lang: &str) -> Option<Vec<String>> {
+    START_FILLER_TEXTS
+        .iter()
+        .find(|(l, _)| *l == lang)
+        .map(|(_, list)| list.iter().map(|s| s.to_string()).collect())
+}
+
+/// The clip banks of one language, published together so the filler path
+/// (orchestrator) and the backchannel path (mic task) always agree on which
+/// language is active.
+#[derive(Clone)]
+pub struct LangBanks {
+    /// ISO 639-1 code of this bank.
+    pub lang: String,
+    /// Backchannel clips for this language.
+    pub backchannel: Arc<FillerBank>,
+    /// Spoken phrases of [`Self::backchannel`], in clip order.
+    pub backchannel_texts: Vec<String>,
+    /// Category of each phrase in [`Self::backchannel_texts`] (parallel array).
+    pub backchannel_categories: Vec<String>,
+    /// End-of-turn filler clips for this language.
+    pub filler: Arc<FillerBank>,
+    /// Start-filler clips for this language.
+    pub start_filler: Arc<FillerBank>,
+}
+
+/// Per-session language state, shared between the turn manager (end-of-turn and
+/// start filler) and the microphone task (backchannel).
+pub struct LanguageState {
+    /// The banks of the configured default language (`LANG_DEFAULT`), i.e. the
+    /// base directories. Kept so switching back needs no regeneration.
+    base: Arc<LangBanks>,
+    /// Currently active banks.
+    current: parking_lot::RwLock<Arc<LangBanks>>,
+    /// Bumped on every switch so the mic task can notice a change with a single
+    /// atomic load per audio frame.
+    generation: AtomicU64,
+}
+
+impl LanguageState {
+    pub fn new(
+        lang: String,
+        backchannel: Arc<FillerBank>,
+        backchannel_texts: Vec<String>,
+        backchannel_categories: Vec<String>,
+        filler: Arc<FillerBank>,
+        start_filler: Arc<FillerBank>,
+    ) -> Self {
+        let base = Arc::new(LangBanks {
+            lang,
+            backchannel,
+            backchannel_texts,
+            backchannel_categories,
+            filler,
+            start_filler,
+        });
+        Self {
+            current: parking_lot::RwLock::new(base.clone()),
+            base,
+            generation: AtomicU64::new(0),
+        }
+    }
+
+    /// The banks currently in use.
+    pub fn current(&self) -> Arc<LangBanks> {
+        self.current.read().clone()
+    }
+
+    /// The banks of the default language (base directories).
+    pub fn base(&self) -> Arc<LangBanks> {
+        self.base.clone()
+    }
+
+    /// Current generation; changes whenever the active language changes.
+    pub fn generation(&self) -> u64 {
+        self.generation.load(Ordering::Acquire)
+    }
+
+    /// Publish a new set of banks and bump the generation.
+    pub fn set(&self, banks: LangBanks) {
+        *self.current.write() = Arc::new(banks);
+        self.generation.fetch_add(1, Ordering::AcqRel);
+    }
+}
+
+/// System prompt of the language-identification call. Written to yield *only*
+/// the ISO code, so the reply can be parsed without a JSON or function-call
+/// round trip (this deployment runs no server-side tool parser).
+const DETECT_SYSTEM_PROMPT: &str = "You are a language identification tool. Read the user's \
+     text and reply with only the ISO 639-1 two-letter code of the language it is written in \
+     (for example: en, es, it, fr, de, pt). No punctuation, no quotes, no explanation. Reply \
+     with und if you cannot tell.";
+
+/// Ask the LLM for the ISO 639-1 code of `sample`.
+///
+/// Best-effort: `None` on any request failure or when the reply does not carry
+/// a plausible code, in which case the currently active language simply stays.
+pub async fn detect_language(llm: &LlmClient, sample: &str) -> Option<String> {
+    let cancel = CancellationToken::new();
+    let reply = match llm
+        .simple_chat(DETECT_SYSTEM_PROMPT, sample, 8, 0.0, &cancel)
+        .await
+    {
+        Ok(r) => r,
+        Err(e) => {
+            warn!(error = %e, "language detection call failed");
+            return None;
+        }
+    };
+    parse_lang_code(&reply)
+}
+
+/// The first run of ASCII letters in `raw`, lowercased, kept only when it looks
+/// like an ISO 639-1 code (`"es."` → `"es"`, `"Spanish"` → `None`,
+/// `"und"` → `None`).
+fn parse_lang_code(raw: &str) -> Option<String> {
+    let mut run = String::new();
+    let mut started = false;
+    for c in raw.trim().chars() {
+        if c.is_ascii_alphabetic() {
+            started = true;
+            run.push(c.to_ascii_lowercase());
+        } else if started {
+            break;
+        }
+    }
+    match run.len() {
+        2 | 3 if run != "und" => Some(run),
+        _ => None,
+    }
+}
+
+const BACKCHANNEL_GEN_PROMPT: &str = "You write backchannel cues: the very short \
+     acknowledgments a listener says while someone else is speaking, like \"mm-hmm\", \
+     \"I see\" or \"right\". Write eight different cues in the language with ISO 639-1 code \
+     {lang}. Each cue is at most three words, ends with an ellipsis and is never a question. \
+     Reply with one cue per line and nothing else: no numbering, no quotes, no explanations.";
+
+const FILLER_GEN_PROMPT: &str = "You write hesitation fillers: the short sounds a speaker \
+     makes to buy a moment while thinking, like \"uhm\", \"well\" or \"let me see\". Write \
+     seven different fillers in the language with ISO 639-1 code {lang}. Each filler is one \
+     or two words ending with an ellipsis. Reply with one filler per line and nothing else: \
+     no numbering, no quotes, no explanations.";
+
+const START_FILLER_GEN_PROMPT: &str = "You write turn-start acknowledgments: the very short \
+     phrases a speaker says to buy a moment right before answering, like \"one moment\", \
+     \"let me see\" or \"okay, coming up\". Write three different phrases in the language \
+     with ISO 639-1 code {lang}. Each phrase is two to four words and ends with an ellipsis. \
+     Reply with one phrase per line and nothing else: no numbering, no quotes, no \
+     explanations.";
+
+/// Generate a backchannel phrase list with the LLM (fallback for languages
+/// without a built-in table). `None` when the call fails or yields nothing
+/// usable.
+pub async fn generate_backchannel_texts(llm: &LlmClient, lang: &str) -> Option<Vec<String>> {
+    let prompt = BACKCHANNEL_GEN_PROMPT.replace("{lang}", lang);
+    generate_texts(llm, &prompt, "backchannel").await
+}
+
+/// Generate an end-of-turn filler phrase list with the LLM.
+pub async fn generate_filler_texts(llm: &LlmClient, lang: &str) -> Option<Vec<String>> {
+    let prompt = FILLER_GEN_PROMPT.replace("{lang}", lang);
+    generate_texts(llm, &prompt, "filler").await
+}
+
+/// Generate a start-filler phrase list with the LLM (fallback for languages
+/// without a built-in table).
+pub async fn generate_start_filler_texts(llm: &LlmClient, lang: &str) -> Option<Vec<String>> {
+    let prompt = START_FILLER_GEN_PROMPT.replace("{lang}", lang);
+    generate_texts(llm, &prompt, "start-filler").await
+}
+
+async fn generate_texts(llm: &LlmClient, prompt: &str, kind: &str) -> Option<Vec<String>> {
+    let cancel = CancellationToken::new();
+    let reply = match llm
+        .simple_chat(prompt, "Generate the list now.", 256, 0.8, &cancel)
+        .await
+    {
+        Ok(r) => r,
+        Err(e) => {
+            warn!(kind, error = %e, "phrase-list generation failed");
+            return None;
+        }
+    };
+    let texts = parse_lines(&reply, LLM_TEXT_LIMIT);
+    if texts.len() < 2 {
+        warn!(kind, lines = texts.len(), "phrase-list generation returned too few usable lines");
+        return None;
+    }
+    info!(kind, phrases = texts.len(), "generated phrase list via LLM");
+    Some(texts)
+}
+
+/// Split an LLM list reply into clean phrases: one per line, bullets/numbering
+/// and surrounding quotes removed, over-long lines dropped.
+fn parse_lines(raw: &str, max: usize) -> Vec<String> {
+    raw.lines()
+        .map(|l| {
+            l.trim()
+                .trim_start_matches(|c: char| {
+                    c.is_ascii_digit() || matches!(c, '-' | '*' | '.' | ')' | ':' | ' ')
+                })
+                .trim_matches(|c| matches!(c, '"' | '\'' | '`'))
+                .trim()
+        })
+        .filter(|l| !l.is_empty() && l.len() <= 60)
+        .take(max)
+        .map(|l| l.to_string())
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_iso_code_from_various_replies() {
+        assert_eq!(parse_lang_code("es"), Some("es".to_string()));
+        assert_eq!(parse_lang_code("EN."), Some("en".to_string()));
+        assert_eq!(parse_lang_code("  it\n"), Some("it".to_string()));
+        assert_eq!(parse_lang_code("und"), None);
+        assert_eq!(parse_lang_code("Spanish"), None);
+        assert_eq!(parse_lang_code(""), None);
+    }
+
+    #[test]
+    fn strips_bullets_and_numbering_from_generated_lists() {
+        let raw = "1. Mmm...\n- Certo...\n\"Va bene...\"\n\n* Capisco...";
+        assert_eq!(
+            parse_lines(raw, 10),
+            vec![
+                "Mmm...".to_string(),
+                "Certo...".to_string(),
+                "Va bene...".to_string(),
+                "Capisco...".to_string(),
+            ]
+        );
+    }
+
+    #[test]
+    fn builtin_tables_cover_the_base_languages() {
+        for lang in ["es", "en", "it", "fr", "de", "pt"] {
+            assert!(backchannel_texts(lang).is_some(), "missing backchannel table for {lang}");
+            assert!(filler_texts(lang).is_some(), "missing filler table for {lang}");
+            assert!(start_filler_texts(lang).is_some(), "missing start-filler table for {lang}");
+        }
+        assert!(backchannel_texts("xx").is_none());
+        assert!(start_filler_texts("xx").is_none());
+    }
+}
diff --git a/src/llm.rs b/src/llm.rs
index 80f60e2..8a6e966 100644
--- a/src/llm.rs
+++ b/src/llm.rs
@@ -23,6 +23,7 @@
 //! - [`LlmClient::chat`] — single blocking request (simplest, no partial output).
 
 use crate::config::Config;
+use crate::tools::ToolRegistry;
 use anyhow::{anyhow, Result};
 use futures_util::StreamExt;
 use reqwest::Client;
@@ -53,6 +54,11 @@ impl ChatMessage {
     pub fn assistant(content: impl Into<String>) -> Self {
         Self { role: "assistant".into(), content: content.into() }
     }
+
+    /// A tool result handed back to the model after a tool call.
+    pub fn tool(content: impl Into<String>) -> Self {
+        Self { role: "tool".into(), content: content.into() }
+    }
 }
 
 /// Client for an OpenAI-compatible `/chat/completions` endpoint.
@@ -72,9 +78,14 @@ pub struct LlmClient {
     /// Strip the chain-of-thought (`reasoning_content` / inline think blocks)
     /// from the reply before it is spoken and shown in the chat box.
     strip_reasoning: bool,
+    /// Optional tool registry. When set, every request advertises the tools and
+    /// the orchestrator runs the call → execute → re-prompt loop. See
+    /// [`crate::tools`].
+    tools: Option<Arc<ToolRegistry>>,
 }
 
 impl LlmClient {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         base_url: &str,
         api_key: &str,
@@ -83,6 +94,7 @@ impl LlmClient {
         temperature: f32,
         enable_thinking: Option<bool>,
         strip_reasoning: bool,
+        tools: Option<Arc<ToolRegistry>>,
     ) -> Self {
         let endpoint = format!("{}/chat/completions", base_url.trim_end_matches('/'));
         // No global request timeout: an SSE stream can legitimately stay open
@@ -100,6 +112,7 @@ impl LlmClient {
             temperature,
             enable_thinking,
             strip_reasoning,
+            tools,
         }
     }
 
@@ -123,6 +136,12 @@ impl LlmClient {
         self.strip_reasoning
     }
 
+    /// The tool registry, if tool calling is configured. Used by the
+    /// orchestrator to execute parsed calls.
+    pub fn tools(&self) -> Option<&Arc<ToolRegistry>> {
+        self.tools.as_ref()
+    }
+
     fn request_body(&self, messages: &[ChatMessage], stream: bool) -> serde_json::Value {
         let mut body = json!({
             "model": self.model,
@@ -134,6 +153,15 @@ impl LlmClient {
         if let Some(enable) = self.enable_thinking {
             body["chat_template_kwargs"] = json!({ "enable_thinking": enable });
         }
+        // Advertise the configured tools so the model can call them. The
+        // server has no tool parser, so the call comes back as text in the
+        // native `<tool_call>` format — parsed client-side in `crate::tools`.
+        if let Some(reg) = &self.tools {
+            if !reg.is_empty() {
+                body["tools"] = reg.openai_tools();
+                body["tool_choice"] = json!("auto");
+            }
+        }
         body
     }
 
@@ -190,6 +218,52 @@ impl LlmClient {
         Ok(self.clean(&self.delta_text(message)))
     }
 
+    /// One-off non-streaming completion with an explicit system/user pair, its
+    /// own token budget and temperature, and **no tools advertised**.
+    ///
+    /// Used by auxiliary calls that must not go through the conversational
+    /// prompt or the tool loop — language detection and phrase-list generation
+    /// (see [`crate::lang`]).
+    pub async fn simple_chat(
+        &self,
+        system: &str,
+        user: &str,
+        max_tokens: u32,
+        temperature: f32,
+        cancel: &CancellationToken,
+    ) -> Result<String> {
+        let mut body = json!({
+            "model": self.model,
+            "messages": [ChatMessage::system(system), ChatMessage::user(user)],
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "stream": false,
+        });
+        if let Some(enable) = self.enable_thinking {
+            body["chat_template_kwargs"] = json!({ "enable_thinking": enable });
+        }
+        let req = self
+            .http
+            .post(&self.endpoint)
+            .header("Authorization", format!("Bearer {}", self.api_key))
+            .json(&body)
+            .send();
+
+        let resp = tokio::select! {
+            r = req => r?,
+            _ = cancel.cancelled() => return Ok(String::new()),
+        };
+
+        let status = resp.status();
+        if !status.is_success() {
+            let text = resp.text().await.unwrap_or_default();
+            return Err(anyhow!("LLM HTTP {}: {}", status, text.trim()));
+        }
+        let value: serde_json::Value = resp.json().await?;
+        let message = &value["choices"][0]["message"];
+        Ok(self.clean(&self.delta_text(message)))
+    }
+
     /// Streaming request. Every clean (think-stripped) text delta is pushed to
     /// `delta_tx` as it arrives; the full clean reply is returned at the end.
     ///
@@ -304,9 +378,31 @@ pub fn create_llm_client(config: &Config) -> Option<Arc<LlmClient>> {
         config.llm_temperature,
         config.llm_enable_thinking,
         config.llm_strip_reasoning,
+        load_tools(config),
     )))
 }
 
+/// Load the tool registry from `LLM_TOOLS_FILE` when tool calling is enabled.
+/// A missing or invalid file is logged and tool calling is disabled — the
+/// pipeline keeps working without tools.
+fn load_tools(config: &Config) -> Option<Arc<ToolRegistry>> {
+    if !config.llm_tools_enabled || config.llm_tools_file.trim().is_empty() {
+        return None;
+    }
+    let path = std::path::Path::new(config.llm_tools_file.trim());
+    match ToolRegistry::load(path, config.llm_tool_timeout_secs, config.llm_tool_result_max_chars) {
+        Ok(reg) if reg.is_empty() => {
+            warn!("tools file present but empty — tool calling disabled");
+            None
+        }
+        Ok(reg) => Some(Arc::new(reg)),
+        Err(e) => {
+            warn!(error = %e, "failed to load tools file — tool calling disabled");
+            None
+        }
+    }
+}
+
 // --- Chain-of-thought stripping --------------------------------------------
 
 // Opening / closing chain-of-thought markers emitted by Qwen3-style reasoning
@@ -414,13 +510,15 @@ mod tests {
     fn request_body_thinking_is_opt_in() {
         let msgs = vec![ChatMessage::user("hi")];
         // Unset: the vendor-specific field must not be sent.
-        let plain = LlmClient::new("http://x/v1", "k", "m", 16, 0.5, None, true);
+        let plain = LlmClient::new("http://x/v1", "k", "m", 16, 0.5, None, true, None);
         assert!(plain.request_body(&msgs, true).get("chat_template_kwargs").is_none());
         // Explicit: forwarded verbatim.
-        let off = LlmClient::new("http://x/v1", "k", "m", 16, 0.5, Some(false), true);
+        let off = LlmClient::new("http://x/v1", "k", "m", 16, 0.5, Some(false), true, None);
         let body = off.request_body(&msgs, false);
         assert_eq!(body["chat_template_kwargs"]["enable_thinking"], false);
         assert_eq!(body["stream"], false);
+        // Without a registry no `tools` field is advertised.
+        assert!(body.get("tools").is_none());
     }
 
     #[test]
diff --git a/src/main.rs b/src/main.rs
index 6069f5e..f594493 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,12 +5,16 @@
 
 mod assets;
 mod audio;
+mod audit;
 mod config;
+mod lang;
 mod llm;
+mod media;
 mod onnx;
 mod orchestrator;
 mod stt;
 mod tls;
+mod tools;
 mod tts;
 mod vad;
 mod web;
@@ -90,33 +94,66 @@ async fn main() -> anyhow::Result<()> {
     // backchannel clips can be synthesized with the configured voice).
     let tts = create_tts_engine(&config);
 
-    // Ensure the filler / backchannel clip banks exist, generating any missing
-    // clip with the TTS engine (see `crate::assets`).
+    // Every clip bank lives in a per-language subdirectory `<dir>/<lang>`
+    // (see `crate::lang`) — including the default language. The base banks of
+    // `LANG_DEFAULT` are generated and loaded from `<dir>/<lang_default>/`, so
+    // the filler, start-filler and backchannel share the exact same layout for
+    // every language and no language is special-cased to the top level.
+    let fillers_dir = assets::lang_dir(&config.fillers_dir, &config.lang_default);
+    let start_filler_dir = assets::lang_dir(&config.start_filler_dir, &config.lang_default);
+    let backchannel_dir = assets::lang_dir(&config.backchannel.dir, &config.lang_default);
+
+    // Ensure the filler clip bank exists, generating any missing clip with the
+    // TTS engine (see `crate::assets`). Existing clips are kept.
     let mut generated = assets::ensure_clips(
-        &config.fillers_dir,
+        &fillers_dir,
         assets::FILLER_CLIPS,
         tts.as_ref(),
         "filler",
     )
     .await;
     if config.backchannel.enabled {
-        generated += assets::ensure_clips(
-            &config.backchannel.dir,
-            assets::BACKCHANNEL_CLIPS,
+        // Like the start filler, the backchannel bank follows its phrase list
+        // (`BACKCHANNEL_TEXTS`): one clip per phrase, re-synthesized only when
+        // the list changes, and one is picked at random when the cue fires.
+        generated += assets::ensure_backchannel_clips(
+            &backchannel_dir,
+            &config.backchannel.texts,
+            tts.as_ref(),
+        )
+        .await;
+    }
+    if config.start_filler_enabled {
+        // The start-filler bank (one clip per START_FILLER_TEXTS phrase) is
+        // re-synthesized whenever the phrase list changes, so editing it takes
+        // effect without deleting the clips by hand; an unchanged list is
+        // skipped to keep startup fast, and a failed synthesis keeps the
+        // previous clip. One clip is picked at random at each turn start.
+        generated += assets::ensure_start_filler_clips(
+            &start_filler_dir,
+            &config.start_filler_texts,
             tts.as_ref(),
-            "backchannel",
         )
         .await;
     }
 
     // Preload filler PCM files (played at end-of-utterance).
-    let fillers = Arc::new(FillerBank::load(&config.fillers_dir, "filler"));
+    let fillers = Arc::new(FillerBank::load(&fillers_dir, "filler"));
+
+    // Preload the start-filler clip (played immediately at turn start).
+    let start_filler = Arc::new(FillerBank::load(&start_filler_dir, "start-filler"));
+    if config.start_filler_enabled && start_filler.is_empty() {
+        tracing::warn!(
+            dir = %start_filler_dir.display(),
+            "start filler enabled but no clip found — the cue stays silent"
+        );
+    }
 
     // Preload backchannel PCM files (played while the user is speaking).
-    let backchannel = Arc::new(FillerBank::load(&config.backchannel.dir, "backchannel"));
+    let backchannel = Arc::new(FillerBank::load(&backchannel_dir, "backchannel"));
     if config.backchannel.enabled && backchannel.is_empty() {
         tracing::warn!(
-            dir = %config.backchannel.dir.display(),
+            dir = %backchannel_dir.display(),
             "backchannel enabled but no clips found — the cue stays silent"
         );
     }
@@ -155,15 +192,36 @@ async fn main() -> anyhow::Result<()> {
             thinking = ?client.enable_thinking(),
             strip_reasoning = client.strip_reasoning(),
             direct_answers = config.llm_direct_answers,
+            tools = client.tools().is_some(),
+            max_tool_iterations = config.llm_tool_max_iterations,
             "LLM reasoning enabled"
         ),
         None => info!("LLM reasoning disabled (LLM_ENABLED=false or unconfigured)"),
     }
 
+    // Multilingual clip banks: the backchannel and the end-of-turn filler are
+    // re-generated on demand in the user's language (see `crate::lang`).
+    if config.lang_detect_enabled {
+        match &llm {
+            Some(_) => info!(
+                default = %config.lang_default,
+                min_chars = config.lang_min_chars,
+                redetect_every = config.lang_redetect_every,
+                llm_fallback = config.lang_llm_fallback_enabled,
+                "language detection enabled (clip banks switch with the user's language)"
+            ),
+            None => tracing::warn!(
+                "LANG_DETECT_ENABLED=true but the LLM is disabled — the clip banks stay in {}",
+                config.lang_default
+            ),
+        }
+    }
+
     let app_state = AppState {
         config: config.clone(),
         tts,
         fillers,
+        start_filler,
         backchannel,
         stt,
         tokenizer,
diff --git a/src/media.rs b/src/media.rs
new file mode 100644
index 0000000..29cee62
--- /dev/null
+++ b/src/media.rs
@@ -0,0 +1,353 @@
+//! External audio source injection (URL / radio / YouTube).
+//!
+//! Decodes an external audio stream into the mixer's dedicated `external`
+//! channel so it is mixed together with the agent's voice. Fetching and
+//! decoding are delegated to external tools, which keeps the engine free of
+//! heavyweight codec dependencies:
+//!
+//! - **`ffmpeg`** decodes direct media URLs, Icecast/Shoutcast radio and HLS
+//!   streams to raw 16-bit LE mono PCM at the mixer's output rate.
+//! - **`yt-dlp`** resolves a YouTube URL to a directly decodable stream URL
+//!   first (ffmpeg cannot resolve YouTube on its own).
+//!
+//! The decoding task writes into the external queue respecting its free space,
+//! so a VOD source is throttled to real time by the mixer's drain rate instead
+//! of flooding — and dropping — the buffer. The channel is independent of the
+//! agent audio: `flush` (barge-in) never touches it and it does not count as
+//! the agent speaking.
+
+use crate::audio::SampleRingBuffer;
+use crate::config::OUTPUT_SAMPLE_RATE;
+use parking_lot::Mutex;
+use serde_json::json;
+use std::process::Stdio;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::io::AsyncReadExt;
+use tokio::process::Command;
+use tokio::sync::mpsc;
+use tokio_util::sync::CancellationToken;
+use tracing::{debug, error, info};
+
+/// Size of the byte buffer used to read ffmpeg's PCM stdout (≈ 93 ms).
+const READ_CHUNK_BYTES: usize = 8192;
+
+/// Manages a single external audio source feeding the mixer's `external`
+/// channel. One instance per WebSocket session.
+pub struct MediaSource {
+    /// Destination queue (the mixer's external channel).
+    queue: SampleRingBuffer,
+    /// Monotonic id of the current playback, so a task that finishes late does
+    /// not clear the state of a newer source that replaced it.
+    generation: AtomicU64,
+    /// Id + cancellation token of the currently active source.
+    current: Mutex<Option<(u64, CancellationToken)>>,
+    /// ffmpeg binary (see `MEDIA_FFMPEG_BIN`).
+    ffmpeg_bin: String,
+    /// yt-dlp binary (see `MEDIA_YTDLP_BIN`); only used for YouTube URLs.
+    ytdlp_bin: String,
+    /// Extra yt-dlp arguments (see `MEDIA_YTDLP_ARGS`).
+    ytdlp_args: Vec<String>,
+    /// Outbound text-event channel used to report state to the client.
+    out_tx: Option<mpsc::UnboundedSender<String>>,
+}
+
+impl MediaSource {
+    /// Create a media source writing into `queue`.
+    pub fn new(
+        queue: SampleRingBuffer,
+        ffmpeg_bin: String,
+        ytdlp_bin: String,
+        ytdlp_args: Vec<String>,
+        out_tx: Option<mpsc::UnboundedSender<String>>,
+    ) -> Arc<Self> {
+        Arc::new(Self {
+            queue,
+            generation: AtomicU64::new(0),
+            current: Mutex::new(None),
+            ffmpeg_bin,
+            ytdlp_bin,
+            ytdlp_args,
+            out_tx,
+        })
+    }
+
+    /// Start playing `url`, replacing any source already playing. Returns
+    /// immediately: resolution and decoding run in a background task.
+    pub fn play(self: &Arc<Self>, url: &str) {
+        let url = url.trim().to_string();
+        if url.is_empty() {
+            self.emit_error("", "empty URL");
+            return;
+        }
+
+        // Stop whatever is playing and clear the channel for a clean start.
+        self.stop();
+
+        let id = self.generation.fetch_add(1, Ordering::Relaxed) + 1;
+        let cancel = CancellationToken::new();
+        *self.current.lock() = Some((id, cancel.clone()));
+
+        let this = self.clone();
+        tokio::spawn(async move { this.run(id, url, cancel).await });
+    }
+
+    /// Stop the current source and clear the external channel.
+    pub fn stop(&self) {
+        if let Some((_, token)) = self.current.lock().take() {
+            token.cancel();
+        }
+        self.queue.clear();
+    }
+
+    /// Resolve + decode loop for one source. Owns the state machine.
+    async fn run(self: Arc<Self>, id: u64, url: String, cancel: CancellationToken) {
+        self.emit(json!({ "type": "audio_source", "state": "loading", "url": url }));
+
+        // YouTube needs yt-dlp to turn the page URL into a media URL.
+        let source = if is_youtube_url(&url) {
+            info!(url = %url, "resolving YouTube source via yt-dlp");
+            match self.resolve_youtube(&url, &cancel).await {
+                Ok(direct) => direct,
+                Err(e) => {
+                    if !cancel.is_cancelled() {
+                        error!(error = %e, url = %url, "YouTube resolution failed");
+                        self.emit_error(&url, &e);
+                    }
+                    self.finish(id);
+                    return;
+                }
+            }
+        } else {
+            url.clone()
+        };
+
+        if cancel.is_cancelled() {
+            self.finish(id);
+            return;
+        }
+
+        info!(url = %url, "external audio source started");
+        self.emit(json!({ "type": "audio_source", "state": "playing", "url": url }));
+
+        match self.decode_into_queue(&source, &cancel).await {
+            Ok(()) => info!(url = %url, "external audio source ended"),
+            Err(e) => {
+                if !cancel.is_cancelled() {
+                    error!(error = %e, url = %url, "external audio decode failed");
+                    self.emit_error(&url, &e);
+                }
+            }
+        }
+
+        if !cancel.is_cancelled() {
+            self.emit(json!({ "type": "audio_source", "state": "stopped", "url": url }));
+        }
+        self.finish(id);
+    }
+
+    /// Clear the "currently active" marker if it still belongs to `id`.
+    fn finish(&self, id: u64) {
+        let mut guard = self.current.lock();
+        if guard.as_ref().map(|(g, _)| *g == id).unwrap_or(false) {
+            *guard = None;
+        }
+    }
+
+    /// Resolve a YouTube URL to a directly decodable stream URL via yt-dlp.
+    async fn resolve_youtube(
+        &self,
+        url: &str,
+        cancel: &CancellationToken,
+    ) -> Result<String, String> {
+        let mut cmd = Command::new(&self.ytdlp_bin);
+        cmd.arg("-f")
+            .arg("bestaudio/best")
+            .arg("-g")
+            .arg("--no-playlist")
+            .arg("--no-warnings")
+            .args(&self.ytdlp_args)
+            .arg(url)
+            .stdin(Stdio::null())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .kill_on_drop(true);
+
+        let child = cmd
+            .spawn()
+            .map_err(|e| format!("failed to spawn yt-dlp ({}): {e}", self.ytdlp_bin))?;
+
+        // `wait_with_output` consumes the child; if the cancel branch wins the
+        // future is dropped and `kill_on_drop` terminates the process.
+        let output = tokio::select! {
+            _ = cancel.cancelled() => return Err("cancelled".to_string()),
+            out = child.wait_with_output() => {
+                out.map_err(|e| format!("yt-dlp wait failed: {e}"))?
+            }
+        };
+
+        if !output.status.success() {
+            let err = String::from_utf8_lossy(&output.stderr);
+            return Err(format!(
+                "yt-dlp exited with {}: {}",
+                output.status,
+                err.trim().lines().last().unwrap_or("")
+            ));
+        }
+
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        stdout
+            .lines()
+            .map(str::trim)
+            .find(|l| l.starts_with("http"))
+            .map(str::to_string)
+            .ok_or_else(|| "yt-dlp returned no stream URL".to_string())
+    }
+
+    /// Decode `source` to raw PCM and stream it into the external queue.
+    async fn decode_into_queue(
+        &self,
+        source: &str,
+        cancel: &CancellationToken,
+    ) -> Result<(), String> {
+        let mut cmd = Command::new(&self.ffmpeg_bin);
+        cmd.arg("-hide_banner")
+            .arg("-loglevel")
+            .arg("error")
+            .arg("-nostdin")
+            // HTTP input resilience for live streams.
+            .arg("-reconnect")
+            .arg("1")
+            .arg("-reconnect_streamed")
+            .arg("1")
+            .arg("-reconnect_delay_max")
+            .arg("5")
+            .arg("-i")
+            .arg(source)
+            .arg("-vn")
+            .arg("-f")
+            .arg("s16le")
+            .arg("-acodec")
+            .arg("pcm_s16le")
+            .arg("-ac")
+            .arg("1")
+            .arg("-ar")
+            .arg(OUTPUT_SAMPLE_RATE.to_string())
+            .arg("pipe:1")
+            .stdin(Stdio::null())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .kill_on_drop(true);
+
+        let mut child = cmd
+            .spawn()
+            .map_err(|e| format!("failed to spawn ffmpeg ({}): {e}", self.ffmpeg_bin))?;
+
+        let mut stdout = child.stdout.take().ok_or("ffmpeg stdout unavailable")?;
+        // Drain stderr in the background so a chatty decoder cannot block on a
+        // full pipe; the text is only surfaced if the decode produced no audio.
+        let stderr = child.stderr.take();
+        let stderr_task = tokio::spawn(async move {
+            let mut s = String::new();
+            if let Some(mut e) = stderr {
+                let _ = e.read_to_string(&mut s).await;
+            }
+            s
+        });
+
+        let mut buf = vec![0u8; READ_CHUNK_BYTES];
+        let mut scratch = vec![0i16; READ_CHUNK_BYTES / 2];
+        let mut total_samples: u64 = 0;
+
+        loop {
+            let n = tokio::select! {
+                _ = cancel.cancelled() => {
+                    let _ = child.kill().await;
+                    let _ = stderr_task.await;
+                    return Ok(());
+                }
+                r = stdout.read(&mut buf) => r.map_err(|e| format!("ffmpeg read error: {e}"))?,
+            };
+            if n == 0 {
+                break;
+            }
+            // 16-bit LE mono -> i16 samples.
+            let ns = n / 2;
+            for i in 0..ns {
+                scratch[i] = i16::from_le_bytes([buf[i * 2], buf[i * 2 + 1]]);
+            }
+            total_samples += self.push_samples(&scratch[..ns], cancel).await as u64;
+
+            if cancel.is_cancelled() {
+                let _ = child.kill().await;
+                let _ = stderr_task.await;
+                return Ok(());
+            }
+        }
+
+        let status = child
+            .wait()
+            .await
+            .map_err(|e| format!("ffmpeg wait failed: {e}"))?;
+        let err_text = stderr_task.await.unwrap_or_default();
+        debug!(samples = total_samples, "ffmpeg decode finished");
+
+        if !status.success() && total_samples == 0 {
+            let msg = err_text.trim();
+            return Err(if msg.is_empty() {
+                format!("ffmpeg exited with {status}")
+            } else {
+                msg.to_string()
+            });
+        }
+        Ok(())
+    }
+
+    /// Push `samples` into the external queue, respecting its free space so a
+    /// fast (VOD) source is throttled to real time by the mixer's drain rate
+    /// instead of dropping audio. Returns the number of samples accepted.
+    async fn push_samples(&self, samples: &[i16], cancel: &CancellationToken) -> usize {
+        let mut off = 0;
+        while off < samples.len() {
+            if cancel.is_cancelled() {
+                break;
+            }
+            let free = self.queue.remaining_capacity();
+            if free == 0 {
+                tokio::select! {
+                    _ = cancel.cancelled() => break,
+                    _ = tokio::time::sleep(Duration::from_millis(20)) => {}
+                }
+                continue;
+            }
+            let take = free.min(samples.len() - off);
+            let n = self.queue.push(&samples[off..off + take]);
+            if n == 0 {
+                break;
+            }
+            off += n;
+        }
+        off
+    }
+
+    /// Send a JSON state event to the client, if a channel is attached.
+    fn emit(&self, value: serde_json::Value) {
+        if let Some(tx) = &self.out_tx {
+            let _ = tx.send(value.to_string());
+        }
+    }
+
+    /// Report an error to the client.
+    fn emit_error(&self, url: &str, msg: &str) {
+        self.emit(json!({ "type": "audio_source", "state": "error", "url": url, "text": msg }));
+    }
+}
+
+/// Whether `url` looks like a YouTube link that needs yt-dlp resolution.
+fn is_youtube_url(url: &str) -> bool {
+    let lower = url.to_ascii_lowercase();
+    lower.contains("youtube.com/")
+        || lower.contains("youtu.be/")
+        || lower.contains("youtube-nocookie.com/")
+}
diff --git a/src/orchestrator/backchannel.rs b/src/orchestrator/backchannel.rs
index 0e57d65..0015838 100644
--- a/src/orchestrator/backchannel.rs
+++ b/src/orchestrator/backchannel.rs
@@ -4,8 +4,15 @@
 //! which is played once the user stops, at end-of-utterance. A backchannel is a
 //! short "mm-hmm" / "ajá" mixed in at a reduced gain to signal that the agent is
 //! listening, without taking the turn. It is emitted only while the agent itself
-//! is silent (otherwise the user is being interrupted) and never more than
-//! `max_per_turn` times.
+//! is silent (otherwise the user is being interrupted).
+//!
+//! To sound natural rather than metronomic, a cue is played only when the user
+//! is in a **micro-pause** ([`VadDetector::silence_ms`](crate::vad::VadDetector::silence_ms)),
+//! at a **random depth** inside that pause, its timing is randomized, a
+//! probabilistic gate skips some qualifying pauses,
+//! recently used clips are not repeated, the volume drifts slightly, and the
+//! phrases are grouped in **categories** that follow a progression through the
+//! turn (an acknowledgment first, agreement later).
 //!
 //! Every behavioural knob is configured from the environment
 //! ([`BackchannelSettings`]), so the feature can be tuned or disabled without a
@@ -13,9 +20,14 @@
 
 use crate::config::{env_bool, env_f32, env_u32, env_u64};
 use crate::orchestrator::FillerBank;
+use std::collections::VecDeque;
 use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
+use tracing::info;
+
+/// Category applied to phrases written without an explicit `category::` prefix.
+pub(crate) const DEFAULT_CATEGORY: &str = "ack";
 
 /// Runtime configuration for the backchannel subsystem, read from `.env`.
 #[derive(Debug, Clone)]
@@ -24,31 +36,110 @@ pub struct BackchannelSettings {
     pub enabled: bool,
     /// Directory of `*.raw` PCM clips (`BACKCHANNEL_DIR`).
     pub dir: PathBuf,
+    /// Phrases spoken by the backchannel bank (`BACKCHANNEL_TEXTS`), one per
+    /// line, with the optional `category::` prefix already stripped. One clip is
+    /// synthesized per phrase at startup. Drama-3 style tags (`[calm]`, …) are
+    /// passed straight through to the TTS.
+    pub texts: Vec<String>,
+    /// Category of each phrase in [`Self::texts`] (parallel array). Lines
+    /// written as `category::phrase` set it; plain lines default to `ack`.
+    pub categories: Vec<String>,
     /// Mix gain applied to backchannel clips (`BACKCHANNEL_GAIN`). Kept low so
     /// the cue stays in the background.
     pub gain: f32,
-    /// Continuous speech required before the first backchannel
+    /// Confirmed speech required before the first cue may be considered
     /// (`BACKCHANNEL_MIN_SPEECH_MS`).
     pub min_speech_ms: u64,
-    /// Minimum spacing between two backchannels (`BACKCHANNEL_INTERVAL_MS`).
+    /// Base spacing between two cues of the same turn
+    /// (`BACKCHANNEL_INTERVAL_MS`); randomized by ±`jitter_ms`/2.
     pub interval_ms: u64,
-    /// Maximum backchannels per user turn (`BACKCHANNEL_MAX_PER_TURN`).
+    /// Timing jitter (`BACKCHANNEL_JITTER_MS`): delays the first cue by
+    /// `0..jitter_ms` after `min_speech_ms` and spreads the spacing.
+    pub jitter_ms: u64,
+    /// Lower bound of the micro-pause window (`BACKCHANNEL_PAUSE_MIN_MS`): the
+    /// earliest depth, inside a pause, at which the user is likely done with the
+    /// current word. The actual reaction depth is drawn at random in
+    /// `[pause_min_ms, pause_max_ms]`.
+    pub pause_min_ms: u64,
+    /// Upper bound of the micro-pause window (`BACKCHANNEL_PAUSE_MAX_MS`): the
+    /// latest depth a cue may react at. Above this the utterance is about to
+    /// close, so a cue would land on the reply.
+    pub pause_max_ms: u64,
+    /// Probability of cueing when a micro-pause qualifies (`BACKCHANNEL_PROB`).
+    pub prob: f32,
+    /// Random per-cue volume scaling as a ± fraction
+    /// (`BACKCHANNEL_VOLUME_JITTER`).
+    pub volume_jitter: f32,
+    /// Maximum cues per user turn (`BACKCHANNEL_MAX_PER_TURN`).
     pub max_per_turn: u32,
 }
 
 impl Default for BackchannelSettings {
     fn default() -> Self {
+        let (texts, categories) = parse_texts(&DEFAULT_BACKCHANNEL_TEXTS.join("\n"));
         Self {
             enabled: true,
             dir: PathBuf::from("assets/backchannel"),
+            texts,
+            categories,
             gain: 0.35,
             min_speech_ms: 1_500,
             interval_ms: 3_000,
-            max_per_turn: 2,
+            jitter_ms: 1_200,
+            pause_min_ms: 96,
+            pause_max_ms: 260,
+            prob: 0.65,
+            volume_jitter: 0.2,
+            max_per_turn: 3,
         }
     }
 }
 
+/// Default backchannel phrases (Spanish, matching the shipped clip set), with
+/// Drama-3 style tags and a category prefix. Used when `BACKCHANNEL_TEXTS` is
+/// unset.
+pub const DEFAULT_BACKCHANNEL_TEXTS: &[&str] = &[
+    "ack::[calm] Mm-hmm...",
+    "ack::[attentive] Ajá...",
+    "agree::[agreeing] Claro...",
+    "ack::[listening] Ya veo...",
+    "ack::[attentive] Sí, sí...",
+    "ack::[calm] Entiendo...",
+    "agree::[relaxed] Vale...",
+    "ack::[thoughtful] Ah, ya...",
+];
+
+/// Split a raw `*_TEXTS` value into `(phrases, categories)`.
+///
+/// One phrase per line; `|` is also accepted as a separator so the list can
+/// live on a single line. A line may carry a `category::` prefix (e.g.
+/// `agree::[agreeing] Claro...`) used by the scheduler to vary the kind of
+/// acknowledgment through the turn; without it the phrase is an `ack`.
+fn parse_texts(raw: &str) -> (Vec<String>, Vec<String>) {
+    let mut texts = Vec::new();
+    let mut categories = Vec::new();
+    for line in raw.split(['\n', '|']) {
+        let line = line.trim();
+        if line.is_empty() {
+            continue;
+        }
+        let (category, phrase) = match line.split_once("::") {
+            Some((c, p)) => (c.trim(), p.trim()),
+            None => (DEFAULT_CATEGORY, line),
+        };
+        if phrase.is_empty() {
+            continue;
+        }
+        texts.push(phrase.to_string());
+        categories.push(if category.is_empty() {
+            DEFAULT_CATEGORY.to_string()
+        } else {
+            category.to_string()
+        });
+    }
+    (texts, categories)
+}
+
 impl BackchannelSettings {
     /// Build the settings from environment variables, falling back to defaults.
     pub fn from_env() -> Self {
@@ -58,19 +149,99 @@ impl BackchannelSettings {
                 s.dir = PathBuf::from(p);
             }
         }
+        if let Ok(t) = std::env::var("BACKCHANNEL_TEXTS") {
+            let (texts, categories) = parse_texts(&t);
+            if !texts.is_empty() {
+                s.texts = texts;
+                s.categories = categories;
+            }
+        }
         s.enabled = env_bool("BACKCHANNEL_ENABLED", s.enabled);
         s.gain = env_f32("BACKCHANNEL_GAIN", s.gain);
         s.min_speech_ms = env_u64("BACKCHANNEL_MIN_SPEECH_MS", s.min_speech_ms);
         s.interval_ms = env_u64("BACKCHANNEL_INTERVAL_MS", s.interval_ms);
+        s.jitter_ms = env_u64("BACKCHANNEL_JITTER_MS", s.jitter_ms);
+        s.pause_min_ms = env_u64("BACKCHANNEL_PAUSE_MIN_MS", s.pause_min_ms);
+        s.pause_max_ms = env_u64("BACKCHANNEL_PAUSE_MAX_MS", s.pause_max_ms);
+        s.prob = env_f32("BACKCHANNEL_PROB", s.prob);
+        s.volume_jitter = env_f32("BACKCHANNEL_VOLUME_JITTER", s.volume_jitter);
         s.max_per_turn = env_u32("BACKCHANNEL_MAX_PER_TURN", s.max_per_turn);
 
         s.gain = s.gain.clamp(0.0, 1.0);
-        // Never cue before the turn has meaningfully started.
-        s.interval_ms = s.interval_ms.max(s.min_speech_ms);
+        s.prob = s.prob.clamp(0.0, 1.0);
+        s.volume_jitter = s.volume_jitter.clamp(0.0, 1.0);
+        // Keep the spacing and the micro-pause window coherent.
+        s.interval_ms = s.interval_ms.max(500);
+        if s.pause_max_ms < s.pause_min_ms {
+            s.pause_max_ms = s.pause_min_ms;
+        }
         s
     }
 }
 
+/// Tiny xorshift64 generator for timing jitter, the probabilistic gate and the
+/// volume drift. The backchannel path is not hot enough to warrant more.
+struct XorShift64(u64);
+
+impl XorShift64 {
+    fn new(seed: u64) -> Self {
+        // OR 1 so the state is never zero (which would make xorshift degenerate).
+        Self(seed | 1)
+    }
+
+    fn next_u64(&mut self) -> u64 {
+        let mut x = self.0;
+        x ^= x << 13;
+        x ^= x >> 7;
+        x ^= x << 17;
+        self.0 = x;
+        x
+    }
+
+    /// Uniform in `[0, 1)`.
+    fn frac(&mut self) -> f32 {
+        (self.next_u64() >> 40) as f32 / (1u64 << 24) as f32
+    }
+
+    /// Uniform integer in `[lo, hi]` inclusive (`lo` when `hi <= lo`).
+    fn range(&mut self, lo: u64, hi: u64) -> u64 {
+        if hi <= lo {
+            lo
+        } else {
+            lo + self.next_u64() % (hi - lo + 1)
+        }
+    }
+}
+
+/// One synthesized clip, with the category of its source phrase.
+struct ClipRef {
+    name: String,
+    category: String,
+}
+
+/// Map a phrase list (and its categories) onto the clip names of `bank`.
+///
+/// Clips are named `{prefix}{index}` in list order and `FillerBank` keeps that
+/// order, so the i-th clip matches the i-th phrase — and thus the i-th
+/// category. A bank that does not match the list (custom clips) leaves the
+/// mapping short; the scheduler then falls back to a plain random pick.
+fn map_clips(bank: &FillerBank, texts: &[String], categories: &[String]) -> Vec<ClipRef> {
+    let names = bank.names();
+    texts
+        .iter()
+        .enumerate()
+        .filter_map(|(i, _)| {
+            names.get(i).map(|name| ClipRef {
+                name: name.clone(),
+                category: categories
+                    .get(i)
+                    .cloned()
+                    .unwrap_or_else(|| DEFAULT_CATEGORY.to_string()),
+            })
+        })
+        .collect()
+}
+
 /// Per-session backchannel decision logic.
 ///
 /// Fed by the VAD: [`on_speech_start`](Self::on_speech_start) when a user turn
@@ -79,33 +250,112 @@ impl BackchannelSettings {
 pub struct BackchannelScheduler {
     bank: Arc<FillerBank>,
     settings: BackchannelSettings,
-    /// Round-robin cursor over the clip bank.
-    next_index: usize,
+    /// Clip name + category per bank entry, in the order of `settings.texts`.
+    clips: Vec<ClipRef>,
+    /// VAD end-of-utterance silence window (`VAD_MIN_SILENCE_MS`), used to cap
+    /// the micro-pause window so a cue never lands on the pause that closes the
+    /// turn.
+    vad_min_silence_ms: u32,
     /// When the current user turn started (only set while speaking).
     turn_start: Option<Instant>,
-    /// When the last backchannel was emitted in this turn.
+    /// When the last cue was emitted in this turn.
     last_emitted: Option<Instant>,
-    /// Backchannels emitted in the current turn.
+    /// Cues emitted in the current turn.
     emitted: u32,
+    /// Earliest instant the first cue of this turn may be played (randomized).
+    first_cue_at: Option<Instant>,
+    /// Randomized gap to wait after the previous cue before the next one.
+    next_gap_ms: u64,
+    /// Whether the current micro-pause was already evaluated (cue or skip).
+    pause_settled: bool,
+    /// Random depth (ms) at which to react inside the current micro-pause, so
+    /// cues do not all land at exactly `pause_min_ms`. Drawn once per pause.
+    pause_target_ms: Option<u64>,
+    /// Categories already used in this turn, for a natural progression.
+    used_categories: Vec<String>,
+    /// Category of the last cue (avoid chaining two cues of the same kind).
+    last_category: Option<String>,
+    /// Names of the most recently used clips (anti-repetition), kept across
+    /// turns so the same cue never plays twice in a row.
+    recent: VecDeque<String>,
+    /// RNG for jitter, the probabilistic gate and the volume drift.
+    rng: XorShift64,
 }
 
 impl BackchannelScheduler {
-    pub fn new(bank: Arc<FillerBank>, settings: BackchannelSettings) -> Self {
+    /// Create a scheduler for one session. `vad_min_silence_ms` is the VAD EOU
+    /// window (`VAD_MIN_SILENCE_MS`); it bounds the micro-pause window.
+    pub fn new(
+        bank: Arc<FillerBank>,
+        settings: BackchannelSettings,
+        vad_min_silence_ms: u32,
+    ) -> Self {
+        let clips = map_clips(&bank, &settings.texts, &settings.categories);
+
+        let seed = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .map(|d| d.as_nanos() as u64)
+            .unwrap_or(0x9E37_79B9_7F4A_7C15);
+
+        // One line so the effective policy (and the parsed categories) is
+        // visible in the log — the knobs are numerous and tuned by ear.
+        let categories: Vec<&str> = clips.iter().map(|c| c.category.as_str()).collect();
+        info!(
+            clips = clips.len(),
+            categories = ?categories,
+            pause_ms = format!("{}..{}", settings.pause_min_ms, settings.pause_max_ms),
+            first_cue_ms = settings.min_speech_ms,
+            interval_ms = settings.interval_ms,
+            jitter_ms = settings.jitter_ms,
+            prob = settings.prob,
+            volume_jitter = settings.volume_jitter,
+            max_per_turn = settings.max_per_turn,
+            "backchannel scheduler ready"
+        );
+
         Self {
             bank,
             settings,
-            next_index: 0,
+            clips,
+            vad_min_silence_ms,
             turn_start: None,
             last_emitted: None,
             emitted: 0,
+            first_cue_at: None,
+            next_gap_ms: 0,
+            pause_settled: false,
+            pause_target_ms: None,
+            used_categories: Vec::new(),
+            last_category: None,
+            recent: VecDeque::new(),
+            rng: XorShift64::new(seed),
         }
     }
 
+    /// Point the scheduler at another language's bank: replace the clip list and
+    /// the phrase/category mapping. Called between turns when the detected user
+    /// language changes (see [`crate::lang`]). The per-turn counters are left as
+    /// they are — the next VAD speech start resets them anyway.
+    pub fn retarget(&mut self, bank: Arc<FillerBank>, texts: &[String], categories: &[String]) {
+        self.clips = map_clips(&bank, texts, categories);
+        self.bank = bank;
+    }
+
     /// Begin a new user turn (VAD speech start).
     pub fn on_speech_start(&mut self) {
-        self.turn_start = Some(Instant::now());
+        let now = Instant::now();
+        self.turn_start = Some(now);
         self.last_emitted = None;
         self.emitted = 0;
+        self.pause_settled = false;
+        self.pause_target_ms = None;
+        self.used_categories.clear();
+        self.last_category = None;
+        // Randomize when the first cue becomes eligible: base delay plus a
+        // random 0..jitter offset, so turns don't all cue at the same instant.
+        let jitter = self.rng.range(0, self.settings.jitter_ms);
+        self.first_cue_at = Some(now + Duration::from_millis(self.settings.min_speech_ms + jitter));
+        self.next_gap_ms = self.settings.interval_ms;
     }
 
     /// Close the current user turn (VAD speech end).
@@ -113,35 +363,176 @@ impl BackchannelScheduler {
         self.turn_start = None;
         self.last_emitted = None;
         self.emitted = 0;
+        self.first_cue_at = None;
+        self.pause_settled = false;
+        self.pause_target_ms = None;
+        self.used_categories.clear();
+        self.last_category = None;
     }
 
     /// Emit a backchannel into `mixer` if the policy allows it right now.
     ///
     /// Must be called while the user is speaking and the agent is silent.
-    /// Returns the clip name when one was emitted.
-    pub fn maybe_emit(&mut self, mixer: &crate::audio::AudioMixer) -> Option<String> {
+    /// `pause_ms` is the length of the micro-pause the user is currently in
+    /// ([`VadDetector::silence_ms`](crate::vad::VadDetector::silence_ms), 0
+    /// while voice is ongoing). Returns the clip `(name, category)` when one
+    /// was emitted.
+    pub fn maybe_emit(
+        &mut self,
+        mixer: &crate::audio::AudioMixer,
+        pause_ms: u64,
+    ) -> Option<(String, String)> {
         if !self.settings.enabled {
             return None;
         }
-        let start = self.turn_start?;
-        if self.emitted >= self.settings.max_per_turn {
+        if self.turn_start.is_none() || self.emitted >= self.settings.max_per_turn {
             return None;
         }
-        if start.elapsed() < Duration::from_millis(self.settings.min_speech_ms) {
+
+        // Cue only inside a micro-pause: never mid-word, and never on the pause
+        // that is long enough to close the utterance (that one belongs to the
+        // reply). A zero-length pause means voice is ongoing: re-arm so the
+        // *next* micro-pause is evaluated.
+        if pause_ms == 0 {
+            self.pause_settled = false;
+            self.pause_target_ms = None;
             return None;
         }
+        let max = self.pause_max();
+        if pause_ms > max {
+            // The pause ran past the window (it is about to close the turn):
+            // abandon it without firing.
+            self.pause_settled = true;
+            return None;
+        }
+        if self.pause_settled {
+            return None;
+        }
+        // At the start of a new micro-pause pick the depth to react at
+        // uniformly inside the window, so the cue does not always land at
+        // exactly `pause_min_ms` — the reaction point varies pause to pause.
+        let target = match self.pause_target_ms {
+            Some(t) => t,
+            None => {
+                let lo = self.settings.pause_min_ms.min(max);
+                let t = self.rng.range(lo, max);
+                self.pause_target_ms = Some(t);
+                t
+            }
+        };
+        if pause_ms < target {
+            return None;
+        }
+
+        // Randomized turn timing: hold off until the first-cue instant.
+        if let Some(first) = self.first_cue_at {
+            if Instant::now() < first {
+                return None;
+            }
+        }
+        // Randomized spacing since the previous cue.
         if let Some(last) = self.last_emitted {
-            if last.elapsed() < Duration::from_millis(self.settings.interval_ms) {
+            if last.elapsed() < Duration::from_millis(self.next_gap_ms) {
                 return None;
             }
         }
 
-        let (name, samples) = self.bank.nth(self.next_index)?;
-        let name = name.to_string();
-        mixer.backchannel_queue.push(samples);
-        self.next_index = self.next_index.wrapping_add(1);
+        // Probabilistic gate: stay silent for some qualifying pauses, so the
+        // cadence matches how a listener nods along instead of a metronome.
+        if self.rng.frac() > self.settings.prob {
+            self.pause_settled = true;
+            return None;
+        }
+
+        let (name, category, samples) = self.select()?;
+        let samples = self.apply_volume(&samples);
+        mixer.backchannel_queue.push(&samples);
+
+        self.pause_settled = true;
         self.last_emitted = Some(Instant::now());
         self.emitted += 1;
-        Some(name)
+        self.used_categories.push(category.clone());
+        self.last_category = Some(category.clone());
+        self.recent.push_back(name.clone());
+        while self.recent.len() > 2 {
+            self.recent.pop_front();
+        }
+        // Randomize the next gap around the configured interval.
+        let half = self.settings.jitter_ms / 2;
+        let lo = self.settings.interval_ms.saturating_sub(half).max(500);
+        let hi = self.settings.interval_ms + half;
+        self.next_gap_ms = self.rng.range(lo, hi);
+        Some((name, category))
+    }
+
+    /// Upper bound of the micro-pause window: the configured maximum, capped so
+    /// it stays below the VAD end-of-utterance window (minus one analysis
+    /// window) — otherwise the cue would land on the pause that ends the turn.
+    fn pause_max(&self) -> u64 {
+        let vad_cap = (self.vad_min_silence_ms.saturating_sub(32) as u64).max(1);
+        self.settings.pause_max_ms.min(vad_cap)
+    }
+
+    /// Pick a clip honouring the category progression and anti-repetition, then
+    /// falling back to a plain random clip when the bank does not match the
+    /// phrase list. Returns `(name, category, samples)`.
+    fn select(&mut self) -> Option<(String, String, Vec<i16>)> {
+        if let Some(idx) = self.select_index() {
+            let clip = &self.clips[idx];
+            if let Some(samples) = self.bank.get(&clip.name) {
+                return Some((clip.name.clone(), clip.category.clone(), samples.clone()));
+            }
+        }
+        self.bank
+            .random()
+            .map(|(n, s)| (n.to_string(), DEFAULT_CATEGORY.to_string(), s.clone()))
+    }
+
+    /// Index of the clip to play: prefer a category other than the last one,
+    /// then categories not yet used this turn (a progression from "listening"
+    /// to "agreeing"), then clips not used recently, and pick uniformly at
+    /// random among whatever remains.
+    fn select_index(&mut self) -> Option<usize> {
+        if self.clips.is_empty() {
+            return None;
+        }
+        let all: Vec<usize> = (0..self.clips.len()).collect();
+
+        let not_last: Vec<usize> = all
+            .iter()
+            .copied()
+            .filter(|&i| Some(&self.clips[i].category) != self.last_category.as_ref())
+            .collect();
+        let pool = if not_last.is_empty() { all } else { not_last };
+
+        let fresh: Vec<usize> = pool
+            .iter()
+            .copied()
+            .filter(|&i| !self.used_categories.contains(&self.clips[i].category))
+            .collect();
+        let pool = if fresh.is_empty() { pool } else { fresh };
+
+        let unrepeated: Vec<usize> = pool
+            .iter()
+            .copied()
+            .filter(|&i| !self.recent.contains(&self.clips[i].name))
+            .collect();
+        let pool = if unrepeated.is_empty() { pool } else { unrepeated };
+
+        Some(pool[(self.rng.next_u64() % pool.len() as u64) as usize])
+    }
+
+    /// Scale a clip by a random ±`volume_jitter` factor so the cues do not all
+    /// sit at exactly the same level.
+    fn apply_volume(&mut self, samples: &[i16]) -> Vec<i16> {
+        let jitter = self.settings.volume_jitter;
+        if jitter <= 0.0 {
+            return samples.to_vec();
+        }
+        let scale = 1.0 + (self.rng.frac() * 2.0 - 1.0) * jitter;
+        samples
+            .iter()
+            .map(|&s| ((s as f32) * scale).clamp(i16::MIN as f32, i16::MAX as f32) as i16)
+            .collect()
     }
 }
diff --git a/src/orchestrator/turn_manager.rs b/src/orchestrator/turn_manager.rs
index 6e595e1..292c7d6 100644
--- a/src/orchestrator/turn_manager.rs
+++ b/src/orchestrator/turn_manager.rs
@@ -9,13 +9,17 @@
 //! - **Without LLM**: transcript → TTS (the original pass-through behaviour).
 
 use crate::audio::{AudioMixer, SampleRingBuffer};
+use crate::audit::SessionAudit;
 use crate::config::Config;
+use crate::lang::{self, LangBanks, LanguageState};
 use crate::llm::{ChatMessage, LlmClient};
 use crate::stt::{Tokenizer, Transcript};
+use crate::tools::ToolCallStripper;
 use crate::tts::TtsEngine;
+use crate::{assets, orchestrator::backchannel::DEFAULT_CATEGORY};
 use serde_json::json;
 use std::collections::HashMap;
-use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering};
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::sync::mpsc;
@@ -62,12 +66,15 @@ fn pump(src: &SampleRingBuffer, dst: &SampleRingBuffer) -> usize {
 }
 
 /// Preloaded PCM samples keyed by name (e.g. "uhm"). Used for the filler bank
-/// injected at end-of-utterance (played round-robin) and, from a different
-/// directory, for the backchannel clips played while the user speaks.
+/// injected at end-of-utterance (played round-robin), for the backchannel clips
+/// played while the user speaks, and for the start-filler bank (both played in
+/// random order).
 pub struct FillerBank {
     samples: HashMap<String, Vec<i16>>,
     /// Names in a stable order, for round-robin selection.
     names: Vec<String>,
+    /// xorshift64 state for [`Self::random`] (seeded from the clock at load).
+    rng: AtomicU64,
 }
 
 impl FillerBank {
@@ -107,17 +114,37 @@ impl FillerBank {
 
         let mut names: Vec<String> = samples.keys().cloned().collect();
         names.sort();
-        Self { samples, names }
+
+        // Seed the xorshift64 state from the wall clock (OR 1 so it is never
+        // zero, which would make xorshift degenerate).
+        let seed = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .map(|d| d.as_nanos() as u64)
+            .unwrap_or(0x9E37_79B9_7F4A_7C15)
+            | 1;
+
+        Self {
+            samples,
+            names,
+            rng: AtomicU64::new(seed),
+        }
     }
 
-    /// Get the samples for a clip by name. Kept for reference/debugging.
-    #[allow(dead_code)]
+    /// Get the samples for a clip by name. Used by the backchannel to play a
+    /// specific (category-selected) clip instead of a uniform random one.
     pub fn get(&self, name: &str) -> Option<&Vec<i16>> {
         self.samples.get(name)
     }
 
+    /// Clip names in the stable (sorted) order used by [`Self::nth`]. The
+    /// backchannel uses it to map the phrase list (and its categories) onto the
+    /// synthesized clips, since clips are named `{prefix}{index}` in list order.
+    pub fn names(&self) -> &[String] {
+        &self.names
+    }
+
     /// Clip at position `index` (wrapping), with its name. Used for the
-    /// round-robin filler and backchannel selection.
+    /// round-robin end-of-utterance filler.
     pub fn nth(&self, index: usize) -> Option<(&str, &Vec<i16>)> {
         if self.names.is_empty() {
             return None;
@@ -126,6 +153,23 @@ impl FillerBank {
         self.samples.get(name).map(|s| (name.as_str(), s))
     }
 
+    /// Clip chosen uniformly at random, with its name. Used by the start filler
+    /// and the backchannel so the cue varies from turn to turn.
+    pub fn random(&self) -> Option<(&str, &Vec<i16>)> {
+        if self.names.is_empty() {
+            return None;
+        }
+        // xorshift64 step over the shared state.
+        let mut x = self.rng.load(Ordering::Relaxed);
+        x ^= x << 13;
+        x ^= x >> 7;
+        x ^= x << 17;
+        self.rng.store(x, Ordering::Relaxed);
+
+        let name = &self.names[(x % self.names.len() as u64) as usize];
+        self.samples.get(name).map(|s| (name.as_str(), s))
+    }
+
     /// Whether the bank holds no clips.
     pub fn is_empty(&self) -> bool {
         self.names.is_empty()
@@ -136,7 +180,10 @@ impl FillerBank {
 pub struct TurnManager {
     mixer: AudioMixer,
     tts: Arc<dyn TtsEngine>,
-    fillers: Arc<FillerBank>,
+    /// Active-language clip banks, shared with the mic task (backchannel). The
+    /// end-of-turn and start fillers are read from here so all three cues
+    /// follow the same language — see [`crate::lang`].
+    langs: Arc<LanguageState>,
     /// Optional tokenizer to decode STT token IDs into text. If `None`, a
     /// placeholder string is sent to the TTS (useful for testing the pipeline
     /// without a real tokenizer).
@@ -154,22 +201,31 @@ pub struct TurnManager {
     /// Outbound text-event channel (JSON strings) consumed by the session
     /// sender task and forwarded to the browser (chat box).
     out_tx: Option<mpsc::UnboundedSender<String>>,
+    /// User turns seen so far, used to schedule the periodic language check.
+    lang_turns: AtomicU64,
+    /// Whether a language-detection call is currently in flight (one at a time).
+    lang_detecting: Arc<AtomicBool>,
+    /// Per-session audit sink: the language switches are recorded here (every
+    /// other event reaches the log through the outbound tap in the session
+    /// sender — see [`crate::audit`]).
+    audit: Arc<SessionAudit>,
 }
 
 impl TurnManager {
     pub fn new(
         mixer: AudioMixer,
         tts: Arc<dyn TtsEngine>,
-        fillers: Arc<FillerBank>,
+        langs: Arc<LanguageState>,
         tokenizer: Option<Tokenizer>,
         llm: Option<Arc<LlmClient>>,
         config: Arc<Config>,
         out_tx: Option<mpsc::UnboundedSender<String>>,
+        audit: Arc<SessionAudit>,
     ) -> Self {
         Self {
             mixer,
             tts,
-            fillers,
+            langs,
             tokenizer,
             cancel: Arc::new(parking_lot::Mutex::new(None)),
             filler_cursor: AtomicUsize::new(0),
@@ -177,13 +233,76 @@ impl TurnManager {
             config,
             history: parking_lot::Mutex::new(Vec::new()),
             out_tx,
+            lang_turns: AtomicU64::new(0),
+            lang_detecting: Arc::new(AtomicBool::new(false)),
+            audit,
         }
     }
 
-    /// Pick the next filler clip round-robin from the bank.
+    /// Pick the next filler clip round-robin from the bank of the active
+    /// language.
     fn next_filler(&self) -> Option<(String, Vec<i16>)> {
+        let banks = self.langs.current();
         let i = self.filler_cursor.fetch_add(1, Ordering::Relaxed);
-        self.fillers.nth(i).map(|(name, s)| (name.to_string(), s.clone()))
+        banks
+            .filler
+            .nth(i)
+            .map(|(name, s)| (name.to_string(), s.clone()))
+    }
+
+    /// Schedule the *start filler* acknowledgment on the mixer's dedicated
+    /// start-filler channel.
+    ///
+    /// Like [`Self::schedule_filler`] this is a latency mask, but with its own
+    /// (shorter) delay, `START_FILLER_GO_DELAY`: the cue is only queued when the
+    /// first response audio is still **late** after that window — if the first
+    /// audio chunk has already reached the mixer (even if it is still inside the
+    /// pre-buffer and playback has not started), the agent is already talking
+    /// and the cue is dropped. One phrase is picked **at random** from the bank
+    /// (built from `START_FILLER_TEXTS`), so the cue varies turn to turn.
+    /// Disabled by `START_FILLER_ENABLED=false`; a barge-in (`cancel`) or a new
+    /// turn drops the pending cue, and `mixer.flush` clears it once queued.
+    fn schedule_start_filler(&self, cancel: &CancellationToken) {
+        if !self.config.start_filler_enabled {
+            return;
+        }
+        // Own the clip: the spawned task must be `'static` (same as the
+        // round-robin filler above).
+        let banks = self.langs.current();
+        let Some((name, samples)) = banks
+            .start_filler
+            .random()
+            .map(|(n, s)| (n.to_string(), s.clone()))
+        else {
+            debug!("start filler enabled but no clip loaded — skipping");
+            return;
+        };
+
+        let delay_ms = self.config.start_filler_go_delay_ms;
+        let mixer = self.mixer.clone();
+        let cancel = cancel.clone();
+        let out_tx = self.out_tx.clone();
+        tokio::spawn(async move {
+            tokio::select! {
+                _ = tokio::time::sleep(Duration::from_millis(delay_ms)) => {}
+                // Barge-in / new turn: never play a stale acknowledgment.
+                _ = cancel.cancelled() => return,
+            }
+            if mixer.tts_audio_arrived() {
+                debug!(
+                    filler = %name,
+                    delay_ms, "first response audio already arrived — start filler skipped"
+                );
+                return;
+            }
+            let queued = mixer.start_filler_queue.push(&samples);
+            debug!(filler = %name, samples = queued, delay_ms, "queued start filler");
+            if let Some(tx) = &out_tx {
+                let _ = tx.send(
+                    json!({ "type": "cue", "kind": "start_filler", "name": name }).to_string(),
+                );
+            }
+        });
     }
 
     /// Schedule the single end-of-turn filler acknowledgment.
@@ -207,6 +326,7 @@ impl TurnManager {
         let delay_ms = self.config.filler_delay_ms;
         let mixer = self.mixer.clone();
         let cancel = cancel.clone();
+        let out_tx = self.out_tx.clone();
         let samples_len = samples.len();
         tokio::spawn(async move {
             tokio::select! {
@@ -223,6 +343,11 @@ impl TurnManager {
             }
             mixer.filler_queue.push(&samples);
             debug!(filler = %name, samples = samples_len, delay_ms, "pushed filler (delayed)");
+            if let Some(tx) = &out_tx {
+                let _ = tx.send(
+                    json!({ "type": "cue", "kind": "filler", "name": name }).to_string(),
+                );
+            }
         });
     }
 
@@ -274,12 +399,14 @@ impl TurnManager {
     /// 2. Cancel any in-flight reply (barge-in within the turn).
     /// 3. Run the LLM (if configured) or send the text straight to the TTS.
     ///
-    /// The filler is not queued here: it is scheduled once the response is
-    /// dispatched, so it only plays if the audio is late (see
-    /// [`Self::schedule_filler`]).
+    /// The latency masks are not queued here: both the start filler and the
+    /// end-of-turn filler are *scheduled* once the response is dispatched, so
+    /// they only play if the audio is late — see [`Self::schedule_filler`] and
+    /// [`Self::schedule_start_filler`].
     async fn handle_user_turn(&self, text: String) {
         self.emit(json!({ "type": "user", "text": text }));
 
+        self.maybe_detect_language(&text);
         self.cancel_current_tts();
 
         match &self.llm {
@@ -288,11 +415,58 @@ impl TurnManager {
         }
     }
 
+    /// Kick off a language check for `text` when the detection schedule allows
+    /// it. Runs in the background so the reply is never delayed: the switch (if
+    /// any) takes effect from the next turn. See [`crate::lang`].
+    ///
+    /// The first turn is always checked; afterwards a sample is sent only every
+    /// `LANG_REDETECT_EVERY` turns, so a language change mid-conversation is
+    /// picked up without paying for a detection call on every turn.
+    fn maybe_detect_language(&self, text: &str) {
+        if !self.config.lang_detect_enabled {
+            return;
+        }
+        let Some(llm) = self.llm.clone() else {
+            return;
+        };
+        // Only the backchannel, the end-of-turn filler and the start filler are
+        // language-aware; with all of them disabled there is nothing to switch.
+        if !self.config.backchannel.enabled
+            && !self.config.filler_enabled
+            && !self.config.start_filler_enabled
+        {
+            return;
+        }
+        if text.chars().count() < self.config.lang_min_chars {
+            return;
+        }
+        let turn = self.lang_turns.fetch_add(1, Ordering::Relaxed);
+        if turn % self.config.lang_redetect_every != 0 {
+            return;
+        }
+        // One detection at a time: a slow LLM call must not pile up.
+        if self.lang_detecting.swap(true, Ordering::AcqRel) {
+            return;
+        }
+        let langs = self.langs.clone();
+        let tts = self.tts.clone();
+        let config = self.config.clone();
+        let detecting = self.lang_detecting.clone();
+        let audit = self.audit.clone();
+        let text = text.to_string();
+        tokio::spawn(async move {
+            switch_language_if_needed(langs, llm, tts, config, &text, audit).await;
+            detecting.store(false, Ordering::Release);
+        });
+    }
+
     /// Run one full LLM turn: stream the reply, chunk it into sentences and
     /// synthesize each sentence as soon as it is complete.
     async fn run_llm_turn(&self, llm: Arc<LlmClient>, user_text: String) {
-        // Build the message list from the rolling history.
-        let messages = {
+        // Build the message list from the rolling history. It grows across
+        // tool rounds (assistant call + tool results) but only the *spoken*
+        // text is written back to the rolling history.
+        let mut messages = {
             let mut hist = self.history.lock();
             hist.push(ChatMessage::user(&user_text));
             let max = self.config.llm_history_messages.max(2);
@@ -313,6 +487,7 @@ impl TurnManager {
         *self.cancel.lock() = Some(cancel.clone());
         self.mixer.mark_stream_start();
         self.schedule_filler(&cancel);
+        self.schedule_start_filler(&cancel);
         debug!(
             endpoint = llm.endpoint(),
             model = llm.model(),
@@ -414,63 +589,129 @@ impl TurnManager {
             }
         });
 
-        // LLM producer: streams clean text deltas into a channel.
-        let (delta_tx, mut delta_rx) = mpsc::unbounded_channel::<String>();
-        let stream_mode = self.config.llm_stream;
-        let llm_cancel = cancel.clone();
-        let llm_task = tokio::spawn(async move {
-            if stream_mode {
-                llm.chat_stream(&messages, &llm_cancel, delta_tx).await
-            } else {
-                let res = llm.chat(&messages, &llm_cancel).await;
-                if let Ok(text) = &res {
-                    let _ = delta_tx.send(text.clone());
-                }
-                res
-            }
-        });
+        // Tool-calling loop. Each round streams one reply; tool call blocks are
+        // stripped from the spoken/displayed text (the model emits them as
+        // text — see `crate::tools`), the calls run over HTTP, and the results
+        // are handed back for the next round. Bounded by
+        // `LLM_TOOL_MAX_ITERATIONS`. With no tools configured the loop runs
+        // exactly once.
+        let registry = llm.tools().cloned();
+        let max_rounds = self.config.llm_tool_max_iterations.max(1);
+        let mut spoken = String::new();
+        let mut round = 0usize;
+
+        loop {
+            // LLM producer: streams clean text deltas into a channel.
+            let (delta_tx, mut delta_rx) = mpsc::unbounded_channel::<String>();
+            let stream_mode = self.config.llm_stream;
+            let llm_cancel = cancel.clone();
+            let llm_round = llm.clone();
+            let round_messages = messages.clone();
+            let llm_task = tokio::spawn(async move {
+                if stream_mode {
+                    llm_round.chat_stream(&round_messages, &llm_cancel, delta_tx).await
+                } else {
+                    let res = llm_round.chat(&round_messages, &llm_cancel).await;
+                    if let Ok(text) = &res {
+                        let _ = delta_tx.send(text.clone());
+                    }
+                    res
+                }
+            });
+
+            // Consume deltas: emit `assistant_delta` events and feed the
+            // splitter, so the TTS starts as soon as the first few words are
+            // available. The stripper holds back tool-call blocks so they are
+            // never spoken nor shown.
+            let mut splitter = SentenceSplitter::new(
+                self.config.llm_stream_first_chunk_chars,
+                self.config.llm_stream_chunk_chars,
+            );
+            let mut stripper = ToolCallStripper::new();
+            let mut raw = String::new();
+            while let Some(delta) = delta_rx.recv().await {
+                if cancel.is_cancelled() {
+                    break;
+                }
+                raw.push_str(&delta);
+                let visible = stripper.push(&delta);
+                if visible.is_empty() {
+                    continue;
+                }
+                self.emit(json!({ "type": "assistant_delta", "text": visible }));
+                spoken.push_str(&visible);
+                for sentence in splitter.push(&visible) {
+                    if sentence_tx.send(sentence).is_err() {
+                        break;
+                    }
+                }
+            }
+            if !cancel.is_cancelled() {
+                let tail = stripper.finish();
+                if !tail.is_empty() {
+                    self.emit(json!({ "type": "assistant_delta", "text": tail }));
+                    for sentence in splitter.push(&tail) {
+                        if sentence_tx.send(sentence).is_err() {
+                            break;
+                        }
+                    }
+                    spoken.push_str(&tail);
+                }
+                if let Some(rest) = splitter.finish() {
+                    let _ = sentence_tx.send(rest);
+                }
+            }
+
+            match llm_task.await {
+                Ok(Ok(_)) => {}
+                Ok(Err(e)) => {
+                    error!(error = %e, "LLM request failed");
+                    self.emit(json!({ "type": "error", "text": e.to_string() }));
+                }
+                Err(e) => {
+                    error!(error = %e, "LLM task join failed");
+                    self.emit(json!({ "type": "error", "text": format!("LLM task failed: {e}") }));
+                }
+            }
 
-        // Consume deltas: emit `assistant_delta` events and feed the splitter,
-        // so the TTS starts as soon as the first few words are available.
-        let mut splitter = SentenceSplitter::new(
-            self.config.llm_stream_first_chunk_chars,
-            self.config.llm_stream_chunk_chars,
-        );
-        let mut full = String::new();
-        while let Some(delta) = delta_rx.recv().await {
             if cancel.is_cancelled() {
                 break;
             }
-            self.emit(json!({ "type": "assistant_delta", "text": delta }));
-            full.push_str(&delta);
-            for sentence in splitter.push(&delta) {
-                if sentence_tx.send(sentence).is_err() {
-                    break;
-                }
-            }
-        }
-        if !cancel.is_cancelled() {
-            if let Some(rest) = splitter.finish() {
-                let _ = sentence_tx.send(rest);
+
+            let calls = stripper.take_calls();
+            if calls.is_empty() {
+                break;
+            }
+            let Some(registry) = registry.as_ref() else {
+                warn!("model emitted a tool call but no tools are configured — ignoring");
+                break;
+            };
+            if round + 1 >= max_rounds {
+                warn!(max_rounds, "tool-call iteration limit reached — stopping");
+                break;
+            }
+            round += 1;
+
+            // Record the model's own call followed by each result, so the next
+            // round sees the exchange (standard OpenAI tool round-trip).
+            messages.push(ChatMessage::assistant(raw.clone()));
+            for call in &calls {
+                info!(tool = %call.name, round, "executing tool call");
+                self.emit(json!({
+                    "type": "tool_call",
+                    "name": &call.name,
+                    "arguments": &call.arguments,
+                }));
+                let result = registry.execute(call).await;
+                messages.push(ChatMessage::tool(result));
             }
         }
+
         drop(sentence_tx);
         let _ = tts_task.await;
 
-        match llm_task.await {
-            Ok(Ok(_)) => {}
-            Ok(Err(e)) => {
-                error!(error = %e, "LLM request failed");
-                self.emit(json!({ "type": "error", "text": e.to_string() }));
-            }
-            Err(e) => {
-                error!(error = %e, "LLM task join failed");
-                self.emit(json!({ "type": "error", "text": format!("LLM task failed: {e}") }));
-            }
-        }
-
-        if !cancel.is_cancelled() && !full.trim().is_empty() {
-            self.history.lock().push(ChatMessage::assistant(full.clone()));
+        if !cancel.is_cancelled() && !spoken.trim().is_empty() {
+            self.history.lock().push(ChatMessage::assistant(spoken.clone()));
             self.emit(json!({ "type": "assistant_end" }));
         }
 
@@ -500,6 +741,12 @@ impl TurnManager {
         self.tts.set_reference(audio_path, text);
     }
 
+    /// Set the gain of the mixer's external audio channel (URL / radio /
+    /// YouTube background source). See [`crate::media`].
+    pub fn set_external_gain(&self, gain: f32) {
+        self.mixer.set_external_gain(gain);
+    }
+
     /// Synthesize `text` directly with the TTS engine, bypassing the LLM.
     /// Used by the playground's "Speak" box to test the TTS pipeline.
     pub async fn speak(&self, text: &str) {
@@ -529,6 +776,7 @@ impl TurnManager {
         let text_owned = text.to_string();
         self.mixer.mark_stream_start();
         self.schedule_filler(&cancel);
+        self.schedule_start_filler(&cancel);
         debug!(
             engine = tts.name(),
             sample_rate = tts.sample_rate(),
@@ -560,6 +808,133 @@ impl TurnManager {
     }
 }
 
+/// Detect the language of `text` and, when it differs from the active one,
+/// build and publish the clip banks for it.
+///
+/// The phrase list comes from the built-in tables ([`crate::lang`]) for the
+/// common languages, or from the LLM when `LANG_LLM_FALLBACK_ENABLED` is set.
+/// Clips are synthesized only when missing — [`assets::ensure_lang_backchannel_clips`]
+/// keeps a per-language index — and live in their own subdirectory, so no other
+/// language is touched. Switching back to the default language restores the
+/// base banks and needs no synthesis at all.
+async fn switch_language_if_needed(
+    langs: Arc<LanguageState>,
+    llm: Arc<LlmClient>,
+    tts: Arc<dyn TtsEngine>,
+    config: Arc<Config>,
+    text: &str,
+    audit: Arc<SessionAudit>,
+) {
+    let Some(lang) = lang::detect_language(&llm, text).await else {
+        return;
+    };
+    let current = langs.current();
+    if lang == current.lang {
+        return;
+    }
+    if lang == config.lang_default {
+        info!(lang = %lang, "user language back to the default — restoring the base clip banks");
+        audit.event(
+            "language_switch",
+            json!({ "from": current.lang, "to": lang, "generated": false }),
+        );
+        langs.set((*langs.base()).clone());
+        return;
+    }
+
+    // Phrase lists: built-in table first, LLM fallback otherwise.
+    let backchannel = match lang::backchannel_texts(&lang) {
+        Some(pairs) => pairs,
+        None if config.lang_llm_fallback_enabled => {
+            match lang::generate_backchannel_texts(&llm, &lang).await {
+                Some(phrases) => phrases
+                    .into_iter()
+                    .map(|p| (DEFAULT_CATEGORY.to_string(), p))
+                    .collect(),
+                None => return,
+            }
+        }
+        None => return,
+    };
+    let filler = match lang::filler_texts(&lang) {
+        Some(texts) => texts,
+        None if config.lang_llm_fallback_enabled => {
+            match lang::generate_filler_texts(&llm, &lang).await {
+                Some(texts) => texts,
+                None => return,
+            }
+        }
+        None => return,
+    };
+    // Start filler is optional: when the language has no phrase list (and the
+    // LLM fallback is unavailable) the cue simply stays silent for it, without
+    // preventing the switch of the banks above.
+    let start_filler = if !config.start_filler_enabled {
+        None
+    } else {
+        match lang::start_filler_texts(&lang) {
+            Some(texts) => Some(texts),
+            None if config.lang_llm_fallback_enabled => {
+                lang::generate_start_filler_texts(&llm, &lang).await
+            }
+            None => None,
+        }
+    };
+
+    info!(
+        from = %current.lang,
+        to = %lang,
+        backchannel = backchannel.len(),
+        filler = filler.len(),
+        start_filler = start_filler.as_ref().map(|t| t.len()).unwrap_or(0),
+        "user language changed — generating the clip banks for it"
+    );
+
+    let phrases: Vec<String> = backchannel.iter().map(|(_, p)| p.clone()).collect();
+    let categories: Vec<String> = backchannel.iter().map(|(c, _)| c.clone()).collect();
+
+    // Idempotent: an unchanged phrase list is skipped via the per-directory
+    // `texts.txt` index, so an already-generated language is just reloaded.
+    assets::ensure_lang_backchannel_clips(&config.backchannel.dir, &lang, &phrases, tts.as_ref())
+        .await;
+    assets::ensure_lang_filler_clips(&config.fillers_dir, &lang, &filler, tts.as_ref()).await;
+    if let Some(texts) = &start_filler {
+        assets::ensure_lang_start_filler_clips(
+            &config.start_filler_dir,
+            &lang,
+            texts,
+            tts.as_ref(),
+        )
+        .await;
+    }
+
+    let backchannel_bank = Arc::new(FillerBank::load(
+        &assets::lang_dir(&config.backchannel.dir, &lang),
+        "backchannel",
+    ));
+    let filler_bank = Arc::new(FillerBank::load(
+        &assets::lang_dir(&config.fillers_dir, &lang),
+        "filler",
+    ));
+    let start_filler_bank = Arc::new(FillerBank::load(
+        &assets::lang_dir(&config.start_filler_dir, &lang),
+        "start-filler",
+    ));
+
+    langs.set(LangBanks {
+        lang,
+        backchannel: backchannel_bank,
+        backchannel_texts: phrases,
+        backchannel_categories: categories,
+        filler: filler_bank,
+        start_filler: start_filler_bank,
+    });
+    audit.event(
+        "language_switch",
+        json!({ "from": current.lang, "to": langs.current().lang, "generated": true }),
+    );
+}
+
 /// Spawn an orchestrator loop that consumes transcripts from `rx` and drives
 /// the turn manager.
 pub fn spawn_orchestrator(
diff --git a/src/tools.rs b/src/tools.rs
new file mode 100644
index 0000000..0c3ab3a
--- /dev/null
+++ b/src/tools.rs
@@ -0,0 +1,475 @@
+//! Configurable HTTP tool calling for the LLM reasoning stage.
+//!
+//! The deployment's OpenAI-compatible server (vLLM) runs **without** a
+//! server-side tool parser (`--enable-auto-tool-choice --tool-call-parser …`),
+//! so it never returns structured `tool_calls` / `finish_reason: "tool_calls"`.
+//! The Qwen model still knows how to call tools and emits the call **as text**
+//! in its native format:
+//!
+//! ```text
+//! <tool_call>
+//! <function=get_weather>
+//! <parameter=city>
+//! Paris
+//! </parameter>
+//! </function>
+//! </tool_call>
+//! ```
+//!
+//! This module therefore parses that native format client-side, executes the
+//! matching HTTP tool and hands the result back to the model on the next
+//! completion (as a `tool` role message). It works with any server, with no
+//! server-side reconfiguration.
+//!
+//! Tool definitions are loaded from a JSON file (`LLM_TOOLS_FILE`), which keeps
+//! verbose JSON schemas out of `.env`:
+//!
+//! ```json
+//! [
+//!   {
+//!     "name": "get_weather",
+//!     "description": "Current weather for a city",
+//!     "parameters": {
+//!       "type": "object",
+//!       "properties": { "city": { "type": "string" } },
+//!       "required": ["city"]
+//!     },
+//!     "url": "https://wttr.in/{city}?format=3",
+//!     "method": "GET",
+//!     "headers": { "X-Api-Key": "…" }
+//!   }
+//! ]
+//! ```
+//!
+//! - `url` may contain `{arg}` placeholders substituted from the call arguments.
+//! - `GET` sends the remaining arguments as query parameters; `POST` (default)
+//!   sends them as a JSON body.
+//! - `headers` are optional and sent verbatim (API keys, etc.).
+
+use anyhow::{Context, Result};
+use reqwest::Client;
+use serde::Deserialize;
+use serde_json::{json, Map, Value};
+use std::collections::HashMap;
+use std::path::Path;
+use std::time::Duration;
+use tracing::{debug, info, warn};
+
+/// Opening / closing markers of a native tool call. Written with `\u{..}`
+/// escapes so the literal tags never appear as markup in this file.
+const TOOL_CALL_OPEN: &str = "\u{3C}tool_call\u{3E}";
+const TOOL_CALL_CLOSE: &str = "\u{3C}/tool_call\u{3E}";
+
+/// One tool definition loaded from `LLM_TOOLS_FILE`.
+#[derive(Debug, Clone, Deserialize)]
+pub struct ToolSpec {
+    /// Function name the model calls (the `name` in the request's `tools`).
+    pub name: String,
+    /// Human/LLM-readable description — this is what the model uses to decide
+    /// when to call the tool, so write it carefully.
+    #[serde(default)]
+    pub description: String,
+    /// JSON Schema for the arguments. Defaults to an empty object schema.
+    #[serde(default)]
+    pub parameters: Value,
+    /// Target URL. May contain `{arg}` placeholders.
+    pub url: String,
+    /// HTTP method (`GET` or `POST`; default `POST`).
+    #[serde(default = "default_method")]
+    pub method: String,
+    /// Extra headers sent with the request (API keys, content type, …).
+    #[serde(default)]
+    pub headers: HashMap<String, String>,
+}
+
+fn default_method() -> String {
+    "POST".to_string()
+}
+
+/// A tool call parsed from the model's native output.
+#[derive(Debug, Clone, PartialEq)]
+pub struct ToolCall {
+    pub name: String,
+    /// Parsed arguments object (may be empty).
+    pub arguments: Value,
+}
+
+/// Loaded tool definitions plus the HTTP client used to execute them.
+pub struct ToolRegistry {
+    specs: Vec<ToolSpec>,
+    http: Client,
+    max_result_chars: usize,
+}
+
+impl ToolRegistry {
+    /// Load the tool list from a JSON file. Returns an error when the file is
+    /// missing, unreadable or not valid JSON.
+    pub fn load(path: &Path, timeout_secs: u64, max_result_chars: usize) -> Result<Self> {
+        let raw = std::fs::read_to_string(path)
+            .with_context(|| format!("reading tools file {}", path.display()))?;
+        let specs: Vec<ToolSpec> =
+            serde_json::from_str(&raw).with_context(|| format!("parsing tools file {}", path.display()))?;
+        if specs.is_empty() {
+            warn!(path = %path.display(), "tools file contains no tool definitions");
+        }
+        for spec in &specs {
+            if spec.name.trim().is_empty() || spec.url.trim().is_empty() {
+                warn!(name = %spec.name, "tool definition with empty name/url ignored");
+            }
+        }
+        let http = Client::builder()
+            .timeout(Duration::from_secs(timeout_secs.max(1)))
+            .build()
+            .unwrap_or_default();
+        info!(
+            path = %path.display(),
+            tools = specs.len(),
+            names = ?specs.iter().map(|s| s.name.as_str()).collect::<Vec<_>>(),
+            "tool calling enabled"
+        );
+        Ok(Self { specs, http, max_result_chars })
+    }
+
+    /// Whether any tool is defined.
+    pub fn is_empty(&self) -> bool {
+        self.specs.is_empty()
+    }
+
+    /// The OpenAI `tools` array forwarded in every chat-completions request, so
+    /// the model knows which functions it may call.
+    pub fn openai_tools(&self) -> Value {
+        Value::Array(
+            self.specs
+                .iter()
+                .map(|s| {
+                    let params = if s.parameters.is_null() {
+                        json!({ "type": "object", "properties": {} })
+                    } else {
+                        s.parameters.clone()
+                    };
+                    json!({
+                        "type": "function",
+                        "function": {
+                            "name": s.name,
+                            "description": s.description,
+                            "parameters": params,
+                        }
+                    })
+                })
+                .collect(),
+        )
+    }
+
+    /// Execute a parsed call and return the text handed back to the model.
+    /// Never fails: an unknown tool or a transport error becomes a textual
+    /// error the model can read and recover from.
+    pub async fn execute(&self, call: &ToolCall) -> String {
+        let Some(spec) = self.specs.iter().find(|s| s.name == call.name) else {
+            warn!(tool = %call.name, "model called an unknown tool");
+            return format!("Error: unknown tool '{}'", call.name);
+        };
+
+        let args = call.arguments.as_object().cloned().unwrap_or_default();
+        let method = spec.method.trim().to_ascii_uppercase();
+        let url = substitute_placeholders(&spec.url, &args);
+
+        let mut request = match method.as_str() {
+            "GET" => {
+                let mut req = self.http.get(&url);
+                // Append arguments that were not already consumed by a `{arg}`
+                // placeholder in the URL.
+                let mut used: Vec<String> = Vec::new();
+                for key in args.keys() {
+                    if spec.url.contains(&format!("{{{key}}}")) {
+                        used.push(key.clone());
+                    }
+                }
+                for (key, value) in &args {
+                    if !used.contains(key) {
+                        req = req.query(&[(key, scalar_to_string(value))]);
+                    }
+                }
+                req
+            }
+            _ => {
+                let body = Value::Object(args.clone());
+                self.http.post(&url).json(&body)
+            }
+        };
+        for (key, value) in &spec.headers {
+            request = request.header(key, substitute_placeholders(value, &args));
+        }
+
+        debug!(tool = %call.name, method = %method, url = %url, "executing tool");
+        match request.send().await {
+            Ok(resp) => {
+                let status = resp.status();
+                let body = resp.text().await.unwrap_or_default();
+                let text = truncate(&body, self.max_result_chars);
+                if !status.is_success() {
+                    warn!(tool = %call.name, status = %status, "tool returned a non-success status");
+                    format!("Error: HTTP {} — {}", status, text.trim())
+                } else {
+                    text.trim().to_string()
+                }
+            }
+            Err(e) => {
+                warn!(tool = %call.name, error = %e, "tool request failed");
+                format!("Error: tool request failed: {e}")
+            }
+        }
+    }
+}
+
+/// Replace every `{arg}` placeholder in `template` with the matching argument.
+fn substitute_placeholders(template: &str, args: &Map<String, Value>) -> String {
+    let mut out = template.to_string();
+    for (key, value) in args {
+        out = out.replace(&format!("{{{key}}}"), &scalar_to_string(value));
+    }
+    out
+}
+
+/// Render a JSON scalar as a string (numbers/booleans without quotes).
+fn scalar_to_string(value: &Value) -> String {
+    match value {
+        Value::String(s) => s.clone(),
+        other => other.to_string(),
+    }
+}
+
+/// Truncate to at most `max` characters on a char boundary.
+fn truncate(s: &str, max: usize) -> String {
+    if max == 0 || s.len() <= max {
+        return s.to_string();
+    }
+    let mut end = max;
+    while end > 0 && !s.is_char_boundary(end) {
+        end -= 1;
+    }
+    format!("{}… [truncated]", &s[..end])
+}
+
+// --- Native-format parsing --------------------------------------------------
+
+/// Remove every complete `<tool_call>…</tool_call>` block from `text` and return
+/// the visible remainder plus the parsed calls.
+///
+/// A block that is still incomplete (no closing marker yet) — and any trailing
+/// partial opening marker — is **held back**, so a tool call never leaks into
+/// the spoken/displayed text while it is still streaming in.
+pub fn split_tool_calls(text: &str) -> (String, Vec<ToolCall>) {
+    let mut visible = String::with_capacity(text.len());
+    let mut calls = Vec::new();
+    let mut rest = text;
+    loop {
+        match rest.find(TOOL_CALL_OPEN) {
+            Some(i) => {
+                visible.push_str(&rest[..i]);
+                let after = &rest[i + TOOL_CALL_OPEN.len()..];
+                match after.find(TOOL_CALL_CLOSE) {
+                    Some(j) => {
+                        if let Some(call) = parse_block(&after[..j]) {
+                            calls.push(call);
+                        }
+                        rest = &after[j + TOOL_CALL_CLOSE.len()..];
+                    }
+                    // Incomplete block: hold the remainder back for the next push.
+                    None => return (visible, calls),
+                }
+            }
+            None => {
+                // Hold back a trailing partial opening marker (e.g. `<tool_c`).
+                let hold = partial_marker_tail(rest);
+                visible.push_str(&rest[..rest.len() - hold]);
+                return (visible, calls);
+            }
+        }
+    }
+}
+
+/// Number of trailing bytes of `s` that are a proper prefix of the opening
+/// marker and therefore must not be emitted yet.
+fn partial_marker_tail(s: &str) -> usize {
+    let marker = TOOL_CALL_OPEN.as_bytes();
+    let max = marker.len().min(s.len());
+    for k in (1..=max).rev() {
+        if s.as_bytes()[s.len() - k..] == marker[..k] {
+            return k;
+        }
+    }
+    0
+}
+
+/// Parse the body of a `<tool_call>` block: a `<function=NAME>` element holding
+/// one or more `<parameter=KEY>VALUE</parameter>` elements.
+fn parse_block(body: &str) -> Option<ToolCall> {
+    let name = element_value(body, "\u{3C}function=", "\u{3E}")?;
+    let mut args = Map::new();
+    let mut rest = body;
+    while let Some(start) = rest.find("\u{3C}parameter=") {
+        let after = &rest[start + "\u{3C}parameter=".len()..];
+        let Some(gt) = after.find('\u{3E}') else { break };
+        let key = after[..gt].trim().to_string();
+        let after = &after[gt + 1..];
+        let Some(end) = after.find("\u{3C}/parameter\u{3E}") else { break };
+        let raw = after[..end].trim();
+        args.insert(key, coerce_value(raw));
+        rest = &after[end + "\u{3C}/parameter\u{3E}".len()..];
+    }
+    Some(ToolCall { name: name.trim().to_string(), arguments: Value::Object(args) })
+}
+
+/// Read the text between `open` and `close` (e.g. `<function=` … `>`).
+fn element_value(s: &str, open: &str, close: &str) -> Option<String> {
+    let start = s.find(open)? + open.len();
+    let after = &s[start..];
+    let end = after.find(close)?;
+    Some(after[..end].to_string())
+}
+
+/// Coerce a parameter value: valid JSON (number/bool/array/object) is parsed,
+/// anything else stays a string.
+fn coerce_value(raw: &str) -> Value {
+    let trimmed = raw.trim();
+    if trimmed.is_empty() {
+        return Value::String(String::new());
+    }
+    match serde_json::from_str::<Value>(trimmed) {
+        Ok(v) if !v.is_string() || trimmed.starts_with('"') => v,
+        _ => Value::String(trimmed.to_string()),
+    }
+}
+
+// --- Streaming stripper -----------------------------------------------------
+
+/// Incremental filter that turns a stream of raw model deltas into visible
+/// text, collecting every complete tool call as a side effect.
+///
+/// Like the chain-of-thought stripper in [`crate::llm`], it recomputes the
+/// clean text from the accumulated raw text on each push, so a `<tool_call>`
+/// block split across deltas is removed as a whole.
+pub struct ToolCallStripper {
+    raw: String,
+    /// Bytes of visible text already returned to the caller.
+    emitted: usize,
+    /// Tool calls found so far (recomputed on every push).
+    calls: Vec<ToolCall>,
+}
+
+impl ToolCallStripper {
+    pub fn new() -> Self {
+        Self { raw: String::new(), emitted: 0, calls: Vec::new() }
+    }
+
+    /// Feed a delta, returning the newly visible (non-tool-call) text.
+    pub fn push(&mut self, delta: &str) -> String {
+        self.raw.push_str(delta);
+        let (visible, calls) = split_tool_calls(&self.raw);
+        self.calls = calls;
+        if visible.len() <= self.emitted {
+            return String::new();
+        }
+        let out = visible[self.emitted..].to_string();
+        self.emitted = visible.len();
+        out
+    }
+
+    /// Flush whatever visible text is left once the stream has ended. A
+    /// never-completed tool-call block is dropped (it was truncated).
+    pub fn finish(&mut self) -> String {
+        let (visible, _) = split_tool_calls(&self.raw);
+        if visible.len() <= self.emitted {
+            return String::new();
+        }
+        let out = visible[self.emitted..].to_string();
+        self.emitted = visible.len();
+        out
+    }
+
+    /// Take the collected tool calls.
+    pub fn take_calls(&mut self) -> Vec<ToolCall> {
+        std::mem::take(&mut self.calls)
+    }
+}
+
+impl Default for ToolCallStripper {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn block(name: &str, params: &[(&str, &str)]) -> String {
+        let mut s = format!("{TOOL_CALL_OPEN}\n<function={name}>\n");
+        for (k, v) in params {
+            s.push_str(&format!("<parameter={k}>\n{v}\n</parameter>\n"));
+        }
+        s.push_str(&format!("</function>\n{TOOL_CALL_CLOSE}"));
+        s
+    }
+
+    #[test]
+    fn parses_native_call() {
+        let text = format!("Let me check.{}", block("get_weather", &[("city", "Paris")]));
+        let (visible, calls) = split_tool_calls(&text);
+        assert_eq!(visible, "Let me check.");
+        assert_eq!(calls.len(), 1);
+        assert_eq!(calls[0].name, "get_weather");
+        assert_eq!(calls[0].arguments["city"], "Paris");
+    }
+
+    #[test]
+    fn parses_multiple_calls_and_typed_args() {
+        let text = format!(
+            "{}{}",
+            block("a", &[("n", "3")]),
+            block("b", &[("flag", "true")])
+        );
+        let (visible, calls) = split_tool_calls(&text);
+        assert!(visible.is_empty());
+        assert_eq!(calls.len(), 2);
+        assert_eq!(calls[0].arguments["n"], 3);
+        assert_eq!(calls[1].arguments["flag"], true);
+    }
+
+    #[test]
+    fn stripper_holds_back_partial_block() {
+        let mut s = ToolCallStripper::new();
+        assert_eq!(s.push("Ciao "), "Ciao ");
+        // Partial opening marker must not leak.
+        assert_eq!(s.push("<tool_ca"), "");
+        assert_eq!(s.push("ll>\n<function=f>\n"), "");
+        assert!(s.take_calls().is_empty());
+        let tail = format!("</function>\n{TOOL_CALL_CLOSE}");
+        assert_eq!(s.push(&tail), "");
+        let calls = s.take_calls();
+        assert_eq!(calls.len(), 1);
+        assert_eq!(calls[0].name, "f");
+    }
+
+    #[test]
+    fn stripper_is_stable_across_deltas() {
+        let text = format!("Sole a Roma.{}", block("get_weather", &[("city", "Rome")]));
+        let mut s = ToolCallStripper::new();
+        let mut out = String::new();
+        for chunk in text.as_bytes().chunks(3) {
+            out.push_str(&s.push(&String::from_utf8_lossy(chunk)));
+        }
+        out.push_str(&s.finish());
+        assert_eq!(out, "Sole a Roma.");
+        let calls = s.take_calls();
+        assert_eq!(calls.len(), 1);
+        assert_eq!(calls[0].arguments["city"], "Rome");
+    }
+
+    #[test]
+    fn plain_text_passes_through_untouched() {
+        let mut s = ToolCallStripper::new();
+        assert_eq!(s.push("Nessun tool qui."), "Nessun tool qui.");
+        assert!(s.take_calls().is_empty());
+    }
+}
diff --git a/src/tts/fish_audio.rs b/src/tts/fish_audio.rs
index 7369763..e26c9c7 100644
--- a/src/tts/fish_audio.rs
+++ b/src/tts/fish_audio.rs
@@ -5,6 +5,12 @@
 //! mixer's output rate, so samples are pushed directly into the TTS queue
 //! without resampling. A [`CancellationToken`] allows immediate interruption
 //! (barge-in).
+//!
+//! Drama 3 can sound overly theatrical on some references. Two mitigations are
+//! applied here, both configurable from the environment: optional sampling
+//! knobs (`temperature` / `top_p` / `top_k`) that trim the tails of the
+//! acoustic token distribution, and a neutral style tag prepended to untagged
+//! requests so plain LLM prose is read in a conversational register.
 
 use crate::audio::SampleRingBuffer;
 use crate::config::Config;
@@ -26,6 +32,11 @@ struct Reference {
 }
 
 /// Request body for the SGLang `/v1/audio/speech` endpoint.
+///
+/// Sampling knobs are optional and only serialized when set. Drama 3 accepts
+/// `temperature`, `top_p` and `top_k` at this level; `repetition_penalty` is
+/// deliberately never sent because this server rejects any value other than
+/// `1.0` (`Drama 3 request: repetition_penalty must be 1.0`).
 #[derive(Debug, Serialize)]
 struct SpeechRequest<'a> {
     model: &'a str,
@@ -35,6 +46,12 @@ struct SpeechRequest<'a> {
     stream: bool,
     #[serde(skip_serializing_if = "Option::is_none")]
     references: Option<Vec<Reference>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    temperature: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    top_p: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    top_k: Option<u32>,
 }
 
 /// Streaming TTS client backed by Fish Audio / SGLang-Omni Drama 3.
@@ -46,6 +63,12 @@ pub struct FishAudioTts {
     voice: String,
     /// Current voice-cloning reference (config default, overridable at runtime).
     reference: Arc<parking_lot::RwLock<Option<Reference>>>,
+    /// Optional sampling overrides (de-emphasis of the recitative register).
+    temperature: Option<f32>,
+    top_p: Option<f32>,
+    top_k: Option<u32>,
+    /// Neutral style tag prepended to untagged synthesis requests.
+    style_tag: String,
 }
 
 impl FishAudioTts {
@@ -61,6 +84,13 @@ impl FishAudioTts {
                 "TTS voice-cloning reference configured"
             );
         }
+        info!(
+            temperature = ?config.tts_temperature,
+            top_p = ?config.tts_top_p,
+            top_k = ?config.tts_top_k,
+            style_tag = %config.tts_style_tag,
+            "TTS de-emphasis settings"
+        );
         Self {
             http: Client::builder()
                 .build()
@@ -69,6 +99,23 @@ impl FishAudioTts {
             model: config.tts_model.clone(),
             voice: config.tts_voice.clone(),
             reference: Arc::new(parking_lot::RwLock::new(reference)),
+            temperature: config.tts_temperature,
+            top_p: config.tts_top_p,
+            top_k: config.tts_top_k,
+            style_tag: config.tts_style_tag.clone(),
+        }
+    }
+
+    /// The text actually sent to the model: the configured neutral style tag is
+    /// prepended unless the text already opens with a style tag or the tag is
+    /// disabled. LLM replies carry no tags, so they get de-emphasized; clip
+    /// banks that start with their own tag are left untouched.
+    fn styled<'a>(&self, text: &'a str) -> std::borrow::Cow<'a, str> {
+        let tag = self.style_tag.trim();
+        if tag.is_empty() || text.trim_start().starts_with('[') {
+            std::borrow::Cow::Borrowed(text)
+        } else {
+            std::borrow::Cow::Owned(format!("{tag} {text}"))
         }
     }
 
@@ -107,14 +154,18 @@ impl TtsEngine for FishAudioTts {
         cancel: &CancellationToken,
     ) -> Result<()> {
         let references = self.reference.read().clone().map(|r| vec![r]);
+        let input = self.styled(text);
 
         let body = SpeechRequest {
             model: &self.model,
-            input: text,
+            input: &input,
             voice: &self.voice,
             response_format: "pcm",
             stream: true,
             references,
+            temperature: self.temperature,
+            top_p: self.top_p,
+            top_k: self.top_k,
         };
 
         info!(model = %self.model, text_len = text.len(), "SGLang TTS request");
@@ -125,7 +176,11 @@ impl TtsEngine for FishAudioTts {
             response_format = "pcm",
             stream = true,
             has_reference = body.references.is_some(),
-            text = %text,
+            temperature = ?self.temperature,
+            top_p = ?self.top_p,
+            top_k = ?self.top_k,
+            styled = input.len() != text.len(),
+            text = %input,
             "TTS request dispatched"
         );
 
diff --git a/src/vad/silero.rs b/src/vad/silero.rs
index 0775e37..78075d1 100644
--- a/src/vad/silero.rs
+++ b/src/vad/silero.rs
@@ -257,6 +257,17 @@ impl VadDetector {
         self.in_speech
     }
 
+    /// Milliseconds of consecutive silence accumulated *inside* the current
+    /// utterance — i.e. the length of the micro-pause the user is currently in.
+    /// Zero while voice is ongoing, and zero outside a confirmed utterance.
+    ///
+    /// Exposed so the backchannel can cue on a natural pause (between words /
+    /// phrases) instead of dropping a cue mid-word. Measured in [`WINDOW_MS`]
+    /// steps, so it is a multiple of 32 ms.
+    pub fn silence_ms(&self) -> u32 {
+        self.silence_run_ms
+    }
+
     /// Feed 16 kHz mono PCM and collect the events it triggers.
     ///
     /// Any number of samples may be pushed; internally they are buffered into
diff --git a/src/web/mivocero.html b/src/web/mivocero.html
index 4a9734f..d8f7491 100644
--- a/src/web/mivocero.html
+++ b/src/web/mivocero.html
@@ -100,6 +100,83 @@
   .meter { height: 8px; background: var(--bg); border-radius: 4px; overflow: hidden; flex: 1; }
   .meter > div { height: 100%; width: 0%; background: linear-gradient(90deg, var(--ok), var(--warn), var(--err)); transition: width .05s; }
   .meters span { font-size: 11px; color: var(--muted); white-space: nowrap; }
+  /* Cue indicators: flash + counter for filler / start filler / backchannel. */
+  .cues { display: flex; gap: 8px; margin-bottom: 10px; }
+  .cue {
+    --cue: var(--accent);
+    flex: 1;
+    min-width: 0;
+    display: flex;
+    align-items: center;
+    gap: 7px;
+    padding: 6px 9px;
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    font-size: 11px;
+    color: var(--muted);
+    transition: border-color .25s, box-shadow .25s;
+  }
+  .cue[data-kind="filler"] { --cue: var(--ok); }
+  .cue[data-kind="start_filler"] { --cue: var(--warn); }
+  .cue[data-kind="backchannel"] { --cue: var(--accent); }
+  .cue .cue-dot {
+    width: 9px; height: 9px; border-radius: 50%; flex: none;
+    background: var(--cue); opacity: .25;
+    transition: opacity .15s, box-shadow .15s, transform .15s;
+  }
+  .cue.active { border-color: var(--cue); box-shadow: 0 0 10px -2px var(--cue); }
+  .cue.active .cue-dot { opacity: 1; box-shadow: 0 0 8px var(--cue); transform: scale(1.3); }
+  .cue .cue-label { text-transform: uppercase; letter-spacing: .4px; white-space: nowrap; }
+  .cue .cue-last {
+    flex: 1 1 auto; min-width: 0; text-align: right;
+    overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+  }
+  .cue .cue-count { color: var(--text); font-weight: 600; font-variant-numeric: tabular-nums; }
+  /* Cue methods: collapsible panel with the live policy of each cue. */
+  .cuemethods {
+    margin-bottom: 10px;
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    background: var(--bg);
+    font-size: 12px;
+  }
+  .cuemethods > summary {
+    display: flex; align-items: center; gap: 8px;
+    padding: 7px 10px; cursor: pointer; list-style: none; color: var(--muted);
+  }
+  .cuemethods > summary::-webkit-details-marker { display: none; }
+  .cuemethods > summary::before {
+    content: '\25B8'; font-size: 10px; transition: transform .15s;
+  }
+  .cuemethods[open] > summary::before { transform: rotate(90deg); }
+  .cuemethods .cm-title { text-transform: uppercase; letter-spacing: .4px; color: var(--text); font-weight: 600; }
+  .cuemethods .cm-hint { margin-left: auto; color: var(--muted); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .cm-cards {
+    display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+    gap: 8px; padding: 0 10px 10px; max-height: 246px; overflow-y: auto;
+  }
+  .cm-empty { color: var(--muted); padding: 2px 0 4px; }
+  .cm-card { --cue: var(--accent); border: 1px solid var(--border); border-left: 3px solid var(--cue); border-radius: 8px; padding: 8px 10px; }
+  .cm-card[data-kind="filler"] { --cue: var(--ok); }
+  .cm-card[data-kind="start_filler"] { --cue: var(--warn); }
+  .cm-card[data-kind="backchannel"] { --cue: var(--accent); }
+  .cm-head { display: flex; align-items: center; gap: 7px; margin-bottom: 5px; }
+  .cm-head .cm-name { text-transform: uppercase; letter-spacing: .4px; font-size: 11px; color: var(--cue); font-weight: 600; }
+  .cm-head .cm-badge {
+    margin-left: auto; font-size: 10px; padding: 1px 7px; border-radius: 999px;
+    border: 1px solid var(--border); color: var(--muted);
+  }
+  .cm-head .cm-badge.on { border-color: var(--cue); color: var(--cue); }
+  .cm-head .cm-badge.off { border-color: var(--err); color: var(--err); }
+  .cm-desc { color: var(--muted); line-height: 1.45; margin-bottom: 6px; }
+  .cm-params { display: flex; flex-wrap: wrap; gap: 4px 6px; }
+  .cm-param {
+    font-size: 11px; color: var(--text);
+    background: var(--panel); border: 1px solid var(--border);
+    border-radius: 6px; padding: 1px 6px;
+  }
+  .cm-param b { color: var(--muted); font-weight: 600; }
   .composer { display: flex; gap: 8px; }
   .composer input {
     flex: 1;
@@ -110,6 +187,30 @@
     color: var(--text);
     font-size: 14px;
   }
+  .mediabar {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin-bottom: 10px;
+  }
+  .mediabar input[type="text"] {
+    flex: 1;
+    min-width: 0;
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 8px 10px;
+    color: var(--text);
+    font-size: 13px;
+  }
+  .mediabar input[type="range"] { width: 88px; accent-color: var(--accent); }
+  .mediabar .state {
+    font-size: 11px;
+    color: var(--muted);
+    white-space: nowrap;
+    min-width: 72px;
+    text-align: right;
+  }
   #log {
     display: none;
     max-height: 110px;
@@ -147,6 +248,42 @@
       <span>🎤</span><div class="meter"><div id="micMeter"></div></div>
       <span>🔊</span><div class="meter"><div id="outMeter"></div></div>
     </div>
+    <div class="cues">
+      <div class="cue" data-kind="filler" id="cueFiller" title="End-of-turn filler (latency mask)">
+        <span class="cue-dot"></span>
+        <span class="cue-label">Filler</span>
+        <span class="cue-last">—</span>
+        <span class="cue-count">0</span>
+      </div>
+      <div class="cue" data-kind="start_filler" id="cueStartFiller" title="Turn-start acknowledgment (latency mask)">
+        <span class="cue-dot"></span>
+        <span class="cue-label">Start filler</span>
+        <span class="cue-last">—</span>
+        <span class="cue-count">0</span>
+      </div>
+      <div class="cue" data-kind="backchannel" id="cueBackchannel" title="Backchannel cue while the user speaks">
+        <span class="cue-dot"></span>
+        <span class="cue-label">Backchannel</span>
+        <span class="cue-last">—</span>
+        <span class="cue-count">0</span>
+      </div>
+    </div>
+    <details class="cuemethods" id="cueMethods">
+      <summary>
+        <span class="cm-title">Cue methods</span>
+        <span class="cm-hint" id="cueMethodsHint">connect to load the live policy</span>
+      </summary>
+      <div class="cm-cards" id="cueCards">
+        <div class="cm-empty">Connect to load the live cue policy from the server.</div>
+      </div>
+    </details>
+    <div class="mediabar">
+      <input type="text" id="mediaUrl" placeholder="🎵 Audio URL / radio / YouTube…" disabled autocomplete="off" />
+      <button type="button" id="btnMediaPlay" disabled>Play</button>
+      <button type="button" id="btnMediaStop" class="danger" disabled>Stop</button>
+      <input type="range" id="mediaVol" min="0" max="150" value="60" title="External audio volume" disabled />
+      <span class="state" id="mediaState">idle</span>
+    </div>
     <form class="composer" id="composer">
       <input type="text" id="textInput" placeholder="Or type a message…" disabled autocomplete="off" />
       <button type="submit" id="btnSend" disabled>Send</button>
@@ -167,6 +304,12 @@
 //   {"type":"assistant_delta","text":"…"}   incremental assistant reply
 //   {"type":"assistant_end"}                assistant finished
 //   {"type":"error","text":"…"}             pipeline error
+//   {"type":"audio_source","state":"…", …}  external audio source status
+//   {"type":"cue","kind":"…","name":"…"}    filler / start filler / backchannel emitted
+//   {"type":"cues","lang":"…","config":{…}}  live cue policy (sent at start)
+//
+// The session closes itself after IDLE_TIMEOUT_MS without any traffic in
+// either direction (see the idle guard below).
 // ---------------------------------------------------------------------------
 
 const SAMPLE_RATE_OUT = 44100;   // server <-> client (matches the TTS rate)
@@ -174,6 +317,10 @@ const SAMPLE_RATE_IN  = 44100;
 const FRAME_MS = 20;
 const FRAME_SAMPLES = SAMPLE_RATE_IN * FRAME_MS / 1000; // 882
 
+// Disconnect the session (releasing the microphone) after this much time
+// without activity.
+const IDLE_TIMEOUT_MS = 2 * 60 * 1000;
+
 const $ = (id) => document.getElementById(id);
 const wsDot = $('connDot');
 const wsText = $('connText');
@@ -186,7 +333,20 @@ const emptyHint = $('emptyHint');
 const composer = $('composer');
 const textInput = $('textInput');
 const btnSend = $('btnSend');
+const mediaUrl = $('mediaUrl');
+const btnMediaPlay = $('btnMediaPlay');
+const btnMediaStop = $('btnMediaStop');
+const mediaVol = $('mediaVol');
+const mediaState = $('mediaState');
 const logEl = $('log');
+// Cue indicators: one tile per filler type, flashed on each server "cue" event.
+const cueEls = {
+  filler: $('cueFiller'),
+  start_filler: $('cueStartFiller'),
+  backchannel: $('cueBackchannel'),
+};
+const cueCounts = { filler: 0, start_filler: 0, backchannel: 0 };
+const cueTimers = { filler: 0, start_filler: 0, backchannel: 0 };
 
 let ws = null;
 let audioCtx = null;
@@ -496,6 +656,128 @@ function feedPlayback(arrayBuffer) {
 
 // --- WebSocket -------------------------------------------------------------
 
+// Cue indicators: flash the matching tile and bump its counter. `kind` is one
+// of "filler" | "start_filler" | "backchannel"; the detail line shows the
+// backchannel category or the clip name.
+function updateCue(ev) {
+  const el = cueEls[ev.kind];
+  if (!el) return;
+  cueCounts[ev.kind] += 1;
+  el.querySelector('.cue-count').textContent = cueCounts[ev.kind];
+  el.querySelector('.cue-last').textContent = ev.category || ev.name || '';
+  el.classList.add('active');
+  clearTimeout(cueTimers[ev.kind]);
+  cueTimers[ev.kind] = setTimeout(() => el.classList.remove('active'), 400);
+}
+
+function resetCues() {
+  for (const kind of Object.keys(cueCounts)) {
+    cueCounts[kind] = 0;
+    clearTimeout(cueTimers[kind]);
+    cueEls[kind].classList.remove('active');
+    cueEls[kind].querySelector('.cue-count').textContent = '0';
+    cueEls[kind].querySelector('.cue-last').textContent = '—';
+  }
+}
+
+// --- Cue methods panel -----------------------------------------------------
+// The method (how each cue decides to fire) plus the live parameters reported
+// by the server in the "cues" event at session start. `params` turns the
+// server payload into [label, value] chips.
+const fmt2 = (v) => (typeof v === 'number' ? v.toFixed(2) : '—');
+
+const CUE_METHODS = {
+  filler: {
+    name: 'Filler',
+    desc: 'End-of-turn latency mask. At most one clip per turn, and only when the '
+        + 'reply audio has not started within the delay — otherwise it is dropped, so '
+        + 'it never talks over the answer. Picked round-robin from the active bank.',
+    params: (c) => [
+      ['delay', c.delay_ms + ' ms'],
+      ['gain idle', fmt2(c.gain_idle)],
+      ['gain duck', fmt2(c.gain_duck)],
+      ['clips', c.clips],
+      ['bank', c.bank],
+    ],
+  },
+  start_filler: {
+    name: 'Start filler',
+    desc: 'Turn-start acknowledgment. Fires only if the first audio chunk of the '
+        + 'reply is still missing after its (shorter) delay; when audio arrives in '
+        + 'time the cue is dropped. A clip is picked at random from the bank.',
+    params: (c) => [
+      ['go delay', c.go_delay_ms + ' ms'],
+      ['clips', c.clips],
+      ['bank', c.bank],
+    ],
+  },
+  backchannel: {
+    name: 'Backchannel',
+    desc: 'While the user keeps speaking (and the agent is silent): a short ack '
+        + 'mixed at low gain. Fires only inside a natural micro-pause, at a random '
+        + 'depth in the pause window, through a probabilistic gate, with randomized '
+        + 'spacing and volume and a per-turn cap. Categories progress ack → agree.',
+    params: (c) => [
+      ['gain', fmt2(c.gain)],
+      ['min speech', c.min_speech_ms + ' ms'],
+      ['interval', c.interval_ms + ' ms'],
+      ['jitter', c.jitter_ms + ' ms'],
+      ['pause', c.pause_min_ms + '–' + c.pause_max_ms + ' ms'],
+      ['prob', fmt2(c.prob)],
+      ['vol jitter', fmt2(c.volume_jitter)],
+      ['max/turn', c.max_per_turn],
+      ['categories', (c.categories || []).join(', ')],
+      ['clips', c.clips],
+    ],
+  },
+};
+
+// Render the three cards from the server "cues" payload (live params + method).
+function renderCues(lang, cfg) {
+  const host = $('cueCards');
+  if (!host || !cfg) return;
+  host.textContent = '';
+  for (const kind of ['filler', 'start_filler', 'backchannel']) {
+    const m = CUE_METHODS[kind];
+    const c = cfg[kind];
+    if (!m || !c) continue;
+
+    const card = document.createElement('div');
+    card.className = 'cm-card';
+    card.dataset.kind = kind;
+
+    const head = document.createElement('div');
+    head.className = 'cm-head';
+    const name = document.createElement('span');
+    name.className = 'cm-name';
+    name.textContent = m.name;
+    const badge = document.createElement('span');
+    badge.className = 'cm-badge ' + (c.enabled ? 'on' : 'off');
+    badge.textContent = c.enabled ? 'on' : 'off';
+    head.append(name, badge);
+
+    const desc = document.createElement('div');
+    desc.className = 'cm-desc';
+    desc.textContent = m.desc;
+
+    const params = document.createElement('div');
+    params.className = 'cm-params';
+    for (const [k, v] of m.params(c)) {
+      const chip = document.createElement('span');
+      chip.className = 'cm-param';
+      const b = document.createElement('b');
+      b.textContent = k + ' ';
+      chip.append(b, document.createTextNode(String(v)));
+      params.append(chip);
+    }
+
+    card.append(head, desc, params);
+    host.append(card);
+  }
+  const hint = $('cueMethodsHint');
+  if (hint) hint.textContent = (lang ? 'lang ' + lang + ' · ' : '') + 'filler · start filler · backchannel';
+}
+
 function handleServerText(text) {
   let event = null;
   try { event = JSON.parse(text); } catch (e) { log('server: ' + text); return; }
@@ -515,11 +797,65 @@ function handleServerText(text) {
       addMessage('error', event.text, 'error');
       log('error: ' + event.text);
       break;
+    case 'audio_source':
+      updateMediaState(event);
+      break;
+    case 'cue':
+      updateCue(event);
+      break;
+    case 'cues':
+      renderCues(event.lang, event.config);
+      break;
     default:
       log('server: ' + text);
   }
 }
 
+// External audio source status → status label + button states.
+function updateMediaState(event) {
+  const st = event.state || '';
+  mediaState.textContent =
+    st === 'playing' ? 'playing' : st === 'loading' ? 'loading…' : st === 'error' ? 'error' : 'idle';
+  btnMediaStop.disabled = !(st === 'playing' || st === 'loading');
+  if (st === 'error') {
+    const msg = event.text || 'unknown error';
+    log('audio source error: ' + msg);
+    addMessage('error', 'Audio source error: ' + msg, 'error');
+  }
+}
+
+function setMediaControlsEnabled(on) {
+  mediaUrl.disabled = !on;
+  mediaVol.disabled = !on;
+  btnMediaPlay.disabled = !on;
+  if (!on) btnMediaStop.disabled = true;
+}
+
+// --- Idle session guard ----------------------------------------------------
+// Reset on any traffic (server audio / events) and on every user action. When
+// it expires the session is closed, which stops the microphone and re-enables
+// the Connect button. A playing external source keeps sending audio frames, so
+// it counts as activity too.
+let idleTimer = 0;
+
+function touchActivity() {
+  if (!ws) return;
+  clearTimeout(idleTimer);
+  idleTimer = setTimeout(onIdleTimeout, IDLE_TIMEOUT_MS);
+}
+
+function stopIdleWatch() {
+  clearTimeout(idleTimer);
+  idleTimer = 0;
+}
+
+function onIdleTimeout() {
+  if (!ws) return;
+  log(`idle timeout — no activity for ${IDLE_TIMEOUT_MS / 60000} min, disconnecting`);
+  addMessage('error', 'Session closed after 2 minutes of inactivity. Press Connect to resume.', 'error');
+  disconnect();
+}
+
 async function connect() {
   if (!navigator.mediaDevices?.getUserMedia) {
     const why = window.isSecureContext
@@ -546,12 +882,19 @@ async function connect() {
   ws.onopen = () => {
     setConn('on', 'connected');
     log('connected');
+    resetCues();
     btnConnect.disabled = true;
     btnInterrupt.disabled = false;
     textInput.disabled = false;
     btnSend.disabled = false;
+    setMediaControlsEnabled(true);
+    mediaState.textContent = 'idle';
+    touchActivity();
+    // Sync the server's external-audio gain with the slider.
+    sendJson({ type: 'audio_source', action: 'volume', gain: mediaVol.value / 100 });
   };
   ws.onmessage = (e) => {
+    touchActivity();
     if (e.data instanceof ArrayBuffer) {
       feedPlayback(e.data);
     } else {
@@ -560,12 +903,16 @@ async function connect() {
   };
   ws.onerror = () => { log('websocket error'); setConn('err', 'error'); };
   ws.onclose = () => {
+    stopIdleWatch();
+    ws = null;   // allow reconnecting from the Connect button
     log('disconnected');
     setConn('', 'disconnected');
     btnConnect.disabled = false;
     btnInterrupt.disabled = true;
     textInput.disabled = true;
     btnSend.disabled = true;
+    setMediaControlsEnabled(false);
+    mediaState.textContent = 'idle';
     endAgentMessage();
     stopAudio();
   };
@@ -579,6 +926,7 @@ function disconnect() {
 function sendJson(obj) {
   if (ws && ws.readyState === WebSocket.OPEN) {
     ws.send(JSON.stringify(obj));
+    touchActivity();
     return true;
   }
   return false;
@@ -592,6 +940,26 @@ btnInterrupt.onclick = () => {
   }
 };
 
+// External audio source (URL / radio / YouTube) controls.
+btnMediaPlay.onclick = () => {
+  const url = mediaUrl.value.trim();
+  if (!url) return;
+  if (sendJson({ type: 'audio_source', action: 'play', url })) {
+    mediaState.textContent = 'loading…';
+    btnMediaStop.disabled = false;
+    log('→ audio_source play ' + url);
+  }
+};
+btnMediaStop.onclick = () => {
+  if (sendJson({ type: 'audio_source', action: 'stop' })) log('→ audio_source stop');
+};
+mediaUrl.addEventListener('keydown', (e) => {
+  if (e.key === 'Enter') { e.preventDefault(); btnMediaPlay.click(); }
+});
+mediaVol.oninput = () => {
+  sendJson({ type: 'audio_source', action: 'volume', gain: mediaVol.value / 100 });
+};
+
 composer.onsubmit = (e) => {
   e.preventDefault();
   const text = textInput.value.trim();
diff --git a/src/ws/handler.rs b/src/ws/handler.rs
index da9f6cd..9ed8c8e 100644
--- a/src/ws/handler.rs
+++ b/src/ws/handler.rs
@@ -18,6 +18,9 @@ pub struct AppState {
     pub config: Arc<Config>,
     pub tts: Arc<dyn TtsEngine>,
     pub fillers: Arc<FillerBank>,
+    /// Preloaded start-filler clip, played immediately at turn start (see
+    /// [`crate::orchestrator::TurnManager`]). Empty => no immediate cue.
+    pub start_filler: Arc<FillerBank>,
     /// Preloaded backchannel clips, played while the user is speaking (see
     /// [`crate::orchestrator::backchannel`]).
     pub backchannel: Arc<FillerBank>,
diff --git a/src/ws/session.rs b/src/ws/session.rs
index 87a87bb..ff99520 100644
--- a/src/ws/session.rs
+++ b/src/ws/session.rs
@@ -1,14 +1,21 @@
 //! Per-session audio loop: receives microphone PCM, feeds the STT worker, and
 //! streams mixed 20 ms frames back to the browser on a strict ticker.
 
+use crate::assets::lang_dir;
 use crate::audio::AudioMixer;
-use crate::config::{FRAME_DURATION_MS, OUTPUT_FRAME_BYTES, OUTPUT_SAMPLE_RATE, STT_SAMPLE_RATE};
+use crate::audit::SessionAudit;
+use crate::config::{
+    Config, FRAME_DURATION_MS, OUTPUT_FRAME_BYTES, OUTPUT_SAMPLE_RATE, STT_SAMPLE_RATE,
+};
+use crate::lang::{LangBanks, LanguageState};
+use crate::media::MediaSource;
 use crate::orchestrator::{spawn_orchestrator, BackchannelScheduler, TurnManager};
 use crate::stt::{SttWorker, Transcript};
 use crate::vad::{VadDetector, VadEvent};
 use crate::ws::handler::AppState;
 use axum::extract::ws::{Message, WebSocket};
 use futures_util::{SinkExt, StreamExt};
+use serde_json::json;
 use std::sync::Arc;
 use tokio::sync::mpsc;
 use tokio::time::{interval, MissedTickBehavior};
@@ -24,6 +31,22 @@ pub async fn run_session(socket: WebSocket, state: AppState) {
 
     let (mut ws_sender, mut ws_receiver) = socket.split();
 
+    // Structured per-session audit log (see `crate::audit`). Best-effort: a
+    // disabled or unwritable sink leaves the session running unchanged. The
+    // opening record snapshots the configuration plus the runtime capabilities
+    // that are not part of `Config`.
+    let audit = Arc::new(SessionAudit::new(&state.config));
+    audit.log_start(
+        &state.config,
+        json!({
+            "stt": state.stt.is_some(),
+            "vad": state.vad.is_some(),
+            "tokenizer": state.tokenizer.is_some(),
+            "llm": state.llm.is_some(),
+            "llm_model": state.llm.as_ref().map(|l| l.model().to_string()),
+        }),
+    );
+
     // Per-session mixer and turn manager.
     let mixer = AudioMixer::new(
         MIXER_QUEUE_CAPACITY,
@@ -31,20 +54,61 @@ pub async fn run_session(socket: WebSocket, state: AppState) {
         state.config.filler_gain_idle,
         state.config.filler_gain_duck,
         state.config.backchannel.gain,
+        state.config.external_audio_gain,
     );
     // Outbound text events (chat box): the turn manager pushes JSON strings,
     // the sender task forwards them on the same WebSocket as the audio frames.
     let (out_tx, out_rx) = mpsc::unbounded_channel::<String>();
+    // Active-language clip banks, shared between the turn manager (end-of-turn
+    // and start filler) and the mic task (backchannel). The session starts on
+    // the configured default language (the base clip directories) and switches
+    // when the user's language is detected — see `crate::lang`.
+    let langs = Arc::new(LanguageState::new(
+        state.config.lang_default.clone(),
+        state.backchannel.clone(),
+        state.config.backchannel.texts.clone(),
+        state.config.backchannel.categories.clone(),
+        state.fillers.clone(),
+        state.start_filler.clone(),
+    ));
+    // Tell the client how the three cues (filler, start filler, backchannel)
+    // work and with which parameters, so the playground can show the live
+    // policy instead of hard-coded values. Sent on the outbound text channel;
+    // the payload mirrors the runtime behaviour in `turn_manager` and
+    // `orchestrator::backchannel`.
+    {
+        let banks = langs.current();
+        let _ = out_tx.send(
+            json!({
+                "type": "cues",
+                "lang": banks.lang,
+                "config": cues_config(&state.config, &banks),
+            })
+            .to_string(),
+        );
+    }
     let turn_manager = Arc::new(TurnManager::new(
         mixer.clone(),
         state.tts.clone(),
-        state.fillers.clone(),
+        langs.clone(),
         state.tokenizer.clone(),
         state.llm.clone(),
         state.config.clone(),
-        Some(out_tx),
+        Some(out_tx.clone()),
+        audit.clone(),
     ));
 
+    // External audio source (URL / radio / YouTube) feeding the mixer's own
+    // channel. It reports state events on the same outbound text channel as the
+    // chat box.
+    let media = MediaSource::new(
+        mixer.external_queue.clone(),
+        state.config.media_ffmpeg_bin.clone(),
+        state.config.media_ytdlp_bin.clone(),
+        state.config.media_ytdlp_args.clone(),
+        Some(out_tx.clone()),
+    );
+
     let vad_settings = state.config.vad.clone();
     let mut vad_detector = state.vad.as_ref().map(|model| {
         info!(
@@ -74,6 +138,8 @@ pub async fn run_session(socket: WebSocket, state: AppState) {
 
     // --- Task 1: receiver loop (mic frames + control text) ---
     let tm_for_interrupt = turn_manager.clone();
+    let media_for_control = media.clone();
+    let audit_for_recv = audit.clone();
     let receiver_handle = tokio::spawn(async move {
         while let Some(msg) = ws_receiver.next().await {
             match msg {
@@ -91,12 +157,19 @@ pub async fn run_session(socket: WebSocket, state: AppState) {
                     let _ = mic_tx.send(resampled);
                 }
                 Ok(Message::Text(text)) => {
-                    handle_control_message(&text, &tm_for_interrupt).await;
+                    handle_control_message(
+                        &text,
+                        &tm_for_interrupt,
+                        &media_for_control,
+                        &audit_for_recv,
+                    )
+                    .await;
                 }
                 Ok(Message::Close(_)) => break,
                 Ok(_) => {}
                 Err(e) => {
                     error!(error = %e, "websocket recv error");
+                    audit_for_recv.event("error", json!({ "where": "receiver", "text": e.to_string() }));
                     break;
                 }
             }
@@ -111,19 +184,38 @@ pub async fn run_session(socket: WebSocket, state: AppState) {
         let settings = vad_settings.clone();
         // Backchannel scheduler: emits short acknowledgments while the user
         // speaks (see `crate::orchestrator::backchannel`).
+        let langs_for_mic = langs.clone();
         let mut backchannel = BackchannelScheduler::new(
-            state.backchannel.clone(),
+            langs.current().backchannel.clone(),
             state.config.backchannel.clone(),
+            settings.min_silence_ms,
         );
         let mixer_for_backchannel = mixer.clone();
+        let out_tx_for_mic = out_tx.clone();
+        let audit_for_mic = audit.clone();
         tokio::spawn(async move {
             let mut frames: u64 = 0;
             let mut samples: u64 = 0;
+            let mut lang_generation = langs_for_mic.generation();
 
             while let Some(frame) = mic_rx.recv().await {
                 frames += 1;
                 samples += frame.len() as u64;
 
+                // Language switch (see `crate::lang`): repoint the backchannel
+                // at the new language's clip bank. One atomic load per frame.
+                let generation = langs_for_mic.generation();
+                if generation != lang_generation {
+                    lang_generation = generation;
+                    let banks = langs_for_mic.current();
+                    backchannel.retarget(
+                        banks.backchannel.clone(),
+                        &banks.backchannel_texts,
+                        &banks.backchannel_categories,
+                    );
+                    info!(lang = %banks.lang, "backchannel switched language");
+                }
+
                 let Some(detector) = vad_detector.as_mut() else {
                     // No VAD: the STT worker segments with its RMS detector; if
                     // STT is disabled we only report mic activity, one line per
@@ -150,6 +242,10 @@ pub async fn run_session(socket: WebSocket, state: AppState) {
                                     prob = format!("{prob:.3}"),
                                     "VAD barge-in — interrupting agent"
                                 );
+                                audit_for_mic.event(
+                                    "barge_in",
+                                    json!({ "source": "vad", "prob": prob }),
+                                );
                                 tm_for_vad.interrupt();
                             }
                         }
@@ -158,6 +254,8 @@ pub async fn run_session(socket: WebSocket, state: AppState) {
                                 prob = format!("{prob:.3}"),
                                 "VAD speech confirmed (min speech reached)"
                             );
+                            audit_for_mic
+                                .event("vad_speech_start", json!({ "prob": prob }));
                             backchannel.on_speech_start();
                         }
                         VadEvent::SpeechEnd {
@@ -165,6 +263,10 @@ pub async fn run_session(socket: WebSocket, state: AppState) {
                             duration_ms,
                             avg_prob,
                         } => {
+                            audit_for_mic.event(
+                                "vad_speech_end",
+                                json!({ "duration_ms": duration_ms, "avg_prob": avg_prob }),
+                            );
                             backchannel.on_speech_end();
                             if settings.segment_stt {
                                 match &worker_for_mic {
@@ -188,12 +290,25 @@ pub async fn run_session(socket: WebSocket, state: AppState) {
                 }
 
                 // While the user keeps speaking and the agent is silent, emit a
-                // brief acknowledgment at most at the configured intervals. The
-                // `!is_speaking()` gate avoids cuing on top of the agent's own
-                // TTS (that would be an interruption, not a backchannel).
+                // brief acknowledgment — but only on a natural micro-pause, so
+                // the cue never lands mid-word. The `!is_speaking()` gate avoids
+                // cuing on top of the agent's own TTS (that would be an
+                // interruption, not a backchannel).
                 if detector.in_speech() && !tm_for_vad.is_speaking() {
-                    if let Some(name) = backchannel.maybe_emit(&mixer_for_backchannel) {
-                        info!(clip = %name, "backchannel emitted during user speech");
+                    let pause_ms = detector.silence_ms() as u64;
+                    if let Some((name, category)) =
+                        backchannel.maybe_emit(&mixer_for_backchannel, pause_ms)
+                    {
+                        info!(clip = %name, category = %category, pause_ms, "backchannel emitted during user speech");
+                        let _ = out_tx_for_mic.send(
+                            json!({
+                                "type": "cue",
+                                "kind": "backchannel",
+                                "name": name,
+                                "category": category,
+                            })
+                            .to_string(),
+                        );
                     }
                 }
 
@@ -209,6 +324,7 @@ pub async fn run_session(socket: WebSocket, state: AppState) {
     };
 
     // --- Task 3: 20 ms sender ticker (mixed audio -> browser) ---
+    let audit_for_send = audit.clone();
     let sender_handle = tokio::spawn(async move {
         let mut ticker = interval(std::time::Duration::from_millis(FRAME_DURATION_MS));
         // Burst: if ticks are missed (event loop busy), catch up by sending
@@ -235,6 +351,11 @@ pub async fn run_session(socket: WebSocket, state: AppState) {
                 event = out_rx.recv(), if events_open => {
                     match event {
                         Some(text) => {
+                            // Audit every outbound event (chat text, assistant
+                            // deltas, cues, tool calls, media state, errors) on
+                            // its way out — this is the single tap point, so
+                            // nothing sent to the client is missed.
+                            audit_for_send.event("out", parse_event(&text));
                             if ws_sender.send(Message::Text(text)).await.is_err() {
                                 break;
                             }
@@ -250,12 +371,17 @@ pub async fn run_session(socket: WebSocket, state: AppState) {
     // Wait for the receiver to finish (client disconnect), then clean up.
     let _ = receiver_handle.await;
     // Cancel any in-flight TTS and flush audio so the synthesis task stops
-    // consuming resources after the client disconnects.
+    // consuming resources after the client disconnects. Also stop the external
+    // audio source (kills the ffmpeg/yt-dlp processes).
     turn_manager.interrupt();
+    media.stop();
     // Dropping the sender will close the socket; abort the other tasks.
     sender_handle.abort();
     mic_feed_handle.abort();
 
+    // Closing audit record: event counts + session duration.
+    audit.summary("client_disconnected");
+
     info!("session ended");
 }
 
@@ -264,13 +390,22 @@ pub async fn run_session(socket: WebSocket, state: AppState) {
 /// JSON control messages (used by the `/mivocero` chat client):
 /// - `{"type":"user_text","text":"…"}`: run a user turn through the LLM.
 /// - `{"type":"interrupt"}`: flush audio and cancel the in-flight reply.
+/// - `{"type":"audio_source","action":"play","url":"…"}`: inject an external
+///   audio source (URL / radio / YouTube) into the mixer's external channel.
+/// - `{"type":"audio_source","action":"stop"}`: stop the external source.
+/// - `{"type":"audio_source","action":"volume","gain":0.6}`: set its gain.
 ///
 /// Legacy plain-text controls (used by the playground):
 /// - `INTERRUPT` / `BAARGEIN`: flush audio and cancel TTS (barge-in).
 /// - `SET_REFERENCE:<path>|<text>`: set the voice-cloning reference.
 /// - `CLEAR_REFERENCE`: remove the voice-cloning reference.
 /// - Any other text: synthesize it as speech (TTS pipeline test).
-async fn handle_control_message(text: &str, turn_manager: &Arc<TurnManager>) {
+async fn handle_control_message(
+    text: &str,
+    turn_manager: &Arc<TurnManager>,
+    media: &Arc<MediaSource>,
+    audit: &SessionAudit,
+) {
     let trimmed = text.trim();
 
     if trimmed.starts_with('{') {
@@ -279,6 +414,10 @@ async fn handle_control_message(text: &str, turn_manager: &Arc<TurnManager>) {
                 Some("user_text") => {
                     if let Some(user_text) = value["text"].as_str() {
                         info!(text = user_text, "client text turn");
+                        audit.event(
+                            "control",
+                            json!({ "type": "user_text", "text": user_text }),
+                        );
                         // Run the turn in its own task: awaiting it here would
                         // block the receive loop for the whole LLM reply and
                         // make the session deaf to `interrupt` messages.
@@ -292,9 +431,37 @@ async fn handle_control_message(text: &str, turn_manager: &Arc<TurnManager>) {
                 }
                 Some("interrupt") => {
                     info!("client requested interrupt (json)");
+                    audit.event("interrupt", json!({ "source": "client" }));
                     turn_manager.interrupt();
                     return;
                 }
+                Some("audio_source") => {
+                    match value["action"].as_str().unwrap_or("") {
+                        "play" => {
+                            if let Some(url) = value["url"].as_str() {
+                                info!(url, "client requested external audio source");
+                                audit.event("media", json!({ "action": "play", "url": url }));
+                                media.play(url);
+                            }
+                        }
+                        "stop" => {
+                            info!("client stopped external audio source");
+                            audit.event("media", json!({ "action": "stop" }));
+                            media.stop();
+                        }
+                        "volume" => {
+                            if let Some(gain) = value["gain"].as_f64() {
+                                let gain = gain as f32;
+                                debug!(gain, "client set external audio gain");
+                                audit
+                                    .event("media", json!({ "action": "volume", "gain": gain }));
+                                turn_manager.set_external_gain(gain);
+                            }
+                        }
+                        other => debug!(action = other, "unknown audio_source action"),
+                    }
+                    return;
+                }
                 _ => {}
             }
         }
@@ -302,11 +469,13 @@ async fn handle_control_message(text: &str, turn_manager: &Arc<TurnManager>) {
 
     if trimmed == "INTERRUPT" || trimmed == "interrupt" || trimmed == "BAARGEIN" || trimmed == "bargein" {
         info!("client requested interrupt");
+        audit.event("interrupt", json!({ "source": "client_legacy" }));
         turn_manager.interrupt();
         return;
     }
     if trimmed == "CLEAR_REFERENCE" || trimmed == "clear_reference" {
         info!("client cleared voice reference");
+        audit.event("reference", json!({ "action": "clear" }));
         turn_manager.set_reference(None, None);
         return;
     }
@@ -316,19 +485,70 @@ async fn handle_control_message(text: &str, turn_manager: &Arc<TurnManager>) {
             None => (rest.trim().to_string(), None),
         };
         if path.is_empty() {
+            audit.event("reference", json!({ "action": "clear" }));
             turn_manager.set_reference(None, None);
         } else {
             info!(audio_path = %path, "client set voice reference");
+            audit.event("reference", json!({ "action": "set", "audio": path }));
             turn_manager.set_reference(Some(path), text);
         }
         return;
     }
     if !trimmed.is_empty() {
         info!(text = trimmed, "client text-to-speech request");
+        audit.event("speak", json!({ "text": trimmed }));
         turn_manager.speak(trimmed).await;
     }
 }
 
+/// Parse an outbound text event into a JSON value for the audit log. Falls back
+/// to a raw wrapper if the payload is not valid JSON (it always is, but the log
+/// must never fail on it).
+fn parse_event(text: &str) -> serde_json::Value {
+    serde_json::from_str(text).unwrap_or_else(|_| json!({ "raw": text }))
+}
+
+/// Snapshot of the three cue policies (filler, start filler, backchannel) for
+/// the playground, sent once as the `cues` event at session start. The values
+/// are the effective runtime parameters; the clip counts are those of the
+/// active language's banks. `backchannel.pause_max_ms` is already capped to the
+/// VAD end-of-utterance window, exactly like
+/// [`BackchannelScheduler::pause_max`](crate::orchestrator::BackchannelScheduler).
+fn cues_config(config: &Config, banks: &LangBanks) -> serde_json::Value {
+    let bc = &config.backchannel;
+    let pause_cap = (config.vad.min_silence_ms.saturating_sub(32) as u64).max(1);
+    json!({
+        "filler": {
+            "enabled": config.filler_enabled,
+            "delay_ms": config.filler_delay_ms,
+            "gain_idle": config.filler_gain_idle,
+            "gain_duck": config.filler_gain_duck,
+            "bank": lang_dir(&config.fillers_dir, &banks.lang).display().to_string(),
+            "clips": banks.filler.names().len(),
+        },
+        "start_filler": {
+            "enabled": config.start_filler_enabled,
+            "go_delay_ms": config.start_filler_go_delay_ms,
+            "bank": lang_dir(&config.start_filler_dir, &banks.lang).display().to_string(),
+            "clips": banks.start_filler.names().len(),
+        },
+        "backchannel": {
+            "enabled": bc.enabled,
+            "gain": bc.gain,
+            "min_speech_ms": bc.min_speech_ms,
+            "interval_ms": bc.interval_ms,
+            "jitter_ms": bc.jitter_ms,
+            "pause_min_ms": bc.pause_min_ms,
+            "pause_max_ms": bc.pause_max_ms.min(pause_cap),
+            "prob": bc.prob,
+            "volume_jitter": bc.volume_jitter,
+            "max_per_turn": bc.max_per_turn,
+            "categories": banks.backchannel_categories,
+            "clips": banks.backchannel.names().len(),
+        },
+    })
+}
+
 /// Resample a mono `i16` PCM buffer from `input_rate` to 16 kHz.
 ///
 /// Uses linear interpolation. Handles the common 16 kHz and 24 kHz cases
diff --git a/tools.example.json b/tools.example.json
new file mode 100644
index 0000000..ab19c3c
--- /dev/null
+++ b/tools.example.json
@@ -0,0 +1,37 @@
+[
+  {
+    "name": "get_weather",
+    "description": "Current weather and temperature for a city. Call this whenever the user asks about the weather, the temperature or the forecast for a specific place.",
+    "parameters": {
+      "type": "object",
+      "properties": {
+        "city": {
+          "type": "string",
+          "description": "City name, e.g. 'Paris' or 'Roma'"
+        }
+      },
+      "required": ["city"]
+    },
+    "url": "https://wttr.in/{city}?format=3",
+    "method": "GET"
+  },
+  {
+    "name": "send_webhook",
+    "description": "POST a JSON payload to the configured webhook endpoint (notification / home-automation hook).",
+    "parameters": {
+      "type": "object",
+      "properties": {
+        "message": {
+          "type": "string",
+          "description": "Text payload to send to the webhook"
+        }
+      },
+      "required": ["message"]
+    },
+    "url": "https://httpbin.org/post",
+    "method": "POST",
+    "headers": {
+      "X-Tool": "audio-agent-engine"
+    }
+  }
+]