Remove denoise feature from UI and backend

The motor-noise denoising feature didn't work well and added significant
complexity. Removed the /api/moves/{move_id}/denoise endpoint, the
_perform_denoise and _apply_noise_profile methods, the denoise toggle
from the experimental panel, and the denoise button from the move list.

Existing .denoised.wav files are still recognized and used for playback
(backward compatibility).

marionette/main.py

@@ -67,7 +67,7 @@ HF_DATASETS_API_URL = "https://huggingface.co/api/datasets"
 DATASET_DATA_SUBDIR = "data"
 NOISE_SUFFIX = ".noise.wav"
 DENOISED_SUFFIX = ".denoised.wav"
-DEFAULT_FEATURES = {"denoise": False, "motion_models": False}
+DEFAULT_FEATURES = {"motion_models": False}
 
 logger = logging.getLogger(__name__)
 
@@ -183,7 +183,6 @@ class UpdateMotionModelPayload(BaseModel):
 
 
 class UpdateExperimentsPayload(BaseModel):
-    denoise: bool | None = Field(default=None, description="Enable or disable denoise feature")
     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)
 
@@ -215,7 +214,6 @@ class Marionette(ReachyMiniApp):
         self._recordings: dict[str, RecordingMetadata] = {}
         self._pending_recording: RecordingRequest | None = None
         self._pending_playback: str | None = None
-        self._pending_denoise: str | None = None
         self._uploaded_audio: dict[str, Path] = {}  # upload_id -> temp file path
         self._playback_cancel_event = threading.Event()
         self._recording_cancel_event = threading.Event()
@@ -331,7 +329,6 @@ class Marionette(ReachyMiniApp):
                     self._mode not in {"idle", "queued"}
                     or self._pending_recording
                     or self._pending_playback
-                    or self._pending_denoise
                 ):
                     raise HTTPException(status_code=409, detail="Robot is busy.")
                 self._preferred_duration = float(request.duration)
@@ -359,7 +356,6 @@ class Marionette(ReachyMiniApp):
                     self._mode != "idle"
                     or self._pending_recording
                     or self._pending_playback
-                    or self._pending_denoise
                 ):
                     raise HTTPException(status_code=409, detail="Robot is busy.")
                 self._pending_playback = payload.move_id
@@ -390,27 +386,6 @@ class Marionette(ReachyMiniApp):
             self._refresh_recordings()
             return {"status": "deleted", "move_id": move_id}
 
-        @self.settings_app.post("/api/moves/{move_id}/denoise")
-        def denoise_move(move_id: str) -> dict[str, Any]:
-            if not self._features.get("denoise"):
-                raise HTTPException(status_code=400, detail="Denoise feature is disabled.")
-            if move_id not in self._recordings:
-                raise HTTPException(status_code=404, detail=f"Move {move_id} not found.")
-            if not self._audio_available:
-                raise HTTPException(status_code=400, detail="Audio backend unavailable for denoise.")
-            with self._state_lock:
-                if (
-                    self._mode not in {"idle", "queued"}
-                    or self._pending_recording
-                    or self._pending_playback
-                    or self._pending_denoise
-                ):
-                    raise HTTPException(status_code=409, detail="Robot is busy.")
-                self._pending_denoise = move_id
-                self._mode = "queued"
-                self._message = f"Denoise queued for {move_id}"
-            return {"status": "queued", "move_id": move_id}
-
         @self.settings_app.get("/api/datasets")
         def list_datasets() -> dict[str, Any]:
             return self._datasets_payload()
@@ -422,7 +397,6 @@ class Marionette(ReachyMiniApp):
                     self._mode not in {"idle", "queued"}
                     or self._pending_recording
                     or self._pending_playback
-                    or self._pending_denoise
                 ):
                     raise HTTPException(status_code=409, detail="Robot is busy.")
                 entry = self._create_dataset(payload.name, payload.label)
@@ -437,7 +411,6 @@ class Marionette(ReachyMiniApp):
                     self._mode not in {"idle", "queued"}
                     or self._pending_recording
                     or self._pending_playback
-                    or self._pending_denoise
                 ):
                     raise HTTPException(status_code=409, detail="Robot is busy.")
                 self._select_dataset(payload.dataset_id)
@@ -451,7 +424,6 @@ class Marionette(ReachyMiniApp):
                     self._mode not in {"idle", "queued"}
                     or self._pending_recording
                     or self._pending_playback
-                    or self._pending_denoise
                 ):
                     raise HTTPException(status_code=409, detail="Robot is busy.")
             result = self._sync_dataset(payload.hf_username, payload.move_ids, payload.dataset_slug)
@@ -464,7 +436,6 @@ class Marionette(ReachyMiniApp):
                     self._mode not in {"idle", "queued"}
                     or self._pending_recording
                     or self._pending_playback
-                    or self._pending_denoise
                 ):
                     raise HTTPException(status_code=409, detail="Robot is busy.")
                 self._set_dataset_root(payload.path)
@@ -598,10 +569,6 @@ class Marionette(ReachyMiniApp):
                         job_type = "play"
                         payload = self._pending_playback
                         self._pending_playback = None
-                    elif self._pending_denoise is not None:
-                        job_type = "denoise"
-                        payload = self._pending_denoise
-                        self._pending_denoise = None
 
                 if job_type == "record" and isinstance(payload, RecordingRequest):
                     self._perform_recording(reachy_mini, stop_event, payload)
@@ -610,9 +577,6 @@ class Marionette(ReachyMiniApp):
                     self._perform_playback(reachy_mini, payload)
                     self._set_idle_state()
                     self._align_head_and_release(reachy_mini)
-                elif job_type == "denoise" and isinstance(payload, str):
-                    self._perform_denoise(reachy_mini, payload)
-                    self._set_idle_state()
                 else:
                     stop_event.wait(0.05)
         finally:
@@ -716,9 +680,8 @@ class Marionette(ReachyMiniApp):
             self._set_state(mode="error", message=f"Move {move_id} missing.", active_move=None)
             return
 
-        prefer_denoised = bool(self._features.get("denoise") and meta.has_denoised_audio)
         try:
-            move = self._load_move(meta.json_path, prefer_denoised=prefer_denoised)
+            move = self._load_move(meta.json_path)
         except Exception as exc:  # pragma: no cover - filesystem failure
             self._set_state(
                 mode="error",
@@ -765,145 +728,6 @@ class Marionette(ReachyMiniApp):
                 active_move=None,
             )
 
-    def _perform_denoise(self, reachy_mini: ReachyMini, move_id: str) -> None:
-        if not self._audio_available:
-            self._set_state(
-                mode="error",
-                message="Audio backend unavailable for motor noise capture.",
-                active_move=None,
-            )
-            return
-
-        meta = self._recordings.get(move_id)
-        if not meta:
-            self._set_state(mode="error", message=f"Move {move_id} missing.", active_move=None)
-            return
-        if not meta.has_audio:
-            self._set_state(
-                mode="error",
-                message=f"No audio track to denoise for {meta.label}.",
-                active_move=None,
-            )
-            return
-
-        try:
-            move = self._load_move(meta.json_path, prefer_denoised=False)
-        except Exception as exc:  # pragma: no cover - filesystem failure
-            self._set_state(
-                mode="error",
-                message=f"Failed to load {move_id}: {exc}",
-                active_move=None,
-            )
-            return
-
-        audio_frames: list[np.ndarray] = []
-        audio_samplerate = AUDIO_SAMPLE_RATE
-        audio_active = False
-
-        def _pull_audio_frames() -> None:
-            if not audio_active:
-                return
-            while True:
-                sample = reachy_mini.media.get_audio_sample()
-                if sample is None:
-                    break
-                audio_frames.append(sample)
-
-        try:
-            reachy_mini.media.start_recording()
-            reported = reachy_mini.media.get_input_audio_samplerate()
-            if reported:
-                audio_samplerate = int(reported)
-            audio_active = True
-        except Exception as exc:
-            self._set_state(
-                mode="error",
-                message=f"Unable to start audio capture: {exc}",
-                active_move=None,
-            )
-            return
-
-        self._set_state(
-            mode="denoise",
-            message=f"Capturing motor noise for {meta.label}",
-            active_move=meta.move_id,
-        )
-
-        success = False
-        self._safe_enable_motors(reachy_mini)
-        try:
-            success = self._stream_playback(
-                reachy_mini,
-                move,
-                play_sound=False,
-                sample_hook=_pull_audio_frames,
-            )
-        finally:
-            self._goto_sleep_and_release(reachy_mini)
-            if audio_active:
-                try:
-                    reachy_mini.media.stop_recording()
-                except Exception:
-                    pass
-            _pull_audio_frames()
-
-        if not success:
-            self._set_state(
-                mode="error",
-                message=f"Motor noise capture canceled for {meta.label}",
-                active_move=None,
-            )
-            return
-
-        if not audio_frames:
-            self._set_state(
-                mode="error",
-                message="No audio captured during motor noise replay.",
-                active_move=None,
-            )
-            return
-
-        noise_path = meta.json_path.with_suffix(NOISE_SUFFIX)
-        denoised_path = meta.json_path.with_suffix(DENOISED_SUFFIX)
-        audio_data = np.concatenate(audio_frames, axis=0)
-        sf.write(str(noise_path), audio_data, audio_samplerate)
-        try:
-            self._apply_noise_profile(meta.json_path, noise_path, denoised_path)
-        except Exception as exc:
-            logger.warning("Noise subtraction failed for %s: %s", meta.move_id, exc)
-        self._refresh_recordings()
-        self._set_state(
-            mode="idle",
-            message=f"Denoised {meta.label}",
-            active_move=None,
-        )
-
-    def _apply_noise_profile(self, json_path: Path, noise_path: Path, target_path: Path) -> None:
-        original_audio = json_path.with_suffix(".wav")
-        if not original_audio.exists():
-            logger.info("No original audio present for %s; skipping denoise.", json_path)
-            return
-        original, orig_rate = sf.read(str(original_audio))
-        noise, noise_rate = sf.read(str(noise_path))
-        if orig_rate != noise_rate:
-            logger.warning(
-                "Noise sample rate mismatch for %s (original=%sHz, noise=%sHz).",
-                json_path.name,
-                orig_rate,
-                noise_rate,
-            )
-            return
-        overlap = min(len(original), len(noise))
-        if overlap == 0:
-            logger.warning("Noise sample empty for %s", json_path.name)
-            return
-        denoised = np.array(original, copy=True)
-        denoised[:overlap] = denoised[:overlap] - noise[:overlap]
-        denoised = np.clip(denoised, -1.0, 1.0)
-        if len(original) > overlap:
-            denoised[overlap:] = original[overlap:]
-        sf.write(str(target_path), denoised, orig_rate)
-
     # ──────── Capture helpers ───────────────────────────────────────────
     def _capture_motion(
         self,
@@ -1814,7 +1638,6 @@ class Marionette(ReachyMiniApp):
                 "recording_stats": self._recording_stats,
                 "pending_recording": self._pending_recording.label if self._pending_recording else None,
                 "pending_playback": self._pending_playback,
-                "pending_denoise": self._pending_denoise,
                 "moves": moves,
                 "config": {
                     "default_duration": DEFAULT_DURATION,
@@ -1826,7 +1649,6 @@ class Marionette(ReachyMiniApp):
                     "dataset_root_path": str(self._dataset_root),
                     "features": dict(self._features),
                     "feature_support": {
-                        "denoise": self._audio_available,
                         "motion_models": True,
                     },
                     "motion_models": self._motion_model_registry.to_payload()

marionette/static/index.html

@@ -211,18 +211,8 @@
               <details id="experimental-details">
                 <summary>Experimental</summary>
                 <div class="experimental-content">
-                  <p class="hint">Toggle prototype features. These may change or disappear without notice.</p>
-                  <div class="field-group">
-                    <label class="toggle">
-                      <input id="feature-denoise" type="checkbox" />
-                      <span>Enable motor-noise denoising for move audio</span>
-                    </label>
-                    <p class="hint small">
-                      Adds a per-move “Denoise” button that records the motor hum separately and subtracts it from the original
-                      track.
-                    </p>
-                  </div>
-                  <div class="field-group">
+                  <p class=”hint”>Toggle prototype features. These 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>

marionette/static/main.js

@@ -59,7 +59,6 @@ const motionModelSelect = document.getElementById("motion-model-select");
 const motionModelHint = document.getElementById("motion-model-hint");
 const experimentalStatus = document.getElementById("experimental-status");
 const featureToggles = {
-  denoise: document.getElementById("feature-denoise"),
   motionModels: document.getElementById("feature-motion-models"),
 };
 
@@ -258,10 +257,6 @@ function renderMoves(moves, mode, config) {
     updateSyncButtonState();
     return;
   }
-  const features = (config && config.features) || {};
-  const support = (config && config.feature_support) || {};
-  const denoiseEnabled = !!features.denoise && support.denoise !== false;
-
   for (const move of moves) {
     const li = document.createElement("li");
     const selection = document.createElement("div");
@@ -292,16 +287,9 @@ function renderMoves(moves, mode, config) {
     const info = document.createElement("div");
     info.className = "move-info";
     const date = new Date(move.created_at * 1000).toLocaleString();
-    const badges = [];
-    if (move.has_denoised_audio) {
-      badges.push("denoised");
-    } else if (move.has_noise_profile) {
-      badges.push("noise profile");
-    }
-    const badgeText = badges.length ? ` • ${badges.join(", ")}` : "";
     info.textContent = `${formatDuration(move.duration)} • ${
       move.has_audio ? "🎙 audio" : "🤐 silent"
-    } • ${date}${badgeText}`;
+    } • ${date}`;
     meta.appendChild(info);
 
     const actions = document.createElement("div");
@@ -331,15 +319,6 @@ function renderMoves(moves, mode, config) {
     deleteBtn.addEventListener("click", () => deleteMove(move.id));
     actions.appendChild(deleteBtn);
 
-    if (denoiseEnabled && move.has_audio) {
-      const denoiseBtn = document.createElement("button");
-      denoiseBtn.className = "play-btn";
-      denoiseBtn.textContent = move.has_denoised_audio ? "Rebuild noise" : "Denoise";
-      denoiseBtn.disabled = busy;
-      denoiseBtn.addEventListener("click", () => queueDenoise(move.id));
-      actions.appendChild(denoiseBtn);
-    }
-
     li.appendChild(selection);
     li.appendChild(actions);
     movesList.appendChild(li);
@@ -425,22 +404,6 @@ async function queuePlayback(moveId) {
   }
 }
 
-async function queueDenoise(moveId) {
-  if (!moveId) return;
-  try {
-    const resp = await fetch(`/api/moves/${encodeURIComponent(moveId)}/denoise`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-    });
-    if (!resp.ok) throw new Error(await resp.text());
-    primaryStatus.textContent = `Denoise queued for ${moveId}.`;
-    await fetchState();
-  } catch (error) {
-    console.error("Denoise error:", error);
-    primaryStatus.textContent = `Unable to denoise ${moveId}.`;
-  }
-}
-
 recordForm.addEventListener("submit", queueRecording);
 refreshBtn.addEventListener("click", fetchState);
 if (datasetSelect) {
@@ -563,11 +526,6 @@ if (motionModelSelect) {
     updateMotionModel(value);
   });
 }
-if (featureToggles.denoise) {
-  featureToggles.denoise.addEventListener("change", (event) => {
-    updateExperimentalFeatures({ denoise: event.target.checked });
-  });
-}
 if (featureToggles.motionModels) {
   featureToggles.motionModels.addEventListener("change", (event) => {
     updateExperimentalFeatures({ motion_models: event.target.checked });
@@ -750,8 +708,8 @@ function updatePhaseFromState(state) {
     phaseStartAt = null;
     phaseEndAt = null;
   }
-  // For "playing" or "denoise", keep the phase cleared
-  if (state.mode === "playing" || state.mode === "denoise") {
+  // For "playing", keep the phase cleared
+  if (state.mode === "playing") {
     phaseMode = state.mode;
     phaseStartAt = null;
     phaseEndAt = null;
@@ -1109,14 +1067,6 @@ function updateExperimentalUI(config) {
   experimentalPanel.hidden = false;
   const features = config.features || {};
   const support = config.feature_support || {};
-  if (featureToggles.denoise) {
-    featureToggles.denoise.checked = !!features.denoise;
-    const supported = support.denoise !== false;
-    featureToggles.denoise.disabled = !supported;
-    featureToggles.denoise.title = supported
-      ? "Capture and subtract motor noise."
-      : "Audio backend unavailable, cannot capture motor noise.";
-  }
   if (featureToggles.motionModels) {
     featureToggles.motionModels.checked = !!features.motion_models;
   }

tests/test_api.py

@@ -72,7 +72,7 @@ class TestStateEndpoint:
             "phase_start_at", "phase_end_at",
             "countdown_ends_at",
             "recording_started_at", "recording_duration", "recording_stats",
-            "pending_recording", "pending_playback", "pending_denoise",
+            "pending_recording", "pending_playback",
             "moves", "config", "datasets",
         }
         assert required_keys.issubset(data.keys())
@@ -105,7 +105,6 @@ class TestStateEndpoint:
         data = client.get("/api/state").json()
         assert data["pending_recording"] is None
         assert data["pending_playback"] is None
-        assert data["pending_denoise"] is None
 
 
 # ──────── Recording endpoint tests ────────────────────────────────────
@@ -422,10 +421,10 @@ class TestMovesRefresh:
 
 
 class TestExperiments:
-    def test_toggle_denoise(self, client: TestClient):
-        resp = client.post("/api/experiments", json={"denoise": True})
-        assert resp.status_code == 200
-        assert resp.json()["features"]["denoise"] is True
+    def test_denoise_feature_removed(self, client: TestClient):
+        """Denoise feature was removed; the features dict should not contain it."""
+        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})