diff --git a/README.md b/README.md
index 5cc8344..3c86f2c 100644
--- a/README.md
+++ b/README.md
@@ -1,16 +1,11 @@
 <div align="center">
   <h1>microWakeWord NVIDIA Docker Trainer UI</h1>
-  <img width="800" alt="Screenshot 2026-04-14 at 11 02 06 PM" src="https://github.com/user-attachments/assets/694f4cb7-e4d8-4e2b-80ec-b40fb41cbfff" />
+  <img width="800" alt="microWakeWord NVIDIA trainer screenshot" src="https://github.com/user-attachments/assets/694f4cb7-e4d8-4e2b-80ec-b40fb41cbfff" />
 </div>
 
-Train custom microWakeWord models in Docker with:
+Train custom microWakeWord models in Docker with NVIDIA/CUDA acceleration, generated Piper samples, device-captured samples, reviewed false-wake negatives, live training logs, and ESPHome firmware flashing.
 
-- uploaded personal voice samples
-- automatically generated Piper TTS samples
-- a browser-based trainer UI
-- live training logs in a popup console
-
-This project no longer records audio in the browser. The UI is now upload-first: users add their own audio files, the app validates or converts them, and training runs from the same page.
+Real samples come from device-captured wake audio, close misses, or manual uploads. Every saved sample is normalized to `16 kHz / mono / 16-bit PCM WAV` before training.
 
 ---
 
@@ -27,41 +22,86 @@ docker pull ghcr.io/tatertotterson/microwakeword:latest
 ```bash
 docker run -d \
   --gpus all \
-  -p 8888:8888 \
+  -p 8789:8789 \
   -v $(pwd):/data \
   ghcr.io/tatertotterson/microwakeword:latest
 ```
 
-What these flags do:
+The flags:
 
-- `--gpus all` enables GPU acceleration
-- `-p 8888:8888` exposes the trainer UI
-- `-v $(pwd):/data` persists models, downloaded voices, datasets, and personal samples
+- `--gpus all` enables GPU acceleration.
+- `-p 8789:8789` exposes the trainer UI and captured-audio endpoint.
+- `-v $(pwd):/data` persists models, downloaded voices, datasets, samples, and firmware caches.
 
-Then open:
+Open:
 
 ```text
-http://localhost:8888
+http://localhost:8789
 ```
 
 ---
 
 ## What The UI Does
 
-- Start a wake word session
-- Test TTS pronunciation
-- Upload one or many personal samples
-- Normalize uploads to `16 kHz / mono / 16-bit PCM WAV`
-- Train with or without personal samples
-- Show a popup console with live progress and logs
-
-Personal samples are optional. If none are uploaded, the trainer can still proceed with TTS-only data after confirmation.
+- `Trainer` starts a wake-word session, shows positive/negative sample counts, and launches training.
+- `Captured Audio` reviews clips sent by ESPHome sats, including wake hits, close misses, and false wakes.
+- `Samples` plays, removes, clears, and manually imports personal or negative samples.
+- `Firmware` builds the latest `microWakeWords` ESPHome YAMLs from GitHub and flashes VoicePE or Satellite1 over OTA.
+- Popup consoles show colorized training and firmware logs while long-running jobs are active.
 
 ---
 
-## Personal Samples
+## Captured Audio Workflow
 
-Accepted upload formats include:
+To collect samples from a sat, flash it with the Tater firmware from [TaterTotterson/microWakeWords](https://github.com/TaterTotterson/microWakeWords). The `Firmware` tab can build and flash the VoicePE or Satellite1 YAMLs directly from that repo.
+
+After flashing, the device exposes ESPHome entities for capture setup:
+
+- `Capture Wake Audio` toggles upload of wake-word triggers.
+- `Capture Close Misses` toggles upload of near misses.
+- `Trainer App URL` sets the trainer address, for example `http://<trainer-ip>:8789`.
+
+ESPHome devices can send raw captured audio to:
+
+```text
+/api/upload_captured_audio_raw
+```
+
+Keep the training app running and reachable at the `Trainer App URL` while capture is enabled. The sats upload clips live; if the app is stopped or the URL is wrong, captured audio will not be saved.
+
+In the `Captured Audio` tab:
+
+- play each clip from the inbox
+- mark good wake-word clips as `This is good`
+- mark bad triggers as `False wake`
+- discard clips that should not be used
+
+Approved clips move into:
+
+```text
+/data/personal_samples/
+```
+
+False wakes move into:
+
+```text
+/data/negative_samples/
+```
+
+Captured audio is boosted for easier playback in the UI, then kept in the correct training format.
+
+---
+
+## Samples
+
+The `Samples` tab is the sample library.
+
+- `Personal` samples are positive examples of the wake word.
+- `Negative` samples are reviewed false wakes or hard negatives.
+- Both can be played back and removed one at a time.
+- Manual upload is available here as an optional seed path.
+
+Accepted manual upload formats include:
 
 - WAV
 - MP3
@@ -72,97 +112,120 @@ Accepted upload formats include:
 - OPUS
 - WEBM
 
-The backend validates or converts uploads with `ffmpeg` and stores the normalized files in:
+Uploads are validated or converted with `ffmpeg` into:
 
 ```text
-/data/personal_samples/
+16 kHz / mono / 16-bit PCM WAV
 ```
 
-Notes:
+Starting a new session does not clear samples. Use the clear buttons in `Samples` if you want to remove saved personal or negative clips.
 
-- starting a new session does not clear personal samples
-- use the `Clear personal samples` button if you want to wipe them
-- any uploaded personal samples are automatically included in training
+---
+
+## Training Flow
+
+1. Enter the wake phrase in `Trainer`.
+2. Choose the language.
+3. Optionally test pronunciation with `Test TTS`.
+4. Review the positive and negative sample counts.
+5. Click `Start training`.
+6. Watch the popup training console.
+
+Personal samples are optional. Training can run with zero personal samples after confirmation, using generated TTS samples and the stock negative datasets.
+
+Reviewed negative samples are converted into `/data/work/reviewed_negative_features/` and inserted into the training YAML as a hard-negative feature set when present.
 
 ---
 
 ## Language Support
 
-The language selector is dynamic.
+The language picker is dynamic.
 
-- `en` is always available
-- non-English languages are populated from Piper voice metadata
-- when you train with a non-English language, the backend downloads all Piper ONNX voices for that selected language only
-- it does not pre-download every language
-- already-downloaded voices are reused on later runs
+- `en` is always available.
+- English keeps the existing dedicated generator model path.
+- Non-English languages are discovered from the Piper voices catalog and any local Piper voice metadata.
+- When a non-English language is selected, the trainer downloads all voices for that selected language only.
+- Already-downloaded voices are reused.
+- It does not download every language up front.
 
-English stays on its existing dedicated generator model path. Non-English languages use the selected language's ONNX Piper voices.
-
-If the Piper catalog is unavailable, already-installed local voices can still be used.
+If the upstream Piper catalog is unavailable, already-installed local voices are used when available.
 
 ---
 
-## Training Behavior
+## Dataset Behavior
 
-1. Enter the wake word
-2. Optionally test pronunciation
-3. Optionally upload personal samples
-4. Click `Start training`
-5. Watch the popup console for:
-   - selected-language voice downloads when needed
-   - sample generation progress
-   - dataset setup
-   - training progress and completion
-
-The `Open console` button lets you reopen the log window after closing it.
-
----
-
-## First Run Notes
-
-The first real training run may download large training assets into `/data`, such as:
+The first training run downloads and prepares missing training assets into `/data`, including:
 
 - Piper voices for the selected language
-- training datasets and background data
-- Python training environment dependencies
+- negative datasets and background data
+- the Python training environment
+- generated samples and augmented feature caches
 
-These are reused later unless you delete `/data`.
+After those assets are prepared, later runs reuse the local copies unless the mounted `/data` contents are deleted.
+
+---
+
+## Firmware Flashing
+
+The `Firmware` tab builds and flashes Tater firmware for supported ESPHome sats.
+
+- Downloads the latest firmware YAML templates from `TaterTotterson/microWakeWords` on GitHub.
+- Lets you choose `VoicePE` or `Satellite1`.
+- Auto-detects ESPHome devices with mDNS when available.
+- Allows manual IP or hostname entry if discovery does not find the device.
+- Saves firmware form values so you do not re-enter sounds and URLs every run.
+- Lists locally trained wake words from `/data/trained_wake_words/` for easy model selection.
+- Builds with ESPHome and flashes OTA.
+- Streams ESPHome output in a colorized firmware console.
+
+Firmware YAMLs are intentionally pulled from GitHub each time. There is no local fallback path in the trainer UI.
 
 ---
 
 ## Output Files
 
-Successful runs produce:
+Successful runs produce timestamped training output folders such as:
 
 ```text
-/data/output/<wake_word>.tflite
-/data/output/<wake_word>.json
+/data/output/<timestamp>-<wake_word>-<samples>-<steps>/<wake_word>.tflite
+/data/output/<timestamp>-<wake_word>-<samples>-<steps>/<wake_word>.json
 ```
 
-If those files already exist, the trainer creates timestamped backups before replacing them.
+The trainer also syncs firmware-ready artifacts into:
+
+```text
+/data/trained_wake_words/<wake_word>.tflite
+/data/trained_wake_words/<wake_word>.json
+```
+
+The firmware tab uses `/data/trained_wake_words/` to populate the wake-word dropdown.
 
 ---
 
 ## Resetting Everything
 
-If you want a clean slate, stop the container and remove the contents of your mounted `/data` directory.
+If you want a clean slate, stop the container and remove the contents of the mounted `/data` directory.
 
-That will remove:
+That removes:
 
 - personal samples
+- negative samples
+- captured inbox clips
 - downloaded Piper voices
 - cached datasets
 - training environments
 - trained models
+- firmware build caches
 
 ---
 
-## Notes
+## Important Notes
 
-- browser microphone recording has been removed
-- personal samples are optional
-- the server module is now `trainer_server.py`
-- the launcher script is now `run.sh`
+- Personal samples are optional.
+- Negative samples are optional but useful for reducing false wakes.
+- The UI server is `trainer_server.py`.
+- The launcher is `run.sh`.
+- Firmware capture settings live on the ESPHome device and can be toggled from the device entities after flashing.
 
 ---
 
diff --git a/cli/wake_word_sample_augmenter b/cli/wake_word_sample_augmenter
index 9e635af..83fb4c1 100644
--- a/cli/wake_word_sample_augmenter
+++ b/cli/wake_word_sample_augmenter
@@ -18,6 +18,8 @@ parser.add_argument("--output-dir", type=str, help="Wake word output dir. Defaul
 # Personal inputs/outputs (NEW)
 parser.add_argument("--personal-dir", type=str, help="Personal WAV dir. Default: <data-dir>/personal_samples", required=False)
 parser.add_argument("--personal-output-dir", type=str, help="Personal features output dir. Default: <data-dir>/work/personal_augmented_features", required=False)
+parser.add_argument("--negative-dir", type=str, help="Reviewed negative WAV dir. Default: <data-dir>/negative_samples", required=False)
+parser.add_argument("--negative-output-dir", type=str, help="Reviewed negative features output dir. Default: <data-dir>/work/reviewed_negative_features", required=False)
 
 # Dataset dirs
 parser.add_argument("--mit-rirs-16k-dir", type=str, help="MIT RIR input directory. Default: <data-dir>/training_datasets/mit_rirs_16k", required=False)
@@ -57,6 +59,17 @@ if not args.personal_output_dir:
 else:
     args.personal_output_dir = os.path.realpath(args.personal_output_dir)
 
+# Reviewed negative defaults
+if not args.negative_dir:
+    args.negative_dir = os.path.join(args.data_dir, "negative_samples")
+else:
+    args.negative_dir = os.path.realpath(args.negative_dir)
+
+if not args.negative_output_dir:
+    args.negative_output_dir = os.path.join(work_dir, "reviewed_negative_features")
+else:
+    args.negative_output_dir = os.path.realpath(args.negative_output_dir)
+
 # Dataset defaults
 if not args.mit_rirs_16k_dir:
     args.mit_rirs_16k_dir = os.path.join(args.data_dir, "training_datasets", "mit_rirs_16k")
@@ -205,7 +218,7 @@ def bind_wav_generator(clips_obj: Clips, wav_dir: str):
 
     clips_obj.audio_generator = types.MethodType(audio_generator_from_wavs, clips_obj)
 
-def generate_feature_set(input_wav_dir: str, out_root_dir: str, label: str):
+def generate_feature_set(input_wav_dir: str, out_root_dir: str, label: str, *, remove_silence: bool = True):
     files = glob.glob(os.path.join(input_wav_dir, "*.wav"))
     if not files:
         print(f"ℹ️  No WAVs found for {label} in: {input_wav_dir} (skipping)")
@@ -218,7 +231,7 @@ def generate_feature_set(input_wav_dir: str, out_root_dir: str, label: str):
         input_directory=input_wav_dir,
         file_pattern="*.wav",
         max_clip_duration_s=5,
-        remove_silence=True,
+        remove_silence=remove_silence,
         random_split_seed=10,
         split_count=0.1,
     )
@@ -263,9 +276,12 @@ def generate_feature_set(input_wav_dir: str, out_root_dir: str, label: str):
 # Wake word generated/TTS features (existing behavior)
 generate_feature_set(args.input_dir, args.output_dir, "generated")
 
-# Personal features (NEW)
+# Personal features
 generate_feature_set(args.personal_dir, args.personal_output_dir, "personal")
 
+# Reviewed false-positive / hard-negative features
+generate_feature_set(args.negative_dir, args.negative_output_dir, "reviewed negatives", remove_silence=False)
+
 END_TIME = datetime.now(timezone.utc).replace(microsecond=0)
 et = END_TIME - START_TIME
 print(f"\n{'=' * 80}")
diff --git a/cli/wake_word_sample_trainer b/cli/wake_word_sample_trainer
index f4fcda2..7abf52d 100644
--- a/cli/wake_word_sample_trainer
+++ b/cli/wake_word_sample_trainer
@@ -111,6 +111,16 @@ else
   echo "ℹ️  No personal features found at ${PERSONAL_FEATURES_DIR}/training (continuing without personal weighting)"
 fi
 
+# Reviewed false-positive features are optional hard negatives.
+REVIEWED_NEGATIVE_FEATURES_DIR="${WORK_DIR}/reviewed_negative_features"
+HAS_REVIEWED_NEGATIVE="false"
+if [ -d "${REVIEWED_NEGATIVE_FEATURES_DIR}/training" ] ; then
+  HAS_REVIEWED_NEGATIVE="true"
+  echo "✅ Found reviewed negative features: ${REVIEWED_NEGATIVE_FEATURES_DIR}/training (will weight as hard negatives)"
+else
+  echo "ℹ️  No reviewed negative features found at ${REVIEWED_NEGATIVE_FEATURES_DIR}/training (continuing with stock negatives)"
+fi
+
 cd "${WORK_DIR}"
 
 echo "===== Starting ${TRAINING_STEPS} training steps ====="
@@ -133,6 +143,7 @@ features:
   truth: true
   type: mmap
 __PERSONAL_FEATURE_MARKER__
+__REVIEWED_NEGATIVE_FEATURE_MARKER__
 - features_dir: __NEG_SPEECH__
   penalty_weight: 1.0
   sampling_weight: 12.0
@@ -208,6 +219,22 @@ else
   sed -i -e "/__PERSONAL_FEATURE_MARKER__/d" "${YAML_PATH}"
 fi
 
+# Insert/remove reviewed hard-negative block
+if [ "${HAS_REVIEWED_NEGATIVE}" = "true" ]; then
+  reviewed_negative_block="$(cat <<EOF
+- features_dir: ${REVIEWED_NEGATIVE_FEATURES_DIR}
+  penalty_weight: 1.25
+  sampling_weight: 8.0
+  truncation_strategy: random
+  truth: false
+  type: mmap
+EOF
+)"
+  perl -0777 -i -pe "s#__REVIEWED_NEGATIVE_FEATURE_MARKER__#${reviewed_negative_block}#g" "${YAML_PATH}"
+else
+  sed -i -e "/__REVIEWED_NEGATIVE_FEATURE_MARKER__/d" "${YAML_PATH}"
+fi
+
 echo "   Wrote training_parameters.yaml"
 rm -rf "${WORK_DIR}/trained_models/wakeword"
 
diff --git a/run.sh b/run.sh
index 1ef1fa8..aa73503 100644
--- a/run.sh
+++ b/run.sh
@@ -6,7 +6,7 @@ ROOTDIR="$(dirname "$(realpath "$0")")"
 # Training convention
 DATA_DIR="${DATA_DIR:-/data}"
 HOST="${REC_HOST:-0.0.0.0}"
-PORT="${REC_PORT:-8888}"
+PORT="${REC_PORT:-8789}"
 
 # Keep trainer UI deps separate from the training venv
 VENV_DIR="${DATA_DIR}/.recorder-venv"
@@ -17,6 +17,7 @@ PIN_FILE="${VENV_DIR}/.pinned_installed"
 FASTAPI_VERSION="${REC_FASTAPI_VERSION:-0.115.6}"
 UVICORN_VERSION="${REC_UVICORN_VERSION:-0.30.6}"
 PY_MULTIPART_VERSION="${REC_PY_MULTIPART_VERSION:-0.0.9}"
+ESPHOME_VERSION="${REC_ESPHOME_VERSION:-2026.4.0}"
 
 echo "microWakeWord Trainer UI (Docker)"
 echo "-> ROOTDIR:  ${ROOTDIR}"
@@ -42,10 +43,27 @@ if [[ ! -f "${PIN_FILE}" ]]; then
   ${PIP} install \
     "fastapi==${FASTAPI_VERSION}" \
     "uvicorn[standard]==${UVICORN_VERSION}" \
-    "python-multipart==${PY_MULTIPART_VERSION}"
+    "python-multipart==${PY_MULTIPART_VERSION}" \
+    "esphome==${ESPHOME_VERSION}"
   touch "${PIN_FILE}"
 else
   echo "Reusing existing trainer UI venv (no upgrades)"
+  if ! "${PY}" - "${ESPHOME_VERSION}" <<'PY' >/dev/null 2>&1
+import importlib.metadata
+import sys
+
+expected = sys.argv[1]
+installed = importlib.metadata.version("esphome")
+raise SystemExit(0 if installed == expected else 1)
+PY
+  then
+    echo "Firmware tab dependencies missing or stale; installing ESPHome firmware dependencies"
+    ${PIP} install \
+      "fastapi==${FASTAPI_VERSION}" \
+      "uvicorn[standard]==${UVICORN_VERSION}" \
+      "python-multipart==${PY_MULTIPART_VERSION}" \
+      "esphome==${ESPHOME_VERSION}"
+  fi
 fi
 
 # -----------------------------
@@ -54,6 +72,9 @@ fi
 export DATA_DIR="${DATA_DIR}"
 export STATIC_DIR="${ROOTDIR}/static"
 export PERSONAL_DIR="${DATA_DIR}/personal_samples"
+export CAPTURED_DIR="${DATA_DIR}/captured_audio"
+export NEGATIVE_DIR="${DATA_DIR}/negative_samples"
+export TRAINED_WAKE_WORDS_DIR="${DATA_DIR}/trained_wake_words"
 
 # IMPORTANT: leave training venv creation to /api/train inside trainer_server.py
 # but still set TRAIN_CMD so the server knows how to invoke training once ready
diff --git a/static/index.html b/static/index.html
index d0a668a..aa65071 100644
--- a/static/index.html
+++ b/static/index.html
@@ -67,6 +67,7 @@
 
     input[type="text"],
     input[type="number"],
+    input[type="password"],
     select {
       padding: 11px 12px;
       font-size: 15px;
@@ -77,6 +78,7 @@
       outline: none;
     }
     input[type="text"] { width: 420px; max-width: 100%; }
+    input[type="password"] { width: 260px; max-width: 100%; }
     input[type="number"] { width: 132px; }
     input::placeholder { color: rgba(236,236,241,0.36); }
 
@@ -191,6 +193,489 @@
       font-size: 13px;
     }
 
+    .field {
+      display: grid;
+      gap: 6px;
+      color: var(--muted);
+      font-size: 13px;
+    }
+
+    .field strong {
+      color: var(--text);
+      font-size: 14px;
+    }
+
+    .field input,
+    .field select {
+      width: 100%;
+    }
+
+    .firmwareGrid {
+      display: grid;
+      grid-template-columns: minmax(260px, 1fr) minmax(160px, 220px) minmax(220px, 280px);
+      gap: 12px;
+      align-items: end;
+    }
+
+    .firmwareHero {
+      position: relative;
+      overflow: hidden;
+      min-height: 176px;
+      background:
+        radial-gradient(520px 220px at 88% 0%, rgba(255,192,127,0.16), transparent 62%),
+        linear-gradient(135deg, rgba(255,138,42,0.12), rgba(255,255,255,0.035) 44%, rgba(255,255,255,0.02));
+    }
+
+    .firmwareHero::after {
+      content: "";
+      position: absolute;
+      inset: auto -80px -120px auto;
+      width: 280px;
+      height: 280px;
+      border-radius: 999px;
+      border: 1px solid rgba(255,192,127,0.12);
+      background: radial-gradient(circle, rgba(255,138,42,0.12), transparent 66%);
+      pointer-events: none;
+    }
+
+    .firmwareHero > * {
+      position: relative;
+      z-index: 1;
+    }
+
+    .firmwareKicker {
+      color: var(--orange2);
+      font-size: 12px;
+      font-weight: 700;
+      letter-spacing: 0.14em;
+      text-transform: uppercase;
+      margin-bottom: 8px;
+    }
+
+    .firmwareHero h3 {
+      font-size: clamp(24px, 4vw, 34px);
+      margin-bottom: 8px;
+    }
+
+    .firmwareHero p {
+      max-width: 680px;
+      margin-bottom: 0;
+    }
+
+    .firmwareSteps {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+      margin-top: 16px;
+    }
+
+    .firmwareStepChip {
+      display: inline-flex;
+      align-items: center;
+      gap: 8px;
+      padding: 8px 10px;
+      border-radius: 999px;
+      border: 1px solid rgba(255,255,255,0.1);
+      background: rgba(0,0,0,0.2);
+      color: var(--muted);
+      font-size: 12px;
+    }
+
+    .firmwareStepChip b {
+      color: var(--orange2);
+      font-weight: 700;
+    }
+
+    .firmwareLayout {
+      display: grid;
+      grid-template-columns: 1fr;
+      gap: 14px;
+      align-items: start;
+    }
+
+    .firmwarePanel {
+      margin-top: 0;
+    }
+
+    .firmwarePanelHeader {
+      display: flex;
+      justify-content: space-between;
+      align-items: flex-start;
+      gap: 14px;
+      margin-bottom: 2px;
+    }
+
+    .firmwarePanelTitle {
+      display: flex;
+      gap: 10px;
+      align-items: flex-start;
+    }
+
+    .firmwareStepBadge {
+      flex: 0 0 auto;
+      display: grid;
+      place-items: center;
+      width: 30px;
+      height: 30px;
+      border-radius: 11px;
+      border: 1px solid rgba(255,138,42,0.36);
+      background: rgba(255,138,42,0.12);
+      color: var(--orange2);
+      font-weight: 800;
+      font-size: 13px;
+    }
+
+    .firmwarePanel h3 {
+      margin-bottom: 4px;
+    }
+
+    .firmwarePanel p {
+      margin-bottom: 0;
+      font-size: 13px;
+    }
+
+    .firmwareTargetGrid {
+      display: grid;
+      grid-template-columns: minmax(220px, 1fr) minmax(220px, 1fr) minmax(120px, 160px);
+      gap: 12px;
+      align-items: end;
+    }
+
+    .firmwareFields {
+      margin-top: 4px;
+    }
+
+    .firmwareSettingsSection {
+      display: grid;
+      gap: 14px;
+      padding: 16px;
+      border-radius: 16px;
+      border: 1px solid rgba(255,255,255,0.08);
+      background:
+        linear-gradient(180deg, rgba(255,255,255,0.045), rgba(255,255,255,0.022)),
+        rgba(255,255,255,0.02);
+    }
+
+    .firmwareSettingsGrid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+      gap: 12px;
+      align-items: end;
+    }
+
+    .readOnlyValue {
+      min-height: 43px;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 10px;
+      padding: 11px 12px;
+      border-radius: 12px;
+      border: 1px solid rgba(255,192,127,0.18);
+      background:
+        linear-gradient(180deg, rgba(255,138,42,0.08), rgba(255,255,255,0.025)),
+        rgba(0,0,0,0.24);
+      color: var(--text);
+      font-size: 15px;
+    }
+
+    .readOnlyValue::after {
+      content: "Locked";
+      flex: 0 0 auto;
+      padding: 3px 8px;
+      border-radius: 999px;
+      border: 1px solid rgba(255,192,127,0.22);
+      color: var(--orange2);
+      background: rgba(255,138,42,0.08);
+      font-size: 11px;
+      font-weight: 700;
+      letter-spacing: 0.04em;
+      text-transform: uppercase;
+    }
+
+    .firmwareActionsPanel {
+      display: grid;
+      grid-template-columns: minmax(260px, 1fr) auto;
+      gap: 16px;
+      align-items: center;
+      margin-top: 0;
+      border-color: rgba(255,138,42,0.16);
+      background:
+        linear-gradient(135deg, rgba(255,138,42,0.1), rgba(255,255,255,0.035)),
+        var(--panel2);
+    }
+
+    .firmwareActions {
+      justify-content: flex-end;
+    }
+
+    .studioHero {
+      position: relative;
+      overflow: hidden;
+      min-height: 176px;
+      background:
+        radial-gradient(520px 220px at 88% 0%, rgba(255,192,127,0.16), transparent 62%),
+        linear-gradient(135deg, rgba(255,138,42,0.12), rgba(255,255,255,0.035) 44%, rgba(255,255,255,0.02));
+    }
+
+    .studioHero.trainerHero {
+      background:
+        radial-gradient(560px 240px at 88% 0%, rgba(255,192,127,0.15), transparent 62%),
+        radial-gradient(360px 220px at 4% 92%, rgba(57,212,160,0.08), transparent 64%),
+        linear-gradient(135deg, rgba(255,138,42,0.12), rgba(255,255,255,0.035) 44%, rgba(255,255,255,0.02));
+    }
+
+    .studioHero.captureHero {
+      background:
+        radial-gradient(540px 220px at 84% 0%, rgba(137,212,255,0.12), transparent 62%),
+        radial-gradient(420px 260px at 0% 88%, rgba(255,138,42,0.1), transparent 66%),
+        linear-gradient(135deg, rgba(255,255,255,0.055), rgba(255,138,42,0.06) 46%, rgba(255,255,255,0.02));
+    }
+
+    .studioHero::after {
+      content: "";
+      position: absolute;
+      inset: auto -80px -120px auto;
+      width: 280px;
+      height: 280px;
+      border-radius: 999px;
+      border: 1px solid rgba(255,192,127,0.12);
+      background: radial-gradient(circle, rgba(255,138,42,0.12), transparent 66%);
+      pointer-events: none;
+    }
+
+    .studioHero > * {
+      position: relative;
+      z-index: 1;
+    }
+
+    .studioKicker {
+      color: var(--orange2);
+      font-size: 12px;
+      font-weight: 700;
+      letter-spacing: 0.14em;
+      text-transform: uppercase;
+      margin-bottom: 8px;
+    }
+
+    .studioHero h3 {
+      font-size: clamp(24px, 4vw, 34px);
+      margin-bottom: 8px;
+    }
+
+    .studioHero p {
+      max-width: 700px;
+      margin-bottom: 0;
+    }
+
+    .studioSteps {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+      margin-top: 16px;
+    }
+
+    .studioStepChip {
+      display: inline-flex;
+      align-items: center;
+      gap: 8px;
+      padding: 8px 10px;
+      border-radius: 999px;
+      border: 1px solid rgba(255,255,255,0.1);
+      background: rgba(0,0,0,0.2);
+      color: var(--muted);
+      font-size: 12px;
+    }
+
+    .studioStepChip b {
+      color: var(--orange2);
+      font-weight: 700;
+    }
+
+    .studioPanel {
+      margin-top: 0;
+    }
+
+    .studioPanelHeader {
+      display: flex;
+      justify-content: space-between;
+      align-items: flex-start;
+      gap: 14px;
+    }
+
+    .studioPanelTitle {
+      display: flex;
+      gap: 10px;
+      align-items: flex-start;
+    }
+
+    .studioStepBadge {
+      flex: 0 0 auto;
+      display: grid;
+      place-items: center;
+      width: 30px;
+      height: 30px;
+      border-radius: 11px;
+      border: 1px solid rgba(255,138,42,0.36);
+      background: rgba(255,138,42,0.12);
+      color: var(--orange2);
+      font-weight: 800;
+      font-size: 13px;
+    }
+
+    .studioPanel h3 {
+      margin-bottom: 4px;
+    }
+
+    .studioPanel p,
+    .studioActionsPanel p {
+      margin-bottom: 0;
+      font-size: 13px;
+    }
+
+    .phraseGrid {
+      display: grid;
+      grid-template-columns: minmax(260px, 1fr) minmax(180px, 240px) auto;
+      gap: 12px;
+      align-items: end;
+    }
+
+    .phraseActions {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 10px;
+      align-items: center;
+    }
+
+    .sampleProgressCard {
+      padding: 14px;
+      border-radius: 16px;
+      border: 1px solid rgba(255,255,255,0.08);
+      background:
+        linear-gradient(180deg, rgba(255,255,255,0.04), rgba(255,255,255,0.02)),
+        rgba(255,255,255,0.02);
+    }
+
+    .studioActionsPanel {
+      display: grid;
+      gap: 16px;
+      margin-top: 0;
+      border-color: rgba(255,138,42,0.16);
+      background:
+        linear-gradient(135deg, rgba(255,138,42,0.1), rgba(255,255,255,0.035)),
+        var(--panel2);
+    }
+
+    .capturedControlPanel {
+      display: grid;
+      grid-template-columns: minmax(260px, 1fr) auto;
+      gap: 16px;
+      align-items: center;
+    }
+
+    .capturedActions {
+      justify-content: flex-end;
+    }
+
+    .sampleLibraryHeader {
+      display: grid;
+      grid-template-columns: minmax(260px, 1fr) auto;
+      gap: 16px;
+      align-items: center;
+    }
+
+    .sampleTypeTabs {
+      display: inline-flex;
+      flex-wrap: wrap;
+      gap: 8px;
+      padding: 6px;
+      border-radius: 999px;
+      border: 1px solid rgba(255,255,255,0.08);
+      background: rgba(0,0,0,0.18);
+    }
+
+    .sampleTypeBtn {
+      min-width: 124px;
+      padding: 8px 12px;
+      border-radius: 999px;
+      font-size: 13px;
+      background: transparent;
+    }
+
+    .sampleTypeBtn.active {
+      border-color: rgba(255,138,42,0.42);
+      background: rgba(255,138,42,0.16);
+      color: var(--orange2);
+    }
+
+    .tabs {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 10px;
+      margin: 4px 0 0;
+    }
+
+    .tabBtn {
+      min-width: 140px;
+      border-radius: 999px;
+      background: rgba(255,255,255,0.04);
+    }
+
+    .tabBtn.active {
+      border-color: rgba(255,138,42,0.42);
+      background: linear-gradient(180deg, rgba(255,138,42,0.2), rgba(255,138,42,0.08));
+      color: var(--orange2);
+    }
+
+    .viewStack[hidden] {
+      display: none !important;
+    }
+
+    .capturedList {
+      display: grid;
+      gap: 12px;
+    }
+
+    .captureCard {
+      display: grid;
+      gap: 12px;
+      padding: 14px;
+      border-radius: 16px;
+      border: 1px solid rgba(255,255,255,0.08);
+      background: rgba(255,255,255,0.03);
+    }
+
+    .captureTitle {
+      margin: 0;
+      font-size: 16px;
+      font-weight: 700;
+    }
+
+    .captureSubtitle {
+      margin: 4px 0 0;
+      color: var(--muted);
+      font-size: 13px;
+    }
+
+    .audioPlayer {
+      width: 100%;
+      border-radius: 12px;
+    }
+
+    .captureActions {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 10px;
+    }
+
+    .emptyState {
+      padding: 18px;
+      border-radius: 16px;
+      border: 1px dashed rgba(255,255,255,0.12);
+      background: rgba(255,255,255,0.03);
+      color: var(--muted);
+    }
+
     .consoleOverlay {
       position: fixed;
       inset: 0;
@@ -201,13 +686,15 @@
       background: rgba(4, 5, 10, 0.5);
       backdrop-filter: blur(10px);
       opacity: 0;
+      visibility: hidden;
       pointer-events: none;
-      transition: opacity 0.18s ease;
-      z-index: 50;
+      transition: opacity 0.18s ease, visibility 0.18s ease;
+      z-index: 10000;
     }
 
     .consoleOverlay.open {
       opacity: 1;
+      visibility: visible;
       pointer-events: auto;
     }
 
@@ -292,6 +779,157 @@
       margin-top: 2px;
     }
 
+    .firmwareLogModal {
+      position: fixed;
+      inset: 0;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 20px;
+      background: rgba(0, 0, 0, 0.64);
+      opacity: 0;
+      visibility: hidden;
+      pointer-events: none;
+      z-index: 12000;
+    }
+
+    .firmwareLogModal.active {
+      visibility: visible;
+      pointer-events: auto;
+      animation: firmwareLogBackdropIn 280ms ease-out both;
+    }
+
+    .firmwareLogDialog {
+      width: min(1320px, 98vw);
+      height: min(94vh, 1040px);
+      display: flex;
+      flex-direction: column;
+      gap: 12px;
+      padding: 18px;
+      border-radius: 22px;
+      border: 1px solid rgba(255,255,255,0.12);
+      background:
+        linear-gradient(180deg, rgba(17, 20, 28, 0.88), rgba(8, 10, 16, 0.96)),
+        rgba(8, 10, 16, 0.88);
+      box-shadow: 0 28px 84px rgba(0,0,0,0.58);
+      backdrop-filter: blur(18px) saturate(1.12);
+      overflow: hidden;
+      opacity: 0;
+      transform: translateY(14px) scale(0.97);
+    }
+
+    .firmwareLogModal.active .firmwareLogDialog {
+      animation: firmwareLogDialogIn 300ms cubic-bezier(0.2, 0.8, 0.2, 1) both;
+    }
+
+    .firmwareLogHeader {
+      display: flex;
+      justify-content: space-between;
+      align-items: flex-start;
+      gap: 16px;
+    }
+
+    .firmwareLogTitle {
+      margin: 0;
+      font-size: 18px;
+    }
+
+    .firmwareLogMeta {
+      margin: 6px 0 0;
+      color: var(--muted);
+      font-size: 13px;
+    }
+
+    .firmwareLogStatus {
+      color: #b7c7e6;
+      font-size: 13px;
+    }
+
+    .firmwareLogConsole {
+      flex: 1 1 auto;
+      min-height: 0;
+      overflow: auto;
+      border: 1px solid rgba(255,138,42,0.22);
+      border-radius: 16px;
+      padding: 12px 14px;
+      background:
+        linear-gradient(180deg, rgba(15, 18, 25, 0.98), rgba(10, 12, 18, 0.98)),
+        radial-gradient(circle at top, rgba(255,138,42,0.08), transparent 40%);
+      box-shadow:
+        inset 0 1px 0 rgba(255,255,255,0.05),
+        inset 0 -1px 0 rgba(0,0,0,0.35);
+      font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+      font-size: 13px;
+      line-height: 1.45;
+      color: #dbe8ff;
+    }
+
+    .firmwareLogLine {
+      display: grid;
+      grid-template-columns: auto minmax(0, 1fr);
+      gap: 10px;
+      align-items: start;
+      padding: 2px 0;
+    }
+
+    .firmwareLogLevel {
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      min-width: 58px;
+      border-radius: 999px;
+      padding: 2px 8px;
+      font-size: 11px;
+      font-weight: 800;
+      letter-spacing: 0.04em;
+      border: 1px solid rgba(255,255,255,0.12);
+      white-space: nowrap;
+    }
+
+    .firmwareLogMessage {
+      white-space: pre-wrap;
+      word-break: break-word;
+    }
+
+    .firmwareLogLine.tone-info .firmwareLogLevel {
+      background: rgba(70, 120, 255, 0.16);
+      border-color: rgba(108, 152, 255, 0.28);
+      color: #bdd3ff;
+    }
+
+    .firmwareLogLine.tone-warn .firmwareLogLevel {
+      background: rgba(245, 167, 36, 0.14);
+      border-color: rgba(245, 167, 36, 0.32);
+      color: #ffd696;
+    }
+
+    .firmwareLogLine.tone-error .firmwareLogLevel {
+      background: rgba(226, 76, 76, 0.15);
+      border-color: rgba(255, 111, 111, 0.34);
+      color: #ffc1c1;
+    }
+
+    .firmwareLogLine.tone-debug .firmwareLogLevel {
+      background: rgba(92, 214, 178, 0.14);
+      border-color: rgba(92, 214, 178, 0.28);
+      color: #bffff0;
+    }
+
+    .firmwareLogEmpty {
+      color: var(--muted);
+    }
+
+    @keyframes firmwareLogBackdropIn {
+      from { opacity: 0; }
+      to { opacity: 1; }
+    }
+
+    @keyframes firmwareLogDialogIn {
+      from { opacity: 0; transform: translateY(14px) scale(0.97); }
+      62% { transform: translateY(-3px) scale(1.01); }
+      to { opacity: 1; transform: translateY(0) scale(1); }
+    }
+
     .consoleMuted { color: #93a0b5; }
     .consoleText { color: #d8e2f1; }
     .consoleCmd { color: #89d4ff; }
@@ -312,12 +950,63 @@
       .wrap { padding: 18px 14px 30px; }
       input[type="text"] { width: 100%; }
       .fileItem { align-items: flex-start; flex-direction: column; }
+      .firmwareGrid { grid-template-columns: 1fr; }
+      .firmwareLayout,
+      .firmwareTargetGrid,
+      .firmwareActionsPanel {
+        grid-template-columns: 1fr;
+      }
+      .firmwareActions {
+        justify-content: stretch;
+      }
+      .firmwareActions button {
+        width: 100%;
+      }
+      .studioPanelHeader,
+      .capturedControlPanel {
+        grid-template-columns: 1fr;
+      }
+      .studioPanelHeader,
+      .capturedControlPanel {
+        flex-direction: column;
+        align-items: stretch;
+      }
+      .phraseGrid {
+        grid-template-columns: 1fr;
+      }
+      .phraseActions,
+      .capturedActions {
+        justify-content: stretch;
+      }
+      .phraseActions button,
+      .capturedActions button {
+        width: 100%;
+      }
+      .sampleLibraryHeader {
+        grid-template-columns: 1fr;
+      }
       .consoleOverlay { padding: 12px; }
       .consoleWindow {
         width: 100%;
         height: min(82vh, 760px);
         padding: 14px;
       }
+      .firmwareLogModal {
+        padding: 12px;
+      }
+      .firmwareLogDialog {
+        width: 100%;
+        height: 88vh;
+        padding: 14px;
+      }
+      .firmwareLogHeader {
+        flex-direction: column;
+        align-items: stretch;
+      }
+      .firmwareLogLine {
+        grid-template-columns: 1fr;
+        gap: 4px;
+      }
       .consoleHeader {
         flex-direction: column;
         align-items: stretch;
@@ -340,80 +1029,342 @@
       <div class="brand">
         <div class="logo"></div>
         <div>
-          <h1>microWakeWord Personal Samples</h1>
-          <p>Start a session, upload your own recorded voice samples, and the app will validate or convert them into the training format used by the existing pipeline.</p>
+          <h1>microWakeWord Trainer Studio</h1>
+          <p>Train wake words, review captured clips, and flash ESPHome firmware from one local workspace.</p>
         </div>
       </div>
     </div>
 
-    <div class="card stack">
-      <div class="row">
-        <input id="phrase" type="text" placeholder='e.g. "tater totterson"' />
-        <button id="startSessionBtn" class="primary">Start session</button>
-        <button id="ttsBtn" disabled>Test TTS</button>
-        <span id="sessionPill" class="pill">No session</span>
-      </div>
-
-      <div class="row">
-        <label class="muted">Language
-          <select id="language">
-            <option value="en" selected>English (en)</option>
-          </select>
-        </label>
-      </div>
+    <div class="tabs">
+      <button id="tabTrainer" class="tabBtn active" type="button">Trainer</button>
+      <button id="tabCaptured" class="tabBtn" type="button">Captured Audio</button>
+      <button id="tabSamples" class="tabBtn" type="button">Samples</button>
+      <button id="tabFirmware" class="tabBtn" type="button">Firmware</button>
     </div>
 
-    <div class="card stack">
-      <div class="row space">
-        <div>
-          <h3>Optional Personal Samples</h3>
-          <p>Personal samples are optional. You can train with TTS only, or upload your own audio here and it will be saved into <code>personal_samples/</code> as 16 kHz mono 16-bit PCM WAV.</p>
-        </div>
-        <span id="status" class="pill">Idle</span>
-      </div>
-
-      <div class="dropzone">
-        <div>
-          <strong>Select one or many files</strong>
-          <p class="muted" style="margin-top:6px;">WAV, MP3, M4A, FLAC, OGG, AAC, OPUS, and WEBM are all fine when ffmpeg is available. Files already in the correct format are kept as-is.</p>
-        </div>
-        <input id="sampleFiles" type="file" accept="audio/*,.wav,.mp3,.m4a,.flac,.ogg,.aac,.webm,.opus" multiple />
-        <span id="selectedPill" class="pill">No files selected</span>
-      </div>
-
-      <div class="row">
-        <button id="uploadBtn" class="primary" disabled>Upload selected samples</button>
-        <button id="clearBtn" disabled>Clear personal samples</button>
-      </div>
-
-      <div class="stack">
+    <div id="trainerView" class="viewStack stack">
+      <div class="card studioHero trainerHero">
         <div class="row space">
-          <strong id="progressLabel">No upload in progress</strong>
-          <span id="progressPct" class="muted">0%</span>
+          <div>
+            <div class="studioKicker">Training Studio</div>
+            <h3>Build a Personal Wake Word</h3>
+            <p>Start with a phrase, review your positive and negative sample counts, then launch the training pipeline with a live console so every step is visible.</p>
+            <div class="studioSteps" aria-label="Training steps">
+              <span class="studioStepChip"><b>1</b> Phrase + voice</span>
+              <span class="studioStepChip"><b>2</b> Review sample counts</span>
+              <span class="studioStepChip"><b>3</b> Train model</span>
+            </div>
+          </div>
         </div>
-        <div class="progressShell">
-          <div id="progressFill" class="progressFill"></div>
-        </div>
-        <div id="progressDetail" class="muted">When you upload, each file is checked and converted only if needed before it is written into <code>personal_samples/</code>.</div>
       </div>
 
-      <div class="statGrid">
-        <div class="stat">
-          <span class="label">Uploaded</span>
-          <span class="value" id="uploadedCount">0</span>
+      <section class="card studioPanel stack">
+        <div class="studioPanelHeader">
+          <div class="studioPanelTitle">
+            <span class="studioStepBadge">1</span>
+            <div>
+              <h3>Phrase + Voice</h3>
+              <p>Name the wake phrase and choose the language/voice set used to generate training audio.</p>
+            </div>
+          </div>
+          <span id="sessionPill" class="pill">No session</span>
         </div>
-        <div class="stat">
-          <span class="label">Training Format</span>
-          <span class="value" style="font-size:18px;">16 kHz / mono / 16-bit WAV</span>
+
+        <div class="phraseGrid">
+          <label class="field">
+            <strong>Wake Phrase</strong>
+            <input id="phrase" type="text" placeholder='e.g. "tater totterson"' />
+          </label>
+          <label class="field">
+            <strong>Language</strong>
+            <select id="language">
+              <option value="en" selected>English (en)</option>
+            </select>
+          </label>
+          <div class="phraseActions">
+            <button id="startSessionBtn" class="primary">Start session</button>
+            <button id="ttsBtn" disabled>Test TTS</button>
+          </div>
+        </div>
+      </section>
+
+      <section class="card studioActionsPanel">
+        <div class="studioPanelHeader">
+          <div class="studioPanelTitle">
+            <span class="studioStepBadge">2</span>
+            <div>
+              <h3>Train Wake Word</h3>
+              <p>Device-captured positives and reviewed negatives are used when present. Manual samples are managed from the Samples tab.</p>
+            </div>
+          </div>
+          <span id="trainState" class="pill">Not started</span>
+        </div>
+        <div class="statGrid">
+          <div class="stat">
+            <span class="label">Positive Samples</span>
+            <span class="value" id="positiveSampleCount">0</span>
+          </div>
+          <div class="stat">
+            <span class="label">Negative Samples</span>
+            <span class="value" id="negativeTrainingCount">0</span>
+          </div>
+          <div class="stat">
+            <span class="label">Training Format</span>
+            <span class="value" style="font-size:18px;">16 kHz / mono / 16-bit WAV</span>
+          </div>
+        </div>
+        <div class="trainAction">
+          <button id="trainBtn" class="primary" disabled>Start training</button>
+        </div>
+        <div class="trainFooter">
+          <span class="muted">The training console opens automatically when a run starts.</span>
+          <button id="openConsoleBtn" disabled>Open console</button>
+        </div>
+      </section>
+    </div>
+
+    <div id="capturedView" class="viewStack stack" hidden>
+      <div class="card studioHero captureHero">
+        <div class="row space">
+          <div>
+            <div class="studioKicker">Capture Review</div>
+            <h3>Captured Audio</h3>
+            <p>Listen to clips sent by your sats, turn good wake-word examples into personal samples, and save false positives as negatives for the next training run.</p>
+            <div class="studioSteps" aria-label="Captured audio review steps">
+              <span class="studioStepChip"><b>1</b> Review inbox</span>
+              <span class="studioStepChip"><b>2</b> Listen + sort</span>
+              <span class="studioStepChip"><b>3</b> Retrain smarter</span>
+            </div>
+          </div>
+          <span id="capturedStatus" class="pill">Inbox idle</span>
         </div>
       </div>
-      <div class="trainAction">
-        <button id="trainBtn" class="primary" disabled>Start training</button>
+
+      <section class="card studioPanel stack">
+        <div class="capturedControlPanel">
+          <div class="studioPanelTitle">
+            <span class="studioStepBadge">1</span>
+            <div>
+              <h3>Review Queue</h3>
+              <p>Refresh clips from the trainer inbox and keep an eye on how many reviewed negatives and personal samples are ready.</p>
+            </div>
+          </div>
+          <div class="row capturedActions">
+            <button id="refreshCapturedBtn" type="button">Refresh inbox</button>
+          </div>
+        </div>
+
+        <div class="statGrid">
+          <div class="stat">
+            <span class="label">Inbox</span>
+            <span class="value" id="capturedCount">0</span>
+          </div>
+          <div class="stat">
+            <span class="label">Reviewed Negatives</span>
+            <span class="value" id="negativeCount">0</span>
+          </div>
+          <div class="stat">
+            <span class="label">Personal Samples</span>
+            <span class="value" id="capturedPersonalCount">0</span>
+          </div>
+        </div>
+      </section>
+
+      <section class="card studioPanel stack">
+        <div class="studioPanelHeader">
+          <div class="studioPanelTitle">
+            <span class="studioStepBadge">2</span>
+            <div>
+              <h3>Listen + Sort</h3>
+              <p>Approve strong wake-word clips into personal samples, or mark false positives as reviewed negatives.</p>
+            </div>
+          </div>
+        </div>
+        <div id="capturedList" class="capturedList">
+          <div class="emptyState">No captured audio yet.</div>
+        </div>
+      </section>
+    </div>
+
+    <div id="samplesView" class="viewStack stack" hidden>
+      <div class="card studioHero captureHero">
+        <div class="row space">
+          <div>
+            <div class="studioKicker">Sample Library</div>
+            <h3>Current Training Samples</h3>
+            <p>Listen to saved positive and negative samples, remove anything that does not belong, or manually import seed recordings when you need a starting point.</p>
+            <div class="studioSteps" aria-label="Sample library steps">
+              <span class="studioStepChip"><b>1</b> Review positives</span>
+              <span class="studioStepChip"><b>2</b> Review negatives</span>
+              <span class="studioStepChip"><b>3</b> Optional import</span>
+            </div>
+          </div>
+          <span id="status" class="pill">Samples idle</span>
+        </div>
       </div>
-      <div class="trainFooter">
-        <span id="trainState" class="pill">Not started</span>
-        <button id="openConsoleBtn" disabled>Open console</button>
+
+      <section class="card studioPanel stack">
+        <div class="sampleLibraryHeader">
+          <div class="studioPanelTitle">
+            <span class="studioStepBadge">1</span>
+            <div>
+              <h3>Saved Samples</h3>
+              <p>Personal samples are positive examples. Negative samples are false wakes and hard negatives.</p>
+            </div>
+          </div>
+          <div class="sampleTypeTabs" aria-label="Sample type tabs">
+            <button id="sampleTabPersonal" class="sampleTypeBtn active" type="button">Personal <span id="samplePersonalCount">0</span></button>
+            <button id="sampleTabNegative" class="sampleTypeBtn" type="button">Negative <span id="sampleNegativeCount">0</span></button>
+          </div>
+        </div>
+
+        <div class="row">
+          <button id="refreshSamplesBtn" type="button">Refresh samples</button>
+          <button id="clearBtn" type="button" disabled>Clear personal samples</button>
+          <button id="clearNegativeBtn" type="button" disabled>Clear negative samples</button>
+        </div>
+
+        <div id="sampleLibraryList" class="capturedList">
+          <div class="emptyState">No samples saved yet.</div>
+        </div>
+      </section>
+
+      <section class="card studioPanel stack">
+        <div class="studioPanelHeader">
+          <div class="studioPanelTitle">
+            <span class="studioStepBadge">2</span>
+            <div>
+              <h3>Manual Sample Import</h3>
+              <p>Optional backup path for seeding positives before your device has captured enough real wake audio.</p>
+            </div>
+          </div>
+        </div>
+
+        <div class="dropzone">
+          <div>
+            <strong>Select one or many files</strong>
+            <p class="muted" style="margin-top:6px;">WAV, MP3, M4A, FLAC, OGG, AAC, OPUS, and WEBM are all fine when ffmpeg is available. Files are converted into <code>personal_samples/</code>.</p>
+          </div>
+          <input id="sampleFiles" type="file" accept="audio/*,.wav,.mp3,.m4a,.flac,.ogg,.aac,.webm,.opus" multiple />
+          <span id="selectedPill" class="pill">No files selected</span>
+        </div>
+
+        <div class="row">
+          <button id="uploadBtn" class="primary" disabled>Upload selected samples</button>
+        </div>
+
+        <div class="sampleProgressCard stack">
+          <div class="row space">
+            <strong id="progressLabel">No upload in progress</strong>
+            <span id="progressPct" class="muted">0%</span>
+          </div>
+          <div class="progressShell">
+            <div id="progressFill" class="progressFill"></div>
+          </div>
+          <div id="progressDetail" class="muted">When you upload, each file is checked and converted only if needed before it is written into <code>personal_samples/</code>.</div>
+        </div>
+      </section>
+    </div>
+
+    <div id="firmwareView" class="viewStack stack" hidden>
+      <div class="card firmwareHero">
+        <div class="row space">
+          <div>
+            <div class="firmwareKicker">Firmware Studio</div>
+            <h3>ESPHome Firmware Flasher</h3>
+            <p>Build a <code>microWakeWords</code> ESPHome firmware template and flash it to a sat over OTA. Auto-detect is best effort; if the device does not show up, enter its IP or hostname manually.</p>
+            <div class="firmwareSteps" aria-label="Firmware flashing steps">
+              <span class="firmwareStepChip"><b>1</b> Pick firmware</span>
+              <span class="firmwareStepChip"><b>2</b> Select target</span>
+              <span class="firmwareStepChip"><b>3</b> Review settings</span>
+              <span class="firmwareStepChip"><b>4</b> Build + flash</span>
+            </div>
+          </div>
+          <span id="firmwareStatus" class="pill">Flasher idle</span>
+        </div>
       </div>
+
+      <div class="firmwareLayout">
+        <section class="card firmwarePanel stack">
+          <div class="firmwarePanelHeader">
+            <div class="firmwarePanelTitle">
+              <span class="firmwareStepBadge">1</span>
+              <div>
+                <h3>Firmware YAML</h3>
+                <p>Choose the VoicePE or Sat1 YAML to build from the shared firmware repo.</p>
+              </div>
+            </div>
+          </div>
+          <label class="field">
+            <strong>YAML File</strong>
+            <select id="firmwareTemplate">
+              <option value="">Loading templates...</option>
+            </select>
+          </label>
+        </section>
+
+        <section class="card firmwarePanel stack">
+          <div class="firmwarePanelHeader">
+            <div class="firmwarePanelTitle">
+              <span class="firmwareStepBadge">2</span>
+              <div>
+                <h3>Target Device</h3>
+                <p>Auto-detect a device or enter the OTA target manually.</p>
+              </div>
+            </div>
+            <span id="firmwareDetectStatus" class="pill">Not scanned</span>
+          </div>
+          <div class="row">
+            <button id="refreshFirmwareBtn" type="button">Auto-detect ESPHome devices</button>
+          </div>
+          <div class="firmwareTargetGrid">
+            <label class="field">
+              <strong>Detected Device</strong>
+              <select id="firmwareDeviceSelect">
+                <option value="">No devices scanned yet</option>
+              </select>
+            </label>
+            <label class="field">
+              <strong>Device IP or Hostname</strong>
+              <input id="firmwareHost" type="text" placeholder="e.g. 10.4.20.139 or tatervpe.local" />
+            </label>
+            <label class="field">
+              <strong>OTA Port</strong>
+              <input id="firmwarePort" type="number" min="1" max="65535" value="3232" />
+            </label>
+          </div>
+        </section>
+      </div>
+
+      <section class="card firmwarePanel stack">
+        <div class="firmwarePanelHeader">
+          <div class="firmwarePanelTitle">
+            <span class="firmwareStepBadge">3</span>
+            <div>
+              <h3>Device Settings</h3>
+              <p>These values come from the selected YAML substitutions and are saved for the next flash.</p>
+            </div>
+          </div>
+        </div>
+        <div id="firmwareFields" class="firmwareFields stack">
+          <div class="emptyState">Firmware template settings will appear here.</div>
+        </div>
+      </section>
+
+      <section class="card firmwareActionsPanel">
+        <div class="firmwarePanelTitle">
+          <span class="firmwareStepBadge">4</span>
+          <div>
+            <h3>Build + Flash</h3>
+            <p>The ESPHome output opens in the console so you can follow build, upload, and reboot progress.</p>
+          </div>
+        </div>
+        <div class="row firmwareActions">
+          <button id="flashFirmwareBtn" class="primary" type="button" disabled>Build + Flash firmware</button>
+          <button id="cleanFirmwareBtn" type="button">Clean build files</button>
+          <button id="openFirmwareConsoleBtn" type="button">Open firmware console</button>
+        </div>
+      </section>
     </div>
   </div>
 
@@ -422,7 +1373,7 @@
       <div class="consoleHeader">
         <div>
           <h3 id="consoleTitle" class="consoleTitle">Training Console</h3>
-          <p class="consoleHint">Live training output appears here with color-coded console styling.</p>
+          <p id="consoleHint" class="consoleHint">Live training output appears here with color-coded console styling.</p>
         </div>
         <button id="closeConsoleBtn">Close</button>
       </div>
@@ -432,6 +1383,22 @@
     </div>
   </div>
 
+  <div id="firmwareLogModal" class="firmwareLogModal" aria-hidden="true">
+    <div id="firmwareLogDialog" class="firmwareLogDialog" role="dialog" aria-modal="true" aria-labelledby="firmwareLogTitle">
+      <div class="firmwareLogHeader">
+        <div>
+          <h3 id="firmwareLogTitle" class="firmwareLogTitle">Firmware Build + Flash</h3>
+          <p id="firmwareLogMeta" class="firmwareLogMeta">ESPHome output will appear here.</p>
+        </div>
+        <button id="closeFirmwareLogBtn" type="button">Close</button>
+      </div>
+      <div id="firmwareLogStatus" class="firmwareLogStatus">Waiting for firmware output...</div>
+      <div id="firmwareLogConsole" class="firmwareLogConsole" role="log" aria-live="polite" aria-label="Firmware build and flash log">
+        <div class="firmwareLogEmpty">No firmware flash started yet.</div>
+      </div>
+    </div>
+  </div>
+
 <script>
   const $ = (id) => document.getElementById(id);
 
@@ -440,15 +1407,35 @@
     training: null,
     availableLanguages: [],
     selectedFiles: [],
+    captured: { items: [], captured_count: 0, negative_count: 0, personal_count: 0 },
+    samples: { personal: [], negative: [], personal_count: 0, negative_count: 0, activeBucket: "personal" },
+    firmware: { devices: [], templates: [], flashing: null, logLines: [], activeTemplateKey: "" },
     uploadBusy: false,
+    reviewBusy: false,
+    firmwareBusy: false,
     trainingPoller: null,
+    firmwarePoller: null,
+    activeView: "trainer",
   };
+  let firmwareProfileSaveTimer = null;
 
   function setPill(el, text, cls) {
     el.className = "pill " + (cls || "");
     el.textContent = text;
   }
 
+  function setActiveView(view) {
+    uiState.activeView = ["captured", "samples", "firmware"].includes(view) ? view : "trainer";
+    $("trainerView").hidden = uiState.activeView !== "trainer";
+    $("capturedView").hidden = uiState.activeView !== "captured";
+    $("samplesView").hidden = uiState.activeView !== "samples";
+    $("firmwareView").hidden = uiState.activeView !== "firmware";
+    $("tabTrainer").classList.toggle("active", uiState.activeView === "trainer");
+    $("tabCaptured").classList.toggle("active", uiState.activeView === "captured");
+    $("tabSamples").classList.toggle("active", uiState.activeView === "samples");
+    $("tabFirmware").classList.toggle("active", uiState.activeView === "firmware");
+  }
+
   async function api(path, opts) {
     const res = await fetch(path, opts);
     const ct = res.headers.get("content-type") || "";
@@ -489,6 +1476,183 @@
       .replaceAll(">", "&gt;");
   }
 
+  function escapeAttr(text) {
+    return escapeHtml(text).replaceAll('"', "&quot;");
+  }
+
+  function formatTimestamp(value) {
+    if (!value) return "";
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? String(value) : parsed.toLocaleString();
+  }
+
+  function captureBadge(item) {
+    if (item.blocked_by_vad) return { label: "Blocked by VAD", cls: "warn" };
+    const eventType = String(item?.event_type || "").toLowerCase();
+    if (eventType.includes("close")) return { label: item.capture_label || "Close miss", cls: "warn" };
+    if (eventType.includes("false")) return { label: item.capture_label || "False trigger", cls: "err" };
+    if (eventType.includes("wake") || eventType.includes("detect")) return { label: item.capture_label || "Wake trigger", cls: "ok" };
+    return { label: item.capture_label || "Captured", cls: "" };
+  }
+
+  function renderCapturedItems(payload) {
+    const data = payload || { items: [], captured_count: 0, negative_count: 0, personal_count: 0 };
+    uiState.captured = data;
+
+    $("capturedCount").textContent = String(Number(data.captured_count || 0));
+    $("negativeCount").textContent = String(Number(data.negative_count || 0));
+    $("capturedPersonalCount").textContent = String(Number(data.personal_count || uiState.session?.takes_received || 0));
+    if (!Number.isFinite(Number(uiState.samples?.negative_count))) {
+      uiState.samples.negative_count = Number(data.negative_count || 0);
+    }
+    if (!Number.isFinite(Number(uiState.samples?.personal_count))) {
+      uiState.samples.personal_count = Number(data.personal_count || uiState.session?.takes_received || 0);
+    }
+    updateTrainingSampleCounts();
+
+    const items = Array.isArray(data.items) ? data.items : [];
+    if (!items.length) {
+      $("capturedList").innerHTML = `<div class="emptyState">No captured audio yet. When the sats start sending clips, they will show up here for review.</div>`;
+      return;
+    }
+
+    $("capturedList").innerHTML = items.map((item) => {
+      const badge = captureBadge(item);
+      const meta = [];
+      if (item.source_device) meta.push(`<span class="pill">${escapeHtml(item.source_device)}</span>`);
+      if (item.wake_word) meta.push(`<span class="pill">${escapeHtml(item.wake_word)}</span>`);
+      if (item.max_probability !== null && item.max_probability !== undefined) meta.push(`<span class="pill">max ${escapeHtml(item.max_probability)}</span>`);
+      if (item.average_probability !== null && item.average_probability !== undefined) meta.push(`<span class="pill">avg ${escapeHtml(item.average_probability)}</span>`);
+      const formatSummary = item.final_format ? describeFormat(item.final_format) : "16 kHz, mono, 16-bit";
+      const when = formatTimestamp(item.captured_at || item.received_at);
+      const actionDisabled = uiState.reviewBusy ? "disabled" : "";
+      return `
+        <div class="captureCard">
+          <div class="row space">
+            <div>
+              <p class="captureTitle">${escapeHtml(item.original_name || item.saved_as)}</p>
+              <p class="captureSubtitle">
+                ${when ? `Captured ${escapeHtml(when)}.` : "Captured clip."}
+                ${escapeHtml(item.message || "")}
+              </p>
+            </div>
+            <span class="pill ${badge.cls}">${escapeHtml(badge.label)}</span>
+          </div>
+          <div class="fileMeta">${meta.join("") || `<span class="muted">No metadata attached</span>`}</div>
+          <audio class="audioPlayer" controls preload="none" src="${escapeHtml(item.audio_url || `/api/audio/captured/${encodeURIComponent(item.saved_as)}`)}"></audio>
+          <div class="muted">Stored as ${escapeHtml(item.saved_as)} · ${escapeHtml(formatSummary)}</div>
+          <div class="captureActions">
+            <button type="button" data-action="approve_personal" data-name="${escapeHtml(item.saved_as)}" ${actionDisabled}>Add to personal samples</button>
+            <button type="button" data-action="mark_negative" data-name="${escapeHtml(item.saved_as)}" ${actionDisabled}>Mark negative</button>
+            <button type="button" data-action="discard" data-name="${escapeHtml(item.saved_as)}" ${actionDisabled}>Discard</button>
+          </div>
+        </div>
+      `;
+    }).join("");
+  }
+
+  async function refreshCapturedAudio() {
+    const data = await api("/api/captured_audio", { method: "GET" });
+    renderCapturedItems(data);
+    setPill($("capturedStatus"), data.captured_count ? `${data.captured_count} clip${data.captured_count === 1 ? "" : "s"} waiting` : "Inbox idle", data.captured_count ? "warn" : "");
+    syncButtons();
+    return data;
+  }
+
+  function updateTrainingSampleCounts() {
+    const personalCount = Number(uiState.samples?.personal_count ?? uiState.session?.takes_received ?? 0);
+    const negativeCount = Number(uiState.samples?.negative_count ?? uiState.captured?.negative_count ?? 0);
+    $("positiveSampleCount").textContent = String(personalCount);
+    $("negativeTrainingCount").textContent = String(negativeCount);
+    $("capturedPersonalCount").textContent = String(personalCount);
+    $("negativeCount").textContent = String(negativeCount);
+    $("samplePersonalCount").textContent = String(personalCount);
+    $("sampleNegativeCount").textContent = String(negativeCount);
+  }
+
+  function renderSampleLibrary(payload) {
+    const data = payload || { personal: [], negative: [], personal_count: 0, negative_count: 0 };
+    uiState.samples = {
+      ...uiState.samples,
+      ...data,
+      personal: Array.isArray(data.personal) ? data.personal : [],
+      negative: Array.isArray(data.negative) ? data.negative : [],
+    };
+    updateTrainingSampleCounts();
+
+    const activeBucket = uiState.samples.activeBucket === "negative" ? "negative" : "personal";
+    $("sampleTabPersonal").classList.toggle("active", activeBucket === "personal");
+    $("sampleTabNegative").classList.toggle("active", activeBucket === "negative");
+
+    const items = activeBucket === "negative" ? uiState.samples.negative : uiState.samples.personal;
+    const label = activeBucket === "negative" ? "negative" : "personal";
+    if (!items.length) {
+      $("sampleLibraryList").innerHTML = `<div class="emptyState">No ${label} samples saved yet.</div>`;
+      return;
+    }
+
+    $("sampleLibraryList").innerHTML = items.map((item) => {
+      const when = formatTimestamp(item.reviewed_at || item.received_at || item.created_at);
+      const formatSummary = item.final_format ? describeFormat(item.final_format) : "16 kHz, mono, 16-bit";
+      const badge = activeBucket === "negative" ? { label: "Negative", cls: "err" } : { label: "Positive", cls: "ok" };
+      const subtitleParts = [];
+      if (item.original_name && item.original_name !== item.saved_as) subtitleParts.push(`From ${item.original_name}`);
+      if (when) subtitleParts.push(`Saved ${when}`);
+      if (item.message) subtitleParts.push(item.message);
+      return `
+        <div class="captureCard">
+          <div class="row space">
+            <div>
+              <p class="captureTitle">${escapeHtml(item.saved_as)}</p>
+              <p class="captureSubtitle">${escapeHtml(subtitleParts.join(" · ") || "Saved training sample.")}</p>
+            </div>
+            <span class="pill ${badge.cls}">${badge.label}</span>
+          </div>
+          <audio class="audioPlayer" controls preload="none" src="${escapeAttr(item.audio_url || `/api/audio/${activeBucket}/${encodeURIComponent(item.saved_as)}`)}"></audio>
+          <div class="muted">Stored in ${activeBucket === "negative" ? "negative_samples" : "personal_samples"} · ${escapeHtml(formatSummary)}</div>
+          <div class="captureActions">
+            <button type="button" data-sample-remove="${escapeAttr(item.saved_as)}" data-bucket="${escapeAttr(activeBucket)}" ${uiState.reviewBusy ? "disabled" : ""}>Remove sample</button>
+          </div>
+        </div>
+      `;
+    }).join("");
+  }
+
+  async function refreshSamples() {
+    const data = await api("/api/samples", { method: "GET" });
+    renderSampleLibrary(data);
+    syncButtons();
+    return data;
+  }
+
+  function setSampleBucket(bucket) {
+    uiState.samples.activeBucket = bucket === "negative" ? "negative" : "personal";
+    renderSampleLibrary(uiState.samples);
+    syncButtons();
+  }
+
+  async function removeSample(bucket, fileName) {
+    if (!bucket || !fileName) return;
+    const ok = confirm(`Remove ${fileName} from ${bucket === "negative" ? "negative_samples" : "personal_samples"}?`);
+    if (!ok) return;
+
+    try {
+      uiState.reviewBusy = true;
+      setPill($("status"), "Removing sample...", "warn");
+      syncButtons();
+      const data = await api(`/api/samples/${encodeURIComponent(bucket)}/${encodeURIComponent(fileName)}`, { method: "DELETE" });
+      renderSampleLibrary(data);
+      await refreshSession();
+      setPill($("status"), "Sample removed", "ok");
+    } catch (error) {
+      setPill($("status"), "Remove failed", "err");
+      alert(error.message);
+    } finally {
+      uiState.reviewBusy = false;
+      syncButtons();
+    }
+  }
+
   function consoleLineClass(line) {
     const trimmed = String(line || "").trim();
     const lower = trimmed.toLowerCase();
@@ -510,17 +1674,131 @@
     }).join("");
   }
 
-  function openConsole(wobble = true) {
-    $("consoleOverlay").classList.add("open");
-    $("consoleOverlay").setAttribute("aria-hidden", "false");
+  function setConsoleMode(title, hint) {
+    $("consoleTitle").textContent = title || "Training Console";
+    $("consoleHint").textContent = hint || "Live output appears here with color-coded console styling.";
+  }
+
+  function openConsole(wobble = true, title = "Training Console", hint = "Live training output appears here with color-coded console styling.") {
+    setConsoleMode(title, hint);
+    const overlay = $("consoleOverlay");
+    const win = $("consoleWindow");
+    overlay.classList.add("open");
+    overlay.setAttribute("aria-hidden", "false");
+    win.setAttribute("tabindex", "-1");
+    try {
+      win.focus({ preventScroll: true });
+    } catch (_) {
+      win.focus();
+    }
     if (wobble) {
-      const win = $("consoleWindow");
       win.classList.remove("wobble");
       void win.offsetWidth;
       win.classList.add("wobble");
     }
   }
 
+  function firmwareLogTone(line) {
+    const text = String(line || "").trim();
+    const lower = text.toLowerCase();
+    const bracketMatch = text.match(/^\[[^\]]+\]\[([A-Z])\]/);
+    const token = bracketMatch?.[1] || "";
+    if (token === "E" || text.includes("✗") || lower.includes("traceback") || lower.includes("error") || lower.includes("failed") || lower.includes("crashed")) {
+      return "error";
+    }
+    if (token === "W" || text.includes("⚠") || lower.includes("warning") || lower.includes("warn")) {
+      return "warn";
+    }
+    if (token === "D" || token === "V" || lower.includes("[debug]")) {
+      return "debug";
+    }
+    return "info";
+  }
+
+  function firmwareLogLevel(line) {
+    const tone = firmwareLogTone(line);
+    if (tone === "error") return "ERROR";
+    if (tone === "warn") return "WARN";
+    if (tone === "debug") return "DEBUG";
+    return "INFO";
+  }
+
+  function renderFirmwareLogLines(lines, reset = true) {
+    const consoleEl = $("firmwareLogConsole");
+    const rows = Array.isArray(lines) ? lines.filter((line) => String(line || "").trim()) : [];
+    const shouldStick = reset || isNearBottom(consoleEl, 28);
+    if (reset) {
+      consoleEl.innerHTML = "";
+    }
+    if (!rows.length) {
+      consoleEl.innerHTML = `<div class="firmwareLogEmpty">Waiting for ESPHome build output...</div>`;
+    } else {
+      consoleEl.innerHTML = rows.map((line) => {
+        const tone = firmwareLogTone(line);
+        return `
+          <div class="firmwareLogLine tone-${tone}">
+            <span class="firmwareLogLevel">${firmwareLogLevel(line)}</span>
+            <span class="firmwareLogMessage">${escapeHtml(line)}</span>
+          </div>
+        `;
+      }).join("");
+    }
+    if (shouldStick) {
+      consoleEl.scrollTop = consoleEl.scrollHeight;
+    }
+  }
+
+  function setFirmwareLogStatus(text) {
+    $("firmwareLogStatus").textContent = String(text || "Waiting for firmware output...").trim() || "Waiting for firmware output...";
+  }
+
+  function openFirmwareConsole(wobble = true, text = null, statusText = "") {
+    const template = selectedFirmwareTemplate();
+    const host = ($("firmwareHost").value || "").trim();
+    const port = ($("firmwarePort").value || "3232").trim();
+    $("firmwareLogTitle").textContent = "Firmware Build + Flash";
+    $("firmwareLogMeta").textContent = [
+      template?.label || template?.value || "Firmware",
+      host ? `${host}:${port || "3232"}` : "",
+    ].filter(Boolean).join(" • ") || "ESPHome output will appear here.";
+    if (text !== null) {
+      renderFirmwareLogLines(String(text).split("\n"), true);
+    } else {
+      renderFirmwareLogLines(uiState.firmware.logLines || [], true);
+    }
+    setFirmwareLogStatus(statusText || "ESPHome build, upload, and flash output appears here.");
+    const modal = $("firmwareLogModal");
+    const dialog = $("firmwareLogDialog");
+    modal.classList.add("active");
+    modal.setAttribute("aria-hidden", "false");
+    dialog.setAttribute("tabindex", "-1");
+    try {
+      dialog.focus({ preventScroll: true });
+    } catch (_) {
+      dialog.focus();
+    }
+    if (wobble) {
+      dialog.style.animation = "none";
+      void dialog.offsetWidth;
+      dialog.style.animation = "";
+    }
+  }
+
+  function closeFirmwareConsole() {
+    $("firmwareLogModal").classList.remove("active");
+    $("firmwareLogModal").setAttribute("aria-hidden", "true");
+  }
+
+  function waitForPaint() {
+    return new Promise((resolve) => {
+      if (typeof requestAnimationFrame === "function") {
+        requestAnimationFrame(() => resolve());
+      } else {
+        setTimeout(resolve, 0);
+      }
+    });
+  }
+
   function closeConsole() {
     $("consoleOverlay").classList.remove("open");
     $("consoleOverlay").setAttribute("aria-hidden", "true");
@@ -533,6 +1811,359 @@
       : "No files selected";
   }
 
+  function renderFirmwareDevices(devices, message) {
+    const list = Array.isArray(devices) ? devices : [];
+    uiState.firmware.devices = list;
+
+    if (!list.length) {
+      $("firmwareDeviceSelect").innerHTML = `<option value="">No devices detected</option>`;
+      setPill($("firmwareDetectStatus"), message || "No devices detected", "warn");
+      return;
+    }
+
+    $("firmwareDeviceSelect").innerHTML = [
+      `<option value="">Choose detected device...</option>`,
+      ...list.map((device, index) => {
+        const label = `${device.name || device.host} (${device.host}:${device.port || 3232})`;
+        return `<option value="${index}">${escapeHtml(label)}</option>`;
+      }),
+    ].join("");
+
+    setPill($("firmwareDetectStatus"), `${list.length} detected`, "ok");
+    if (!($("firmwareHost").value || "").trim()) {
+      $("firmwareDeviceSelect").value = "0";
+      applySelectedFirmwareDevice();
+    }
+  }
+
+  async function refreshFirmwareDevices() {
+    setPill($("firmwareDetectStatus"), "Scanning mDNS...", "warn");
+    const data = await api("/api/firmware/devices", { method: "GET" });
+    renderFirmwareDevices(data.devices, data.message);
+    syncButtons();
+    return data;
+  }
+
+  function applySelectedFirmwareDevice() {
+    const indexText = $("firmwareDeviceSelect").value;
+    if (indexText === "") return;
+    const device = uiState.firmware.devices[Number(indexText)];
+    if (!device) return;
+    $("firmwareHost").value = device.host || "";
+    $("firmwarePort").value = device.port || 3232;
+    syncButtons();
+    scheduleFirmwareProfileSave();
+  }
+
+  function selectedFirmwareTemplate() {
+    const key = $("firmwareTemplate").value;
+    const match = (uiState.firmware.templates || []).find((item) => String(item.value || "") === key);
+    if (match) return match;
+    if (!key) return null;
+    const label = $("firmwareTemplate").selectedOptions?.[0]?.textContent || key;
+    return { value: key, label };
+  }
+
+  function applyFirmwareTemplateTarget(template = selectedFirmwareTemplate()) {
+    if (!template) return;
+    if (template.target_host) {
+      $("firmwareHost").value = template.target_host;
+    }
+    if (template.target_port) {
+      $("firmwarePort").value = template.target_port;
+    }
+  }
+
+  function renderFirmwareTemplates(payload) {
+    const templates = Array.isArray(payload?.templates) ? payload.templates : [];
+    const previousTemplateKey = $("firmwareTemplate").value || uiState.firmware.activeTemplateKey || "";
+    uiState.firmware.templates = templates;
+    $("firmwareTemplate").innerHTML = templates.length
+      ? templates.map((item) => `<option value="${escapeAttr(item.value)}">${escapeHtml(item.label || item.value)}</option>`).join("")
+      : `<option value="">No firmware templates found</option>`;
+    if (previousTemplateKey && templates.some((item) => String(item.value || "") === previousTemplateKey)) {
+      $("firmwareTemplate").value = previousTemplateKey;
+    } else if (payload?.active_template_key) {
+      $("firmwareTemplate").value = payload.active_template_key;
+    }
+    uiState.firmware.activeTemplateKey = $("firmwareTemplate").value;
+    renderFirmwareFields();
+    applyFirmwareTemplateTarget();
+  }
+
+  function renderFirmwareFields() {
+    const template = selectedFirmwareTemplate();
+    const fields = Array.isArray(template?.fields) ? template.fields : [];
+    if (!fields.length) {
+      $("firmwareFields").innerHTML = `<div class="emptyState">No editable settings were found for this firmware template. You can continue with the selected template and target device.</div>`;
+      return;
+    }
+
+    const groups = new Map();
+    fields.forEach((field) => {
+      const section = String(field.section || "Firmware");
+      if (!groups.has(section)) groups.set(section, []);
+      groups.get(section).push(field);
+    });
+
+    $("firmwareFields").innerHTML = Array.from(groups.entries()).map(([section, rows]) => `
+      <section class="firmwareSettingsSection">
+        <div class="row space">
+          <h3 style="margin:0;">${escapeHtml(section)}</h3>
+        </div>
+        <div class="firmwareSettingsGrid">
+          ${rows.map((field) => renderFirmwareField(field)).join("")}
+        </div>
+      </section>
+    `).join("");
+  }
+
+  function renderFirmwareField(field) {
+    const key = String(field.key || "");
+    const label = String(field.label || key || "Value");
+    const type = String(field.type || "text");
+    const value = field.value ?? "";
+    const placeholder = field.placeholder ? ` placeholder="${escapeAttr(field.placeholder)}"` : "";
+    const description = field.description ? `<span class="muted">${escapeHtml(field.description)}</span>` : "";
+    const options = Array.isArray(field.options) ? field.options : [];
+    if (field.read_only) {
+      return `
+        <label class="field">
+          <strong>${escapeHtml(label)}</strong>
+          <span class="readOnlyValue">${escapeHtml(value || "(from YAML)")}</span>
+          ${description}
+        </label>
+      `;
+    }
+    if (type === "wake_word_select") {
+      const optionHtml = options.length
+        ? options.map((option) => {
+            const optionValue = String(option.key || "");
+            const selected = optionValue && optionValue === String(value || "") ? " selected" : "";
+            return `
+              <option value="${escapeAttr(optionValue)}"${selected}
+                data-wake-word-name="${escapeAttr(option.wake_word_name || optionValue)}"
+                data-wake-word-url="${escapeAttr(option.json_url || "")}">
+                ${escapeHtml(option.label || optionValue)}
+              </option>
+            `;
+          }).join("")
+        : "";
+      return `
+        <label class="field">
+          <strong>${escapeHtml(label)}</strong>
+          <select data-firmware-field="${escapeAttr(key)}" data-wake-word-select ${options.length ? "" : "disabled"}>
+            <option value="">${escapeHtml(placeholder || "Choose a trained wake word...")}</option>
+            ${optionHtml}
+          </select>
+          ${description}
+        </label>
+      `;
+    }
+    if (type === "checkbox") {
+      return `
+        <label class="field">
+          <strong>${escapeHtml(label)}</strong>
+          <span class="row">
+            <input data-firmware-field="${escapeAttr(key)}" type="checkbox" ${value ? "checked" : ""} style="width:auto;" />
+            <span class="muted">Enabled</span>
+          </span>
+          ${description}
+        </label>
+      `;
+    }
+    return `
+      <label class="field">
+        <strong>${escapeHtml(label)}</strong>
+        <input data-firmware-field="${escapeAttr(key)}" type="${type === "password" ? "password" : "text"}" value="${escapeAttr(value)}"${placeholder} autocomplete="off" />
+        ${description}
+      </label>
+    `;
+  }
+
+  function applyWakeWordSelection(select) {
+    const option = select?.selectedOptions?.[0];
+    if (!option || !select.value) return;
+    const wakeWordName = option.dataset.wakeWordName || "";
+    const wakeWordUrl = option.dataset.wakeWordUrl || "";
+    const nameInput = document.querySelector('[data-firmware-field="wake_word_name"]');
+    const urlInput = document.querySelector('[data-firmware-field="wake_word_model_url"]');
+    if (nameInput && wakeWordName) {
+      nameInput.value = wakeWordName;
+    }
+    if (urlInput && wakeWordUrl) {
+      urlInput.value = wakeWordUrl;
+    }
+    setPill($("firmwareStatus"), "Wake word selected", "ok");
+    scheduleFirmwareProfileSave();
+    syncButtons();
+  }
+
+  async function refreshFirmwareTemplates() {
+    const data = await api("/api/firmware/templates", { method: "GET" });
+    renderFirmwareTemplates(data);
+    if (Array.isArray(data.warnings) && data.warnings.length) {
+      setPill($("firmwareStatus"), "Template warning", "warn");
+    }
+    syncButtons();
+    return data;
+  }
+
+  function collectFirmwareValues() {
+    const values = {};
+    document.querySelectorAll("[data-firmware-field]").forEach((field) => {
+      const key = String(field.dataset.firmwareField || "");
+      if (!key) return;
+      if (field instanceof HTMLInputElement && field.type === "checkbox") {
+        values[key] = field.checked;
+      } else {
+        values[key] = field.value || "";
+      }
+    });
+    return values;
+  }
+
+  async function saveFirmwareProfileNow({ templateKey = null, quiet = false } = {}) {
+    const key = String(templateKey || $("firmwareTemplate").value || "").trim();
+    if (!key) return null;
+    const values = collectFirmwareValues();
+    values.__target_host = ($("firmwareHost").value || "").trim();
+    values.__target_port = ($("firmwarePort").value || "3232").trim();
+    const result = await api("/api/firmware/profile", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ template_key: key, values }),
+    });
+    if (!quiet && !uiState.firmwareBusy) {
+      setPill($("firmwareStatus"), "Settings saved", "ok");
+    }
+    return result;
+  }
+
+  function scheduleFirmwareProfileSave() {
+    if (firmwareProfileSaveTimer) {
+      clearTimeout(firmwareProfileSaveTimer);
+    }
+    firmwareProfileSaveTimer = setTimeout(async () => {
+      firmwareProfileSaveTimer = null;
+      try {
+        await saveFirmwareProfileNow({ quiet: false });
+      } catch (error) {
+        if (!uiState.firmwareBusy) {
+          setPill($("firmwareStatus"), "Settings save failed", "warn");
+        }
+      }
+    }, 550);
+  }
+
+  function flushFirmwareProfileSave(templateKey = null) {
+    if (firmwareProfileSaveTimer) {
+      clearTimeout(firmwareProfileSaveTimer);
+      firmwareProfileSaveTimer = null;
+    }
+    return saveFirmwareProfileNow({ templateKey, quiet: true }).catch(() => null);
+  }
+
+  async function startFirmwareFlash() {
+    const host = ($("firmwareHost").value || "").trim();
+    const port = ($("firmwarePort").value || "3232").trim();
+    const template = selectedFirmwareTemplate();
+    if (!template) {
+      alert("Choose a firmware template first.");
+      return;
+    }
+    if (!host) {
+      alert("Enter the device IP or hostname first.");
+      return;
+    }
+
+    const ok = confirm(`Build and flash ${template.label || template.value} firmware to ${host}:${port || "3232"}?\n\nMake sure this is the correct device before continuing.`);
+    if (!ok) return;
+
+    uiState.firmwareBusy = true;
+    uiState.firmware.logLines = [
+      "===== Firmware Build + Flash Console =====",
+      `→ Target: ${host}:${port || "3232"}`,
+      "→ Contacting trainer server to start the build...",
+    ];
+    setPill($("firmwareStatus"), "Starting build + flash...", "warn");
+    openFirmwareConsole(true, uiState.firmware.logLines.join("\n"), "Starting firmware build + flash...");
+    syncButtons();
+    await flushFirmwareProfileSave();
+    await waitForPaint();
+
+    try {
+      const status = await api("/api/firmware/build_flash", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          template_key: template.value,
+          host,
+          port: port || "3232",
+          values: collectFirmwareValues(),
+        }),
+      });
+      uiState.firmware.flashing = status;
+      uiState.firmware.logLines = (status.log_lines || []).length
+        ? status.log_lines
+        : [...uiState.firmware.logLines, "✓ Build session started. Waiting for ESPHome output..."];
+      openFirmwareConsole(false, uiState.firmware.logLines.join("\n") || "(waiting for flash output)", status.message || "Firmware session started.");
+      pollFirmwareFlash(status.session_id);
+    } catch (error) {
+      uiState.firmwareBusy = false;
+      setPill($("firmwareStatus"), "Flash failed to start", "err");
+      uiState.firmware.logLines = [String(error.message || error)];
+      openFirmwareConsole(false, uiState.firmware.logLines.join("\n"), "Firmware flash failed to start.");
+      syncButtons();
+      alert("Flash failed to start: " + error.message);
+    }
+  }
+
+  async function pollFirmwareFlash(sessionId) {
+    if (uiState.firmwarePoller || !sessionId) return;
+    uiState.firmwarePoller = true;
+
+    try {
+      for (;;) {
+        const status = await api(`/api/firmware/flash_status/${encodeURIComponent(sessionId)}`, { method: "GET" });
+        uiState.firmware.flashing = status;
+        const lines = status.log_lines || [];
+        uiState.firmware.logLines = lines;
+        renderFirmwareLogLines(lines.length ? lines : ["(waiting for flash output)"], true);
+
+        if (status.running) {
+          setPill($("firmwareStatus"), status.message || "Firmware build + flash running", "warn");
+          setFirmwareLogStatus(status.message || "Firmware build + flash running.");
+        } else {
+          uiState.firmwareBusy = false;
+          if (status.exit_code === 0) {
+            setPill($("firmwareStatus"), "Firmware flashed successfully", "ok");
+            setFirmwareLogStatus("Firmware flashed successfully.");
+          } else {
+            setPill($("firmwareStatus"), `Firmware build + flash failed (${status.exit_code})`, "err");
+            setFirmwareLogStatus(`Firmware build + flash failed (${status.exit_code}).`);
+          }
+          syncButtons();
+          break;
+        }
+
+        syncButtons();
+        await new Promise((resolve) => setTimeout(resolve, 1200));
+      }
+    } catch (error) {
+      uiState.firmwareBusy = false;
+      setPill($("firmwareStatus"), "Flash status lost", "err");
+      uiState.firmware.logLines = [
+        ...(uiState.firmware.logLines || []),
+        `✗ Flash status lost: ${error.message || error}`,
+      ];
+      openFirmwareConsole(false, uiState.firmware.logLines.join("\n"), "Firmware status polling failed.");
+      syncButtons();
+    } finally {
+      uiState.firmwarePoller = null;
+    }
+  }
+
   function renderLanguageOptions(languages, preferredLanguage) {
     const select = $("language");
     const current = preferredLanguage || select.value || "en";
@@ -556,15 +2187,25 @@
     const training = uiState.training || {};
     const hasPhrase = Boolean(($("phrase").value || "").trim());
     const hasSelected = uiState.selectedFiles.length > 0;
-    const sampleCount = Number(uiState.session?.takes_received || 0);
+    const sampleCount = Number(uiState.samples?.personal_count ?? uiState.session?.takes_received ?? 0);
     const hasConsole = Boolean(training.running || training.exit_code !== null || (training.log_lines || []).length);
+    const negativeCount = Number(uiState.samples?.negative_count ?? uiState.captured?.negative_count ?? 0);
+    const firmwareHost = ($("firmwareHost").value || "").trim();
+    const firmwareTemplate = ($("firmwareTemplate").value || "").trim();
 
     $("ttsBtn").disabled = !hasPhrase || uiState.uploadBusy;
     $("uploadBtn").disabled = !hasSession || !hasSelected || uiState.uploadBusy;
-    $("clearBtn").disabled = sampleCount === 0 || uiState.uploadBusy;
+    $("clearBtn").disabled = sampleCount === 0 || uiState.uploadBusy || uiState.reviewBusy;
     $("openConsoleBtn").disabled = !hasConsole;
     $("trainBtn").disabled = !hasSession || uiState.uploadBusy || Boolean(training.running);
     $("startSessionBtn").disabled = uiState.uploadBusy;
+    $("refreshCapturedBtn").disabled = uiState.reviewBusy;
+    $("clearNegativeBtn").disabled = uiState.reviewBusy || negativeCount === 0;
+    $("refreshSamplesBtn").disabled = uiState.reviewBusy || uiState.uploadBusy;
+    $("refreshFirmwareBtn").disabled = uiState.firmwareBusy;
+    $("cleanFirmwareBtn").disabled = uiState.firmwareBusy;
+    $("openFirmwareConsoleBtn").disabled = false;
+    $("flashFirmwareBtn").disabled = uiState.firmwareBusy || !firmwareHost || !firmwareTemplate;
   }
 
   function refreshSessionUI(session) {
@@ -576,7 +2217,10 @@
     }
 
     const uploaded = Number(session?.takes_received || 0);
-    $("uploadedCount").textContent = String(uploaded);
+    if (!Number.isFinite(Number(uiState.samples?.personal_count))) {
+      uiState.samples.personal_count = uploaded;
+    }
+    updateTrainingSampleCounts();
     uiState.training = session?.training || uiState.training;
 
     if (session?.safe_word) {
@@ -693,7 +2337,7 @@
       $("sampleFiles").value = "";
       renderSelectedFiles();
 
-      const session = await refreshSession();
+      const [session] = await Promise.all([refreshSession(), refreshSamples()]);
       const uploaded = Number(session?.takes_received || 0);
       setPill($("status"), `Uploaded ${uploaded} sample${uploaded === 1 ? "" : "s"}`, "ok");
       const parts = [];
@@ -711,14 +2355,46 @@
     }
   }
 
+  async function handleCapturedAction(fileName, action) {
+    if (!fileName || !action) return;
+    if (action === "discard") {
+      const ok = confirm(`Discard ${fileName} from the captured-audio inbox?`);
+      if (!ok) return;
+    }
+
+    uiState.reviewBusy = true;
+    setPill($("capturedStatus"), "Applying review action...", "warn");
+    syncButtons();
+
+    try {
+      await api(`/api/captured_audio/${encodeURIComponent(fileName)}/${action}`, { method: "POST" });
+      await Promise.all([refreshSession(), refreshCapturedAudio(), refreshSamples()]);
+
+      if (action === "approve_personal") {
+        setPill($("capturedStatus"), "Moved into personal samples", "ok");
+        setPill($("status"), "Captured clip added to personal samples", "ok");
+      } else if (action === "mark_negative") {
+        setPill($("capturedStatus"), "Moved into reviewed negatives", "ok");
+      } else {
+        setPill($("capturedStatus"), "Captured clip discarded", "");
+      }
+    } catch (error) {
+      setPill($("capturedStatus"), "Review action failed", "err");
+      alert(error.message);
+    } finally {
+      uiState.reviewBusy = false;
+      syncButtons();
+    }
+  }
+
   async function startTrainingWithPrompt() {
-    const session = await refreshSession();
-    const uploaded = Number(session?.takes_received || 0);
+    const [session, samples] = await Promise.all([refreshSession(), refreshSamples()]);
+    const uploaded = Number(samples?.personal_count ?? session?.takes_received ?? 0);
 
     let allowNoPersonal = false;
     if (uploaded === 0) {
       const ok = confirm(
-        `No personal voice samples were uploaded yet.\n\nTrain anyway without personal voices?`
+        `No positive samples are saved yet.\n\nTrain anyway without personal voices?`
       );
       if (!ok) {
         setPill($("status"), "Training canceled", "warn");
@@ -729,7 +2405,7 @@
 
     uiState.training = { running: true, exit_code: null, log_lines: [] };
     setConsoleLogAutoScroll($("trainLog"), "===== Training Console =====\nWaiting for training output...");
-    openConsole(true);
+    openConsole(true, "Training Console", "Live training output appears here with color-coded console styling.");
     syncButtons();
     setPill($("status"), "Starting training...", "warn");
     setPill($("trainState"), "Training running", "warn");
@@ -785,6 +2461,30 @@
   }
 
   $("phrase").addEventListener("input", syncButtons);
+  $("tabTrainer").addEventListener("click", () => setActiveView("trainer"));
+  $("tabCaptured").addEventListener("click", () => setActiveView("captured"));
+  $("tabSamples").addEventListener("click", () => {
+    setActiveView("samples");
+    refreshSamples().catch((error) => {
+      setPill($("status"), "Sample refresh failed", "err");
+      alert("Sample refresh failed: " + error.message);
+    });
+  });
+  $("tabFirmware").addEventListener("click", () => {
+    setActiveView("firmware");
+    refreshFirmwareTemplates().catch((error) => {
+      setPill($("firmwareStatus"), "Templates failed", "err");
+      uiState.firmware.logLines = [`Template load failed: ${error.message}`];
+      setConsoleLogAutoScroll($("trainLog"), uiState.firmware.logLines.join("\n"));
+    });
+    if (!uiState.firmware.devices.length) {
+      refreshFirmwareDevices().catch((error) => {
+        setPill($("firmwareDetectStatus"), "Scan failed", "err");
+        uiState.firmware.logLines = [`Device scan failed: ${error.message}`];
+        setConsoleLogAutoScroll($("trainLog"), uiState.firmware.logLines.join("\n"));
+      });
+    }
+  });
 
   $("sampleFiles").addEventListener("change", () => {
     uiState.selectedFiles = Array.from($("sampleFiles").files || []);
@@ -792,14 +2492,79 @@
     syncButtons();
   });
 
+  $("firmwareHost").addEventListener("input", () => {
+    syncButtons();
+    scheduleFirmwareProfileSave();
+  });
+  $("firmwarePort").addEventListener("input", () => {
+    syncButtons();
+    scheduleFirmwareProfileSave();
+  });
+  $("firmwareTemplate").addEventListener("change", () => {
+    flushFirmwareProfileSave(uiState.firmware.activeTemplateKey);
+    uiState.firmware.activeTemplateKey = $("firmwareTemplate").value;
+    renderFirmwareFields();
+    applyFirmwareTemplateTarget();
+    syncButtons();
+  });
+  $("firmwareFields").addEventListener("input", () => {
+    syncButtons();
+    scheduleFirmwareProfileSave();
+  });
+  $("firmwareFields").addEventListener("change", (event) => {
+    const select = event.target.closest("select[data-wake-word-select]");
+    if (select) {
+      applyWakeWordSelection(select);
+      return;
+    }
+    syncButtons();
+    scheduleFirmwareProfileSave();
+  });
+  $("firmwareDeviceSelect").addEventListener("change", applySelectedFirmwareDevice);
+  $("refreshFirmwareBtn").addEventListener("click", async () => {
+    try {
+      await refreshFirmwareDevices();
+    } catch (error) {
+      setPill($("firmwareDetectStatus"), "Scan failed", "err");
+      alert("Device scan failed: " + error.message);
+    }
+  });
+  $("flashFirmwareBtn").addEventListener("click", startFirmwareFlash);
+  $("cleanFirmwareBtn").addEventListener("click", async () => {
+    try {
+      setPill($("firmwareStatus"), "Cleaning build files...", "warn");
+      const result = await api("/api/firmware/clean", { method: "POST" });
+      setPill($("firmwareStatus"), result.message || "Build files cleaned", "ok");
+    } catch (error) {
+      setPill($("firmwareStatus"), "Clean failed", "err");
+      alert("Clean failed: " + error.message);
+    } finally {
+      syncButtons();
+    }
+  });
+  $("openFirmwareConsoleBtn").addEventListener("click", () => {
+    openFirmwareConsole(true, (uiState.firmware.logLines || []).join("\n") || "(no firmware flash started)", uiState.firmwareBusy ? "Firmware build + flash running." : "No active firmware flash.");
+  });
+
   $("openConsoleBtn").addEventListener("click", () => {
-    openConsole(true);
+    setConsoleLogAutoScroll($("trainLog"), (uiState.training?.log_lines || []).join("\n") || "(no training started)");
+    openConsole(true, "Training Console", "Live training output appears here with color-coded console styling.");
   });
 
   $("closeConsoleBtn").addEventListener("click", () => {
     closeConsole();
   });
 
+  $("closeFirmwareLogBtn").addEventListener("click", () => {
+    closeFirmwareConsole();
+  });
+
+  $("firmwareLogModal").addEventListener("click", (event) => {
+    if (event.target === $("firmwareLogModal")) {
+      closeFirmwareConsole();
+    }
+  });
+
   $("consoleOverlay").addEventListener("click", (event) => {
     if (event.target === $("consoleOverlay")) {
       closeConsole();
@@ -809,6 +2574,7 @@
   document.addEventListener("keydown", (event) => {
     if (event.key === "Escape") {
       closeConsole();
+      closeFirmwareConsole();
     }
   });
 
@@ -853,9 +2619,60 @@
   });
 
   $("uploadBtn").addEventListener("click", uploadSelectedFiles);
+  $("refreshSamplesBtn").addEventListener("click", async () => {
+    try {
+      await refreshSamples();
+      setPill($("status"), "Samples refreshed", "ok");
+    } catch (error) {
+      setPill($("status"), "Sample refresh failed", "err");
+      alert("Sample refresh failed: " + error.message);
+    }
+  });
+  $("sampleTabPersonal").addEventListener("click", () => setSampleBucket("personal"));
+  $("sampleTabNegative").addEventListener("click", () => setSampleBucket("negative"));
+  $("sampleLibraryList").addEventListener("click", async (event) => {
+    const button = event.target.closest("button[data-sample-remove][data-bucket]");
+    if (!button) return;
+    await removeSample(button.dataset.bucket, button.dataset.sampleRemove);
+  });
+  $("refreshCapturedBtn").addEventListener("click", async () => {
+    try {
+      await refreshCapturedAudio();
+    } catch (error) {
+      setPill($("capturedStatus"), "Refresh failed", "err");
+      alert("Refresh failed: " + error.message);
+    }
+  });
+
+  $("clearNegativeBtn").addEventListener("click", async () => {
+    const count = Number(uiState.samples?.negative_count ?? uiState.captured?.negative_count ?? 0);
+    const ok = confirm(`Clear ${count} reviewed negative sample${count === 1 ? "" : "s"} from negative_samples?`);
+    if (!ok) return;
+
+    try {
+      uiState.reviewBusy = true;
+      setPill($("status"), "Clearing negative samples...", "warn");
+      syncButtons();
+      await api("/api/reset_negative_samples", { method: "POST" });
+      await Promise.all([refreshCapturedAudio(), refreshSamples()]);
+      setPill($("status"), "Negative samples cleared", "ok");
+    } catch (error) {
+      setPill($("status"), "Clear failed", "err");
+      alert("Clear failed: " + error.message);
+    } finally {
+      uiState.reviewBusy = false;
+      syncButtons();
+    }
+  });
+
+  $("capturedList").addEventListener("click", async (event) => {
+    const button = event.target.closest("button[data-action][data-name]");
+    if (!button) return;
+    await handleCapturedAction(button.dataset.name, button.dataset.action);
+  });
 
   $("clearBtn").addEventListener("click", async () => {
-    const count = Number(uiState.session?.takes_received || 0);
+    const count = Number(uiState.samples?.personal_count ?? uiState.session?.takes_received ?? 0);
     const ok = confirm(`Clear ${count} personal sample${count === 1 ? "" : "s"} from personal_samples?`);
     if (!ok) return;
 
@@ -865,7 +2682,7 @@
       setPill($("status"), "Clearing samples...", "warn");
       updateProgress(0, "Clearing personal samples", "Removing saved WAV files from personal_samples.");
       await api("/api/reset_recordings", { method: "POST" });
-      await refreshSession();
+      await Promise.all([refreshSession(), refreshSamples()]);
       updateProgress(0, "No upload in progress", "personal_samples is empty.");
       setPill($("status"), "Personal samples cleared", "ok");
     } catch (error) {
@@ -883,7 +2700,7 @@
     } catch (error) {
       uiState.training = { running: false, exit_code: 1, log_lines: [String(error.message || error)] };
       setConsoleLogAutoScroll($("trainLog"), String(error.message || error));
-      openConsole(true);
+      openConsole(true, "Training Console", "Live training output appears here with color-coded console styling.");
       syncButtons();
       setPill($("status"), "Train failed", "err");
       setPill($("trainState"), "Start failed", "err");
@@ -892,12 +2709,24 @@
   });
 
   async function bootstrap() {
+    setActiveView("trainer");
     renderSelectedFiles();
     updateProgress(0, "No upload in progress", "Choose files and upload when you are ready.");
 
     try {
       await refreshSession();
+      await refreshSamples();
+      await refreshCapturedAudio();
+    } catch (_) {}
 
+    try {
+      await refreshFirmwareTemplates();
+    } catch (error) {
+      setPill($("firmwareStatus"), "Templates failed", "err");
+      uiState.firmware.logLines = [`Template load failed: ${error.message}`];
+    }
+
+    try {
       const trainStatus = await api("/api/train_status", { method: "GET" });
       const training = trainStatus.training || {};
       uiState.training = training;
@@ -906,7 +2735,7 @@
       }
       if (training.running) {
         setPill($("trainState"), "Training running", "warn");
-        openConsole(false);
+        openConsole(false, "Training Console", "Live training output appears here with color-coded console styling.");
         pollTraining();
       } else if (training.exit_code === 0) {
         setPill($("trainState"), "Training finished", "ok");
diff --git a/train_wake_word b/train_wake_word
index aa47be5..659a446 100755
--- a/train_wake_word
+++ b/train_wake_word
@@ -150,6 +150,7 @@ if ${CLEANUP_WORK_DIR} ; then
       "${DATA_DIR}/work/wake_word_samples" \
       "${DATA_DIR}/work/wake_word_samples_augmented" \
       "${DATA_DIR}/work/personal_augmented_features" \
+      "${DATA_DIR}/work/reviewed_negative_features" \
       "${DATA_DIR}/work/last_wake_word" || :
 fi
 
diff --git a/trainer_server.py b/trainer_server.py
index cb69cf3..ee22d58 100644
--- a/trainer_server.py
+++ b/trainer_server.py
@@ -1,35 +1,46 @@
+#!/usr/bin/env python3
+
 # trainer_server.py
+import contextlib
+import copy
 import io
 import os
 import re
 import json
 import shutil
+import socket
 import subprocess
+import sys
 import tempfile
 import threading
 import time
+import uuid
 import wave
-from datetime import datetime
+from array import array
+from datetime import datetime, timezone
+from math import log10
 from pathlib import Path
-from typing import Dict, Any, List, Optional, Tuple
-from urllib.request import Request, urlopen
+from typing import Dict, Any, List, Callable, Optional, Tuple
+from urllib.parse import quote, urlparse
+from urllib.request import Request as URLRequest, urlopen
 
-from fastapi import FastAPI, UploadFile, File, Form
-from fastapi.responses import HTMLResponse, JSONResponse
+import yaml
+from fastapi import FastAPI, UploadFile, File, Form, Header, Request
+from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 
 ROOT_DIR = Path(__file__).resolve().parent
 
-# In Docker CLI world, DATA_DIR should be /data
+# In Docker, /data is the persistent workspace mounted by the user.
 DATA_DIR = Path(os.environ.get("DATA_DIR", "/data")).resolve()
-
-# UI files live next to this script by default
 STATIC_DIR = Path(os.environ.get("STATIC_DIR", str(ROOT_DIR / "static"))).resolve()
-
-# Personal samples MUST land in /data/personal_samples for your CLI pipeline
 PERSONAL_DIR = Path(os.environ.get("PERSONAL_DIR", str(DATA_DIR / "personal_samples"))).resolve()
+CAPTURED_DIR = Path(os.environ.get("CAPTURED_DIR", str(DATA_DIR / "captured_audio"))).resolve()
+NEGATIVE_DIR = Path(os.environ.get("NEGATIVE_DIR", str(DATA_DIR / "negative_samples"))).resolve()
+TRAINED_WAKE_WORDS_DIR = Path(
+    os.environ.get("TRAINED_WAKE_WORDS_DIR", str(DATA_DIR / "trained_wake_words"))
+).resolve()
 
-# CLI folder inside repo
 CLI_DIR = Path(os.environ.get("CLI_DIR", str(ROOT_DIR / "cli"))).resolve()
 PIPER_ROOT = DATA_DIR / "tools" / "piper-sample-generator"
 PIPER_VOICES_DIR = PIPER_ROOT / "voices"
@@ -45,7 +56,7 @@ PIPER_CATALOG_CACHE_TTL_SECONDS = int(os.environ.get("PIPER_CATALOG_CACHE_TTL_SE
 PIPER_CATALOG_CACHE_FILE = Path(
     os.environ.get(
         "PIPER_CATALOG_CACHE_FILE",
-        str(ROOT_DIR / ".cache" / "piper_voices_catalog.json"),
+        str(DATA_DIR / ".cache" / "piper_voices_catalog.json"),
     )
 ).resolve()
 
@@ -54,9 +65,8 @@ DATASET_CLEANUP_INTERMEDIATE = os.environ.get("REC_DATASET_CLEANUP_INTERMEDIATE_
 
 TRAIN_CMD = os.environ.get(
     "TRAIN_CMD",
-    f"source '{DATA_DIR}/.venv/bin/activate' && train_wake_word --data-dir '{DATA_DIR}'"
+    f"source '{DATA_DIR}/.venv/bin/activate' && train_wake_word --data-dir '{DATA_DIR}'",
 )
-
 DEFAULT_LANGUAGE = os.environ.get("MWW_LANGUAGE", "en")
 
 TAKES_PER_SPEAKER_DEFAULT = int(os.environ.get("REC_TAKES_PER_SPEAKER", "10"))
@@ -64,14 +74,50 @@ SPEAKERS_TOTAL_DEFAULT = int(os.environ.get("REC_SPEAKERS_TOTAL", "1"))
 TARGET_SAMPLE_RATE = 16000
 TARGET_CHANNELS = 1
 TARGET_SAMPLE_WIDTH_BYTES = 2
+CAPTURE_GAIN_PROFILE = "capture_rms_v1"
 
-# Tail lines shown to UI
+# Firmware build/flash cache lives inside /data so Docker runs can reuse downloads.
+FIRMWARE_CACHE_DIR = Path(os.environ.get("FIRMWARE_CACHE_DIR", str(DATA_DIR / ".cache" / "firmware_flasher"))).resolve()
+FIRMWARE_HELPER = ROOT_DIR / "cli" / "flash_esphome_ota.py"
+FIRMWARE_DEFAULT_OTA_PORT = int(os.environ.get("ESPHOME_OTA_PORT", "3232"))
+FIRMWARE_DISCOVERY_SECONDS = float(os.environ.get("ESPHOME_DISCOVERY_SECONDS", "2.5"))
+FIRMWARE_MAX_LOG_LINES = int(os.environ.get("FIRMWARE_MAX_LOG_LINES", "500"))
+FIRMWARE_GITHUB_OWNER = os.environ.get("FIRMWARE_GITHUB_OWNER", "TaterTotterson")
+FIRMWARE_GITHUB_REPO = os.environ.get("FIRMWARE_GITHUB_REPO", "microWakeWords")
+FIRMWARE_GITHUB_REF = os.environ.get("FIRMWARE_GITHUB_REF", "main")
+FIRMWARE_PLATFORMIO_DIR = FIRMWARE_CACHE_DIR / "platformio"
+FIRMWARE_HOME_DIR = FIRMWARE_CACHE_DIR / "home"
+FIRMWARE_XDG_CACHE_DIR = FIRMWARE_CACHE_DIR / "cache"
+FIRMWARE_PROFILE_FILE = Path(
+    os.environ.get("FIRMWARE_PROFILE_FILE", str(FIRMWARE_CACHE_DIR / "profiles.json"))
+).resolve()
 TRAIN_LOG_TAIL_LINES = int(os.environ.get("REC_TRAIN_LOG_TAIL_LINES", "400"))
-# Safety cap for reads (bytes) to avoid giant file reads
-TRAIN_LOG_MAX_BYTES = int(os.environ.get("REC_TRAIN_LOG_MAX_BYTES", str(512 * 1024)))  # 512KB
+TRAIN_LOG_MAX_BYTES = int(os.environ.get("REC_TRAIN_LOG_MAX_BYTES", str(512 * 1024)))
+
+FIRMWARE_TEMPLATE_SPECS = (
+    {
+        "key": "voicepe",
+        "label": "VoicePE (voicePE-TaterTimer.yaml)",
+        "path": "voicePE-TaterTimer.yaml",
+        "identity_key": "device_name",
+        "friendly_key": "friendly_name",
+        "fixed_keys": {"device_name"},
+        "auto_keys": {"ha_voice_ip"},
+    },
+    {
+        "key": "satellite1",
+        "label": "Sat1 (satellite1-TaterTimer.yaml)",
+        "path": "satellite1-TaterTimer.yaml",
+        "identity_key": "node_name",
+        "friendly_key": "friendly_name",
+        "fixed_keys": {"node_name"},
+        "auto_keys": {"ha_voice_ip"},
+    },
+)
 
 app = FastAPI(title="microWakeWord Personal Samples")
 
+# Serve static UI
 STATIC_DIR.mkdir(parents=True, exist_ok=True)
 app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
 
@@ -84,27 +130,26 @@ def safe_name(raw: str) -> str:
     return s or "wakeword"
 
 
+# -------------------- In-memory session state --------------------
 STATE: Dict[str, Any] = {
     "raw_phrase": None,
     "safe_word": None,
     "language": DEFAULT_LANGUAGE,
 
+    # multi-speaker
     "speakers_total": SPEAKERS_TOTAL_DEFAULT,
     "takes_per_speaker": TAKES_PER_SPEAKER_DEFAULT,
 
-    "takes_received": 0,
-    "takes": [],
+    # recording progress
+    "takes_received": 0,   # total across all speakers
+    "takes": [],           # list of saved filenames
 
     "training": {
         "running": False,
         "exit_code": None,
-        "log_lines": [],          # legacy in-memory tail (kept, but not relied on)
-        "log_path": None,         # path to recorder_training.log
+        "log_lines": [],
+        "log_path": None,
         "safe_word": None,
-
-        # prevent UI duplication when UI appends:
-        "last_sent_tail": [],      # last tail snapshot (list of lines)
-        "last_log_size": 0,        # detect truncation
     },
 }
 
@@ -115,21 +160,180 @@ PIPER_CATALOG_CACHE: Dict[str, Any] = {
     "fetched_at": 0.0,
     "entries": None,
 }
+FIRMWARE_LOCK = threading.Lock()
+FIRMWARE_SESSIONS: Dict[str, Dict[str, Any]] = {}
+ANSI_ESCAPE_RE = re.compile(r"\x1B(?:\[[0-?]*[ -/]*[@-~]|[@-Z\\-_])")
+
+
+class _FirmwareYamlLoader(yaml.SafeLoader):
+    pass
+
+
+class _FirmwareYamlDumper(yaml.SafeDumper):
+    pass
+
+
+class _TaggedYamlValue:
+    __slots__ = ("tag", "value")
+
+    def __init__(self, tag: str, value: Any) -> None:
+        self.tag = str(tag or "")
+        self.value = value
+
+
+def _construct_secret(loader: yaml.SafeLoader, node: yaml.Node) -> Dict[str, str]:
+    return {"__secret__": loader.construct_scalar(node)}
+
+
+def _construct_tagged_yaml(loader: yaml.SafeLoader, tag_suffix: str, node: yaml.Node) -> _TaggedYamlValue:
+    tag = f"!{tag_suffix}"
+    if isinstance(node, yaml.ScalarNode):
+        value = loader.construct_scalar(node)
+    elif isinstance(node, yaml.SequenceNode):
+        value = loader.construct_sequence(node, deep=True)
+    elif isinstance(node, yaml.MappingNode):
+        value = loader.construct_mapping(node, deep=True)
+    else:
+        value = loader.construct_object(node, deep=True)
+    return _TaggedYamlValue(tag, value)
+
+
+def _represent_tagged_yaml(dumper: yaml.SafeDumper, value: _TaggedYamlValue) -> yaml.Node:
+    payload = value.value
+    if isinstance(payload, dict):
+        return dumper.represent_mapping(value.tag, payload)
+    if isinstance(payload, list):
+        return dumper.represent_sequence(value.tag, payload)
+    return dumper.represent_scalar(value.tag, "" if payload is None else str(payload))
+
+
+_FirmwareYamlLoader.add_constructor("!secret", _construct_secret)
+_FirmwareYamlLoader.add_multi_constructor("!", _construct_tagged_yaml)
+_FirmwareYamlDumper.add_representer(_TaggedYamlValue, _represent_tagged_yaml)
 
 
 def _reset_personal_samples_dir():
-    PERSONAL_DIR.mkdir(parents=True, exist_ok=True)
-    for p in PERSONAL_DIR.glob("*.wav"):
-        try:
-            p.unlink()
-        except Exception:
-            pass
+    _reset_audio_dir(PERSONAL_DIR)
 
 
+def _reset_audio_dir(directory: Path):
+    directory.mkdir(parents=True, exist_ok=True)
+    for p in directory.iterdir():
+        if p.is_file() and p.suffix.lower() in {".wav", ".json"}:
+            try:
+                p.unlink()
+            except Exception:
+                pass
+
+
+def _list_audio_samples(directory: Path) -> List[str]:
+    directory.mkdir(parents=True, exist_ok=True)
+    return sorted(p.name for p in directory.glob("*.wav"))
+
 
 def _list_personal_samples() -> List[str]:
-    PERSONAL_DIR.mkdir(parents=True, exist_ok=True)
-    return sorted(p.name for p in PERSONAL_DIR.glob("*.wav"))
+    return _list_audio_samples(PERSONAL_DIR)
+
+
+def _list_negative_samples() -> List[str]:
+    return _list_audio_samples(NEGATIVE_DIR)
+
+
+def _list_captured_sample_names() -> List[str]:
+    return _list_audio_samples(CAPTURED_DIR)
+
+
+def _sync_trained_wake_word_artifacts() -> None:
+    """Mirror generated output artifacts into /data/trained_wake_words for firmware flashing."""
+    TRAINED_WAKE_WORDS_DIR.mkdir(parents=True, exist_ok=True)
+    candidate_jsons: list[Path] = []
+
+    output_dir = DATA_DIR / "output"
+    if output_dir.exists():
+        candidate_jsons.extend(output_dir.rglob("*.json"))
+
+    # One-time migration for older root-level outputs.
+    candidate_jsons.extend(ROOT_DIR.glob("*.json"))
+
+    for json_path in sorted(candidate_jsons):
+        if TRAINED_WAKE_WORDS_DIR in json_path.parents:
+            continue
+        try:
+            meta = json.loads(json_path.read_text(encoding="utf-8"))
+        except Exception:
+            continue
+        if not isinstance(meta, dict):
+            continue
+
+        model_name = str(meta.get("model") or json_path.with_suffix(".tflite").name).strip()
+        tflite_path = (json_path.parent / Path(model_name).name).resolve()
+        if not tflite_path.exists():
+            fallback = json_path.with_suffix(".tflite")
+            if fallback.exists():
+                tflite_path = fallback.resolve()
+            else:
+                continue
+
+        for source_path in (json_path, tflite_path):
+            dest_path = TRAINED_WAKE_WORDS_DIR / source_path.name
+            if not dest_path.exists() or source_path.stat().st_mtime > dest_path.stat().st_mtime:
+                shutil.copy2(source_path, dest_path)
+
+        if json_path.parent == ROOT_DIR:
+            with contextlib.suppress(Exception):
+                json_path.unlink()
+            with contextlib.suppress(Exception):
+                tflite_path.unlink()
+
+
+def _list_trained_wake_words(base_url: str = "") -> List[Dict[str, str]]:
+    _sync_trained_wake_word_artifacts()
+    base = str(base_url or "").rstrip("/")
+    rows: List[Dict[str, str]] = []
+    seen: set[str] = set()
+
+    for json_path in sorted(TRAINED_WAKE_WORDS_DIR.glob("*.json")):
+        try:
+            meta = json.loads(json_path.read_text(encoding="utf-8"))
+        except Exception:
+            continue
+        if not isinstance(meta, dict):
+            continue
+
+        model_name = str(meta.get("model") or json_path.with_suffix(".tflite").name).strip()
+        model_path = TRAINED_WAKE_WORDS_DIR / Path(model_name).name
+        if not model_path.exists():
+            continue
+
+        safe = json_path.stem
+        if safe in seen:
+            continue
+        seen.add(safe)
+
+        wake_word = str(meta.get("wake_word") or safe.replace("_", " ")).strip()
+        json_url = f"/api/trained_wake_words/{quote(json_path.name)}"
+        model_url = f"/api/trained_wake_words/{quote(model_path.name)}"
+        if base:
+            json_url = f"{base}{json_url}"
+            model_url = f"{base}{model_url}"
+
+        rows.append(
+            {
+                "key": safe,
+                "label": wake_word or safe,
+                "wake_word_name": safe,
+                "wake_word": wake_word or safe,
+                "json_url": json_url,
+                "model_url": model_url,
+                "json_file": json_path.name,
+                "model_file": model_path.name,
+            }
+        )
+    return rows
+
+
+def _request_base_url(request: Request) -> str:
+    return str(request.base_url).rstrip("/")
 
 
 def _sync_personal_samples_state() -> List[str]:
@@ -173,8 +377,8 @@ def _register_language(
         entry["regions"].append(region)
 
 
-def _fetch_piper_catalog() -> Optional[Dict[str, Any]]:
-    req = Request(
+def _fetch_piper_catalog() -> Dict[str, Any] | None:
+    req = URLRequest(
         PIPER_VOICES_INDEX_URL,
         headers={"User-Agent": "microWakeWord-Trainer/1.0"},
     )
@@ -183,7 +387,7 @@ def _fetch_piper_catalog() -> Optional[Dict[str, Any]]:
     return data if isinstance(data, dict) else None
 
 
-def _read_cached_piper_catalog_file() -> Optional[Dict[str, Any]]:
+def _read_cached_piper_catalog_file() -> Dict[str, Any] | None:
     try:
         if not PIPER_CATALOG_CACHE_FILE.exists():
             return None
@@ -204,7 +408,7 @@ def _write_cached_piper_catalog_file(data: Dict[str, Any]):
         pass
 
 
-def _load_piper_catalog() -> Optional[Dict[str, Any]]:
+def _load_piper_catalog() -> Dict[str, Any] | None:
     now = time.time()
     with PIPER_CATALOG_LOCK:
         cached = PIPER_CATALOG_CACHE.get("entries")
@@ -295,7 +499,7 @@ def _normalize_language(language: str | None) -> str:
     return "en"
 
 
-def _catalog_voice_files(language_family: str) -> List[Tuple[str, str]]:
+def _catalog_voice_files(language_family: str) -> List[tuple[str, str]]:
     if not language_family or language_family == "en":
         return []
 
@@ -373,12 +577,11 @@ def _ensure_non_english_language_voices(language_family: str, log) -> Dict[str,
     }
 
 
-def _find_ffmpeg() -> Optional[str]:
+def _find_ffmpeg() -> str | None:
     candidates = [
         shutil.which("ffmpeg"),
-        "/usr/bin/ffmpeg",
-        "/usr/local/bin/ffmpeg",
         "/opt/homebrew/bin/ffmpeg",
+        "/usr/local/bin/ffmpeg",
         "/opt/homebrew/opt/ffmpeg@7/bin/ffmpeg",
         "/opt/homebrew/opt/ffmpeg/bin/ffmpeg",
     ]
@@ -388,7 +591,7 @@ def _find_ffmpeg() -> Optional[str]:
     return None
 
 
-def _inspect_wav_bytes(data: bytes) -> Optional[Dict[str, Any]]:
+def _inspect_wav_bytes(data: bytes) -> Dict[str, Any] | None:
     try:
         with wave.open(io.BytesIO(data), "rb") as wf:
             frames = wf.getnframes()
@@ -407,7 +610,7 @@ def _inspect_wav_bytes(data: bytes) -> Optional[Dict[str, Any]]:
         return None
 
 
-def _is_target_wav(info: Optional[Dict[str, Any]]) -> bool:
+def _is_target_wav(info: Dict[str, Any] | None) -> bool:
     return bool(
         info
         and info.get("container") == "wav"
@@ -420,16 +623,83 @@ def _is_target_wav(info: Optional[Dict[str, Any]]) -> bool:
 
 
 def _next_personal_sample_name(original_name: str) -> str:
-    current = _list_personal_samples()
+    return _next_directory_sample_name(PERSONAL_DIR, "sample", original_name)
+
+
+def _next_negative_sample_name(original_name: str) -> str:
+    return _next_directory_sample_name(NEGATIVE_DIR, "negative", original_name)
+
+
+def _next_captured_sample_name(original_name: str) -> str:
+    return _next_directory_sample_name(CAPTURED_DIR, "captured", original_name)
+
+
+def _next_directory_sample_name(directory: Path, prefix: str, original_name: str) -> str:
+    current = _list_audio_samples(directory)
     next_index = 1
     for name in current:
-        match = re.match(r"sample_(\d{4})", name)
+        match = re.match(rf"{re.escape(prefix)}_(\d{{4}})", name)
         if match:
             next_index = max(next_index, int(match.group(1)) + 1)
 
     stem = safe_name(Path(original_name or "sample").stem)
     suffix = f"_{stem[:32]}" if stem and stem != "wakeword" else ""
-    return f"sample_{next_index:04d}{suffix}.wav"
+    return f"{prefix}_{next_index:04d}{suffix}.wav"
+
+
+def _parse_bool(value: Any) -> bool:
+    if isinstance(value, bool):
+        return value
+    return str(value or "").strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _parse_float(value: Any) -> float | None:
+    if value in (None, ""):
+        return None
+    try:
+        return float(value)
+    except Exception:
+        return None
+
+
+def _audio_sidecar_path(audio_path: Path) -> Path:
+    return audio_path.with_suffix(".json")
+
+
+def _load_sidecar_json(audio_path: Path) -> Dict[str, Any]:
+    sidecar = _audio_sidecar_path(audio_path)
+    if not sidecar.exists():
+        return {}
+    try:
+        data = json.loads(sidecar.read_text(encoding="utf-8"))
+        return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def _write_sidecar_json(audio_path: Path, payload: Dict[str, Any]):
+    _audio_sidecar_path(audio_path).write_text(
+        json.dumps(payload, indent=2, ensure_ascii=True),
+        encoding="utf-8",
+    )
+
+
+def _remove_audio_with_sidecar(audio_path: Path):
+    if audio_path.exists():
+        audio_path.unlink()
+    sidecar = _audio_sidecar_path(audio_path)
+    if sidecar.exists():
+        sidecar.unlink()
+
+
+def _resolve_audio_path(directory: Path, file_name: str) -> Path:
+    candidate = Path(file_name or "").name
+    if not candidate or candidate != (file_name or "") or not candidate.endswith(".wav"):
+        raise FileNotFoundError("Invalid audio file name.")
+    path = (directory / candidate).resolve()
+    if path.parent != directory.resolve() or not path.exists():
+        raise FileNotFoundError("Audio file not found.")
+    return path
 
 
 def _format_hint_from_filename(original_name: str) -> Dict[str, Any]:
@@ -480,55 +750,334 @@ def _normalize_audio_to_target_wav(data: bytes, original_name: str) -> bytes:
         return dst_path.read_bytes()
 
 
-def _save_personal_sample(data: bytes, original_name: str, out_name: Optional[str] = None) -> Dict[str, Any]:
+def _boost_target_wav_bytes(
+    data: bytes,
+    *,
+    target_peak_ratio: float = 0.88,
+    target_rms_ratio: float | None = None,
+    max_gain_ratio: float = 10.0,
+    min_gain_ratio: float = 1.25,
+    profile: str | None = None,
+) -> tuple[bytes, Dict[str, Any]]:
+    info = _inspect_wav_bytes(data) or {}
+    if not _is_target_wav(info):
+        return data, {"applied": False, "reason": "not_target_wav"}
+
+    with wave.open(io.BytesIO(data), "rb") as wf:
+        raw_frames = wf.readframes(wf.getnframes())
+
+    if not raw_frames:
+        return data, {"applied": False, "reason": "empty"}
+
+    samples = array("h")
+    samples.frombytes(raw_frames)
+    if sys.byteorder != "little":
+        samples.byteswap()
+
+    peak = max(abs(sample) for sample in samples) if samples else 0
+    if peak <= 0:
+        return data, {"applied": False, "reason": "silent", "peak_ratio": 0.0}
+
+    peak_ratio = peak / 32767.0
+    rms_ratio = (sum(sample * sample for sample in samples) / len(samples)) ** 0.5 / 32767.0
+    desired_peak = max(0.05, min(target_peak_ratio, 0.98))
+    peak_limited_gain = desired_peak / peak_ratio
+    target_gain = peak_limited_gain
+    if target_rms_ratio is not None and rms_ratio > 0:
+        target_gain = min(target_rms_ratio / rms_ratio, peak_limited_gain)
+    gain_ratio = min(max_gain_ratio, target_gain)
+
+    if gain_ratio < min_gain_ratio:
+        return data, {
+            "applied": False,
+            "reason": "already_loud_enough",
+            "peak_ratio": round(peak_ratio, 4),
+            "rms_ratio": round(rms_ratio, 4),
+            "gain_ratio": round(gain_ratio, 3),
+            "gain_db": round(20.0 * log10(max(gain_ratio, 1e-9)), 2),
+            "profile": profile or "",
+        }
+
+    boosted = array("h", (max(-32768, min(32767, int(round(sample * gain_ratio)))) for sample in samples))
+    if sys.byteorder != "little":
+        boosted.byteswap()
+
+    buf = io.BytesIO()
+    with wave.open(buf, "wb") as wav:
+        wav.setnchannels(TARGET_CHANNELS)
+        wav.setsampwidth(TARGET_SAMPLE_WIDTH_BYTES)
+        wav.setframerate(TARGET_SAMPLE_RATE)
+        wav.writeframes(boosted.tobytes())
+
+    return buf.getvalue(), {
+        "applied": True,
+        "peak_ratio": round(peak_ratio, 4),
+        "rms_ratio": round(rms_ratio, 4),
+        "gain_ratio": round(gain_ratio, 3),
+        "gain_db": round(20.0 * log10(max(gain_ratio, 1e-9)), 2),
+        "profile": profile or "",
+    }
+
+
+def _build_audio_result_message(*, converted: bool, postprocess_info: Dict[str, Any] | None = None) -> str:
+    message = (
+        "Converted to 16 kHz mono 16-bit PCM WAV"
+        if converted
+        else "Already in the correct 16 kHz mono 16-bit PCM WAV format"
+    )
+    if postprocess_info and postprocess_info.get("applied"):
+        message += f"; boosted {postprocess_info['gain_db']} dB for clearer captured playback"
+    return message
+
+
+def _ensure_captured_playback_ready(audio_path: Path, metadata: Dict[str, Any] | None = None) -> Dict[str, Any]:
+    metadata = dict(metadata or {})
+    existing_postprocess = metadata.get("postprocess")
+    if isinstance(existing_postprocess, dict) and existing_postprocess.get("profile") == CAPTURE_GAIN_PROFILE:
+        return metadata
+
+    with SAMPLES_LOCK:
+        data = audio_path.read_bytes()
+        final_bytes, postprocess_info = _boost_target_wav_bytes(
+            data,
+            target_peak_ratio=0.88,
+            target_rms_ratio=0.06,
+            max_gain_ratio=220.0,
+            profile=CAPTURE_GAIN_PROFILE,
+        )
+        if postprocess_info.get("applied"):
+            audio_path.write_bytes(final_bytes)
+        if isinstance(existing_postprocess, dict):
+            try:
+                previous_gain = float(existing_postprocess.get("gain_ratio") or 1.0)
+            except Exception:
+                previous_gain = 1.0
+            current_gain = float(postprocess_info.get("gain_ratio") or 1.0)
+            total_gain = previous_gain * current_gain
+            if previous_gain != 1.0:
+                postprocess_info["gain_ratio"] = round(total_gain, 3)
+                postprocess_info["gain_db"] = round(20.0 * log10(max(total_gain, 1e-9)), 2)
+        metadata["postprocess"] = postprocess_info
+        metadata["final_format"] = _inspect_wav_bytes(final_bytes) or metadata.get("final_format") or {}
+        metadata["message"] = _build_audio_result_message(
+            converted=bool(metadata.get("converted")),
+            postprocess_info=postprocess_info,
+        )
+        _write_sidecar_json(audio_path, metadata)
+
+    return metadata
+
+
+def _save_audio_sample(
+    data: bytes,
+    original_name: str,
+    *,
+    target_dir: Path,
+    out_name: str,
+    postprocess_target_wav: Callable[[bytes], tuple[bytes, Dict[str, Any]]] | None = None,
+) -> Dict[str, Any]:
     if not data:
         raise ValueError("Empty or invalid audio file.")
 
     original_info = _inspect_wav_bytes(data) or _format_hint_from_filename(original_name)
     normalized = _is_target_wav(original_info)
     final_bytes = data if normalized else _normalize_audio_to_target_wav(data, original_name)
+    postprocess_info: Dict[str, Any] = {"applied": False}
+    if postprocess_target_wav is not None:
+        final_bytes, postprocess_info = postprocess_target_wav(final_bytes)
     final_info = _inspect_wav_bytes(final_bytes)
 
     if not _is_target_wav(final_info):
         raise ValueError("Uploaded audio could not be normalized to 16 kHz mono 16-bit PCM WAV.")
 
     with SAMPLES_LOCK:
-        PERSONAL_DIR.mkdir(parents=True, exist_ok=True)
-        final_name = out_name or _next_personal_sample_name(original_name)
-        out_path = PERSONAL_DIR / final_name
+        target_dir.mkdir(parents=True, exist_ok=True)
+        final_name = out_name
+        out_path = target_dir / final_name
         out_path.write_bytes(final_bytes)
 
     return {
         "saved_as": final_name,
         "converted": not normalized,
+        "postprocess": postprocess_info,
         "original_name": original_name or final_name,
         "detected_format": original_info,
         "final_format": final_info,
-        "message": (
-            "Converted to 16 kHz mono 16-bit PCM WAV"
-            if not normalized
-            else "Already in the correct 16 kHz mono 16-bit PCM WAV format"
+        "message": _build_audio_result_message(
+            converted=not normalized,
+            postprocess_info=postprocess_info,
         ),
     }
 
-def _clear_training_log():
-    """
-    Truncate recorder_training.log for a fresh session.
-    """
-    log_path = DATA_DIR / "recorder_training.log"
-    log_path.parent.mkdir(parents=True, exist_ok=True)
 
-    with open(log_path, "w", encoding="utf-8") as lf:
-        lf.write("================================================================================\n")
-        lf.write("===== New recorder session started =====\n")
-        lf.write("================================================================================\n")
-        lf.flush()
+def _save_personal_sample(data: bytes, original_name: str, out_name: str | None = None) -> Dict[str, Any]:
+    return _save_audio_sample(
+        data,
+        original_name,
+        target_dir=PERSONAL_DIR,
+        out_name=out_name or _next_personal_sample_name(original_name),
+    )
 
-    with STATE_LOCK:
-        STATE["training"]["log_path"] = str(log_path)
-        STATE["training"]["log_lines"] = []
-        STATE["training"]["last_sent_tail"] = []
-        STATE["training"]["last_log_size"] = 0
+
+def _save_captured_sample(data: bytes, original_name: str, out_name: str | None = None) -> Dict[str, Any]:
+    return _save_audio_sample(
+        data,
+        original_name,
+        target_dir=CAPTURED_DIR,
+        out_name=out_name or _next_captured_sample_name(original_name),
+        postprocess_target_wav=lambda wav_data: _boost_target_wav_bytes(
+            wav_data,
+            target_peak_ratio=0.88,
+            target_rms_ratio=0.06,
+            max_gain_ratio=220.0,
+            profile=CAPTURE_GAIN_PROFILE,
+        ),
+    )
+
+
+def _pcm_s16le_to_wav_bytes(
+    pcm_data: bytes,
+    *,
+    sample_rate: int = TARGET_SAMPLE_RATE,
+    channels: int = TARGET_CHANNELS,
+    sample_width_bytes: int = TARGET_SAMPLE_WIDTH_BYTES,
+) -> bytes:
+    if not pcm_data:
+        raise ValueError("Captured audio payload was empty.")
+
+    if sample_width_bytes <= 0:
+        raise ValueError("Invalid sample width for PCM conversion.")
+
+    frame_width = channels * sample_width_bytes
+    if frame_width <= 0 or (len(pcm_data) % frame_width) != 0:
+        raise ValueError("Captured PCM payload does not align to whole audio frames.")
+
+    buf = io.BytesIO()
+    with wave.open(buf, "wb") as wav:
+        wav.setnchannels(channels)
+        wav.setsampwidth(sample_width_bytes)
+        wav.setframerate(sample_rate)
+        wav.writeframes(pcm_data)
+    return buf.getvalue()
+
+
+def _captured_item_from_path(audio_path: Path) -> Dict[str, Any]:
+    meta = _ensure_captured_playback_ready(audio_path, _load_sidecar_json(audio_path))
+    stat = audio_path.stat()
+    event_type = str(meta.get("event_type") or "captured").strip() or "captured"
+    final_format = meta.get("final_format") or _inspect_wav_bytes(audio_path.read_bytes()) or {}
+    return {
+        "saved_as": audio_path.name,
+        "original_name": meta.get("original_name") or audio_path.name,
+        "source_device": meta.get("source_device") or "",
+        "wake_word": meta.get("wake_word") or "",
+        "event_type": event_type,
+        "capture_label": str(meta.get("capture_label") or event_type.replace("_", " ").title()),
+        "received_at": meta.get("received_at") or datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc).isoformat(),
+        "captured_at": meta.get("captured_at") or "",
+        "converted": bool(meta.get("converted")),
+        "blocked_by_vad": bool(meta.get("blocked_by_vad")),
+        "max_probability": meta.get("max_probability"),
+        "average_probability": meta.get("average_probability"),
+        "detected_format": meta.get("detected_format") or {},
+        "final_format": final_format,
+        "postprocess": meta.get("postprocess") or {},
+        "message": meta.get("message") or "",
+        "notes": meta.get("notes") or "",
+        "review_status": meta.get("review_status") or "pending",
+        "size_bytes": stat.st_size,
+        "audio_url": f"/api/audio/captured/{audio_path.name}",
+    }
+
+
+def _list_captured_items() -> List[Dict[str, Any]]:
+    items: List[Dict[str, Any]] = []
+    CAPTURED_DIR.mkdir(parents=True, exist_ok=True)
+    for audio_path in sorted(CAPTURED_DIR.glob("*.wav"), key=lambda p: p.stat().st_mtime, reverse=True):
+        try:
+            items.append(_captured_item_from_path(audio_path))
+        except Exception:
+            continue
+    return items
+
+
+def _sample_item_from_path(audio_path: Path, bucket: str) -> Dict[str, Any]:
+    meta = _load_sidecar_json(audio_path)
+    stat = audio_path.stat()
+    final_format = meta.get("final_format") or _inspect_wav_bytes(audio_path.read_bytes()) or {}
+    return {
+        "bucket": bucket,
+        "saved_as": audio_path.name,
+        "original_name": meta.get("original_name") or audio_path.name,
+        "wake_word": meta.get("wake_word") or "",
+        "event_type": meta.get("event_type") or "",
+        "review_status": meta.get("review_status") or "",
+        "received_at": meta.get("received_at") or "",
+        "reviewed_at": meta.get("reviewed_at") or "",
+        "created_at": datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc).isoformat(),
+        "converted": bool(meta.get("converted")),
+        "final_format": final_format,
+        "message": meta.get("message") or "",
+        "size_bytes": stat.st_size,
+        "audio_url": f"/api/audio/{bucket}/{audio_path.name}",
+    }
+
+
+def _list_sample_items(directory: Path, bucket: str) -> List[Dict[str, Any]]:
+    directory.mkdir(parents=True, exist_ok=True)
+    items: List[Dict[str, Any]] = []
+    for audio_path in sorted(directory.glob("*.wav"), key=lambda p: p.stat().st_mtime, reverse=True):
+        try:
+            items.append(_sample_item_from_path(audio_path, bucket))
+        except Exception:
+            continue
+    return items
+
+
+def _samples_payload() -> Dict[str, Any]:
+    takes = _sync_personal_samples_state()
+    personal_items = _list_sample_items(PERSONAL_DIR, "personal")
+    negative_items = _list_sample_items(NEGATIVE_DIR, "negative")
+    return {
+        "ok": True,
+        "personal": personal_items,
+        "negative": negative_items,
+        "personal_count": len(personal_items),
+        "negative_count": len(negative_items),
+        "takes_received": len(takes),
+    }
+
+
+def _move_captured_audio(file_name: str, target_dir: Path, *, target_prefix: str, review_status: str) -> Dict[str, Any]:
+    with SAMPLES_LOCK:
+        src_path = _resolve_audio_path(CAPTURED_DIR, file_name)
+        metadata = _load_sidecar_json(src_path)
+        original_name = str(metadata.get("original_name") or src_path.name)
+        if target_prefix == "sample":
+            target_name = _next_personal_sample_name(original_name)
+        else:
+            target_name = _next_negative_sample_name(original_name)
+
+        target_dir.mkdir(parents=True, exist_ok=True)
+        dst_path = target_dir / target_name
+        src_path.replace(dst_path)
+
+        metadata["review_status"] = review_status
+        metadata["reviewed_at"] = datetime.now(timezone.utc).isoformat()
+        metadata["saved_as"] = target_name
+        _write_sidecar_json(dst_path, metadata)
+
+        stale_sidecar = _audio_sidecar_path(src_path)
+        if stale_sidecar.exists():
+            stale_sidecar.unlink()
+
+    takes = _sync_personal_samples_state()
+    return {
+        "saved_as": target_name,
+        "captured_remaining": len(_list_captured_sample_names()),
+        "negative_count": len(_list_negative_samples()),
+        "takes_received": len(takes),
+    }
 
 
 def _append_train_log(line: str):
@@ -540,6 +1089,23 @@ def _append_train_log(line: str):
             del buf[: (len(buf) - 250)]
 
 
+def _clear_training_log():
+    log_path = DATA_DIR / "recorder_training.log"
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(log_path, "w", encoding="utf-8") as lf:
+        lf.write("================================================================================\n")
+        lf.write("===== New trainer session started =====\n")
+        lf.write("================================================================================\n")
+        lf.flush()
+
+    with STATE_LOCK:
+        STATE["training"]["log_path"] = str(log_path)
+        STATE["training"]["log_lines"] = []
+        STATE["training"]["last_sent_tail"] = []
+        STATE["training"]["last_log_size"] = 0
+
+
 def _title_from_phrase(raw_phrase: str) -> str:
     s = re.sub(r"[^a-zA-Z0-9 ]+", " ", raw_phrase or "").strip()
     s = re.sub(r"\s+", " ", s)
@@ -640,10 +1206,6 @@ def _ensure_training_datasets(log_path: Path) -> None:
 
 
 def _read_tail_lines(log_path: Path, max_lines: int) -> List[str]:
-    """
-    Read the last N lines, bounded by TRAIN_LOG_MAX_BYTES.
-    Returns list of lines (no trailing newlines).
-    """
     if not log_path.exists():
         return []
 
@@ -663,35 +1225,22 @@ def _read_tail_lines(log_path: Path, max_lines: int) -> List[str]:
 
 
 def _compute_new_lines(prev_tail: List[str], new_tail: List[str]) -> List[str]:
-    """
-    Given previous and current tail snapshots, return only the newly-added lines.
-    Works even if the tail window shifts.
-    """
     if not prev_tail:
         return new_tail
 
-    # Try to find the largest suffix of prev_tail that matches a prefix of new_tail
     max_k = min(len(prev_tail), len(new_tail))
     for k in range(max_k, 0, -1):
         if prev_tail[-k:] == new_tail[:k]:
             return new_tail[k:]
 
-    # If no overlap, just return full new_tail (probably truncation or big jump)
     return new_tail
 
 
-# -------------------- output artifact normalization --------------------
-
 def _find_latest_output_pair(output_dir: Path) -> Tuple[Optional[Path], Optional[Path]]:
-    """
-    Find the most recently modified .tflite and its matching .json (same basename)
-    in output_dir. Falls back to newest .json if an exact match doesn't exist.
-    Returns (tflite_path, json_path) or (None, None).
-    """
     if not output_dir.exists():
         return (None, None)
 
-    tflites = sorted(output_dir.glob("*.tflite"), key=lambda p: p.stat().st_mtime, reverse=True)
+    tflites = sorted(output_dir.rglob("*.tflite"), key=lambda p: p.stat().st_mtime, reverse=True)
     if not tflites:
         return (None, None)
 
@@ -700,14 +1249,11 @@ def _find_latest_output_pair(output_dir: Path) -> Tuple[Optional[Path], Optional
     if js.exists():
         return (tfl, js)
 
-    jsons = sorted(output_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
+    jsons = sorted(output_dir.rglob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
     return (tfl, jsons[0] if jsons else None)
 
 
 def _deep_replace_strings(obj: Any, old: str, new: str) -> Any:
-    """
-    Recursively replace occurrences of old in any string values with new.
-    """
     if isinstance(obj, str):
         return obj.replace(old, new)
     if isinstance(obj, list):
@@ -718,80 +1264,57 @@ def _deep_replace_strings(obj: Any, old: str, new: str) -> Any:
 
 
 def _normalize_output_artifacts(safe_word: str, log_path: Path) -> None:
-    """
-    Rename output artifacts to <safe_word>.tflite / <safe_word>.json
-    and patch the JSON so it references the renamed tflite.
-
-    Handles weird trainer names like ____r_.tflite by normalizing post-run.
-    """
-    out_dir = DATA_DIR / "output"
-    tfl, js = _find_latest_output_pair(out_dir)
+    output_root = DATA_DIR / "output"
+    tfl, js = _find_latest_output_pair(output_root)
 
     if not tfl:
-        _append_train_log(f"⚠️ No .tflite found in {out_dir}")
+        _append_train_log(f"⚠️ No .tflite found in {output_root}")
         return
 
-    new_tfl = out_dir / f"{safe_word}.tflite"
-    new_js = out_dir / f"{safe_word}.json"
+    new_tfl = tfl.parent / f"{safe_word}.tflite"
+    new_js = tfl.parent / f"{safe_word}.json"
     old_tfl_name = tfl.name
 
-    # Already normalized
-    if tfl.name == new_tfl.name and (js and js.name == new_js.name):
-        _append_train_log(f"✅ Output names already normalized: {new_tfl.name}")
-        return
-
-    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
-
-    def backup_if_exists(p: Path, suffix: str) -> None:
-        if p.exists():
-            bk = out_dir / f"{safe_word}.{ts}.bak{suffix}"
-            shutil.move(str(p), str(bk))
-            _append_train_log(f"↪️ Backed up existing {p.name} → {bk.name}")
-
-    # Avoid clobbering existing target files (back them up)
-    if new_tfl.exists() and new_tfl.resolve() != tfl.resolve():
-        backup_if_exists(new_tfl, ".tflite")
-    if new_js.exists() and (not js or new_js.resolve() != js.resolve()):
-        backup_if_exists(new_js, ".json")
-
-    # Rename tflite
     if tfl.resolve() != new_tfl.resolve():
-        new_tfl.parent.mkdir(parents=True, exist_ok=True)
+        if new_tfl.exists():
+            backup = new_tfl.with_name(f"{new_tfl.stem}.{datetime.now().strftime('%Y%m%d_%H%M%S')}.bak.tflite")
+            shutil.move(str(new_tfl), str(backup))
+            _append_train_log(f"↪️ Backed up existing {new_tfl.name} → {backup.name}")
         shutil.move(str(tfl), str(new_tfl))
         _append_train_log(f"✅ Renamed model: {old_tfl_name} → {new_tfl.name}")
 
-    # Rename + patch json if present
     if js and js.exists():
-        # Read JSON before move (safer if we want the old name)
         try:
             data = json.loads(js.read_text(encoding="utf-8"))
         except Exception:
             data = None
 
         if js.resolve() != new_js.resolve():
+            if new_js.exists():
+                backup = new_js.with_name(f"{new_js.stem}.{datetime.now().strftime('%Y%m%d_%H%M%S')}.bak.json")
+                shutil.move(str(new_js), str(backup))
+                _append_train_log(f"↪️ Backed up existing {new_js.name} → {backup.name}")
             shutil.move(str(js), str(new_js))
             _append_train_log(f"✅ Renamed metadata: {js.name} → {new_js.name}")
 
         if data is not None:
             patched = _deep_replace_strings(data, old_tfl_name, new_tfl.name)
-
-            # Patch common keys if present
             for key in ("model", "model_file", "model_filename", "tflite", "tflite_file", "tflite_filename"):
                 if isinstance(patched, dict) and key in patched and isinstance(patched[key], str):
                     patched[key] = new_tfl.name
-
             new_js.write_text(json.dumps(patched, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
             _append_train_log(f"✅ Patched JSON to reference: {new_tfl.name}")
     else:
         _append_train_log("⚠️ No .json found to patch (model renamed only)")
 
+    _sync_trained_wake_word_artifacts()
+    _append_train_log(f"✅ Trained wake words synced to {TRAINED_WAKE_WORDS_DIR}")
 
-# -------------------- training worker --------------------
 
-def _run_training_background(safe_word: str, allow_no_personal: bool):
+def _run_training_background(safe_word: str, language: str, allow_no_personal: bool):
+    language = (language or DEFAULT_LANGUAGE).strip().lower() or DEFAULT_LANGUAGE
     with STATE_LOCK:
         raw_phrase = STATE.get("raw_phrase") or ""
-        language = STATE.get("language") or DEFAULT_LANGUAGE
 
     wake_word_title = _title_from_phrase(raw_phrase)
 
@@ -806,13 +1329,13 @@ def _run_training_background(safe_word: str, allow_no_personal: bool):
         STATE["training"]["log_path"] = str(log_path)
 
     _append_train_log("================================================================================")
-    _append_train_log("===== Recorder Training Run =====")
+    _append_train_log("===== Nvidia Docker Training Run =====")
     _append_train_log("================================================================================")
 
     try:
         with open(log_path, "a", encoding="utf-8") as lf:
             lf.write("\n" + ("=" * 80) + "\n")
-            lf.write("===== Recorder Training Run =====\n")
+            lf.write("===== Nvidia Docker Training Run =====\n")
             lf.write(("=" * 80) + "\n")
             lf.flush()
     except Exception:
@@ -857,7 +1380,6 @@ def _run_training_background(safe_word: str, allow_no_personal: bool):
         with STATE_LOCK:
             STATE["training"]["exit_code"] = rc
 
-        # Normalize output artifact names on success
         if rc == 0:
             _normalize_output_artifacts(safe_word, log_path)
 
@@ -871,6 +1393,760 @@ def _run_training_background(safe_word: str, allow_no_personal: bool):
             STATE["training"]["running"] = False
 
 
+# -------------------- Firmware flasher --------------------
+def _template_default_string(raw_value: Any) -> str:
+    if isinstance(raw_value, dict) and raw_value.get("__secret__"):
+        return ""
+    if isinstance(raw_value, bool):
+        return "true" if raw_value else "false"
+    if raw_value is None:
+        return ""
+    return str(raw_value)
+
+
+def _humanize_key(key: str) -> str:
+    token = str(key or "").strip()
+    if not token:
+        return "Value"
+    special = {
+        "ha": "HA",
+        "ip": "IP",
+        "id": "ID",
+        "ssid": "SSID",
+        "wifi": "Wi-Fi",
+        "xmos": "XMOS",
+        "fw": "FW",
+    }
+    return " ".join(special.get(part.lower(), part.capitalize()) for part in token.replace("_", " ").split())
+
+
+def _firmware_template_spec(template_key: str) -> Dict[str, Any]:
+    token = (template_key or "").strip().lower()
+    for spec in FIRMWARE_TEMPLATE_SPECS:
+        if str(spec.get("key") or "").lower() == token:
+            return dict(spec)
+    raise ValueError("Unknown firmware template.")
+
+
+def _firmware_raw_url(path: str) -> str:
+    clean = str(path or "").strip().lstrip("/")
+    return f"https://raw.githubusercontent.com/{FIRMWARE_GITHUB_OWNER}/{FIRMWARE_GITHUB_REPO}/{FIRMWARE_GITHUB_REF}/{clean}"
+
+
+def _fetch_text_url(url: str, timeout: float = 20) -> str:
+    req = URLRequest(url, headers={"User-Agent": "microWakeWord-Trainer/1.0"})
+    with urlopen(req, timeout=timeout) as response:
+        charset = response.headers.get_content_charset() or "utf-8"
+        return response.read().decode(charset, errors="replace")
+
+
+def _load_firmware_template_text(spec: Dict[str, Any]) -> tuple[str, str]:
+    rel_path = str(spec.get("path") or "").strip()
+    url = _firmware_raw_url(rel_path)
+    try:
+        return _fetch_text_url(url, timeout=20), url
+    except Exception as exc:
+        raise RuntimeError(f"Could not download firmware template from {url}: {exc}") from exc
+
+
+def _extract_substitution_sections(raw_text: str) -> Dict[str, str]:
+    section_map: Dict[str, str] = {}
+    in_substitutions = False
+    current_section = "Firmware"
+
+    for line in raw_text.splitlines():
+        if not in_substitutions:
+            if re.match(r"^\s*substitutions:\s*$", line):
+                in_substitutions = True
+            continue
+        if line and not line.startswith((" ", "\t")):
+            break
+        stripped = line.strip()
+        if not stripped:
+            continue
+        if stripped.startswith("#"):
+            comment = stripped[1:].strip()
+            if comment and set(comment) > {"-"} and len(comment) <= 48 and re.search(r"[A-Za-z]", comment):
+                current_section = comment.title() if comment.isupper() else comment
+            continue
+        match = re.match(r"^([A-Za-z0-9_]+)\s*:", stripped)
+        if match:
+            section_map[match.group(1)] = current_section
+    return section_map
+
+
+def _load_firmware_profiles() -> Dict[str, Dict[str, str]]:
+    with contextlib.suppress(Exception):
+        if FIRMWARE_PROFILE_FILE.exists():
+            parsed = json.loads(FIRMWARE_PROFILE_FILE.read_text(encoding="utf-8"))
+            if isinstance(parsed, dict):
+                return {
+                    str(key): {str(k): str(v) for k, v in value.items()}
+                    for key, value in parsed.items()
+                    if isinstance(value, dict)
+                }
+    return {}
+
+
+def _save_firmware_profile(template_key: str, values: Dict[str, str]) -> None:
+    FIRMWARE_PROFILE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    profiles = _load_firmware_profiles()
+    profiles[template_key] = {str(key): str(value) for key, value in values.items() if str(key)}
+    FIRMWARE_PROFILE_FILE.write_text(json.dumps(profiles, indent=2, sort_keys=True), encoding="utf-8")
+
+
+def _normalize_firmware_profile_update(template_key: str, values: Dict[str, Any]) -> Dict[str, str]:
+    ctx = _load_firmware_template_context(template_key)
+    spec = ctx["spec"]
+    profile = ctx.get("profile") if isinstance(ctx.get("profile"), dict) else {}
+    substitutions = ctx["substitutions"]
+    normalized: Dict[str, str] = dict(profile)
+    fixed_keys = set(spec.get("fixed_keys") or set())
+    identity_key = str(spec.get("identity_key") or "").strip()
+    if identity_key:
+        fixed_keys.add(identity_key)
+
+    for key in substitutions.keys():
+        key_text = str(key or "").strip()
+        if not key_text:
+            continue
+        default = _template_default_string(substitutions.get(key_text))
+        if key_text in fixed_keys:
+            normalized[key_text] = default
+            continue
+        if key_text == "wifi_password":
+            raw_password = str(values.get(key_text) or "").strip()
+            if raw_password:
+                normalized[key_text] = raw_password
+            elif key_text not in normalized:
+                normalized[key_text] = ""
+            continue
+        if key_text == "hidden_ssid":
+            if key_text in values:
+                normalized[key_text] = "true" if _parse_bool(values.get(key_text)) else "false"
+            elif key_text not in normalized:
+                normalized[key_text] = "true" if str(default).lower() == "true" else "false"
+            continue
+        if key_text in values:
+            normalized[key_text] = str(values.get(key_text) or "").strip()
+        elif key_text not in normalized:
+            normalized[key_text] = default
+
+    wake_word_choice = str(values.get("wake_word_choice") or "").strip()
+    if wake_word_choice:
+        normalized["wake_word_choice"] = wake_word_choice
+
+    target_host = str(values.get("__target_host") or "").strip()
+    target_port = str(values.get("__target_port") or "").strip()
+    if target_port == "6053":
+        target_port = str(FIRMWARE_DEFAULT_OTA_PORT)
+    if target_host:
+        normalized["__target_host"] = target_host
+    if target_port:
+        normalized["__target_port"] = target_port
+
+    return normalized
+
+
+def _load_firmware_template_context(template_key: str) -> Dict[str, Any]:
+    spec = _firmware_template_spec(template_key)
+    raw_text, source_label = _load_firmware_template_text(spec)
+    parsed = yaml.load(raw_text, Loader=_FirmwareYamlLoader)
+    if not isinstance(parsed, dict):
+        raise RuntimeError(f"Firmware template {spec.get('label') or template_key} did not parse into a YAML mapping.")
+    substitutions = parsed.get("substitutions") if isinstance(parsed.get("substitutions"), dict) else {}
+    if not substitutions:
+        raise RuntimeError(f"Firmware template {spec.get('label') or template_key} has no substitutions.")
+    return {
+        "spec": spec,
+        "raw_text": raw_text,
+        "source_label": source_label,
+        "template_doc": parsed,
+        "substitutions": dict(substitutions),
+        "sections": _extract_substitution_sections(raw_text),
+        "profile": _load_firmware_profiles().get(str(spec.get("key") or ""), {}),
+    }
+
+
+def _firmware_template_fields(template_key: str, base_url: str = "") -> List[Dict[str, Any]]:
+    ctx = _load_firmware_template_context(template_key)
+    spec = ctx["spec"]
+    profile = ctx.get("profile") if isinstance(ctx.get("profile"), dict) else {}
+    fields: List[Dict[str, Any]] = []
+    fixed_keys = set(spec.get("fixed_keys") or set())
+    identity_key = str(spec.get("identity_key") or "").strip()
+    if identity_key:
+        fixed_keys.add(identity_key)
+    hidden_keys = {"ha_voice_ip"} | set(spec.get("auto_keys") or set())
+    trained_wake_words = _list_trained_wake_words(base_url)
+    current_wake_word_name = str(
+        profile.get("wake_word_name") or _template_default_string(ctx["substitutions"].get("wake_word_name"))
+    ).strip()
+    saved_wake_word_choice = str(profile.get("wake_word_choice") or "").strip()
+    selected_wake_word = next(
+        (row["key"] for row in trained_wake_words if row.get("key") == saved_wake_word_choice),
+        "",
+    ) or next(
+        (row["key"] for row in trained_wake_words if row.get("wake_word_name") == current_wake_word_name),
+        "",
+    )
+    wake_picker_added = False
+
+    for key, raw_value in ctx["substitutions"].items():
+        key_text = str(key or "").strip()
+        if not key_text or key_text in hidden_keys:
+            continue
+
+        if key_text in {"wake_word_name", "wake_word_model_url"} and not wake_picker_added:
+            fields.append(
+                {
+                    "key": "wake_word_choice",
+                    "label": "Trained Wake Word",
+                    "type": "wake_word_select",
+                    "value": selected_wake_word,
+                    "placeholder": "Choose a trained wake word...",
+                    "description": (
+                        "Select a locally trained wake word to fill the name and model URL below."
+                        if trained_wake_words
+                        else "No locally trained wake words found yet. Train one first, then return here."
+                    ),
+                    "options": trained_wake_words,
+                    "section": "Micro Wake Word",
+                }
+            )
+            wake_picker_added = True
+
+        default = _template_default_string(raw_value)
+        saved = str(profile.get(key_text) or "")
+        field_type = "text"
+        read_only = key_text in fixed_keys
+        value = default if read_only else (saved or default)
+        placeholder = ""
+        description = ""
+        label = _humanize_key(key_text)
+
+        if read_only:
+            label = "Device Name" if key_text == identity_key else label
+            description = "Locked to the selected firmware YAML."
+        elif key_text == "wifi_password":
+            field_type = "password"
+            value = ""
+            placeholder = "Leave blank to keep saved password" if saved else "Required before flashing"
+            description = "Required for the first build. Leave blank later to keep the saved value."
+        elif key_text == "hidden_ssid":
+            field_type = "checkbox"
+            value = str(saved or default).lower() == "true"
+        elif key_text == "wifi_ssid":
+            placeholder = "Your Wi-Fi SSID"
+            description = "Required before build + flash."
+        elif key_text == "wake_word_model_url":
+            placeholder = "https://.../wake_word.json"
+        elif key_text == "wake_word_name":
+            placeholder = "hey_tater"
+        section = ctx["sections"].get(key_text) or "Firmware"
+        if key_text in {"wake_word_name", "wake_word_model_url"}:
+            section = "Micro Wake Word"
+        elif key_text.endswith("_sound_file"):
+            section = "Sounds"
+
+        fields.append(
+            {
+                "key": key_text,
+                "label": label,
+                "type": field_type,
+                "value": value,
+                "placeholder": placeholder,
+                "description": description,
+                "read_only": read_only,
+                "section": section,
+            }
+        )
+    return fields
+
+
+def _esphome_pythonpath() -> str:
+    existing = os.environ.get("PYTHONPATH", "")
+    candidates = []
+    env_repo = os.environ.get("ESPHOME_REPO_DIR")
+    if env_repo:
+        candidates.extend(Path(part).expanduser() for part in env_repo.split(os.pathsep) if part)
+    candidates.append(ROOT_DIR.parent / "esphome")
+
+    paths = [str(path) for path in candidates if (path / "esphome").is_dir()]
+    if existing:
+        paths.append(existing)
+    return os.pathsep.join(paths)
+
+
+def _render_firmware_config(template_key: str, values: Dict[str, Any], host: str, session_id: str) -> tuple[Path, Dict[str, str]]:
+    ctx = _load_firmware_template_context(template_key)
+    spec = ctx["spec"]
+    profile = ctx.get("profile") if isinstance(ctx.get("profile"), dict) else {}
+    substitutions = ctx["substitutions"]
+    normalized: Dict[str, str] = dict(profile)
+    fixed_keys = set(spec.get("fixed_keys") or set())
+    identity_key = str(spec.get("identity_key") or "").strip()
+    if identity_key:
+        fixed_keys.add(identity_key)
+
+    for key in substitutions.keys():
+        key_text = str(key or "").strip()
+        if not key_text:
+            continue
+        raw_value = values.get(key_text)
+        if key_text in fixed_keys:
+            normalized[key_text] = _template_default_string(substitutions.get(key_text))
+        elif key_text == "wifi_password":
+            normalized[key_text] = str(raw_value or "").strip() or str(profile.get(key_text) or "")
+        elif key_text == "hidden_ssid":
+            normalized[key_text] = "true" if bool(raw_value) else "false"
+        elif key_text == "ha_voice_ip":
+            normalized[key_text] = host
+        else:
+            normalized[key_text] = str(raw_value if raw_value is not None else "").strip() or _template_default_string(
+                substitutions.get(key_text)
+            )
+
+    missing = []
+    if not normalized.get("wifi_ssid"):
+        missing.append("Wi-Fi SSID")
+    if not normalized.get("wifi_password"):
+        missing.append("Wi-Fi password")
+    if not host:
+        missing.append("device IP or hostname")
+    if missing:
+        raise RuntimeError(f"Missing required firmware values: {', '.join(missing)}.")
+
+    config = copy.deepcopy(ctx["template_doc"])
+    config["substitutions"] = {key: str(normalized.get(key, "")) for key in substitutions.keys()}
+    esphome_block = config.get("esphome") if isinstance(config.get("esphome"), dict) else None
+    if isinstance(esphome_block, dict):
+        esphome_block["build_path"] = str(FIRMWARE_CACHE_DIR / "builds" / session_id / str(spec.get("key") or template_key))
+        config["esphome"] = esphome_block
+
+    session_dir = FIRMWARE_CACHE_DIR / "configs" / session_id
+    session_dir.mkdir(parents=True, exist_ok=True)
+    config_path = session_dir / f"{str(spec.get('key') or template_key)}.yaml"
+    config_path.write_text(yaml.dump(config, Dumper=_FirmwareYamlDumper, sort_keys=False, allow_unicode=True), encoding="utf-8")
+    _save_firmware_profile(str(spec.get("key") or template_key), normalized)
+    return config_path, normalized
+
+
+def _firmware_session_payload(session_id: str) -> Dict[str, Any]:
+    with FIRMWARE_LOCK:
+        session = FIRMWARE_SESSIONS.get(session_id)
+        if not isinstance(session, dict):
+            return {"ok": False, "error": "Firmware flash session not found."}
+        return {
+            "ok": True,
+            "session_id": session_id,
+            "running": bool(session.get("running")),
+            "exit_code": session.get("exit_code"),
+            "host": session.get("host"),
+            "port": session.get("port"),
+            "filename": session.get("filename"),
+            "message": session.get("message") or "",
+            "log_lines": list(session.get("log_lines") or []),
+            "started_at": session.get("started_at"),
+            "finished_at": session.get("finished_at"),
+        }
+
+
+def _clean_terminal_text(value: Any) -> str:
+    text_value = str(value or "")
+    if not text_value:
+        return ""
+    clean = ANSI_ESCAPE_RE.sub("", text_value).replace("\r", "")
+    clean = "".join(ch for ch in clean if ch == "\t" or ord(ch) >= 32)
+    return clean.strip()
+
+
+def _append_firmware_log(session_id: str, line: str):
+    clean = _clean_terminal_text(line)
+    if not clean:
+        return
+    with FIRMWARE_LOCK:
+        session = FIRMWARE_SESSIONS.get(session_id)
+        if not isinstance(session, dict):
+            return
+        lines: List[str] = session.setdefault("log_lines", [])
+        lines.append(clean)
+        if len(lines) > FIRMWARE_MAX_LOG_LINES:
+            del lines[: len(lines) - FIRMWARE_MAX_LOG_LINES]
+
+
+def _firmware_runner_env(*, include_esphome_pythonpath: bool = False) -> Dict[str, str]:
+    FIRMWARE_HOME_DIR.mkdir(parents=True, exist_ok=True)
+    FIRMWARE_XDG_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    FIRMWARE_PLATFORMIO_DIR.mkdir(parents=True, exist_ok=True)
+    env = os.environ.copy()
+    env.pop("PYTHONPATH", None)
+    env["PYTHONUNBUFFERED"] = "1"
+    env["HOME"] = str(FIRMWARE_HOME_DIR)
+    env["XDG_CACHE_HOME"] = str(FIRMWARE_XDG_CACHE_DIR)
+    env["PLATFORMIO_CORE_DIR"] = str(FIRMWARE_PLATFORMIO_DIR)
+    env["PLATFORMIO_CACHE_DIR"] = str(FIRMWARE_PLATFORMIO_DIR / "cache")
+    if include_esphome_pythonpath:
+        pythonpath = _esphome_pythonpath()
+        if pythonpath:
+            env["PYTHONPATH"] = pythonpath
+    return env
+
+
+def _normalize_firmware_filename(raw_name: str) -> str:
+    name = Path(raw_name or "firmware.bin").name
+    name = re.sub(r"[^A-Za-z0-9._-]+", "_", name).strip("._")
+    return name or "firmware.bin"
+
+
+def _parse_flash_target(raw_host: str, raw_port: Any = None) -> tuple[str, int]:
+    host_text = (raw_host or "").strip()
+    if not host_text:
+        raise ValueError("Device IP or hostname is required.")
+
+    if "://" in host_text:
+        parsed = urlparse(host_text)
+        host_text = parsed.hostname or ""
+        if raw_port in (None, "") and parsed.port:
+            raw_port = parsed.port
+
+    host_text = host_text.strip().strip("/")
+    if "/" in host_text:
+        host_text = host_text.split("/", 1)[0].strip()
+
+    if host_text.count(":") == 1:
+        maybe_host, maybe_port = host_text.rsplit(":", 1)
+        if maybe_port.isdigit():
+            host_text = maybe_host.strip("[]")
+            raw_port = maybe_port
+
+    host_text = host_text.strip("[]").strip()
+    if not host_text:
+        raise ValueError("Device IP or hostname is required.")
+    if not re.match(r"^[A-Za-z0-9_.:-]+$", host_text):
+        raise ValueError("Device host contains unsupported characters.")
+
+    try:
+        port = int(raw_port or FIRMWARE_DEFAULT_OTA_PORT)
+    except Exception as exc:
+        raise ValueError("OTA port must be a number.") from exc
+    if port < 1 or port > 65535:
+        raise ValueError("OTA port must be between 1 and 65535.")
+    return host_text, port
+
+
+def _firmware_display_command(command: List[str]) -> str:
+    parts = []
+    skip_next = False
+    for token in command:
+        if skip_next:
+            parts.append("***")
+            skip_next = False
+            continue
+        parts.append(token)
+        if token == "--password":
+            skip_next = True
+    return " ".join(parts)
+
+
+def _run_firmware_flash_background(session_id: str):
+    with FIRMWARE_LOCK:
+        session = FIRMWARE_SESSIONS.get(session_id)
+        if not isinstance(session, dict):
+            return
+        host = str(session.get("host") or "")
+        port = int(session.get("port") or FIRMWARE_DEFAULT_OTA_PORT)
+        password = str(session.get("password") or "")
+        firmware_path = str(session.get("firmware_path") or "")
+
+    command = [
+        sys.executable,
+        "-u",
+        str(FIRMWARE_HELPER),
+        "--host",
+        host,
+        "--port",
+        str(port),
+    ]
+    if password:
+        command.extend(["--password", password])
+    command.append(firmware_path)
+
+    _append_firmware_log(session_id, "===== Firmware Flash Console =====")
+    _append_firmware_log(session_id, f"→ Device: {host}:{port}")
+    _append_firmware_log(session_id, f"→ Running: {_firmware_display_command(command)}")
+
+    try:
+        env = _firmware_runner_env()
+        proc = subprocess.Popen(
+            command,
+            cwd=str(ROOT_DIR),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            env=env,
+        )
+        with FIRMWARE_LOCK:
+            live = FIRMWARE_SESSIONS.get(session_id)
+            if isinstance(live, dict):
+                live["pid"] = int(proc.pid or 0)
+                live["message"] = "Firmware upload running."
+
+        assert proc.stdout is not None
+        for line in proc.stdout:
+            for part in line.replace("\r", "\n").splitlines():
+                _append_firmware_log(session_id, part)
+        rc = proc.wait()
+
+        if rc == 0:
+            _append_firmware_log(session_id, f"✓ Firmware flash finished (exit_code={rc})")
+        else:
+            _append_firmware_log(session_id, f"✗ Firmware flash failed (exit_code={rc})")
+        with FIRMWARE_LOCK:
+            live = FIRMWARE_SESSIONS.get(session_id)
+            if isinstance(live, dict):
+                live["running"] = False
+                live["exit_code"] = int(rc)
+                live["finished_at"] = datetime.now(timezone.utc).isoformat()
+                live["message"] = "Firmware upload completed." if rc == 0 else f"Firmware upload failed with exit code {rc}."
+    except Exception as exc:
+        _append_firmware_log(session_id, f"✗ Firmware flash crashed: {exc!r}")
+        with FIRMWARE_LOCK:
+            live = FIRMWARE_SESSIONS.get(session_id)
+            if isinstance(live, dict):
+                live["running"] = False
+                live["exit_code"] = 999
+                live["finished_at"] = datetime.now(timezone.utc).isoformat()
+                live["message"] = f"Firmware upload crashed: {exc}"
+
+
+def _run_firmware_build_flash_background(session_id: str):
+    with FIRMWARE_LOCK:
+        session = FIRMWARE_SESSIONS.get(session_id)
+        if not isinstance(session, dict):
+            return
+        host = str(session.get("host") or "")
+        port = int(session.get("port") or FIRMWARE_DEFAULT_OTA_PORT)
+        template_key = str(session.get("template_key") or "")
+        values = session.get("values") if isinstance(session.get("values"), dict) else {}
+
+    try:
+        config_path, _normalized = _render_firmware_config(template_key, values, host, session_id)
+    except Exception as exc:
+        _append_firmware_log(session_id, f"✗ Failed to prepare firmware config: {exc}")
+        with FIRMWARE_LOCK:
+            live = FIRMWARE_SESSIONS.get(session_id)
+            if isinstance(live, dict):
+                live["running"] = False
+                live["exit_code"] = 998
+                live["finished_at"] = datetime.now(timezone.utc).isoformat()
+                live["message"] = f"Firmware config failed: {exc}"
+        return
+
+    command = [
+        sys.executable,
+        "-m",
+        "esphome",
+        "run",
+        str(config_path),
+        "--no-logs",
+        "--device",
+        host,
+    ]
+
+    _append_firmware_log(session_id, "===== Firmware Build + Flash Console =====")
+    _append_firmware_log(session_id, f"→ Template: {template_key}")
+    _append_firmware_log(session_id, f"→ Device: {host}:{port}")
+    _append_firmware_log(session_id, f"→ Config: {config_path}")
+    _append_firmware_log(session_id, "→ Running: " + " ".join(command))
+
+    try:
+        env = _firmware_runner_env(include_esphome_pythonpath=True)
+        proc = subprocess.Popen(
+            command,
+            cwd=str(ROOT_DIR),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            env=env,
+        )
+        with FIRMWARE_LOCK:
+            live = FIRMWARE_SESSIONS.get(session_id)
+            if isinstance(live, dict):
+                live["pid"] = int(proc.pid or 0)
+                live["message"] = "Firmware build + flash running."
+                live["config_path"] = str(config_path)
+
+        assert proc.stdout is not None
+        for line in proc.stdout:
+            for part in line.replace("\r", "\n").splitlines():
+                _append_firmware_log(session_id, part)
+        rc = proc.wait()
+
+        if rc == 0:
+            _append_firmware_log(session_id, f"✓ Firmware build + flash finished (exit_code={rc})")
+        else:
+            with FIRMWARE_LOCK:
+                live_lines = list((FIRMWARE_SESSIONS.get(session_id) or {}).get("log_lines") or [])
+            joined_lines = "\n".join(live_lines)
+            if "uv installation via pip failed" in joined_lines or "Failed to install Python dependencies into penv" in joined_lines:
+                _append_firmware_log(
+                    session_id,
+                    "Tip: PlatformIO's ESP-IDF Python environment crashed while installing dependencies. "
+                    "Run Clean Build Files once, then retry the flash.",
+                )
+            _append_firmware_log(session_id, f"✗ Firmware build + flash failed (exit_code={rc})")
+        with FIRMWARE_LOCK:
+            live = FIRMWARE_SESSIONS.get(session_id)
+            if isinstance(live, dict):
+                live["running"] = False
+                live["exit_code"] = int(rc)
+                live["finished_at"] = datetime.now(timezone.utc).isoformat()
+                live["message"] = "Firmware flashed successfully." if rc == 0 else f"Firmware build + flash failed with exit code {rc}."
+    except Exception as exc:
+        _append_firmware_log(session_id, f"✗ Firmware build + flash crashed: {exc!r}")
+        with FIRMWARE_LOCK:
+            live = FIRMWARE_SESSIONS.get(session_id)
+            if isinstance(live, dict):
+                live["running"] = False
+                live["exit_code"] = 999
+                live["finished_at"] = datetime.now(timezone.utc).isoformat()
+                live["message"] = f"Firmware build + flash crashed: {exc}"
+
+
+def _dedupe_discovered_devices(devices: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    seen = set()
+    clean_devices: List[Dict[str, Any]] = []
+    for item in devices:
+        host = str(item.get("host") or "").strip()
+        name = str(item.get("name") or host or "ESPHome device").strip()
+        if not host:
+            continue
+        key = (host.lower(), int(item.get("port") or FIRMWARE_DEFAULT_OTA_PORT))
+        if key in seen:
+            continue
+        seen.add(key)
+        clean_devices.append(
+            {
+                "name": name,
+                "host": host,
+                "port": int(item.get("port") or FIRMWARE_DEFAULT_OTA_PORT),
+                "source": item.get("source") or "mdns",
+            }
+        )
+    return sorted(clean_devices, key=lambda row: (str(row.get("name") or "").lower(), str(row.get("host") or "")))
+
+
+def _discover_with_zeroconf(timeout_seconds: float) -> List[Dict[str, Any]]:
+    try:
+        from zeroconf import ServiceBrowser, ServiceListener, Zeroconf
+    except Exception:
+        return []
+
+    devices: List[Dict[str, Any]] = []
+
+    class Listener(ServiceListener):
+        def add_service(self, zeroconf, service_type, name):
+            info = zeroconf.get_service_info(service_type, name, timeout=1000)
+            if info is None:
+                return
+            addresses = []
+            for raw in getattr(info, "addresses", []) or []:
+                try:
+                    family = socket.AF_INET6 if len(raw) == 16 else socket.AF_INET
+                    addresses.append(socket.inet_ntop(family, raw))
+                except Exception:
+                    continue
+            host = addresses[0] if addresses else str(getattr(info, "server", "") or "").rstrip(".")
+            label = name.replace(service_type, "").rstrip(".") or host
+            devices.append(
+                {
+                    "name": label,
+                    "host": host,
+                    "port": FIRMWARE_DEFAULT_OTA_PORT,
+                    "source": "zeroconf",
+                }
+            )
+
+        def update_service(self, zeroconf, service_type, name):
+            self.add_service(zeroconf, service_type, name)
+
+        def remove_service(self, zeroconf, service_type, name):
+            return None
+
+    zeroconf = Zeroconf()
+    try:
+        ServiceBrowser(zeroconf, "_esphomelib._tcp.local.", Listener())
+        time.sleep(max(0.5, timeout_seconds))
+    finally:
+        zeroconf.close()
+    return _dedupe_discovered_devices(devices)
+
+
+def _discover_with_dns_sd(timeout_seconds: float) -> List[Dict[str, Any]]:
+    if not shutil.which("dns-sd"):
+        return []
+    try:
+        proc = subprocess.Popen(
+            ["dns-sd", "-B", "_esphomelib._tcp", "local"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+        )
+    except Exception:
+        return []
+
+    try:
+        time.sleep(max(0.5, timeout_seconds))
+        proc.terminate()
+        output, _ = proc.communicate(timeout=1.5)
+    except Exception:
+        with contextlib.suppress(Exception):
+            proc.kill()
+        output = ""
+
+    devices: List[Dict[str, Any]] = []
+    for line in (output or "").splitlines():
+        if " Add " not in f" {line} " or "_esphomelib._tcp" not in line:
+            continue
+        parts = line.split(None, 6)
+        if len(parts) < 7:
+            continue
+        instance = parts[-1].strip()
+        if not instance or instance.lower().startswith("local."):
+            continue
+        hostname = f"{re.sub(r'[^A-Za-z0-9_-]+', '-', instance).strip('-')}.local"
+        host = hostname
+        try:
+            host = socket.gethostbyname(hostname)
+        except Exception:
+            pass
+        devices.append(
+            {
+                "name": instance,
+                "host": host,
+                "port": FIRMWARE_DEFAULT_OTA_PORT,
+                "source": "dns-sd",
+            }
+        )
+    return _dedupe_discovered_devices(devices)
+
+
+def _discover_esphome_devices() -> tuple[List[Dict[str, Any]], str]:
+    devices = _discover_with_zeroconf(FIRMWARE_DISCOVERY_SECONDS)
+    if devices:
+        return devices, f"Found {len(devices)} ESPHome device{'' if len(devices) == 1 else 's'} with mDNS."
+
+    devices = _discover_with_dns_sd(FIRMWARE_DISCOVERY_SECONDS)
+    if devices:
+        return devices, f"Found {len(devices)} ESPHome device{'' if len(devices) == 1 else 's'} with dns-sd."
+
+    return [], "No ESPHome devices were auto-detected. Enter the device IP or hostname manually."
+
+
+# -------------------- Routes --------------------
 @app.get("/", response_class=HTMLResponse)
 def index():
     html_path = STATIC_DIR / "index.html"
@@ -879,7 +2155,10 @@ def index():
             "<h3>Missing UI</h3><p>Create <code>static/index.html</code>.</p>",
             status_code=500,
         )
-    return HTMLResponse(html_path.read_text(encoding="utf-8"))
+    return HTMLResponse(
+        html_path.read_text(encoding="utf-8"),
+        headers={"Cache-Control": "no-store, max-age=0"},
+    )
 
 
 @app.post("/api/start_session")
@@ -904,10 +2183,9 @@ def start_session(payload: Dict[str, Any]):
         STATE["language"] = language
         STATE["speakers_total"] = speakers_total
         STATE["takes_per_speaker"] = takes_per_speaker
-
+        # do not interrupt training if running
     takes = _sync_personal_samples_state()
 
-    # Always wipe log on start_session (even if same wakeword)
     _clear_training_log()
 
     return {
@@ -997,6 +2275,413 @@ async def upload_personal_sample(file: UploadFile = File(...)):
     return {"ok": True, **result, "takes_received": len(takes)}
 
 
+@app.post("/api/upload_captured_audio")
+async def upload_captured_audio(
+    file: UploadFile = File(...),
+    source_device: str | None = Form(None),
+    wake_word: str | None = Form(None),
+    event_type: str | None = Form(None),
+    captured_at: str | None = Form(None),
+    blocked_by_vad: str | None = Form(None),
+    max_probability: str | None = Form(None),
+    average_probability: str | None = Form(None),
+    notes: str | None = Form(None),
+    metadata_json: str | None = Form(None),
+):
+    data = await file.read()
+    try:
+        result = _save_captured_sample(data, file.filename or "captured")
+    except Exception as e:
+        return JSONResponse({"ok": False, "error": str(e)}, status_code=400)
+
+    extra_meta: Dict[str, Any] = {}
+    if metadata_json:
+        try:
+            parsed = json.loads(metadata_json)
+            if isinstance(parsed, dict):
+                extra_meta = parsed
+        except Exception:
+            return JSONResponse({"ok": False, "error": "metadata_json must be a JSON object"}, status_code=400)
+
+    with STATE_LOCK:
+        current_safe_word = STATE.get("safe_word")
+
+    audio_path = CAPTURED_DIR / result["saved_as"]
+    sidecar = {
+        **extra_meta,
+        "saved_as": result["saved_as"],
+        "original_name": result["original_name"],
+        "source_device": source_device or extra_meta.get("source_device") or "",
+        "wake_word": wake_word or extra_meta.get("wake_word") or current_safe_word or "",
+        "event_type": (event_type or extra_meta.get("event_type") or "captured").strip() or "captured",
+        "capture_label": extra_meta.get("capture_label") or "",
+        "captured_at": captured_at or extra_meta.get("captured_at") or "",
+        "received_at": datetime.now(timezone.utc).isoformat(),
+        "blocked_by_vad": _parse_bool(extra_meta.get("blocked_by_vad") if blocked_by_vad is None else blocked_by_vad),
+        "max_probability": _parse_float(extra_meta.get("max_probability") if max_probability is None else max_probability),
+        "average_probability": _parse_float(
+            extra_meta.get("average_probability") if average_probability is None else average_probability
+        ),
+        "notes": notes or extra_meta.get("notes") or "",
+        "converted": result["converted"],
+        "detected_format": result["detected_format"],
+        "final_format": result["final_format"],
+        "postprocess": result["postprocess"],
+        "message": result["message"],
+        "review_status": "pending",
+    }
+    _write_sidecar_json(audio_path, sidecar)
+
+    return {
+        "ok": True,
+        "item": _captured_item_from_path(audio_path),
+        "captured_count": len(_list_captured_sample_names()),
+    }
+
+
+@app.post("/api/upload_captured_audio_raw")
+async def upload_captured_audio_raw(
+    request: Request,
+    x_audio_format: str | None = Header(default=None),
+    x_original_name: str | None = Header(default=None),
+    x_source_device: str | None = Header(default=None),
+    x_wake_word: str | None = Header(default=None),
+    x_event_type: str | None = Header(default=None),
+    x_captured_at: str | None = Header(default=None),
+    x_blocked_by_vad: str | None = Header(default=None),
+    x_max_probability: str | None = Header(default=None),
+    x_average_probability: str | None = Header(default=None),
+    x_notes: str | None = Header(default=None),
+):
+    raw_data = await request.body()
+    audio_format = (x_audio_format or "wav").strip().lower()
+
+    try:
+        if audio_format == "pcm_s16le":
+            data = _pcm_s16le_to_wav_bytes(raw_data)
+            original_name = x_original_name or "captured.raw.wav"
+        elif audio_format in {"wav", "audio/wav", "audio/x-wav"}:
+            data = raw_data
+            original_name = x_original_name or "captured.wav"
+        else:
+            raise ValueError(f"Unsupported x-audio-format '{audio_format}'.")
+
+        result = _save_captured_sample(data, original_name)
+    except Exception as e:
+        return JSONResponse({"ok": False, "error": str(e)}, status_code=400)
+
+    with STATE_LOCK:
+        current_safe_word = STATE.get("safe_word")
+
+    audio_path = CAPTURED_DIR / result["saved_as"]
+    sidecar = {
+        "saved_as": result["saved_as"],
+        "original_name": result["original_name"],
+        "source_device": x_source_device or "",
+        "wake_word": x_wake_word or current_safe_word or "",
+        "event_type": (x_event_type or "captured").strip() or "captured",
+        "capture_label": "",
+        "captured_at": x_captured_at or "",
+        "received_at": datetime.now(timezone.utc).isoformat(),
+        "blocked_by_vad": _parse_bool(x_blocked_by_vad),
+        "max_probability": _parse_float(x_max_probability),
+        "average_probability": _parse_float(x_average_probability),
+        "notes": x_notes or "",
+        "converted": result["converted"],
+        "detected_format": result["detected_format"],
+        "final_format": result["final_format"],
+        "postprocess": result["postprocess"],
+        "message": result["message"],
+        "review_status": "pending",
+    }
+    _write_sidecar_json(audio_path, sidecar)
+
+    return {
+        "ok": True,
+        "item": _captured_item_from_path(audio_path),
+        "captured_count": len(_list_captured_sample_names()),
+    }
+
+
+@app.get("/api/captured_audio")
+def captured_audio():
+    takes = _sync_personal_samples_state()
+    items = _list_captured_items()
+    samples = _samples_payload()
+    return {
+        "ok": True,
+        "items": items,
+        "captured_count": len(items),
+        "negative_count": samples["negative_count"],
+        "personal_count": len(takes),
+    }
+
+
+@app.get("/api/samples")
+def samples():
+    return _samples_payload()
+
+
+@app.get("/api/audio/{bucket}/{file_name}")
+def audio_file(bucket: str, file_name: str):
+    bucket_map = {
+        "captured": CAPTURED_DIR,
+        "personal": PERSONAL_DIR,
+        "negative": NEGATIVE_DIR,
+    }
+    directory = bucket_map.get(bucket)
+    if directory is None:
+        return JSONResponse({"ok": False, "error": "Unknown audio bucket."}, status_code=404)
+    try:
+        path = _resolve_audio_path(directory, file_name)
+    except FileNotFoundError as e:
+        return JSONResponse({"ok": False, "error": str(e)}, status_code=404)
+    if bucket == "captured":
+        _ensure_captured_playback_ready(path, _load_sidecar_json(path))
+    return FileResponse(path, media_type="audio/wav", filename=path.name)
+
+
+@app.delete("/api/samples/{bucket}/{file_name}")
+def delete_sample(bucket: str, file_name: str):
+    bucket_map = {
+        "personal": PERSONAL_DIR,
+        "negative": NEGATIVE_DIR,
+    }
+    directory = bucket_map.get(bucket)
+    if directory is None:
+        return JSONResponse({"ok": False, "error": "Unknown sample bucket."}, status_code=404)
+    try:
+        path = _resolve_audio_path(directory, file_name)
+        _remove_audio_with_sidecar(path)
+    except FileNotFoundError as e:
+        return JSONResponse({"ok": False, "error": str(e)}, status_code=404)
+    return _samples_payload()
+
+
+@app.post("/api/captured_audio/{file_name}/approve_personal")
+def approve_captured_audio_to_personal(file_name: str):
+    try:
+        result = _move_captured_audio(file_name, PERSONAL_DIR, target_prefix="sample", review_status="approved_personal")
+    except FileNotFoundError as e:
+        return JSONResponse({"ok": False, "error": str(e)}, status_code=404)
+    except Exception as e:
+        return JSONResponse({"ok": False, "error": str(e)}, status_code=400)
+    return {"ok": True, **result}
+
+
+@app.post("/api/captured_audio/{file_name}/mark_negative")
+def mark_captured_audio_negative(file_name: str):
+    try:
+        result = _move_captured_audio(file_name, NEGATIVE_DIR, target_prefix="negative", review_status="approved_negative")
+    except FileNotFoundError as e:
+        return JSONResponse({"ok": False, "error": str(e)}, status_code=404)
+    except Exception as e:
+        return JSONResponse({"ok": False, "error": str(e)}, status_code=400)
+    return {"ok": True, **result}
+
+
+@app.post("/api/captured_audio/{file_name}/discard")
+def discard_captured_audio(file_name: str):
+    try:
+        path = _resolve_audio_path(CAPTURED_DIR, file_name)
+        _remove_audio_with_sidecar(path)
+    except FileNotFoundError as e:
+        return JSONResponse({"ok": False, "error": str(e)}, status_code=404)
+    return {"ok": True, "captured_count": len(_list_captured_sample_names())}
+
+
+@app.get("/api/firmware/devices")
+def firmware_devices():
+    devices, message = _discover_esphome_devices()
+    return {"ok": True, "devices": devices, "message": message}
+
+
+@app.get("/api/firmware/templates")
+def firmware_templates(request: Request):
+    templates = []
+    warnings = []
+    base_url = _request_base_url(request)
+    wake_words = _list_trained_wake_words(base_url)
+    profiles = _load_firmware_profiles()
+    for spec in FIRMWARE_TEMPLATE_SPECS:
+        key = str(spec.get("key") or "")
+        profile = profiles.get(key, {})
+        target_port = str(profile.get("__target_port") or "")
+        if target_port == "6053":
+            target_port = str(FIRMWARE_DEFAULT_OTA_PORT)
+        row = {
+            "value": key,
+            "label": str(spec.get("label") or key),
+            "source_url": _firmware_raw_url(str(spec.get("path") or "")),
+            "target_host": str(profile.get("__target_host") or ""),
+            "target_port": target_port,
+            "fields": [],
+        }
+        try:
+            row["fields"] = _firmware_template_fields(key, base_url)
+        except Exception as exc:
+            warnings.append(f"{row['label']}: {exc}")
+        templates.append(row)
+    return {
+        "ok": True,
+        "templates": templates,
+        "active_template_key": templates[0]["value"] if templates else "",
+        "wake_words": wake_words,
+        "warnings": warnings,
+    }
+
+
+@app.post("/api/firmware/profile")
+def firmware_profile(payload: Dict[str, Any]):
+    body = payload if isinstance(payload, dict) else {}
+    try:
+        template_key = str(body.get("template_key") or "").strip()
+        _firmware_template_spec(template_key)
+        values = body.get("values") if isinstance(body.get("values"), dict) else {}
+        saved = _normalize_firmware_profile_update(template_key, values)
+        _save_firmware_profile(template_key, saved)
+    except Exception as e:
+        return JSONResponse({"ok": False, "error": str(e)}, status_code=400)
+    return {"ok": True, "template_key": template_key, "saved_fields": sorted(saved.keys())}
+
+
+@app.get("/api/trained_wake_words/catalog")
+def trained_wake_words_catalog(request: Request):
+    return {"ok": True, "wake_words": _list_trained_wake_words(_request_base_url(request))}
+
+
+@app.get("/api/trained_wake_words/{filename}")
+def trained_wake_word_artifact(filename: str):
+    safe_filename = Path(filename or "").name
+    if not safe_filename or Path(safe_filename).suffix.lower() not in {".json", ".tflite"}:
+        return JSONResponse({"ok": False, "error": "Unsupported wake word artifact."}, status_code=400)
+    _sync_trained_wake_word_artifacts()
+    artifact_path = TRAINED_WAKE_WORDS_DIR / safe_filename
+    if not artifact_path.exists() or not artifact_path.is_file():
+        return JSONResponse({"ok": False, "error": "Wake word artifact not found."}, status_code=404)
+    media_type = "application/json" if artifact_path.suffix.lower() == ".json" else "application/octet-stream"
+    return FileResponse(str(artifact_path), media_type=media_type, filename=artifact_path.name)
+
+
+@app.post("/api/firmware/build_flash")
+def firmware_build_flash(payload: Dict[str, Any]):
+    body = payload if isinstance(payload, dict) else {}
+    try:
+        target_host, target_port = _parse_flash_target(str(body.get("host") or ""), body.get("port"))
+        template_key = str(body.get("template_key") or "").strip()
+        _firmware_template_spec(template_key)
+    except Exception as e:
+        return JSONResponse({"ok": False, "error": str(e)}, status_code=400)
+
+    values = body.get("values") if isinstance(body.get("values"), dict) else {}
+    session_id = f"fw_{uuid.uuid4().hex}"
+    session = {
+        "id": session_id,
+        "mode": "build_flash",
+        "running": True,
+        "exit_code": None,
+        "host": target_host,
+        "port": target_port,
+        "template_key": template_key,
+        "filename": "",
+        "values": values,
+        "message": "Preparing firmware build + flash.",
+        "log_lines": [],
+        "started_at": datetime.now(timezone.utc).isoformat(),
+        "finished_at": None,
+        "pid": None,
+    }
+    with FIRMWARE_LOCK:
+        FIRMWARE_SESSIONS[session_id] = session
+
+    worker = threading.Thread(target=_run_firmware_build_flash_background, args=(session_id,), daemon=True)
+    worker.start()
+    return _firmware_session_payload(session_id)
+
+
+@app.post("/api/firmware/clean")
+def firmware_clean():
+    active = []
+    with FIRMWARE_LOCK:
+        for session in FIRMWARE_SESSIONS.values():
+            if isinstance(session, dict) and bool(session.get("running")):
+                active.append(str(session.get("host") or session.get("template_key") or "firmware session"))
+    if active:
+        return JSONResponse({"ok": False, "error": f"Wait for active firmware session(s) to finish: {', '.join(active[:3])}."}, status_code=400)
+
+    removed = []
+    for child in ("configs", "builds", "platformio", "home", "cache"):
+        path = FIRMWARE_CACHE_DIR / child
+        if path.exists():
+            shutil.rmtree(path, ignore_errors=True)
+            removed.append(child)
+    return {
+        "ok": True,
+        "removed": removed,
+        "message": "Cleaned firmware build files." if removed else "No firmware build files needed cleaning.",
+    }
+
+
+@app.post("/api/firmware/flash")
+async def firmware_flash(
+    file: UploadFile = File(...),
+    host: str = Form(...),
+    port: str | None = Form(None),
+    password: str | None = Form(None),
+):
+    try:
+        target_host, target_port = _parse_flash_target(host, port)
+    except Exception as e:
+        return JSONResponse({"ok": False, "error": str(e)}, status_code=400)
+
+    original_name = file.filename or "firmware.bin"
+    filename = _normalize_firmware_filename(original_name)
+    if not filename.lower().endswith(".bin"):
+        return JSONResponse({"ok": False, "error": "Firmware upload must be a compiled .bin file."}, status_code=400)
+
+    data = await file.read()
+    if not data:
+        return JSONResponse({"ok": False, "error": "Firmware file is empty."}, status_code=400)
+    if not FIRMWARE_HELPER.exists():
+        return JSONResponse({"ok": False, "error": f"Firmware helper not found: {FIRMWARE_HELPER}"}, status_code=500)
+
+    session_id = f"fw_{uuid.uuid4().hex}"
+    session_dir = FIRMWARE_CACHE_DIR / session_id
+    session_dir.mkdir(parents=True, exist_ok=True)
+    firmware_path = session_dir / filename
+    firmware_path.write_bytes(data)
+
+    session = {
+        "id": session_id,
+        "running": True,
+        "exit_code": None,
+        "host": target_host,
+        "port": target_port,
+        "password": password or "",
+        "filename": filename,
+        "firmware_path": str(firmware_path),
+        "message": "Preparing firmware upload.",
+        "log_lines": [],
+        "started_at": datetime.now(timezone.utc).isoformat(),
+        "finished_at": None,
+        "pid": None,
+    }
+    with FIRMWARE_LOCK:
+        FIRMWARE_SESSIONS[session_id] = session
+
+    worker = threading.Thread(target=_run_firmware_flash_background, args=(session_id,), daemon=True)
+    worker.start()
+    return _firmware_session_payload(session_id)
+
+
+@app.get("/api/firmware/flash_status/{session_id}")
+def firmware_flash_status(session_id: str):
+    payload = _firmware_session_payload(session_id)
+    if not payload.get("ok"):
+        return JSONResponse(payload, status_code=404)
+    return payload
+
+
 @app.post("/api/train")
 def train_now(payload: Dict[str, Any] = None):
     payload = payload or {}
@@ -1004,6 +2689,7 @@ def train_now(payload: Dict[str, Any] = None):
 
     with STATE_LOCK:
         safe_word = STATE["safe_word"]
+        language = (STATE.get("language") or DEFAULT_LANGUAGE)
         takes_received = int(STATE["takes_received"])
         speakers_total = int(STATE["speakers_total"])
         takes_per_speaker = int(STATE["takes_per_speaker"])
@@ -1029,7 +2715,7 @@ def train_now(payload: Dict[str, Any] = None):
             status_code=400,
         )
 
-    t = threading.Thread(target=_run_training_background, args=(safe_word, allow_no_personal), daemon=True)
+    t = threading.Thread(target=_run_training_background, args=(safe_word, language, allow_no_personal), daemon=True)
     t.start()
 
     return {
@@ -1043,9 +2729,6 @@ def train_now(payload: Dict[str, Any] = None):
 
 @app.get("/api/train_status")
 def train_status():
-    """
-    Return only NEW lines since last poll (prevents UI duplication spam even if UI appends).
-    """
     with STATE_LOCK:
         tr = dict(STATE["training"])
         log_path_str = tr.get("log_path")
@@ -1064,20 +2747,18 @@ def train_status():
             except Exception:
                 size_now = 0
 
-            # If file was truncated/cleared, reset history
             if size_now < prev_size:
                 prev_tail = []
 
             full_tail = _read_tail_lines(p, TRAIN_LOG_TAIL_LINES)
             new_lines = _compute_new_lines(prev_tail, full_tail)
 
-    # Save snapshot for next poll
     with STATE_LOCK:
         STATE["training"]["last_sent_tail"] = full_tail
         STATE["training"]["last_log_size"] = size_now
 
-    tr["log_text"] = "\n".join(new_lines)  # ONLY new lines
-    tr["log_tail_preview"] = "\n".join(full_tail)  # optional: handy for debugging
+    tr["log_text"] = "\n".join(new_lines)
+    tr["log_tail_preview"] = "\n".join(full_tail)
     tr["log_lines"] = full_tail
     return {"ok": True, "training": tr}
 
@@ -1087,3 +2768,9 @@ def reset_recordings():
     _reset_personal_samples_dir()
     takes = _sync_personal_samples_state()
     return {"ok": True, "takes_received": len(takes), "takes": takes}
+
+
+@app.post("/api/reset_negative_samples")
+def reset_negative_samples():
+    _reset_audio_dir(NEGATIVE_DIR)
+    return {"ok": True, "negative_count": len(_list_negative_samples())}