livepilot 1.10.6 → 1.10.8

package/mcp_server/runtime/remote_commands.py

@@ -21,18 +21,20 @@ REMOTE_COMMANDS: frozenset[str] = frozenset({
     "set_track_solo", "set_track_arm", "stop_track_clips",
     "set_group_fold", "set_track_input_monitoring",
     "get_freeze_status", "freeze_track", "flatten_track",
-    # clips (11)
+    # clips (12)
     "get_clip_info", "create_clip", "delete_clip", "duplicate_clip",
     "fire_clip", "stop_clip", "set_clip_name", "set_clip_color",
     "set_clip_loop", "set_clip_launch", "set_clip_warp_mode",
+    "set_clip_pitch",
     # notes (8)
     "add_notes", "get_notes", "remove_notes", "remove_notes_by_id",
     "modify_notes", "duplicate_notes", "transpose_notes", "quantize_clip",
-    # mixing (11)
+    # mixing (12)
     "set_track_volume", "set_track_pan", "set_track_send",
     "get_return_tracks", "get_master_track", "set_master_volume",
     "get_track_routing", "get_track_meters", "get_master_meters",
     "get_mix_snapshot", "set_track_routing",
+    "set_compressor_sidechain",  # BUG-A3 — Python LOM path (was M4L bridge)
     # scenes (12)
     "get_scenes_info", "create_scene", "delete_scene", "duplicate_scene",
     "fire_scene", "set_scene_name", "set_scene_color", "set_scene_tempo",
@@ -80,6 +82,12 @@ BRIDGE_COMMANDS: frozenset[str] = frozenset({
     "remove_warp_marker", "capture_audio", "capture_stop",
     "check_flucoma", "scrub_clip", "stop_scrub", "get_display_values",
     "get_plugin_params", "map_plugin_param", "get_plugin_presets",
+    # Deep-LOM writes that the Python Remote Script cannot reach (live on
+    # the sample child object or require device-selection semantics that
+    # only Max JS LiveAPI exposes). See mcp_server/tools/analyzer.py for
+    # the matching MCP tools that route through bridge.send_command.
+    "simpler_set_warp",
+    "compressor_set_sidechain",
     # NOTE: load_sample_to_simpler used to live here, but it's actually an
     # async Python MCP tool in mcp_server/tools/analyzer.py, not a bridge
     # command. It has no case in livepilot_bridge.js and no @register handler

package/mcp_server/sample_engine/analyzer.py

@@ -188,14 +188,30 @@ def build_profile_from_filename(
     source: str = "filesystem",
     duration_seconds: float = 0.0,
 ) -> SampleProfile:
-    """Build a SampleProfile from filename metadata only (no spectral analysis).
-
-    This is the fallback when M4L bridge is unavailable.
+    """Build a SampleProfile from filename metadata + offline spectral
+    analysis (BUG-B49 fix).
+
+    Filename still supplies key / bpm / material-type hints when
+    present, but we now ALSO open the audio file via soundfile and
+    compute:
+        - duration_seconds (exact)
+        - frequency_center / frequency_spread (FFT-based centroid)
+        - brightness (high-band energy ratio)
+        - transient_density (RMS-gradient peak count)
+        - has_clear_downbeat (peak-interval consistency)
+    These used to be zeros regardless of file contents — downstream
+    critics had no real data.
+
+    If soundfile isn't available or the file can't be decoded, we
+    gracefully fall back to the filename-only path (legacy behavior).
     """
     name = os.path.splitext(os.path.basename(file_path))[0]
     metadata = parse_filename_metadata(file_path)
     material = classify_material_from_name(name)
 
+    # Offline spectral analysis — best-effort, never raises.
+    spectral = _analyze_audio_file(file_path)
+
     profile = SampleProfile(
         source=source,
         file_path=file_path,
@@ -206,7 +222,14 @@ def build_profile_from_filename(
         bpm_confidence=0.5 if metadata.get("bpm") else 0.0,
         material_type=material,
         material_confidence=0.4,  # filename-only is low confidence
-        duration_seconds=duration_seconds,
+        duration_seconds=(
+            spectral.get("duration_seconds") or duration_seconds
+        ),
+        frequency_center=spectral.get("frequency_center", 0.0),
+        frequency_spread=spectral.get("frequency_spread", 0.0),
+        brightness=spectral.get("brightness", 0.0),
+        transient_density=spectral.get("transient_density", 0.0),
+        has_clear_downbeat=spectral.get("has_clear_downbeat", False),
     )
 
     profile.suggested_mode = suggest_simpler_mode(profile)
@@ -214,3 +237,107 @@ def build_profile_from_filename(
     profile.suggested_warp_mode = suggest_warp_mode(profile)
 
     return profile
+
+
+def _analyze_audio_file(file_path: str) -> dict:
+    """Read an audio file and compute lightweight spectral/temporal
+    features via numpy. Returns {} if the file can't be decoded.
+
+    Uses soundfile (already a dependency) + numpy FFT — no librosa
+    required. Falls back cleanly so file-not-found / unsupported
+    format doesn't break the analyzer.
+    """
+    try:
+        import soundfile as sf
+        import numpy as np
+    except ImportError:
+        return {}
+
+    if not file_path or not os.path.exists(file_path):
+        return {}
+
+    try:
+        data, samplerate = sf.read(file_path, dtype="float32")
+    except Exception:
+        return {}
+
+    # Downmix to mono
+    if data.ndim > 1:
+        data = data.mean(axis=1)
+    if data.size == 0 or samplerate <= 0:
+        return {}
+
+    duration = float(data.size) / float(samplerate)
+
+    # Spectral centroid via magnitude-weighted frequency average.
+    # Use a Welch-style average over ~50ms windows to stabilize.
+    win_len = max(1024, int(samplerate * 0.05))
+    hop = win_len // 2
+    centroids: list[float] = []
+    spreads: list[float] = []
+    frames = range(0, max(len(data) - win_len, 1), hop)
+    for start in frames:
+        frame = data[start:start + win_len]
+        if len(frame) < 32:
+            continue
+        # Hann-window + FFT
+        mags = np.abs(np.fft.rfft(frame * np.hanning(len(frame))))
+        total = mags.sum()
+        if total <= 0:
+            continue
+        freqs = np.linspace(0, samplerate / 2, len(mags))
+        c = float((mags * freqs).sum() / total)
+        centroids.append(c)
+        # Spectral spread = sqrt(sum(mags * (freqs - c)**2) / total)
+        s = float(np.sqrt(((mags * (freqs - c) ** 2).sum()) / total))
+        spreads.append(s)
+
+    if not centroids:
+        return {"duration_seconds": duration}
+
+    frequency_center = float(np.mean(centroids))
+    frequency_spread = float(np.mean(spreads))
+    # Brightness: fraction of energy above 4kHz
+    # Use a single FFT on the whole signal for this (cheap)
+    full_mags = np.abs(np.fft.rfft(data * np.hanning(len(data))))
+    full_freqs = np.linspace(0, samplerate / 2, len(full_mags))
+    total_energy = full_mags.sum() or 1.0
+    high_energy = full_mags[full_freqs >= 4000].sum()
+    brightness = float(high_energy / total_energy)
+
+    # Transient density: peak count in rectified-RMS gradient
+    # Coarse envelope over ~20ms windows
+    env_win = max(256, int(samplerate * 0.02))
+    envelope = np.array([
+        float(np.sqrt(np.mean(data[i:i + env_win] ** 2)))
+        for i in range(0, len(data), env_win)
+    ])
+    if envelope.size > 1:
+        diffs = np.diff(envelope)
+        # Count upward transitions above a dynamic threshold
+        thresh = max(envelope.std() * 1.5, 1e-4)
+        peaks = int(np.sum(diffs > thresh))
+        transient_density = float(peaks / max(duration, 0.001))
+    else:
+        transient_density = 0.0
+
+    # Clear downbeat: peaks evenly spaced
+    has_clear_downbeat = False
+    if envelope.size > 4:
+        # Find top-N peaks and check interval stddev
+        peak_positions = np.argsort(envelope)[-8:]
+        peak_positions.sort()
+        if len(peak_positions) >= 3:
+            intervals = np.diff(peak_positions)
+            if intervals.size > 0 and float(np.mean(intervals)) > 0:
+                cv = float(np.std(intervals)) / float(np.mean(intervals))
+                has_clear_downbeat = cv < 0.5  # low variation → steady
+
+    return {
+        "duration_seconds": duration,
+        "frequency_center": frequency_center,
+        "frequency_spread": frequency_spread,
+        "brightness": brightness,
+        "transient_density": transient_density,
+        "has_clear_downbeat": has_clear_downbeat,
+    }

package/mcp_server/sample_engine/critics.py

@@ -164,21 +164,36 @@ def run_frequency_fit_critic(
 ) -> CriticResult:
     """Score frequency fit against existing mix.
 
-    Without mix_snapshot (no M4L bridge), returns neutral 0.5.
+    BUG-B38 fix: the old stub branch returned a neutral 0.5 "fair"
+    score even when the analyzer had no spectral data at all —
+    misleading the user into thinking the sample was a middling fit
+    when in reality the critic couldn't evaluate anything. We now
+    mark the result as explicitly unavailable (score=-1 sentinel +
+    available=False + rating="unavailable") so downstream aggregators
+    can skip this critic rather than fold a fake 0.5 into the overall
+    score.
     """
     if mix_snapshot is None or not mix_snapshot:
         return CriticResult(
-            critic_name="frequency_fit", score=0.5,
-            recommendation="No spectral data — verify frequency fit by ear",
-            adjustments=[{"note": "stub — spectral overlap analysis not yet implemented"}],
+            critic_name="frequency_fit",
+            score=-1.0,
+            available=False,
+            rating_override="unavailable",
+            recommendation=(
+                "No mix snapshot available — load LivePilot_Analyzer on "
+                "master and call get_mix_snapshot first. Falling back to "
+                "by-ear verification."
+            ),
         )
 
     # Basic frequency overlap check using mix_snapshot track data
-    # mix_snapshot expected shape: {"tracks": [{"name": ..., "peak_frequency": ...}]}
     tracks = mix_snapshot.get("tracks", [])
     if not tracks:
         return CriticResult(
-            critic_name="frequency_fit", score=0.5,
+            critic_name="frequency_fit",
+            score=-1.0,
+            available=False,
+            rating_override="unavailable",
             recommendation="Mix snapshot has no track data",
         )
 
@@ -186,8 +201,14 @@ def run_frequency_fit_critic(
     sample_center = profile.frequency_center
     if sample_center <= 0:
         return CriticResult(
-            critic_name="frequency_fit", score=0.5,
-            recommendation="Sample has no spectral data — verify by ear",
+            critic_name="frequency_fit",
+            score=-1.0,
+            available=False,
+            rating_override="unavailable",
+            recommendation=(
+                "Sample has no spectral data — analyze_sample couldn't "
+                "decode the file, or it's a clip-only reference."
+            ),
         )
 
     # Count tracks with energy near the sample's center frequency

package/mcp_server/sample_engine/models.py

@@ -82,15 +82,32 @@ class SampleIntent:
 
 @dataclass
 class CriticResult:
-    """Result from a single sample critic."""
+    """Result from a single sample critic.
+
+    BUG-B38: added `available` + rating override so critics can
+    explicitly mark themselves as unevaluated (e.g. no mix snapshot
+    for frequency_fit) rather than returning a misleading 0.5 score.
+    Downstream aggregators check `available` before folding a critic's
+    score into the composite.
+    """
 
     critic_name: str
     score: float
     recommendation: str
     adjustments: list = field(default_factory=list)
+    # Explicit availability flag — False when critic couldn't evaluate
+    # (score will be -1.0 sentinel; aggregators should skip)
+    available: bool = True
+    # Optional hand-set rating label — overrides the score-based
+    # default when provided (used for "unavailable" status)
+    rating_override: str = ""
 
     @property
     def rating(self) -> str:
+        if self.rating_override:
+            return self.rating_override
+        if not self.available:
+            return "unavailable"
         if self.score >= 0.8:
             return "excellent"
         if self.score >= 0.6:
@@ -102,6 +119,8 @@ class CriticResult:
     def to_dict(self) -> dict:
         d = asdict(self)
         d["rating"] = self.rating
+        # Strip internal override from payload (not for consumers)
+        d.pop("rating_override", None)
         return d
 
 
@@ -120,11 +139,30 @@ class SampleFitReport:
 
     @property
     def overall_score(self) -> float:
+        """Average over AVAILABLE critics only.
+
+        BUG-B38 reshaped frequency_fit to report ``-1.0`` with
+        ``available=False`` when no mix snapshot is present. The previous
+        aggregator mean-folded that sentinel into the overall score,
+        dropping it by ~17 points (one critic out of six). The fix is to
+        respect the ``available`` flag — same contract every other caller
+        uses.
+        """
         if not self.critics:
             return 0.0
-        scores = [c.score if isinstance(c, CriticResult) else c.get("score", 0)
-                  for c in self.critics.values()]
-        return sum(scores) / len(scores) if scores else 0.0
+        available_scores = []
+        for c in self.critics.values():
+            if isinstance(c, CriticResult):
+                if c.available is False:
+                    continue
+                available_scores.append(c.score)
+            else:  # legacy dict shape
+                if c.get("available") is False:
+                    continue
+                available_scores.append(c.get("score", 0))
+        if not available_scores:
+            return 0.0
+        return sum(available_scores) / len(available_scores)
 
     def to_dict(self) -> dict:
         return {

package/mcp_server/sample_engine/tools.py

@@ -104,30 +104,64 @@ def evaluate_sample_fit(
                 logger.debug("get_track_info(%d) skipped: %s", i, exc)
                 continue
 
-        # Detect key from MIDI tracks
+        # Detect key from MIDI tracks.
+        # BUG-B37 fix: the old code checked clip_info.get("is_midi") but
+        # the Remote Script returns is_midi_clip (different field name),
+        # so the check always failed and song_key stayed None —
+        # key_fit then reported "Song key unknown" even on obvious
+        # Dm sessions. Now we check both field names for safety AND
+        # aggregate notes from all harmonic tracks via harmonic_score
+        # (Batch 5 helper), so key detection uses the richest signal.
         try:
             from ..tools._theory_engine import detect_key
-            for i in range(min(track_count, 8)):
+            from ..tools._composition_engine.harmony import harmonic_score
+
+            # Collect all tracks' notes, scored by harmonic-ness
+            harmonic_pool: list[dict] = []
+            for i in range(min(track_count, 16)):
                 try:
                     clip_info = ableton.send_command("get_clip_info", {
                         "track_index": i, "clip_index": 0,
                     })
-                    if clip_info.get("is_midi"):
-                        notes_result = ableton.send_command("get_notes", {
-                            "track_index": i, "clip_index": 0,
-                        })
-                        notes = notes_result.get("notes", [])
-                        if notes:
-                            key_result = detect_key(notes)
-                            mode = key_result.get("mode", "")
-                            mode_suffix = "m" if "minor" in mode else ""
-                            song_key = f"{key_result['tonic_name']}{mode_suffix}"
-                            break
                 except Exception as exc:
-                    logger.debug("key detection on track %d skipped: %s", i, exc)
+                    logger.debug("get_clip_info(%d) skipped: %s", i, exc)
+                    continue
+                # Accept either the new is_midi_clip field or the legacy
+                # is_midi (in case some install combines versions)
+                is_midi = (
+                    clip_info.get("is_midi_clip")
+                    or clip_info.get("is_midi")
+                    or False
+                )
+                if not is_midi:
                     continue
+                try:
+                    notes_result = ableton.send_command("get_notes", {
+                        "track_index": i, "clip_index": 0,
+                    })
+                except Exception as exc:
+                    logger.debug("get_notes(%d) skipped: %s", i, exc)
+                    continue
+                notes = notes_result.get("notes", []) if isinstance(
+                    notes_result, dict
+                ) else []
+                if not notes:
+                    continue
+                track_name = (
+                    existing_roles[i] if i < len(existing_roles) else ""
+                )
+                if harmonic_score(notes, track_name) >= 0.3:
+                    harmonic_pool.extend(notes)
+
+            if harmonic_pool:
+                key_result = detect_key(harmonic_pool)
+                mode = key_result.get("mode", "")
+                mode_suffix = "m" if "minor" in mode else ""
+                song_key = f"{key_result['tonic_name']}{mode_suffix}"
         except ImportError:
             pass
+        except Exception as exc:
+            logger.debug("key aggregation failed: %s", exc)
     except Exception as exc:
         logger.warning("session context for evaluate_sample_fit failed: %s", exc)
 

package/mcp_server/semantic_moves/__init__.py

@@ -14,3 +14,4 @@ from . import transition_compilers  # noqa: F401
 from . import sound_design_compilers  # noqa: F401
 from . import performance_compilers  # noqa: F401
 from . import sample_compilers  # noqa: F401
+from . import device_creation_compilers  # noqa: F401

package/mcp_server/semantic_moves/compiler.py

@@ -24,14 +24,22 @@ class CompiledStep:
     params: dict                 # Concrete params, e.g. {"track_index": 0, "volume": 0.72}
     description: str             # Human-readable, e.g. "Push Drums from 0.65 → 0.72"
     verify_after: bool = True    # Whether to check meters after this step
+    # Optional explicit backend. If set, the execution router uses it verbatim
+    # and skips classify_step(). Leave None to let the router auto-classify at
+    # dispatch time — safe because test_move_annotations enforces every
+    # registered move's steps map to a known backend.
+    backend: Optional[str] = None
 
     def to_dict(self) -> dict:
-        return {
+        d = {
             "tool": self.tool,
             "params": self.params,
             "description": self.description,
             "verify_after": self.verify_after,
         }
+        if self.backend:
+            d["backend"] = self.backend
+        return d
 
 
 @dataclass

package/mcp_server/semantic_moves/device_creation_compilers.py

@@ -0,0 +1,47 @@
+"""Family compiler for device-creation semantic moves.
+
+Device-creation moves generate custom M4L devices via the Device Forge
+(``generate_m4l_effect``). Unlike mix/sound-design moves — where the
+compiler inspects the kernel's track topology — device-creation moves
+are parametric: the plan_template already contains the tool call and
+concrete arguments.
+
+We therefore use a single family-level compiler that just maps
+``plan_template`` → ``CompiledStep`` objects. This keeps the registry
+honest (every move is either compilable or analytical_only) without
+duplicating templates into per-move compilers.
+"""
+from __future__ import annotations
+
+from .compiler import CompiledPlan, CompiledStep, register_family_compiler
+from .models import SemanticMove
+
+
+def _compile_device_creation(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Map plan_template steps straight to CompiledStep.
+
+    plan_template is trusted for this family: each step already has
+    ``tool``, ``params``, ``description``, and ``backend`` annotated.
+    """
+    steps: list[CompiledStep] = []
+    for step in move.plan_template:
+        steps.append(CompiledStep(
+            tool=step.get("tool", ""),
+            params=step.get("params", {}),
+            description=step.get("description", ""),
+            verify_after=bool(step.get("verify_after", True)),
+            backend=step.get("backend"),
+        ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level=move.risk_level,
+        summary=move.intent,
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=[],
+    )
+
+
+register_family_compiler("device_creation", _compile_device_creation)

package/mcp_server/semantic_moves/mix_compilers.py

@@ -282,6 +282,173 @@ def _compile_reduce_repetition(move: SemanticMove, kernel: dict) -> CompiledPlan
     )
 
 
+def _compile_make_kick_bass_lock(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'make_kick_bass_lock': carve space between kick and bass.
+
+    Strategy: reduce bass level slightly (clears sub for kick), verify both
+    tracks remain active. Sidechain compressor insertion is left as a future
+    step — it requires device selection + parameter mapping that varies too
+    much across projects to hardcode safely.
+    """
+    steps: list[CompiledStep] = []
+    warnings: list[str] = []
+    descriptions: list[str] = []
+
+    bass_tracks = resolvers.find_tracks_by_role(kernel, ["bass"])
+    kick_tracks = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
+
+    if not bass_tracks:
+        warnings.append("No bass track found — cannot lock kick and bass")
+    if not kick_tracks:
+        warnings.append("No kick/drum track found — reference track missing")
+
+    steps.append(CompiledStep(
+        tool="get_master_spectrum",
+        params={},
+        description="Read current sub/low balance before carving",
+        verify_after=False,
+    ))
+
+    if bass_tracks:
+        bass = bass_tracks[0]
+        idx = bass["index"]
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": idx, "volume": 0.60},
+            description=f"Pull {bass['name']} to 0.60 to clear sub for kick",
+        ))
+        descriptions.append(f"Pull {bass['name']} to 0.60")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify kick and bass both still producing audio",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        before_reads=[{"tool": "get_master_spectrum", "params": {}}],
+        after_reads=[
+            {"tool": "get_master_spectrum", "params": {}},
+            {"tool": "get_track_meters", "params": {"include_stereo": True}},
+        ],
+        risk_level="low",
+        summary="; ".join(descriptions) if descriptions else "No kick/bass changes compiled",
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
+    )
+
+
+def _compile_create_buildup_tension(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'create_buildup_tension': pull harmony back, raise perc energy.
+
+    We apply volume moves as the minimal, reversible tension-builder. Filter
+    rises and send ramps belong in an automation recipe — we issue a tension
+    gesture template step if the gesture engine is available, otherwise fall
+    back to direct volume changes only.
+    """
+    steps: list[CompiledStep] = []
+    warnings: list[str] = []
+    descriptions: list[str] = []
+
+    perc_tracks = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
+    harmony_tracks = resolvers.find_tracks_by_role(kernel, ["chords", "pad"])
+
+    if not perc_tracks and not harmony_tracks:
+        warnings.append("No percussion or harmony tracks found — cannot build tension")
+
+    # Raise perc for energy
+    for pt in perc_tracks[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": pt["index"], "volume": 0.78},
+            description=f"Push {pt['name']} to 0.78 for rising energy",
+        ))
+        descriptions.append(f"Push {pt['name']} to 0.78")
+
+    # Pull harmony slightly to amplify perc contrast
+    for ht in harmony_tracks[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": ht["index"], "volume": 0.35},
+            description=f"Pull {ht['name']} to 0.35 to create harmonic vacuum before drop",
+        ))
+        descriptions.append(f"Pull {ht['name']} to 0.35")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify tension steps did not silence any track",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        before_reads=[{"tool": "get_emotional_arc", "params": {}}],
+        after_reads=[
+            {"tool": "get_emotional_arc", "params": {}},
+            {"tool": "get_track_meters", "params": {"include_stereo": True}},
+        ],
+        risk_level="medium",
+        summary="; ".join(descriptions) if descriptions else "No tracks to ratchet",
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
+    )
+
+
+def _compile_smooth_scene_handoff(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'smooth_scene_handoff': reduce master volume briefly around the handoff.
+
+    Without knowing which two scenes are involved, the compiler can only do a
+    conservative energy dip using master volume. A future version should take
+    scene indices via kernel.intent_context and apply targeted crossfades.
+    """
+    steps: list[CompiledStep] = []
+    warnings: list[str] = []
+    descriptions: list[str] = []
+
+    # Minimal approach — gentle master dip the agent can reverse easily.
+    steps.append(CompiledStep(
+        tool="get_master_meters",
+        params={},
+        description="Record current master level for handoff reference",
+        verify_after=False,
+    ))
+
+    steps.append(CompiledStep(
+        tool="set_master_volume",
+        params={"volume": 0.78},
+        description="Gentle master dip for transition",
+    ))
+    descriptions.append("Master dip to 0.78")
+
+    steps.append(CompiledStep(
+        tool="get_master_meters",
+        params={},
+        description="Verify master dip applied without clipping",
+    ))
+
+    warnings.append(
+        "Scene-aware handoff (from_scene/to_scene) not yet compiled — "
+        "this is a conservative energy-dip fallback"
+    )
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        before_reads=[{"tool": "get_emotional_arc", "params": {}}],
+        after_reads=[{"tool": "get_emotional_arc", "params": {}}],
+        risk_level="low",
+        summary="; ".join(descriptions),
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
+    )
+
+
 # ── Register all compilers ──────────────────────────────────────────────────
 
 register_compiler("make_punchier", _compile_make_punchier)
@@ -289,3 +456,6 @@ register_compiler("tighten_low_end", _compile_tighten_low_end)
 register_compiler("widen_stereo", _compile_widen_stereo)
 register_compiler("darken_without_losing_width", _compile_darken_mix)
 register_compiler("reduce_repetition_fatigue", _compile_reduce_repetition)
+register_compiler("make_kick_bass_lock", _compile_make_kick_bass_lock)
+register_compiler("create_buildup_tension", _compile_create_buildup_tension)
+register_compiler("smooth_scene_handoff", _compile_smooth_scene_handoff)