Expand test suite to ~170 tests across 3 tiers

Unit tests (65 → 95): Add 7 new test classes covering upload-audio
endpoint, motion model endpoint, community datasets, corrupt data
recovery, concurrent state rejection, duration edge cases, and sync
dataset validation.

E2E tests (18 → 44): Add 8 new test classes covering recording
lifecycle, playback lifecycle, delete with confirm/cancel dialogs,
dataset creation/switching, audio source radios, settings panel,
and form edge cases including localStorage persistence.

Hardware tests (24 → 31): Add 4 new test classes for existing
recording playback, record-then-playback fidelity and timing,
antenna/body_yaw data verification, and synthetic antenna playback.

Also:
- Add make_wav_bytes() helper to conftest.py for upload tests
- Create tests/REMOTE_TESTING.md documenting SSH/rsync workflow
- Update run_tests.py TEST_CLASS_DESCRIPTIONS with all new classes
- Update TESTING.md tables with new test counts
- Fix smart quotes (U+201D) in index.html that broke CSS selectors

TESTING.md

@@ -146,7 +146,7 @@ pytest tests/ --browser chromium
 | TestStartingUpMode | 3 | Starting-up mode rejects commands |
 | TestRecordEndpoint | 9 | POST /api/record validation and state transitions |
 | TestPlayEndpoint | 3 | POST /api/play validation |
-| TestStopEndpoints | 2 | POST /api/play/stop and /api/record/stop |
+| TestStopEndpoints | 3 | POST /api/play/stop and /api/record/stop |
 | TestMoveDelete | 4 | DELETE /api/moves/:id and file cleanup |
 | TestDatasets | 11 | Dataset create, select, root change, origin |
 | TestRegistryPersistence | 3 | Registry file survival across restarts |
@@ -154,6 +154,13 @@ pytest tests/ --browser chromium
 | TestExperiments | 4 | Feature toggles and experimental settings |
 | TestHfAutoLogin | 5 | HF auto-login detection and caching |
 | TestSensorData | 1 | Sensor data dummy endpoint |
+| TestUploadAudio | 7 | POST /api/upload-audio validation and integration |
+| TestMotionModelEndpoint | 4 | POST /api/motion-model enable, set, persist |
+| TestCommunityDatasets | 3 | Community dataset listing and download validation |
+| TestCorruptData | 4 | Malformed JSON and corrupt registry recovery |
+| TestConcurrentStateChanges | 4 | Concurrent operations rejected when busy |
+| TestDurationEdgeCases | 3 | Duration boundary validation (gt=0.5, le=300) |
+| TestSyncDatasetExtended | 4 | Sync endpoint edge cases and validation |
 
 ### E2E browser tests (`tests/e2e/test_ui.py`)
 
@@ -165,6 +172,14 @@ pytest tests/ --browser chromium
 | TestFormValidation | 5 | Form fields and HTML5 validation |
 | TestRecordingSubmission | 1 | Recording submission changes mode |
 | TestDatasetUI | 2 | Dataset UI elements visible |
+| TestRecordingLifecycle | 4 | Recording submit, stop, and injected move visibility |
+| TestPlaybackLifecycle | 3 | Play button, queued playback, and move metadata |
+| TestDeleteMove | 3 | Delete button, confirm/cancel dialog handling |
+| TestCreateDataset | 4 | New dataset form show/hide/create/validate |
+| TestSwitchDataset | 2 | Dataset switching and dropdown population |
+| TestAudioSourceRadios | 3 | Audio source radio buttons and upload area toggle |
+| TestSettingsPanel | 3 | Settings expand, experimental toggle, root display |
+| TestFormEdgeCases | 4 | Empty/long/special labels and localStorage persistence |
 
 ### Hardware tests (`tests/test_hardware.py`)
 
@@ -177,6 +192,10 @@ pytest tests/ --browser chromium
 | TestMotionAccuracy | 3 | Synthetic playback accuracy — reference vs observed poses |
 | TestMultiDuration | 7 | Recording and playback across 1s/3s/5s/10s durations |
 | TestPerformance | 3 | Startup, recording, and playback latency benchmarks |
+| TestExistingRecordingPlayback | 2 | Play back existing audio and silent recordings |
+| TestRecordingRoundTrip | 2 | Record → playback fidelity and timing verification |
+| TestAntennaAndBodyYaw | 2 | Verify antenna and body_yaw data in recordings |
+| TestPlaybackAntennas | 1 | Synthetic antenna oscillation playback |
 | TestHardwareAudio | 3 | Audio recording and playback (may skip on mic issues) |
 
 ## View the matrix without running tests
@@ -246,7 +265,7 @@ git push
 
 ```
 tests/
-├── conftest.py          # Shared fixtures (TestClient, temp paths)
+├── conftest.py          # Shared fixtures (TestClient, temp paths, make_wav_bytes)
 ├── test_api.py          # Unit tests — backend API
 ├── test_hardware.py     # Hardware integration tests (real robot)
 ├── pose_utils.py        # Trajectory comparison utilities
@@ -255,7 +274,11 @@ tests/
 │   └── test_ui.py       # E2E browser tests
 ├── run_tests.py         # Test runner + matrix logger + web export
 ├── run_on_robot.py      # Remote test runner (SSH + rsync to robot)
+├── run_smoke_on_robot.py # Smoke test runner (SSH + rsync)
+├── smoke_test_on_robot.py # Smoke test script (runs on robot)
 ├── show_matrix.py       # Matrix viewer
+├── REMOTE_TESTING.md    # SSH/rsync workflow documentation
+├── HARDWARE_TEST_PLAN.md # Hardware test plan
 └── test_results.json    # Auto-generated results log (git-ignored)
 
 marionette/static/

marionette/static/index.html

@@ -158,44 +158,44 @@
         </details>
       </section>
 
-      <section class=”panel config-panel”>
-        <details id=”config-details”>
+      <section class="panel config-panel">
+        <details id="config-details">
           <summary>Settings</summary>
-          <div class=”config-content”>
-            <form id=”dataset-root-form” class=”settings-row”>
-              <div class=”field-group” style=”flex:1”>
-                <label for=”dataset-root-input”>Datasets folder</label>
+          <div class="config-content">
+            <form id="dataset-root-form" class="settings-row">
+              <div class="field-group" style="flex:1">
+                <label for="dataset-root-input">Datasets folder</label>
                 <input
-                  id=”dataset-root-input”
-                  type=”text”
-                  placeholder=”/home/user/datasets”
+                  id="dataset-root-input"
+                  type="text"
+                  placeholder="/home/user/datasets"
                   required
                 />
-                <p class=”hint”>All datasets live under <code id=”dataset-root-inline”>local_dataset/</code>.</p>
+                <p class="hint">All datasets live under <code id="dataset-root-inline">local_dataset/</code>.</p>
               </div>
-              <button type=”submit” class=”ghost-btn”>Update</button>
+              <button type="submit" class="ghost-btn">Update</button>
             </form>
 
-            <div class=”experimental-block” id=”experimental-panel” hidden>
-              <details id=”experimental-details”>
+            <div class="experimental-block" id="experimental-panel" hidden>
+              <details id="experimental-details">
                 <summary>Experimental</summary>
-                <div class=”experimental-content”>
-                  <p class=”hint”>Prototype features. May change or disappear without notice.</p>
-                  <div class=”field-group”>
-                    <label class=”toggle”>
-                      <input id=”feature-motion-models” type=”checkbox” />
+                <div class="experimental-content">
+                  <p class="hint">Prototype features. May change or disappear without notice.</p>
+                  <div class="field-group">
+                    <label class="toggle">
+                      <input id="feature-motion-models" type="checkbox" />
                       <span>Enable motion compensation models</span>
                     </label>
-                    <p class=”hint small”>
+                    <p class="hint small">
                       Replay moves through predictive filters to compensate P-controller lag.
                     </p>
                   </div>
-                  <div class=”field-group” id=”motion-model-group” hidden>
-                    <label for=”motion-model-select”>Motion model</label>
-                    <select id=”motion-model-select”></select>
-                    <p class=”hint” id=”motion-model-hint”></p>
+                  <div class="field-group" id="motion-model-group" hidden>
+                    <label for="motion-model-select">Motion model</label>
+                    <select id="motion-model-select"></select>
+                    <p class="hint" id="motion-model-hint"></p>
                   </div>
-                  <p class=”hint” id=”experimental-status”></p>
+                  <p class="hint" id="experimental-status"></p>
                 </div>
               </details>
             </div>

tests/REMOTE_TESTING.md

@@ -0,0 +1,190 @@
+# Remote Testing on Reachy Mini
+
+Run hardware tests directly on the robot via SSH + rsync. This avoids
+network-latency artefacts and ensures audio playback uses the robot's
+local speakers (WAV files are silently dropped over WebRTC).
+
+## Robot Models
+
+| Model | Default hostname | User | Notes |
+|-------|-----------------|------|-------|
+| **Wireless** | `reachy-mini.local` | `pollen` | Wi-Fi, mDNS discovery |
+| **Lite** | `reachy-mini.local` | `pollen` | Same procedure, may differ in hostname/IP |
+
+Both models use the same venv on-robot:
+
+```
+/venvs/apps_venv/bin/python
+```
+
+## One-Time SSH Key Setup
+
+Identical across Linux, macOS, and Windows (WSL2/Git Bash):
+
+```bash
+# Generate a key if you don't already have one
+ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519
+
+# Copy it to the robot (password: pollen)
+ssh-copy-id pollen@reachy-mini.local
+
+# Verify passwordless access
+ssh pollen@reachy-mini.local echo OK
+```
+
+## Network Discovery
+
+The robot advertises itself via mDNS as `reachy-mini.local`.
+
+| Platform | mDNS support | Notes |
+|----------|-------------|-------|
+| **Linux (Ubuntu)** | Requires `avahi-daemon` | Usually pre-installed; `sudo apt install avahi-daemon` if not |
+| **macOS** | Built-in (Bonjour) | Works out of the box |
+| **Windows** | Not native | Use WSL2 or Git Bash; fall back to `--host <IP>` |
+
+If mDNS doesn't resolve, find the robot's IP from your router or use:
+
+```bash
+python tests/run_on_robot.py --host 192.168.1.42
+```
+
+## What Gets Synced
+
+The `run_on_robot.py` script uses `rsync -avz --delete` to sync three
+items to `/tmp/marionette_test/` on the robot:
+
+| Local path | Remote path | Contents |
+|-----------|------------|----------|
+| `marionette/` | `/tmp/marionette_test/marionette/` | Python package |
+| `tests/` | `/tmp/marionette_test/tests/` | Test files |
+| `pyproject.toml` | `/tmp/marionette_test/pyproject.toml` | Package metadata |
+
+### Excluded from sync
+
+- `__pycache__/` — bytecode cache
+- `*.egg-info/` — build artefacts
+- `build/` — build output
+- `local_dataset/` — user data
+- `.pytest_cache/` — pytest cache
+- `dataset_registry.json` — local state
+- `temp_uploads/` — uploaded audio files
+- `tests/e2e/` — browser tests (no browser on robot)
+- `tests/test_results.json` — local results log
+- `.git/` — version control
+
+## Commands
+
+### Run hardware tests on the robot
+
+```bash
+cd marionette
+python tests/run_on_robot.py
+```
+
+This will:
+1. Create `/tmp/marionette_test/` on the robot
+2. rsync the code (excluding E2E tests, caches, user data)
+3. Install missing dev deps (`pytest`, `httpx`, `pytest-json-report`, `scipy`)
+4. Run `pytest -m hardware -v` on the robot, streaming output
+5. Fetch the JSON report and print a summary
+
+**Options:**
+
+```bash
+python tests/run_on_robot.py --dry-run             # show what would be synced
+python tests/run_on_robot.py --host 192.168.1.42   # custom host/IP
+python tests/run_on_robot.py --user pollen          # custom SSH user
+python tests/run_on_robot.py -k test_playback       # extra pytest args
+```
+
+### Run smoke test on the robot
+
+A quick check that the robot moves and audio plays:
+
+```bash
+cd marionette
+python tests/run_smoke_on_robot.py
+```
+
+### Via the main test runner
+
+```bash
+cd marionette
+python tests/run_tests.py --on-robot
+python tests/run_tests.py --on-robot --host 192.168.1.42
+```
+
+## Platform Notes
+
+### Ubuntu (Linux)
+
+- Ensure `avahi-daemon` is running for `.local` resolution
+- If the default system mic is the robot's mic, audio recording tests
+  may hang — use an external mic or skip audio tests with `-k "not Audio"`
+- Tested with Python 3.10+
+
+### macOS
+
+- Bonjour handles `.local` resolution automatically
+- No known issues with SSH/rsync workflow
+
+### Windows
+
+- Use WSL2 or Git Bash for SSH/rsync
+- mDNS (`.local`) doesn't work natively — use `--host <IP>` instead
+- Or install Bonjour Print Services for mDNS support
+
+## For AI Agents
+
+### Prerequisites
+
+- **Sandbox must be disabled** — the robot SDK uses Zenoh on `tcp/localhost:7447`
+  which requires real network access. Use `/sandbox` → disable in Claude Code.
+- **Bash permissions** — must be allowed for running SSH commands
+
+### Detecting the robot
+
+```bash
+# Quick connectivity check (exits 0 if robot is reachable)
+cd marionette
+python tests/check_robot.py
+```
+
+This imports `ReachyMini()` and checks for a response. Times out after
+15 seconds if the robot is unreachable.
+
+### What's pre-installed on the robot
+
+The robot runs Ubuntu with Python 3.10 in `/venvs/apps_venv/`. The
+following are already available:
+
+- `reachy_mini` SDK
+- `numpy`, `scipy`
+- `soundfile` (for audio)
+- Standard system tools: `rsync`, `ssh`, `python3`
+
+Dev dependencies (`pytest`, `httpx`, `pytest-json-report`) are installed
+automatically by `run_on_robot.py` if missing.
+
+### Running tests programmatically
+
+```python
+import subprocess
+result = subprocess.run(
+    ["python", "tests/run_on_robot.py", "--host", "reachy-mini.local"],
+    cwd="/path/to/marionette",
+    capture_output=True, text=True,
+)
+print(result.stdout)
+```
+
+## Troubleshooting
+
+| Problem | Solution |
+|---------|----------|
+| `ssh: Could not resolve hostname reachy-mini.local` | Install avahi-daemon (Linux) or use `--host <IP>` |
+| `Permission denied (publickey)` | Run `ssh-copy-id pollen@reachy-mini.local` |
+| `rsync: connection unexpectedly closed` | Check robot is powered on and on the same network |
+| `ReachyMini() connection timed out` | Robot may be starting up — wait 30s and retry |
+| Audio tests hang | System mic may be the robot's mic; use external mic or skip with `-k "not Audio"` |
+| `ModuleNotFoundError: No module named 'marionette'` | Ensure `PYTHONPATH` includes the sync dir (handled by `run_on_robot.py`) |

tests/conftest.py

@@ -1,6 +1,9 @@
 """Shared fixtures for Marionette tests."""
 
+import io
 import json
+import struct
+import wave
 from pathlib import Path
 
 import pytest
@@ -9,6 +12,22 @@ from fastapi.testclient import TestClient
 from marionette.main import Marionette, create_app
 
 
+def make_wav_bytes(duration: float = 1.0, sample_rate: int = 44100) -> bytes:
+    """Build a valid WAV file in memory using only stdlib.
+
+    Returns raw bytes suitable for uploading via TestClient.
+    """
+    n_frames = int(duration * sample_rate)
+    buf = io.BytesIO()
+    with wave.open(buf, "wb") as wf:
+        wf.setnchannels(1)
+        wf.setsampwidth(2)  # 16-bit
+        wf.setframerate(sample_rate)
+        # Write silence (all zeros)
+        wf.writeframes(struct.pack(f"<{n_frames}h", *([0] * n_frames)))
+    return buf.getvalue()
+
+
 def pytest_collection_modifyitems(config, items):
     """Auto-skip @pytest.mark.hardware tests unless -m hardware is given."""
     marker_expr = config.getoption("-m", default="")

tests/e2e/test_ui.py

@@ -167,3 +167,472 @@ class TestDatasetUI:
     def test_new_dataset_button_exists(self, page: Page, base_url: str):
         page.goto(base_url)
         expect(page.locator("#new-dataset-btn")).to_be_visible()
+
+
+# ──────── Recording lifecycle tests ──────────────────────────────────
+
+
+class TestRecordingLifecycle:
+    def test_submit_recording_shows_queued(self, page: Page, base_url: str, test_marionette):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        page.locator("#record-options summary").click()
+        page.locator("#audio-source-none").check()
+        page.locator("#duration").fill("2")
+        page.locator("#label").fill("lifecycle-test")
+        page.locator("#record-btn").click()
+        page.wait_for_timeout(2000)
+
+        pill_text = page.locator("#mode-pill").text_content()
+        assert pill_text is not None
+        assert "queued" in pill_text.lower() or "countdown" in pill_text.lower()
+
+        test_marionette._set_idle_state()
+        test_marionette._pending_recording = None
+
+    def test_stop_button_visible_when_queued(self, page: Page, base_url: str, test_marionette):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        page.locator("#record-options summary").click()
+        page.locator("#audio-source-none").check()
+        page.locator("#duration").fill("2")
+        page.locator("#record-btn").click()
+        page.wait_for_timeout(2000)
+
+        # Stop recording button should be visible in queued/countdown/recording mode
+        # Note: in queued mode, the stop-recording-btn may not be shown by the JS
+        # (JS only shows it in recording/countdown). Check either is visible.
+        stop_rec = page.locator("#stop-recording-btn")
+        # It may be hidden if mode is just "queued" — the UI only shows stop in recording/countdown
+        # The important thing is the mode changed from idle
+        pill = page.locator("#mode-pill").text_content() or ""
+        assert "idle" not in pill.lower()
+
+        test_marionette._set_idle_state()
+        test_marionette._pending_recording = None
+
+    def test_stop_recording_returns_to_idle(self, page: Page, base_url: str, test_marionette):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        page.locator("#record-options summary").click()
+        page.locator("#audio-source-none").check()
+        page.locator("#duration").fill("2")
+        page.locator("#record-btn").click()
+        page.wait_for_timeout(2000)
+
+        # Stop via API (simpler than clicking a potentially hidden button)
+        import httpx
+        httpx.post(f"{base_url}/api/record/stop", timeout=5)
+        page.wait_for_timeout(2000)
+
+        pill_text = page.locator("#mode-pill").text_content() or ""
+        assert "idle" in pill_text.lower()
+
+        test_marionette._set_idle_state()
+        test_marionette._pending_recording = None
+
+    def test_injected_move_appears_in_list(self, page: Page, base_url: str, test_marionette):
+        import json
+        data_dir = test_marionette._dataset_dir
+        move_data = {
+            "description": "injected",
+            "time": [0.0, 0.01, 0.02],
+            "set_target_data": [
+                {"head": [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]], "antennas": [0,0], "body_yaw": 0.0}
+                for _ in range(3)
+            ],
+        }
+        (data_dir / "e2e-injected.json").write_text(json.dumps(move_data))
+        test_marionette._refresh_recordings()
+
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        moves_text = page.locator("#moves-list").text_content() or ""
+        assert "e2e-injected" in moves_text
+
+        # Cleanup
+        (data_dir / "e2e-injected.json").unlink(missing_ok=True)
+        test_marionette._refresh_recordings()
+
+
+# ──────── Playback lifecycle tests ───────────────────────────────────
+
+
+class TestPlaybackLifecycle:
+    def _inject_move(self, test_marionette, move_id="e2e-play-test"):
+        import json
+        data_dir = test_marionette._dataset_dir
+        move_data = {
+            "description": "playback test",
+            "time": [i * 0.01 for i in range(100)],
+            "set_target_data": [
+                {"head": [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]], "antennas": [0,0], "body_yaw": 0.0}
+                for _ in range(100)
+            ],
+        }
+        (data_dir / f"{move_id}.json").write_text(json.dumps(move_data))
+        test_marionette._refresh_recordings()
+        return data_dir / f"{move_id}.json"
+
+    def test_play_button_exists_for_move(self, page: Page, base_url: str, test_marionette):
+        self._inject_move(test_marionette)
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        play_btns = page.locator(".play-btn")
+        assert play_btns.count() > 0
+
+        # Cleanup
+        (test_marionette._dataset_dir / "e2e-play-test.json").unlink(missing_ok=True)
+        test_marionette._refresh_recordings()
+
+    def test_click_play_queues_playback(self, page: Page, base_url: str, test_marionette):
+        self._inject_move(test_marionette)
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        page.locator(".play-btn").first.click()
+        page.wait_for_timeout(2000)
+
+        pill_text = page.locator("#mode-pill").text_content() or ""
+        assert "queued" in pill_text.lower() or "playing" in pill_text.lower()
+
+        test_marionette._set_idle_state()
+        test_marionette._pending_playback = None
+        (test_marionette._dataset_dir / "e2e-play-test.json").unlink(missing_ok=True)
+        test_marionette._refresh_recordings()
+
+    def test_move_metadata_displayed(self, page: Page, base_url: str, test_marionette):
+        self._inject_move(test_marionette)
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        # Check move label is visible
+        label_el = page.locator(".move-label").first
+        expect(label_el).to_be_visible()
+        # Check move info (duration, etc.) is visible
+        info_el = page.locator(".move-info").first
+        expect(info_el).to_be_visible()
+
+        (test_marionette._dataset_dir / "e2e-play-test.json").unlink(missing_ok=True)
+        test_marionette._refresh_recordings()
+
+
+# ──────── Delete move tests ──────────────────────────────────────────
+
+
+class TestDeleteMove:
+    def _inject_move(self, test_marionette, move_id="e2e-delete-test"):
+        import json
+        data_dir = test_marionette._dataset_dir
+        move_data = {
+            "description": "delete test",
+            "time": [0.0, 0.01],
+            "set_target_data": [
+                {"head": [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]], "antennas": [0,0], "body_yaw": 0.0}
+                for _ in range(2)
+            ],
+        }
+        path = data_dir / f"{move_id}.json"
+        path.write_text(json.dumps(move_data))
+        test_marionette._refresh_recordings()
+        return path
+
+    def test_delete_button_exists(self, page: Page, base_url: str, test_marionette):
+        self._inject_move(test_marionette)
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        delete_btns = page.locator(".play-btn.danger")
+        assert delete_btns.count() > 0
+
+        (test_marionette._dataset_dir / "e2e-delete-test.json").unlink(missing_ok=True)
+        test_marionette._refresh_recordings()
+
+    def test_delete_confirm_removes_move(self, page: Page, base_url: str, test_marionette):
+        self._inject_move(test_marionette)
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        # Register dialog handler BEFORE clicking
+        page.once("dialog", lambda dialog: dialog.accept())
+        page.locator(".play-btn.danger").first.click()
+        page.wait_for_timeout(3000)
+
+        moves_text = page.locator("#moves-list").text_content() or ""
+        assert "e2e-delete-test" not in moves_text
+
+    def test_delete_cancel_keeps_move(self, page: Page, base_url: str, test_marionette):
+        self._inject_move(test_marionette)
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        # Register dialog handler BEFORE clicking
+        page.once("dialog", lambda dialog: dialog.dismiss())
+        page.locator(".play-btn.danger").first.click()
+        page.wait_for_timeout(2000)
+
+        moves_text = page.locator("#moves-list").text_content() or ""
+        assert "e2e-delete-test" in moves_text
+
+        (test_marionette._dataset_dir / "e2e-delete-test.json").unlink(missing_ok=True)
+        test_marionette._refresh_recordings()
+
+
+# ──────── Create dataset tests ───────────────────────────────────────
+
+
+class TestCreateDataset:
+    def test_new_dataset_button_shows_form(self, page: Page, base_url: str):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        page.locator("#new-dataset-btn").click()
+        expect(page.locator("#inline-dataset-form")).to_be_visible()
+
+    def test_cancel_hides_form(self, page: Page, base_url: str):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        page.locator("#new-dataset-btn").click()
+        expect(page.locator("#inline-dataset-form")).to_be_visible()
+
+        page.locator("#inline-dataset-cancel").click()
+        expect(page.locator("#inline-dataset-form")).to_be_hidden()
+
+    def test_create_dataset_appears_in_dropdown(self, page: Page, base_url: str, test_marionette):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        page.locator("#new-dataset-btn").click()
+        page.locator("#inline-dataset-name").fill("e2e-test-ds")
+        page.locator("#inline-dataset-create").click()
+        page.wait_for_timeout(2000)
+
+        # Check the dropdown contains the new dataset
+        options_text = page.locator("#dataset-select").text_content() or ""
+        assert "e2e-test-ds" in options_text.lower()
+
+    def test_empty_name_not_submitted(self, page: Page, base_url: str):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        page.locator("#new-dataset-btn").click()
+        page.locator("#inline-dataset-name").fill("")
+        page.locator("#inline-dataset-create").click()
+        page.wait_for_timeout(500)
+
+        # Form should still be visible (validation prevented submission)
+        expect(page.locator("#inline-dataset-form")).to_be_visible()
+
+
+# ──────── Switch dataset tests ───────────────────────────────────────
+
+
+class TestSwitchDataset:
+    def test_switch_dataset_changes_moves(self, page: Page, base_url: str, test_marionette):
+        import json, httpx
+
+        # Create a second dataset via API
+        resp = httpx.post(f"{base_url}/api/datasets", json={"name": "e2e-switch-a"}, timeout=5)
+        assert resp.status_code == 200
+
+        # Inject a move into it
+        data_dir = test_marionette._dataset_dir
+        move_data = {
+            "description": "switch test",
+            "time": [0.0, 0.01],
+            "set_target_data": [
+                {"head": [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]], "antennas": [0,0], "body_yaw": 0.0}
+                for _ in range(2)
+            ],
+        }
+        (data_dir / "switch-move.json").write_text(json.dumps(move_data))
+        test_marionette._refresh_recordings()
+
+        # Get dataset list
+        state = httpx.get(f"{base_url}/api/state", timeout=5).json()
+        entries = state["datasets"]["entries"]
+        other_ds = [e for e in entries if e["id"] != state["datasets"]["active_id"]]
+
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        # Verify the injected move is visible
+        assert "switch-move" in (page.locator("#moves-list").text_content() or "")
+
+        if other_ds:
+            # Switch to a different dataset
+            page.locator("#dataset-select").select_option(other_ds[0]["id"])
+            page.wait_for_timeout(2000)
+
+            # The moves list should change (no "switch-move" in the other dataset)
+            moves_text = page.locator("#moves-list").text_content() or ""
+            assert "switch-move" not in moves_text
+
+        # Cleanup
+        (data_dir / "switch-move.json").unlink(missing_ok=True)
+        test_marionette._refresh_recordings()
+
+    def test_dropdown_lists_all_datasets(self, page: Page, base_url: str):
+        import httpx
+
+        # Create a dataset via API
+        httpx.post(f"{base_url}/api/datasets", json={"name": "e2e-dropdown-check"}, timeout=5)
+
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        options = page.locator("#dataset-select option")
+        assert options.count() >= 2  # at least default + newly created
+
+
+# ──────── Audio source radio tests ───────────────────────────────────
+
+
+class TestAudioSourceRadios:
+    def test_default_audio_source(self, page: Page, base_url: str):
+        page.goto(base_url)
+        page.locator("#record-options summary").click()
+        # Default may be mic (if audio available) or none
+        mic = page.locator("#audio-source-mic")
+        none = page.locator("#audio-source-none")
+        # At least one should be checked
+        mic_checked = mic.is_checked()
+        none_checked = none.is_checked()
+        assert mic_checked or none_checked
+
+    def test_upload_radio_shows_upload_area(self, page: Page, base_url: str):
+        page.goto(base_url)
+        page.locator("#record-options summary").click()
+        page.locator("#audio-source-upload").check()
+        page.wait_for_timeout(500)
+        expect(page.locator("#audio-upload-group")).to_be_visible()
+
+    def test_none_radio_hides_upload_area(self, page: Page, base_url: str):
+        page.goto(base_url)
+        page.locator("#record-options summary").click()
+        page.locator("#audio-source-upload").check()
+        page.wait_for_timeout(500)
+        expect(page.locator("#audio-upload-group")).to_be_visible()
+
+        page.locator("#audio-source-none").check()
+        page.wait_for_timeout(500)
+        expect(page.locator("#audio-upload-group")).to_be_hidden()
+
+
+# ──────── Settings panel tests ───────────────────────────────────────
+
+
+class TestSettingsPanel:
+    def test_settings_expands(self, page: Page, base_url: str):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        # Use direct child selector to avoid matching nested summary
+        summary = page.locator("#config-details > summary")
+        summary.scroll_into_view_if_needed()
+        summary.click()
+        expect(page.locator("#dataset-root-form")).to_be_visible()
+
+    def test_experimental_toggle(self, page: Page, base_url: str):
+        import httpx
+        # Enable motion_models via API first
+        httpx.post(f"{base_url}/api/experiments", json={"motion_models": True}, timeout=5)
+
+        page.goto(base_url)
+        # Wait for poll to update the UI (experimental panel hidden until first poll)
+        page.wait_for_timeout(3000)
+
+        # After poll, the experimental panel should be visible and checkbox attached
+        checkbox = page.locator("#feature-motion-models")
+        expect(checkbox).to_be_attached()
+
+    def test_dataset_root_displayed(self, page: Page, base_url: str):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        summary = page.locator("#config-details > summary")
+        summary.scroll_into_view_if_needed()
+        summary.click()
+        root_input = page.locator("#dataset-root-input")
+        value = root_input.input_value()
+        assert len(value) > 0
+
+
+# ──────── Form edge case tests ───────────────────────────────────────
+
+
+class TestFormEdgeCases:
+    def test_empty_label_accepted(self, page: Page, base_url: str, test_marionette):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        page.locator("#record-options summary").click()
+        page.locator("#audio-source-none").check()
+        page.locator("#label").fill("")
+        page.locator("#duration").fill("2")
+        page.locator("#record-btn").click()
+        page.wait_for_timeout(2000)
+
+        pill = page.locator("#mode-pill").text_content() or ""
+        assert "queued" in pill.lower() or "countdown" in pill.lower()
+
+        test_marionette._set_idle_state()
+        test_marionette._pending_recording = None
+
+    def test_long_label_accepted(self, page: Page, base_url: str, test_marionette):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        page.locator("#record-options summary").click()
+        page.locator("#audio-source-none").check()
+        long_label = "a" * 80
+        page.locator("#label").fill(long_label)
+        page.locator("#duration").fill("2")
+        page.locator("#record-btn").click()
+        page.wait_for_timeout(2000)
+
+        pill = page.locator("#mode-pill").text_content() or ""
+        assert "queued" in pill.lower() or "countdown" in pill.lower()
+
+        test_marionette._set_idle_state()
+        test_marionette._pending_recording = None
+
+    def test_special_chars_in_label(self, page: Page, base_url: str, test_marionette):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        page.locator("#record-options summary").click()
+        page.locator("#audio-source-none").check()
+        page.locator("#label").fill("my move @#$!")
+        page.locator("#duration").fill("2")
+        page.locator("#record-btn").click()
+        page.wait_for_timeout(2000)
+
+        pill = page.locator("#mode-pill").text_content() or ""
+        assert "queued" in pill.lower() or "countdown" in pill.lower()
+
+        test_marionette._set_idle_state()
+        test_marionette._pending_recording = None
+
+    def test_label_persists_in_localstorage(self, page: Page, base_url: str):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        label_input = page.locator("#label")
+        label_input.fill("persistent-label")
+        # Trigger the change event so JS stores it
+        label_input.dispatch_event("change")
+        page.wait_for_timeout(500)
+
+        # Reload and check
+        page.reload()
+        page.wait_for_timeout(2000)
+
+        restored = page.locator("#label").input_value()
+        assert restored == "persistent-label"

tests/run_tests.py

@@ -48,6 +48,13 @@ TEST_CLASS_DESCRIPTIONS: dict[str, tuple[str, str]] = {
     "TestExperiments": ("unit", "Feature toggles and experimental settings"),
     "TestHfAutoLogin": ("unit", "HF auto-login detection and caching"),
     "TestSensorData": ("unit", "Sensor data dummy endpoint"),
+    "TestUploadAudio": ("unit", "POST /api/upload-audio validation and integration"),
+    "TestMotionModelEndpoint": ("unit", "POST /api/motion-model enable, set, persist"),
+    "TestCommunityDatasets": ("unit", "Community dataset listing and download validation"),
+    "TestCorruptData": ("unit", "Malformed JSON and corrupt registry recovery"),
+    "TestConcurrentStateChanges": ("unit", "Concurrent operations rejected when busy"),
+    "TestDurationEdgeCases": ("unit", "Duration boundary validation (gt=0.5, le=300)"),
+    "TestSyncDatasetExtended": ("unit", "Sync endpoint edge cases and validation"),
     # E2E
     "TestPageLoad": ("e2e", "Page loads and main sections visible"),
     "TestIdleState": ("e2e", "Idle state display and controls"),
@@ -55,6 +62,14 @@ TEST_CLASS_DESCRIPTIONS: dict[str, tuple[str, str]] = {
     "TestFormValidation": ("e2e", "Form fields and HTML5 validation"),
     "TestRecordingSubmission": ("e2e", "Recording submission changes mode"),
     "TestDatasetUI": ("e2e", "Dataset UI elements visible"),
+    "TestRecordingLifecycle": ("e2e", "Recording submit, stop, and injected move visibility"),
+    "TestPlaybackLifecycle": ("e2e", "Play button, queued playback, and move metadata"),
+    "TestDeleteMove": ("e2e", "Delete button, confirm/cancel dialog handling"),
+    "TestCreateDataset": ("e2e", "New dataset form show/hide/create/validate"),
+    "TestSwitchDataset": ("e2e", "Dataset switching and dropdown population"),
+    "TestAudioSourceRadios": ("e2e", "Audio source radio buttons and upload area toggle"),
+    "TestSettingsPanel": ("e2e", "Settings expand, experimental toggle, root display"),
+    "TestFormEdgeCases": ("e2e", "Empty/long/special labels and localStorage persistence"),
     # Hardware
     "TestHardwareStartup": ("hardware", "Robot reaches idle after startup"),
     "TestHardwareRecording": ("hardware", "Record and verify motion capture"),
@@ -64,6 +79,10 @@ TEST_CLASS_DESCRIPTIONS: dict[str, tuple[str, str]] = {
     "TestMultiDuration": ("hardware", "Recording and playback across 1s/3s/5s/10s durations"),
     "TestPerformance": ("hardware", "Startup, recording, and playback latency benchmarks"),
     "TestHardwareAudio": ("hardware", "Audio recording and playback (may skip on mic issues)"),
+    "TestExistingRecordingPlayback": ("hardware", "Play back existing audio and silent recordings"),
+    "TestRecordingRoundTrip": ("hardware", "Record → playback fidelity and timing verification"),
+    "TestAntennaAndBodyYaw": ("hardware", "Verify antenna and body_yaw data in recordings"),
+    "TestPlaybackAntennas": ("hardware", "Synthetic antenna oscillation playback"),
 }
 
 

tests/test_api.py

@@ -615,3 +615,305 @@ class TestSensorData:
         resp = client.get("/sensor_data")
         assert resp.status_code == 200
         assert resp.json() == {}
+
+
+# ──────── Upload audio tests ─────────────────────────────────────────
+
+
+class TestUploadAudio:
+    def test_upload_wav_returns_upload_id(self, client: TestClient):
+        from conftest import make_wav_bytes
+
+        wav = make_wav_bytes(1.0)
+        resp = client.post(
+            "/api/upload-audio",
+            files={"file": ("test.wav", BytesIO(wav), "audio/wav")},
+        )
+        assert resp.status_code == 200
+        data = resp.json()
+        assert "upload_id" in data
+        assert data["filename"] == "test.wav"
+
+    def test_upload_wav_duration_extracted(self, client: TestClient):
+        from conftest import make_wav_bytes
+
+        wav = make_wav_bytes(2.0)
+        resp = client.post(
+            "/api/upload-audio",
+            files={"file": ("two-sec.wav", BytesIO(wav), "audio/wav")},
+        )
+        assert resp.status_code == 200
+        duration = resp.json().get("duration")
+        # Duration may be None if soundfile is unavailable, skip check in that case
+        if duration is not None:
+            assert abs(duration - 2.0) < 0.5
+
+    def test_upload_rejects_unsupported_format(self, client: TestClient):
+        resp = client.post(
+            "/api/upload-audio",
+            files={"file": ("notes.txt", BytesIO(b"hello"), "text/plain")},
+        )
+        assert resp.status_code == 400
+
+    def test_upload_rejects_empty_filename(self, client: TestClient):
+        resp = client.post(
+            "/api/upload-audio",
+            files={"file": ("", BytesIO(b"data"), "audio/wav")},
+        )
+        assert resp.status_code in (400, 422)
+
+    def test_upload_mp3_accepted(self, client: TestClient):
+        # A minimal fake MP3 — server accepts based on extension
+        resp = client.post(
+            "/api/upload-audio",
+            files={"file": ("song.mp3", BytesIO(b"\xff\xfb\x90\x00" + b"\x00" * 100), "audio/mpeg")},
+        )
+        # Accepted (200) or 500 if soundfile can't parse — never 400 for extension
+        assert resp.status_code in (200, 500)
+
+    def test_uploaded_audio_id_usable_in_record(self, client: TestClient, marionette: Marionette):
+        from conftest import make_wav_bytes
+
+        wav = make_wav_bytes(1.0)
+        upload_resp = client.post(
+            "/api/upload-audio",
+            files={"file": ("rec.wav", BytesIO(wav), "audio/wav")},
+        )
+        assert upload_resp.status_code == 200
+        upload_id = upload_resp.json()["upload_id"]
+
+        resp = client.post("/api/record", json={
+            "duration": 3.0,
+            "record_audio": False,
+            "uploaded_audio_id": upload_id,
+        })
+        assert resp.status_code == 200
+        assert resp.json()["accepted"] is True
+
+    def test_record_with_invalid_upload_id(self, client: TestClient):
+        resp = client.post("/api/record", json={
+            "duration": 3.0,
+            "record_audio": False,
+            "uploaded_audio_id": "nonexistent-uuid",
+        })
+        assert resp.status_code == 400
+
+
+# ──────── Motion model endpoint tests ────────────────────────────────
+
+
+class TestMotionModelEndpoint:
+    def test_motion_model_rejected_when_disabled(self, client: TestClient):
+        resp = client.post("/api/motion-model", json={"name": "no_model"})
+        assert resp.status_code == 400
+
+    def test_enable_then_set_model(self, client: TestClient):
+        client.post("/api/experiments", json={"motion_models": True})
+        resp = client.post("/api/motion-model", json={"name": "no_model"})
+        assert resp.status_code == 200
+        assert resp.json()["active"] == "no_model"
+
+    def test_set_unknown_model_returns_404(self, client: TestClient):
+        client.post("/api/experiments", json={"motion_models": True})
+        resp = client.post("/api/motion-model", json={"name": "totally_fake_model"})
+        assert resp.status_code == 404
+
+    def test_model_persisted_in_registry(
+        self, tmp_registry: Path, tmp_dataset_root: Path
+    ):
+        app1, m1 = create_app(registry_path=tmp_registry, dataset_root=tmp_dataset_root)
+        c1 = TestClient(app1)
+        c1.post("/api/experiments", json={"motion_models": True})
+        c1.post("/api/motion-model", json={"name": "no_model"})
+
+        _, m2 = create_app(registry_path=tmp_registry, dataset_root=tmp_dataset_root)
+        assert m2._motion_model_registry.active == "no_model"
+
+
+# ──────── Community datasets tests ───────────────────────────────────
+
+
+class TestCommunityDatasets:
+    def test_community_returns_empty_list(self, client: TestClient, marionette: Marionette):
+        """When HTTP fetch returns empty, endpoint returns an empty list."""
+        original = marionette._fetch_community_datasets_http
+        marionette._fetch_community_datasets_http = lambda: []
+        try:
+            resp = client.get("/api/datasets/community")
+            assert resp.status_code == 200
+            # May be empty list (HfApi also not available in test env)
+            assert isinstance(resp.json()["datasets"], list)
+        finally:
+            marionette._fetch_community_datasets_http = original
+
+    def test_download_rejects_invalid_repo_id(self, client: TestClient):
+        resp = client.post("/api/datasets/download", json={"repo_id": "no-slash"})
+        assert resp.status_code == 400
+
+    def test_download_rejects_duplicate_folder(self, client: TestClient, marionette: Marionette):
+        # Create a dataset first
+        client.post("/api/datasets", json={"name": "existing-ds"})
+        # Try to download with the same folder name
+        resp = client.post("/api/datasets/download", json={
+            "repo_id": "someone/existing-ds",
+            "name": "existing-ds",
+        })
+        assert resp.status_code == 409
+
+
+# ──────── Corrupt data tests ────────────────────────────────────────
+
+
+class TestCorruptData:
+    def test_malformed_json_skipped(self, marionette: Marionette):
+        data_dir = marionette._dataset_dir
+        (data_dir / "bad-file.json").write_text("{{{", encoding="utf-8")
+        marionette._refresh_recordings()
+        assert "bad-file" not in marionette._recordings
+
+    def test_json_missing_time_key(self, marionette: Marionette):
+        data_dir = marionette._dataset_dir
+        (data_dir / "no-time.json").write_text(
+            json.dumps({"description": "test"}), encoding="utf-8"
+        )
+        marionette._refresh_recordings()
+        # File is loaded but with duration 0 (empty timestamps)
+        if "no-time" in marionette._recordings:
+            assert marionette._recordings["no-time"].duration == 0.0
+
+    def test_json_empty_time_array(self, marionette: Marionette):
+        data_dir = marionette._dataset_dir
+        (data_dir / "empty-time.json").write_text(
+            json.dumps({"time": [], "set_target_data": []}), encoding="utf-8"
+        )
+        marionette._refresh_recordings()
+        if "empty-time" in marionette._recordings:
+            assert marionette._recordings["empty-time"].duration == 0.0
+
+    def test_corrupt_registry_recovers(self, tmp_path: Path):
+        reg = tmp_path / "corrupt_reg.json"
+        reg.write_text("NOT VALID JSON {{{", encoding="utf-8")
+        ds_root = tmp_path / "ds"
+        ds_root.mkdir()
+        app, m = create_app(registry_path=reg, dataset_root=ds_root)
+        # Should have recovered with defaults
+        assert m._active_dataset_id is not None
+        assert len(m._datasets) >= 1
+
+
+# ──────── Concurrent state change tests ─────────────────────────────
+
+
+class TestConcurrentStateChanges:
+    def test_play_while_queued_rejected(
+        self, client: TestClient, marionette: Marionette, sample_move_json: dict
+    ):
+        data_dir = marionette._dataset_dir
+        (data_dir / "play-test.json").write_text(json.dumps(sample_move_json))
+        marionette._refresh_recordings()
+
+        # Submit a recording to enter queued state
+        client.post("/api/record", json={"duration": 3.0, "record_audio": False})
+        assert client.get("/api/state").json()["mode"] == "queued"
+
+        resp = client.post("/api/play", json={"move_id": "play-test"})
+        assert resp.status_code == 409
+
+    def test_record_while_playing_rejected(
+        self, client: TestClient, marionette: Marionette
+    ):
+        marionette._set_state(mode="playing", message="Playing…", active_move="x")
+        resp = client.post("/api/record", json={"duration": 3.0, "record_audio": False})
+        assert resp.status_code == 409
+        marionette._set_idle_state()
+
+    def test_sync_while_busy_rejected(
+        self, client: TestClient, marionette: Marionette
+    ):
+        marionette._set_state(mode="recording", message="Recording…", active_move=None)
+        resp = client.post("/api/datasets/sync", json={"move_ids": ["x"]})
+        assert resp.status_code == 409
+        marionette._set_idle_state()
+
+    def test_dataset_root_change_while_busy(
+        self, client: TestClient, marionette: Marionette, tmp_path: Path
+    ):
+        marionette._set_state(mode="recording", message="Recording…", active_move=None)
+        resp = client.post("/api/datasets/root", json={"path": str(tmp_path)})
+        assert resp.status_code == 409
+        marionette._set_idle_state()
+
+
+# ──────── Duration edge case tests ──────────────────────────────────
+
+
+class TestDurationEdgeCases:
+    def test_duration_just_above_minimum(self, client: TestClient):
+        resp = client.post("/api/record", json={"duration": 0.51, "record_audio": False})
+        assert resp.status_code == 200
+
+    def test_duration_at_maximum(self, client: TestClient, marionette: Marionette):
+        resp = client.post("/api/record", json={"duration": 300.0, "record_audio": False})
+        assert resp.status_code == 200
+
+    def test_duration_at_minimum_boundary_rejected(self, client: TestClient):
+        """Pydantic field has gt=0.5, so exactly 0.5 should be rejected."""
+        resp = client.post("/api/record", json={"duration": 0.5, "record_audio": False})
+        assert resp.status_code == 422
+
+
+# ──────── Sync dataset extended tests ───────────────────────────────
+
+
+class TestSyncDatasetExtended:
+    def test_sync_empty_move_ids_rejected(self, client: TestClient):
+        """Pydantic min_items=1 should reject empty move_ids."""
+        resp = client.post("/api/datasets/sync", json={"move_ids": []})
+        assert resp.status_code == 422
+
+    def test_sync_nonexistent_moves(self, client: TestClient, marionette: Marionette):
+        import marionette.main as mm
+        original_whoami = mm.hf_whoami
+        marionette._hf_checked = False
+        marionette._hf_username = None
+        mm.hf_whoami = lambda: {"name": "testuser"}
+        try:
+            resp = client.post("/api/datasets/sync", json={
+                "move_ids": ["fake-move-id"],
+            })
+            assert resp.status_code == 404
+        finally:
+            mm.hf_whoami = original_whoami
+
+    def test_sync_no_active_dataset(self, client: TestClient, marionette: Marionette):
+        import marionette.main as mm
+        original_whoami = mm.hf_whoami
+        mm.hf_whoami = lambda: {"name": "testuser"}
+        marionette._hf_checked = False
+        marionette._hf_username = None
+
+        # Save and clear active dataset
+        old_id = marionette._active_dataset_id
+        marionette._active_dataset_id = None
+        # Clear recordings to avoid "move not found" before "no active dataset"
+        marionette._recordings = {}
+        try:
+            resp = client.post("/api/datasets/sync", json={
+                "move_ids": ["any-move"],
+            })
+            # Should be 404 for the move not found (since recordings is empty)
+            assert resp.status_code == 404
+        finally:
+            marionette._active_dataset_id = old_id
+            mm.hf_whoami = original_whoami
+
+    def test_record_on_downloaded_dataset_rejected(
+        self, client: TestClient, marionette: Marionette
+    ):
+        entry = marionette._create_dataset_internal("dl-sync-test", "DL Sync Test", origin="downloaded")
+        marionette._select_dataset(entry.dataset_id)
+        marionette._refresh_recordings()
+
+        resp = client.post("/api/record", json={"duration": 3.0, "record_audio": False})
+        assert resp.status_code == 409
+        assert "downloaded" in resp.json()["detail"].lower()

tests/test_hardware.py

@@ -967,6 +967,250 @@ class TestPerformance:
         assert rate > 50, f"Pose read rate too low: {rate:.0f}/s (need >50 for 100Hz recording)"
 
 
+class TestExistingRecordingPlayback:
+    """Play back existing recordings from the dataset."""
+
+    def test_playback_real_audio_recording(self, base_url: str):
+        """Find a move with audio and play it back."""
+        import httpx
+
+        _ensure_idle(base_url)
+        state = httpx.get(f"{base_url}/api/state", timeout=5).json()
+        move = next((m for m in state["moves"] if m["has_audio"]), None)
+        if move is None:
+            pytest.skip("No audio moves available for playback test")
+
+        resp = httpx.post(
+            f"{base_url}/api/play",
+            json={"move_id": move["id"]},
+            timeout=5,
+        )
+        assert resp.status_code == 200
+        _wait_for_mode(base_url, "idle", timeout=move["duration"] + 15)
+
+    def test_playback_real_silent_recording(self, base_url: str):
+        """Find a silent move and play it back."""
+        import httpx
+
+        _ensure_idle(base_url)
+        state = httpx.get(f"{base_url}/api/state", timeout=5).json()
+        move = next((m for m in state["moves"] if not m["has_audio"]), None)
+        if move is None:
+            pytest.skip("No silent moves available for playback test")
+
+        resp = httpx.post(
+            f"{base_url}/api/play",
+            json={"move_id": move["id"]},
+            timeout=5,
+        )
+        assert resp.status_code == 200
+        _wait_for_mode(base_url, "idle", timeout=move["duration"] + 15)
+
+
+class TestRecordingRoundTrip:
+    """Record, read JSON, play back, and verify timing and fidelity."""
+
+    def test_record_then_playback_fidelity(
+        self, base_url: str, hw_marionette, hw_reachy,
+    ):
+        """Record 3s, play back, observe poses, compare trajectories."""
+        import httpx
+        from pose_utils import compare_trajectories
+
+        duration = 3.0
+        _ensure_idle(base_url)
+
+        resp = httpx.post(
+            f"{base_url}/api/record",
+            json={"duration": duration, "record_audio": False, "label": "roundtrip-fidelity"},
+            timeout=5,
+        )
+        assert resp.status_code == 200
+        move_id = resp.json()["move_id"]
+        _wait_for_mode(base_url, "idle", timeout=COUNTDOWN_SECONDS + duration + 10)
+
+        # Read the recorded JSON
+        json_path = hw_marionette._dataset_dir / f"{move_id}.json"
+        assert json_path.exists()
+        data = json.loads(json_path.read_text())
+        ref_times = data["time"]
+        ref_frames = data["set_target_data"]
+
+        # Play back and observe
+        _ensure_idle(base_url)
+        resp = httpx.post(
+            f"{base_url}/api/play",
+            json={"move_id": move_id},
+            timeout=5,
+        )
+        assert resp.status_code == 200
+
+        observed_times, observed_frames = _observe_playback(
+            base_url, hw_reachy, duration,
+        )
+
+        assert len(observed_frames) > 50, (
+            f"Too few observed frames: {len(observed_frames)}"
+        )
+
+        metrics = compare_trajectories(
+            ref_times, ref_frames, observed_times, observed_frames,
+        )
+        print(f"\nRound-trip fidelity ({len(observed_frames)} frames):")
+        print(metrics.summary())
+
+        assert metrics.magic_mean < 50, (
+            f"Mean magic distance too high: {metrics.magic_mean:.1f}\n"
+            f"{metrics.summary()}"
+        )
+
+        # Cleanup
+        httpx.delete(f"{base_url}/api/moves/{move_id}", timeout=5)
+
+    def test_record_playback_timing(self, base_url: str, hw_marionette):
+        """Record 3s, play back, verify wall-clock duration within 20%."""
+        import httpx
+
+        duration = 3.0
+        _ensure_idle(base_url)
+
+        resp = httpx.post(
+            f"{base_url}/api/record",
+            json={"duration": duration, "record_audio": False, "label": "roundtrip-timing"},
+            timeout=5,
+        )
+        assert resp.status_code == 200
+        move_id = resp.json()["move_id"]
+        _wait_for_mode(base_url, "idle", timeout=COUNTDOWN_SECONDS + duration + 10)
+
+        # Play back and measure
+        _ensure_idle(base_url)
+        t0 = time.time()
+        resp = httpx.post(
+            f"{base_url}/api/play",
+            json={"move_id": move_id},
+            timeout=5,
+        )
+        assert resp.status_code == 200
+        _wait_for_mode(base_url, "idle", timeout=duration + 30)
+        playback_time = time.time() - t0
+
+        # Should be within 20% of the recording duration (plus overhead)
+        assert playback_time > duration * 0.8, (
+            f"Playback too fast: {playback_time:.2f}s (expected ~{duration}s)"
+        )
+        assert playback_time < duration * 1.2 + 10, (
+            f"Playback too slow: {playback_time:.2f}s (expected ~{duration}s + overhead)"
+        )
+        print(f"\nRound-trip timing: playback took {playback_time:.2f}s for {duration}s recording")
+
+        # Cleanup
+        httpx.delete(f"{base_url}/api/moves/{move_id}", timeout=5)
+
+
+class TestAntennaAndBodyYaw:
+    """Verify recording JSON contains antenna and body_yaw data."""
+
+    def test_recording_has_antenna_data(self, base_url: str, hw_marionette):
+        """Every frame should have 'antennas' (2-element list)."""
+        import httpx
+
+        _ensure_idle(base_url)
+        resp = httpx.post(
+            f"{base_url}/api/record",
+            json={"duration": 2.0, "record_audio": False, "label": "antenna-check"},
+            timeout=5,
+        )
+        assert resp.status_code == 200
+        move_id = resp.json()["move_id"]
+        _wait_for_mode(base_url, "idle", timeout=COUNTDOWN_SECONDS + 2 + 10)
+
+        json_path = hw_marionette._dataset_dir / f"{move_id}.json"
+        data = json.loads(json_path.read_text())
+        for frame in data["set_target_data"]:
+            assert "antennas" in frame, "Frame missing 'antennas' key"
+            assert len(frame["antennas"]) == 2, f"Expected 2 antenna values, got {len(frame['antennas'])}"
+
+        httpx.delete(f"{base_url}/api/moves/{move_id}", timeout=5)
+
+    def test_recording_has_body_yaw(self, base_url: str, hw_marionette):
+        """Every frame should have 'body_yaw' (float)."""
+        import httpx
+
+        _ensure_idle(base_url)
+        resp = httpx.post(
+            f"{base_url}/api/record",
+            json={"duration": 2.0, "record_audio": False, "label": "bodyyaw-check"},
+            timeout=5,
+        )
+        assert resp.status_code == 200
+        move_id = resp.json()["move_id"]
+        _wait_for_mode(base_url, "idle", timeout=COUNTDOWN_SECONDS + 2 + 10)
+
+        json_path = hw_marionette._dataset_dir / f"{move_id}.json"
+        data = json.loads(json_path.read_text())
+        for frame in data["set_target_data"]:
+            assert "body_yaw" in frame, "Frame missing 'body_yaw' key"
+            assert isinstance(frame["body_yaw"], (int, float)), f"body_yaw should be numeric, got {type(frame['body_yaw'])}"
+
+        httpx.delete(f"{base_url}/api/moves/{move_id}", timeout=5)
+
+
+class TestPlaybackAntennas:
+    """Test synthetic moves with antenna data play back correctly."""
+
+    def test_synthetic_antenna_motion_completes(
+        self, base_url: str, hw_marionette, hw_reachy,
+    ):
+        """Create synthetic move with antenna oscillation, play back."""
+        import httpx
+        import numpy as np
+
+        duration = 3.0
+        _ensure_idle(base_url)
+
+        # Create synthetic move with antenna oscillation
+        dt = 1.0 / MOTION_SAMPLE_RATE
+        n = int(duration * MOTION_SAMPLE_RATE)
+        timestamps = [i * dt for i in range(n)]
+        frames = []
+        for i in range(n):
+            t = i * dt
+            antenna_val = 0.3 * np.sin(2 * np.pi * 0.5 * t)
+            frames.append({
+                "head": np.eye(4).tolist(),
+                "antennas": [antenna_val, -antenna_val],
+                "body_yaw": 0.0,
+                "check_collision": False,
+            })
+
+        move_id = "synth-antenna-osc"
+        data = {
+            "description": "Synthetic antenna oscillation",
+            "time": timestamps,
+            "set_target_data": frames,
+        }
+        json_path = hw_marionette._dataset_dir / f"{move_id}.json"
+        json_path.write_text(json.dumps(data), encoding="utf-8")
+        hw_marionette._refresh_recordings()
+
+        # Play back
+        resp = httpx.post(
+            f"{base_url}/api/play",
+            json={"move_id": move_id},
+            timeout=5,
+        )
+        assert resp.status_code == 200
+
+        _wait_for_mode(base_url, "idle", timeout=duration + 15)
+
+        state = httpx.get(f"{base_url}/api/state", timeout=5).json()
+        assert state["mode"] == "idle"
+
+        # Cleanup
+        httpx.delete(f"{base_url}/api/moves/{move_id}", timeout=5)
+
+
 class TestHardwareAudio:
     """Audio recording/playback tests — run last.