Simplify replay compensation: always-on lead model, default lead tuned, and GUI tuning UX

- make lead compensation the only replay model (remove model toggle/selection paths)
- set default lead params to validated values (head=15, antennas=4)
- add persistent lead-param API (POST /api/motion-model/lead)
- simplify Settings UI: replace Experimental model controls with a dedicated “Lead compensation”
section
- expose only head/antenna lead frame inputs in GUI
- add hint text: 1 frame = 10 ms (100 Hz control loop)
- update tests/state contracts for always-on lead compensation configuration

marionette/main.py

@@ -102,7 +102,6 @@ HF_DATASETS_API_URL = "https://huggingface.co/api/datasets"
 DATASET_DATA_SUBDIR = "data"
 NOISE_SUFFIX = ".noise.wav"
 DENOISED_SUFFIX = ".denoised.wav"
-DEFAULT_FEATURES = {"motion_models": True}
 
 logger = logging.getLogger(__name__)
 
@@ -219,10 +218,6 @@ class DownloadDatasetPayload(BaseModel):
     )
 
 
-class UpdateMotionModelPayload(BaseModel):
-    name: str = Field(..., description="Motion model identifier to activate")
-
-
 class UpdateLeadCompensationPayload(BaseModel):
     lead_frames_head: int | None = Field(
         default=None, ge=0, le=2000, description="Look-ahead for head/body in 100Hz frames"
@@ -233,7 +228,6 @@ class UpdateLeadCompensationPayload(BaseModel):
 
 
 class UpdateExperimentsPayload(BaseModel):
-    motion_models: bool | None = Field(default=None, description="Enable or disable motion model feature")
     duration_seconds: float | None = Field(default=None, gt=0.5, le=300.0)
     welcome_messages: int | None = Field(default=None, ge=0, le=2, description="Number of welcome messages at startup (0, 1, or 2)")
 
@@ -262,10 +256,9 @@ class Marionette(ReachyMiniApp):
         self._dataset_root: Path
         self._dataset_dir: Path
         self._motion_model_registry = MotionModelRegistry()
-        self._features: dict[str, bool] = DEFAULT_FEATURES.copy()
         self._preferred_duration: float = DEFAULT_DURATION
         self._welcome_messages: int = 2  # 0=none, 1=intro only, 2=intro+second
-        self._load_dataset_registry()  # may overwrite _features, _preferred_duration, _welcome_messages
+        self._load_dataset_registry()  # may overwrite _preferred_duration and _welcome_messages
 
         self._recordings: dict[str, RecordingMetadata] = {}
         self._pending_recording: RecordingRequest | None = None
@@ -542,40 +535,22 @@ class Marionette(ReachyMiniApp):
         def update_experiments(payload: UpdateExperimentsPayload) -> dict[str, Any]:
             updates = payload.dict(exclude_none=True)
             if not updates:
-                return {"status": "unchanged", "features": self._features}
+                return {"status": "unchanged"}
             with self._state_lock:
                 for key, value in updates.items():
-                    if key in self._features:
-                        self._features[key] = bool(value)
-                    elif key == "duration_seconds":
+                    if key == "duration_seconds":
                         self._preferred_duration = float(value)
                     elif key == "welcome_messages":
                         self._welcome_messages = max(0, min(2, int(value)))
                 self._save_dataset_registry()
             return {
                 "status": "updated",
-                "features": self._features,
                 "preferred_duration": self._preferred_duration,
-                "motion_models": self._motion_model_registry.to_payload()
-                if self._features.get("motion_models")
-                else None,
+                "motion_models": self._motion_model_registry.to_payload(),
             }
 
-        @self.settings_app.post("/api/motion-model")
-        def update_motion_model(payload: UpdateMotionModelPayload) -> dict[str, Any]:
-            if not self._features.get("motion_models"):
-                raise HTTPException(status_code=400, detail="Motion model feature is disabled.")
-            try:
-                self._motion_model_registry.set_active(payload.name)
-            except KeyError as exc:
-                raise HTTPException(status_code=404, detail=f"Unknown motion model '{payload.name}'.") from exc
-            self._save_dataset_registry()
-            return {"status": "updated", "active": self._motion_model_registry.active}
-
         @self.settings_app.post("/api/motion-model/lead")
         def update_motion_model_lead(payload: UpdateLeadCompensationPayload) -> dict[str, Any]:
-            if not self._features.get("motion_models"):
-                raise HTTPException(status_code=400, detail="Motion model feature is disabled.")
             params = payload.dict(exclude_none=True)
             if not params:
                 return {
@@ -1347,8 +1322,6 @@ class Marionette(ReachyMiniApp):
         return True
 
     def _apply_motion_model(self, move: RecordedMove) -> RecordedMove:
-        if not self._features.get("motion_models"):
-            return move
         try:
             return self._motion_model_registry.apply(move)
         except Exception as exc:
@@ -1470,11 +1443,6 @@ class Marionette(ReachyMiniApp):
         else:
             raw = {}
 
-        stored_model = raw.get("motion_model", "lead_compensation")
-        try:
-            self._motion_model_registry.set_active(stored_model)
-        except KeyError:
-            self._motion_model_registry.set_active("no_model")
         raw_params = raw.get("motion_model_params", {})
         if isinstance(raw_params, dict):
             for model_name, params in raw_params.items():
@@ -1483,12 +1451,6 @@ class Marionette(ReachyMiniApp):
                         self._motion_model_registry.set_model_params(model_name, params)
                     except KeyError:
                         continue
-
-        raw_features = raw.get("features") or {}
-        self._features = DEFAULT_FEATURES.copy()
-        for key in self._features:
-            if key in raw_features:
-                self._features[key] = bool(raw_features[key])
         self._preferred_duration = float(raw.get("preferred_duration", DEFAULT_DURATION))
         self._welcome_messages = int(raw.get("welcome_messages", 2))
 
@@ -1555,11 +1517,9 @@ class Marionette(ReachyMiniApp):
         data = {
             "active": self._active_dataset_id,
             "root_path": str(self._dataset_root),
-            "motion_model": self._motion_model_registry.active,
             "motion_model_params": {
                 "lead_compensation": self._motion_model_registry.get_model_params("lead_compensation"),
             },
-            "features": self._features,
             "preferred_duration": self._preferred_duration,
             "welcome_messages": self._welcome_messages,
             "datasets": [
@@ -2197,13 +2157,7 @@ class Marionette(ReachyMiniApp):
                     "active_dataset_path": str(self._dataset_dir),
                     "dataset_root_path": str(self._dataset_root),
                     "hf_username": self._check_hf_login(),
-                    "features": dict(self._features),
-                    "feature_support": {
-                        "motion_models": True,
-                    },
-                    "motion_models": self._motion_model_registry.to_payload()
-                    if self._features.get("motion_models")
-                    else None,
+                    "motion_models": self._motion_model_registry.to_payload(),
                     "welcome_messages": self._welcome_messages,
                 },
                 "datasets": self._datasets_payload(),

marionette/motion_models.py

@@ -1,12 +1,9 @@
-"""Simple motion model prototypes to improve replay fidelity."""
+"""Lead compensation for replay fidelity."""
 
 from __future__ import annotations
 
 import copy
-from dataclasses import dataclass
-from typing import Any, Dict, List
-
-import numpy as np
+from typing import Any, Dict
 
 try:
     from reachy_mini.motion.recorded_move import RecordedMove
@@ -19,18 +16,7 @@ def _deepcopy_move(move: Dict[str, Any]) -> Dict[str, Any]:
     return copy.deepcopy(move)
 
 
-class MotionModel:
-    """Base helper for prototype models."""
-
-    name: str = "no_model"
-    label: str = "No compensation"
-    description: str = "Stream the recorded trajectory as-is."
-
-    def transform(self, move: Dict[str, Any]) -> Dict[str, Any]:
-        return _deepcopy_move(move)
-
-
-class LeadCompensationModel(MotionModel):
+class LeadCompensationModel:
     """Shift commands ahead in time to compensate for controller lag.
 
     Uses separate lead values for antennas vs head/body, since antennas
@@ -41,7 +27,7 @@ class LeadCompensationModel(MotionModel):
     label = "Lead compensation"
     description = "Issues commands a few frames ahead to counter fixed latency."
 
-    def __init__(self, lead_frames_antennas: int = 3, lead_frames_head: int = 10) -> None:
+    def __init__(self, lead_frames_antennas: int = 4, lead_frames_head: int = 15) -> None:
         self.lead_frames_antennas = max(0, int(lead_frames_antennas))
         self.lead_frames_head = max(0, int(lead_frames_head))
 
@@ -51,7 +37,6 @@ class LeadCompensationModel(MotionModel):
         if not data:
             return patched
         total = len(data)
-        # Take a snapshot of the original data for look-ahead reads.
         original = [copy.deepcopy(f) for f in data]
         for idx in range(total):
             ant_src = min(idx + self.lead_frames_antennas, total - 1)
@@ -63,146 +48,53 @@ class LeadCompensationModel(MotionModel):
         return patched
 
 
-class AveragingModel(MotionModel):
-    """Apply a small moving-average filter to reduce play/backlash artifacts."""
-
-    name = "moving_average"
-    label = "Moving average"
-    description = "Smooths the trajectory with a small window to reduce overshoot."
-
-    def __init__(self, window: int = 3) -> None:
-        self.window = max(2, int(window))
-
-    def transform(self, move: Dict[str, Any]) -> Dict[str, Any]:
-        patched = _deepcopy_move(move)
-        data = patched.get("set_target_data", [])
-        if not data:
-            return patched
-        window = self.window
-        half = window // 2
-        for idx in range(len(data)):
-            start = max(0, idx - half)
-            end = min(len(data), idx + half + 1)
-            slice_frames = data[start:end]
-            if len(slice_frames) <= 1:
-                continue
-            averaged = _average_frames(slice_frames)
-            data[idx] = averaged
-        return patched
-
-
-def _average_frames(frames: List[Dict[str, Any]]) -> Dict[str, Any]:
-    heads = [np.asarray(frame["head"], dtype=float) for frame in frames]
-    antennas = [np.asarray(frame["antennas"], dtype=float) for frame in frames]
-    yaw = [float(frame.get("body_yaw", 0.0)) for frame in frames]
-    head_avg = np.mean(heads, axis=0)
-    antennas_avg = np.mean(antennas, axis=0)
-    yaw_avg = float(np.mean(yaw))
-    averaged = copy.deepcopy(frames[len(frames) // 2])
-    averaged["head"] = head_avg.tolist()
-    averaged["antennas"] = antennas_avg.tolist()
-    averaged["body_yaw"] = yaw_avg
-    return averaged
-
-
-class StaticOffsetModel(MotionModel):
-    """Adds a constant bias on antennas to compensate small mechanical play."""
-
-    name = "static_offset"
-    label = "Static offset"
-    description = "Adds a small bias to antennas joints to counter play."
-
-    def __init__(self, offset: float = 0.01) -> None:
-        self.offset = float(offset)
-
-    def transform(self, move: Dict[str, Any]) -> Dict[str, Any]:
-        patched = _deepcopy_move(move)
-        data = patched.get("set_target_data", [])
-        if not data:
-            return patched
-        for frame in data:
-            antennas = np.asarray(frame["antennas"], dtype=float)
-            antennas += self.offset
-            frame["antennas"] = antennas.tolist()
-        return patched
-
-
 class MotionModelRegistry:
-    """Registry + state for experimental motion models."""
-
-    def __init__(self, active: str = "lead_compensation") -> None:
-        self._models: Dict[str, MotionModel] = {
-            "no_model": MotionModel(),
-            LeadCompensationModel.name: LeadCompensationModel(),
-            AveragingModel.name: AveragingModel(),
-            StaticOffsetModel.name: StaticOffsetModel(),
-        }
-        self._active = active if active in self._models else "no_model"
+    """Always-on lead compensation model."""
+
+    def __init__(self) -> None:
+        self._model = LeadCompensationModel()
+        self._active = LeadCompensationModel.name
 
     @property
     def active(self) -> str:
         return self._active
 
-    def set_active(self, name: str) -> None:
-        if name not in self._models:
-            raise KeyError(name)
-        self._active = name
-
     def set_model_params(self, name: str, params: Dict[str, Any]) -> None:
-        model = self._models.get(name)
-        if model is None:
+        if name != LeadCompensationModel.name:
             raise KeyError(name)
-        if name == LeadCompensationModel.name:
-            head = params.get("lead_frames_head")
-            antennas = params.get("lead_frames_antennas")
-            if head is not None:
-                model.lead_frames_head = max(0, int(head))
-            if antennas is not None:
-                model.lead_frames_antennas = max(0, int(antennas))
+        head = params.get("lead_frames_head")
+        antennas = params.get("lead_frames_antennas")
+        if head is not None:
+            self._model.lead_frames_head = max(0, int(head))
+        if antennas is not None:
+            self._model.lead_frames_antennas = max(0, int(antennas))
 
     def get_model_params(self, name: str) -> Dict[str, Any]:
-        model = self._models.get(name)
-        if model is None:
+        if name != LeadCompensationModel.name:
             raise KeyError(name)
-        if name == LeadCompensationModel.name:
-            return {
-                "lead_frames_head": int(model.lead_frames_head),
-                "lead_frames_antennas": int(model.lead_frames_antennas),
-            }
-        return {}
-
-    def list_models(self) -> List[Dict[str, str]]:
-        return [
-            {
-                "name": name,
-                "label": model.label,
-                "description": model.description,
-            }
-            for name, model in self._models.items()
-        ]
+        return {
+            "lead_frames_head": int(self._model.lead_frames_head),
+            "lead_frames_antennas": int(self._model.lead_frames_antennas),
+        }
 
     def transform_move(self, move_data: Dict[str, Any]) -> Dict[str, Any]:
-        model = self._models.get(self._active)
-        if model is None:
-            return _deepcopy_move(move_data)
-        return model.transform(move_data)
+        return self._model.transform(move_data)
 
     def apply(self, recorded_move: RecordedMove) -> RecordedMove:
         if RecordedMove is None:
             raise RuntimeError("reachy_mini is unavailable.")
-        if self._active == "no_model":
-            return recorded_move
         mutated = self.transform_move(recorded_move.move)
         return RecordedMove(mutated, recorded_move.sound_path)
 
     def to_payload(self) -> Dict[str, Any]:
-        params: Dict[str, Any] = {}
-        for name in self._models:
-            model_params = self.get_model_params(name)
-            if model_params:
-                params[name] = model_params
         return {
             "active": self._active,
-            "models": self.list_models(),
-            "params": params,
+            "models": [
+                {
+                    "name": LeadCompensationModel.name,
+                    "label": LeadCompensationModel.label,
+                    "description": LeadCompensationModel.description,
+                }
+            ],
+            "params": {LeadCompensationModel.name: self.get_model_params(LeadCompensationModel.name)},
         }

marionette/static/index.html

@@ -201,31 +201,19 @@
     <p class="settings-hint" id="welcome-msg-hint">Takes effect on next app restart</p>
   </div>
 
-  <!-- Experimental features -->
-  <div class="settings-section" id="experimental-section">
-    <h3>Experimental</h3>
-    <label class="settings-toggle">
-      <span>Motion compensation models</span>
-      <input type="checkbox" id="feature-motion-models"/>
-    </label>
-    <div id="motion-model-group" style="display:none">
-      <div class="settings-row">
-        <span class="settings-label">Model</span>
-        <select class="settings-input" id="motion-model-select" style="cursor:pointer"></select>
-      </div>
-      <div id="lead-comp-group" style="display:none">
-        <div class="settings-row">
-          <span class="settings-label">Head lead (frames)</span>
-          <input class="settings-input" id="lead-frames-head" type="number" min="0" max="2000" step="1"/>
-        </div>
-        <div class="settings-row">
-          <span class="settings-label">Antenna lead (frames)</span>
-          <input class="settings-input" id="lead-frames-antennas" type="number" min="0" max="2000" step="1"/>
-        </div>
-        <p class="settings-hint">Applied only during replay (never during recording).</p>
-      </div>
-      <p class="settings-hint" id="motion-model-hint"></p>
+  <!-- Lead compensation -->
+  <div class="settings-section" id="lead-comp-section">
+    <h3>Lead compensation</h3>
+    <div class="settings-row">
+      <span class="settings-label">Head lead (frames)</span>
+      <input class="settings-input" id="lead-frames-head" type="number" min="0" max="2000" step="1"/>
+    </div>
+    <div class="settings-row">
+      <span class="settings-label">Antenna lead (frames)</span>
+      <input class="settings-input" id="lead-frames-antennas" type="number" min="0" max="2000" step="1"/>
     </div>
+    <p class="settings-hint">1 frame = 10 ms (100 Hz control loop).</p>
+    <p class="settings-hint">Applied only during replay (never during recording).</p>
   </div>
 </div>
 

marionette/static/main.js

@@ -85,11 +85,6 @@ const $hfLogoutBtn = document.getElementById('hf-logout-btn');
 const $datasetRootInput = document.getElementById('dataset-root-input');
 const $datasetRootHint = document.getElementById('dataset-root-hint');
 const $updateRootBtn = document.getElementById('update-root-btn');
-const $featureMotionModels = document.getElementById('feature-motion-models');
-const $motionModelGroup = document.getElementById('motion-model-group');
-const $motionModelSelect = document.getElementById('motion-model-select');
-const $motionModelHint = document.getElementById('motion-model-hint');
-const $leadCompGroup = document.getElementById('lead-comp-group');
 const $leadFramesHead = document.getElementById('lead-frames-head');
 const $leadFramesAntennas = document.getElementById('lead-frames-antennas');
 const $fetchCommunityBtn = document.getElementById('fetch-community-btn');
@@ -251,8 +246,8 @@ function updateUI(s) {
       if (radio && !radio.checked) radio.checked = true;
     }
 
-    // Experimental features
-    updateExperimentalUI(s.config);
+    // Lead compensation
+    updateLeadCompUI(s.config);
   }
 
   // ── Datasets ──
@@ -743,44 +738,22 @@ async function downloadCommunity() {
 
 
 // ═══════════════════════════════════════════════════════════════════════
-// SECTION 9: EXPERIMENTAL FEATURES UI
+// SECTION 9: LEAD COMPENSATION UI
 // ═══════════════════════════════════════════════════════════════════════
 
-function updateExperimentalUI(config) {
-  const features = config.features || {};
-  $featureMotionModels.checked = !!features.motion_models;
-
+function updateLeadCompUI(config) {
   const modelsPayload = config.motion_models;
-  const hasModels = modelsPayload && Array.isArray(modelsPayload.models) && modelsPayload.models.length;
-  const enabled = features.motion_models && hasModels;
-  $motionModelGroup.style.display = enabled ? '' : 'none';
-
-  if (!enabled) return;
-  $motionModelSelect.innerHTML = '';
-  modelsPayload.models.forEach(m => {
-    const o = document.createElement('option');
-    o.value = m.name;
-    o.textContent = m.label;
-    $motionModelSelect.appendChild(o);
-  });
-  $motionModelSelect.value = modelsPayload.active || '';
-  const current = modelsPayload.models.find(m => m.name === modelsPayload.active);
-  if ($motionModelHint) $motionModelHint.textContent = current ? current.description : '';
-
-  const isLeadComp = modelsPayload.active === 'lead_compensation';
-  if ($leadCompGroup) $leadCompGroup.style.display = isLeadComp ? '' : 'none';
-  if (isLeadComp) {
-    const params = modelsPayload.params?.lead_compensation || {};
-    if ($leadFramesHead && document.activeElement !== $leadFramesHead && Number.isFinite(params.lead_frames_head)) {
-      $leadFramesHead.value = String(params.lead_frames_head);
-    }
-    if (
-      $leadFramesAntennas
-      && document.activeElement !== $leadFramesAntennas
-      && Number.isFinite(params.lead_frames_antennas)
-    ) {
-      $leadFramesAntennas.value = String(params.lead_frames_antennas);
-    }
+  if (!modelsPayload) return;
+  const params = modelsPayload.params?.lead_compensation || {};
+  if ($leadFramesHead && document.activeElement !== $leadFramesHead && Number.isFinite(params.lead_frames_head)) {
+    $leadFramesHead.value = String(params.lead_frames_head);
+  }
+  if (
+    $leadFramesAntennas
+    && document.activeElement !== $leadFramesAntennas
+    && Number.isFinite(params.lead_frames_antennas)
+  ) {
+    $leadFramesAntennas.value = String(params.lead_frames_antennas);
   }
 }
 
@@ -927,24 +900,6 @@ document.querySelectorAll('input[name="welcome-msgs"]').forEach(r => {
   });
 });
 
-/* Experimental features */
-$featureMotionModels.addEventListener('change', e => {
-  fetch('/api/experiments', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ motion_models: e.target.checked }),
-  }).then(() => fetchState());
-});
-$motionModelSelect.addEventListener('change', e => {
-  if (e.target.value) {
-    fetch('/api/motion-model', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ name: e.target.value }),
-    }).then(() => fetchState());
-  }
-});
-
 function saveLeadCompensationParams() {
   const head = parseInt($leadFramesHead?.value ?? '', 10);
   const antennas = parseInt($leadFramesAntennas?.value ?? '', 10);

tests/test_api.py

@@ -99,7 +99,7 @@ class TestStateEndpoint:
         assert config["countdown_seconds"] == COUNTDOWN_SECONDS
         assert config["motion_sample_rate"] == MOTION_SAMPLE_RATE
         assert isinstance(config["audio_available"], bool)
-        assert isinstance(config["features"], dict)
+        assert "motion_models" in config
 
     def test_initial_moves_empty(self, client: TestClient):
         data = client.get("/api/state").json()
@@ -509,19 +509,15 @@ class TestMovesRefresh:
         assert move["has_audio"] is False
 
 
-# ──────── Experiment / feature toggle tests ───────────────────────────
+# ──────── Settings tests ───────────────────────────
 
 
 class TestExperiments:
-    def test_denoise_feature_removed(self, client: TestClient):
-        """Denoise feature was removed; the features dict should not contain it."""
+    def test_motion_models_present(self, client: TestClient):
         data = client.get("/api/state").json()
-        assert "denoise" not in data["config"]["features"]
-
-    def test_toggle_motion_models(self, client: TestClient):
-        resp = client.post("/api/experiments", json={"motion_models": True})
-        assert resp.status_code == 200
-        assert resp.json()["features"]["motion_models"] is True
+        mm = data["config"]["motion_models"]
+        assert mm["active"] == "lead_compensation"
+        assert "lead_compensation" in mm["params"]
 
     def test_update_duration(self, client: TestClient):
         resp = client.post("/api/experiments", json={"duration_seconds": 10.0})
@@ -897,39 +893,11 @@ class TestTimingSync:
         assert marionette._stream_playback(_FakeReachy(), _FakeMove()) is True
 
 
-# ──────── Motion model endpoint tests ────────────────────────────────
+# ──────── Lead compensation endpoint tests ────────────────────────────────
 
 
 class TestMotionModelEndpoint:
-    def test_motion_model_rejected_when_disabled(self, client: TestClient):
-        client.post("/api/experiments", json={"motion_models": False})
-        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"
-
     def test_update_lead_compensation_params(self, client: TestClient):
-        client.post("/api/experiments", json={"motion_models": True})
         resp = client.post(
             "/api/motion-model/lead",
             json={"lead_frames_head": 3, "lead_frames_antennas": 1},
@@ -950,7 +918,6 @@ class TestMotionModelEndpoint:
     ):
         app1, _ = 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/lead",
             json={"lead_frames_head": 4, "lead_frames_antennas": 2},
@@ -1257,7 +1224,7 @@ class TestApiContracts:
             "default_duration", "preferred_duration", "countdown_seconds",
             "motion_sample_rate", "audio_available",
             "active_dataset_path", "dataset_root_path",
-            "hf_username", "features", "feature_support",
+            "hf_username", "motion_models",
         }
         assert required.issubset(config.keys()), (
             f"Missing config keys: {required - config.keys()}"
@@ -1333,11 +1300,11 @@ class TestApiContracts:
         assert "folder" in ds
 
     def test_experiments_response_shape(self, client: TestClient):
-        resp = client.post("/api/experiments", json={"motion_models": True})
+        resp = client.post("/api/experiments", json={"duration_seconds": 7.0})
         assert resp.status_code == 200
         data = resp.json()
         assert "status" in data
-        assert "features" in data
+        assert "preferred_duration" in data
 
 
 # ──────── Audio-only recording tests ─────────────────────────────────