livepilot 1.27.1 → 1.27.3

package/mcp_server/preview_studio/models.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import hashlib
+import json
 import time
 from dataclasses import asdict, dataclass, field
 from typing import Optional
@@ -9,6 +11,38 @@ from typing import Optional
 from ..runtime.degradation import DegradationInfo
 
 
+def compute_session_fingerprint(session_info: Optional[dict]) -> str:
+    """Lightweight fingerprint of session topology (track_count + ordered
+    track names).
+
+    PreviewSet and WonderSession cache compiled plans that reference
+    positional track/device indices. Those indices are only valid against
+    the session topology that existed when the plan was compiled — if the
+    user adds/removes/reorders tracks before the plan is committed, replaying
+    those indices can silently hit the wrong track.
+
+    This helper is the single source of truth for that fingerprint, shared
+    by preview_studio and wonder_mode so both stamp/verify it the same way.
+    Callers stamp it at creation time from session_info they already fetched
+    (never triggers its own Ableton round-trip). At commit/replay time they
+    fetch a fresh session_info and compare fingerprints.
+
+    Returns "" when session_info is missing/malformed — an empty fingerprint
+    means "no signal available" and callers must skip the staleness check
+    (this keeps older cached/persisted objects, built before this field
+    existed, committable).
+    """
+    if not isinstance(session_info, dict) or not session_info:
+        return ""
+    tracks = session_info.get("tracks")
+    if not isinstance(tracks, list):
+        tracks = []
+    names = [str(t.get("name", "")) for t in tracks if isinstance(t, dict)]
+    track_count = session_info.get("track_count", len(names))
+    seed = json.dumps({"track_count": track_count, "track_names": names}, sort_keys=True)
+    return hashlib.sha256(seed.encode()).hexdigest()[:16]
+
+
 @dataclass
 class PreviewVariant:
     """One creative option in a preview set."""
@@ -66,6 +100,11 @@ class PreviewSet:
     # can inspect .degradation.is_degraded to tell synthesized preview
     # topology apart from a real kernel-backed compile.
     degradation: DegradationInfo = field(default_factory=DegradationInfo)
+    # Session-identity guard — see compute_session_fingerprint(). Stamped at
+    # creation time from the session_info the creator already fetched. Empty
+    # string means "no signal" (older objects, or created without a live
+    # session) and callers must skip the staleness check.
+    session_fingerprint: str = ""
 
     def to_dict(self) -> dict:
         return {
@@ -79,4 +118,5 @@ class PreviewSet:
             "status": self.status,
             "variant_count": len(self.variants),
             "degradation": self.degradation.to_dict(),
+            "session_fingerprint": self.session_fingerprint,
         }

package/mcp_server/preview_studio/tools.py

@@ -15,6 +15,7 @@ from fastmcp import Context
 
 from ..server import mcp
 from . import engine
+from .models import compute_session_fingerprint
 import logging
 
 logger = logging.getLogger(__name__)
@@ -114,6 +115,11 @@ def create_preview_set(
             source_kernel_id=kernel_id,
             variants=preview_variants,
             created_at_ms=now,
+            # Carry forward the fingerprint the WonderSession stamped at
+            # enter_wonder_mode time so commit_preview_variant can still
+            # detect a topology change even though this PreviewSet was
+            # built from ws.variants rather than a fresh kernel fetch.
+            session_fingerprint=getattr(ws, "session_fingerprint", ""),
         )
         engine.store_preview_set(ps)
 
@@ -286,6 +292,40 @@ async def commit_preview_variant(
             "available_variants": available,
         }
 
+    # ── Session-identity guard (state-layer hardening) ──
+    # PreviewSet.session_fingerprint is stamped at creation time from the
+    # session_info the creator already had in hand (see engine.py /
+    # create_preview_set). The compiled_plan cached on each variant carries
+    # positional track/device indices that are only valid against that same
+    # topology. If the fingerprint is set, re-check it against a fresh
+    # get_session_info before replaying those indices — a track added/
+    # removed/reordered since the preview was built means "commit" would
+    # silently apply to the wrong track. Absent fingerprint (older/degraded
+    # objects predating this field) skips the check entirely — no new
+    # round-trip, no behavior change for them.
+    if ps.session_fingerprint:
+        ableton = _get_ableton(ctx)
+        fresh_session_info: dict = {}
+        try:
+            fresh_session_info = await ableton.send_command_async("get_session_info", {}) or {}
+        except Exception as exc:
+            logger.debug("commit_preview_variant: session refresh failed: %s", exc)
+            fresh_session_info = {}
+        if isinstance(fresh_session_info, dict) and "error" not in fresh_session_info:
+            current_fingerprint = compute_session_fingerprint(fresh_session_info)
+            if current_fingerprint and current_fingerprint != ps.session_fingerprint:
+                return {
+                    "error": (
+                        "session changed since preview was created — "
+                        "rebuild the preview set"
+                    ),
+                    "code": "STATE_ERROR",
+                    "set_id": set_id,
+                    "variant_id": variant_id,
+                }
+        # else: couldn't refresh (Ableton unreachable) — fail open rather
+        # than blocking a legitimate commit on a transient fetch error.
+
     # ── Truth-gap guard: refuse to "commit" a variant that can't execute ──
     # If the variant was flagged blocked/failed upstream or lacks a
     # compiled plan, the old code still marked preview_set.status='committed'
@@ -503,7 +543,11 @@ async def render_preview_variant(
         plan = variant.compiled_plan
         steps = plan if isinstance(plan, list) else plan.get("steps", [])
 
-        from ..runtime.execution_router import execute_plan_steps_async, filter_apply_steps
+        from ..runtime.execution_router import (
+            execute_plan_steps_async,
+            filter_apply_steps,
+            undo_remote_steps,
+        )
 
         # Read-only verification steps (meters/spectrum/info) don't create undo
         # points in Ableton — counting them and then undoing walks back earlier
@@ -511,6 +555,7 @@ async def render_preview_variant(
         apply_steps = filter_apply_steps(steps)
 
         applied_count = 0
+        exec_results: list = []
         playback_started = False
         preview_mode = "metadata_only_preview"
         spectral_before: Optional[dict] = None
@@ -523,7 +568,7 @@ async def render_preview_variant(
 
         try:
             # ── 1. Capture BEFORE metadata ──
-            before_info = ableton.send_command("get_session_info", {}) or {}
+            before_info = await ableton.send_command_async("get_session_info", {}) or {}
 
             # ── 2. Apply the variant (write steps only) ──
             exec_results = await execute_plan_steps_async(
@@ -542,7 +587,7 @@ async def render_preview_variant(
                 }
 
             # ── 3. Capture AFTER metadata (variant is live) ──
-            after_info = ableton.send_command("get_session_info", {}) or {}
+            after_info = await ableton.send_command_async("get_session_info", {}) or {}
 
             # ── 4. Audible capture WHILE variant is still applied ──
             # This is the critical ordering fix: previously this block ran AFTER
@@ -558,7 +603,7 @@ async def render_preview_variant(
                     tempo = before_info.get("tempo", 120) or 120
                     play_seconds = min(bars * (60.0 / tempo) * 4, 8.0)
 
-                    ableton.send_command("start_playback", {})
+                    await ableton.send_command_async("start_playback", {})
                     playback_started = True
 
                     import asyncio as _asyncio
@@ -567,7 +612,7 @@ async def render_preview_variant(
 
                     spectral_after = cache.get_all()
 
-                    ableton.send_command("stop_playback", {})
+                    await ableton.send_command_async("stop_playback", {})
                     playback_started = False
 
                     preview_mode = "audible_preview"
@@ -582,16 +627,15 @@ async def render_preview_variant(
             # ── 5. Cleanup: stop playback if still running, then undo everything ──
             if playback_started:
                 try:
-                    ableton.send_command("stop_playback", {})
+                    await ableton.send_command_async("stop_playback", {})
                 except Exception as exc:
                     logger.debug("render_preview_variant failed: %s", exc)
 
-            for _ in range(applied_count):
-                try:
-                    ableton.send_command("undo")
-                except Exception as exc:
-                    logger.debug("render_preview_variant failed: %s", exc)
-                    break
+            # Only remote_command steps land on Ableton's linear undo stack.
+            # Bridge (M4L/OSC) and mcp_tool steps do NOT, so counting them and
+            # then issuing that many `undo`s walks back unrelated prior user
+            # edits — undo_remote_steps filters to remote_command successes.
+            await undo_remote_steps(ableton, exec_results)
 
         variant.status = "rendered"
         variant.preview_mode = preview_mode

package/mcp_server/project_brain/arrangement_graph.py

@@ -48,6 +48,10 @@ def build_arrangement_graph(
             section_type=ce_sec.section_type.value,
             energy=ce_sec.energy,
             density=ce_sec.density,
+            # Clip-presence active tracks — includes audio tracks that carry
+            # no MIDI notes. Without this, role inference would only see
+            # tracks that appear in notes_map and drop every audio track.
+            tracks_active=list(getattr(ce_sec, "tracks_active", []) or []),
         ))
 
     # Build boundary list (transitions between adjacent sections)

package/mcp_server/project_brain/models.py

@@ -128,6 +128,7 @@ class SectionNode:
     section_type: str = "unknown"
     energy: float = 0.0
     density: float = 0.0
+    tracks_active: list[int] = field(default_factory=list)
 
     def to_dict(self) -> dict:
         return {
@@ -137,6 +138,7 @@ class SectionNode:
             "section_type": self.section_type,
             "energy": self.energy,
             "density": self.density,
+            "tracks_active": list(self.tracks_active),
         }
 
 

package/mcp_server/project_brain/role_graph.py

@@ -41,18 +41,24 @@ def build_role_graph(
     # Convert brain section dicts to composition-engine SectionNodes
     ce_sections = []
     for sec in sections:
-        # Determine which tracks are active in this section
-        # If notes_map has data for this section, those tracks are active
+        # Determine which tracks are active in this section.
+        # Primary source is the clip-presence matrix (`tracks_active`),
+        # which includes AUDIO tracks that carry no MIDI notes. Union in
+        # any note-bearing tracks as a fallback so MIDI-only data (legacy
+        # callers that pass no tracks_active) still produces roles.
         section_id = sec.get("section_id", sec.get("id", ""))
-        active_tracks = []
+        active_set = {int(t) for t in (sec.get("tracks_active") or [])}
         section_notes = notes_map.get(section_id, {})
         for t_idx, notes in section_notes.items():
             if notes:
-                active_tracks.append(t_idx)
+                active_set.add(int(t_idx))
 
-        # Also include all tracks if no notes data (assume all active)
-        if not active_tracks and not notes_map:
-            active_tracks = [t.get("index", 0) for t in track_data]
+        # Also include all tracks if no clip-presence and no notes data
+        # (assume all active — e.g. a bare section with no matrix info).
+        if not active_set and not notes_map:
+            active_set = {int(t.get("index", 0)) for t in track_data}
+
+        active_tracks = sorted(active_set)
 
         try:
             stype = CESectionType(sec.get("section_type", "unknown"))

package/mcp_server/reference_engine/gap_analyzer.py

@@ -22,10 +22,49 @@ _RELEVANCE_THRESHOLDS: dict[str, float] = {
     "harmonic": 0.0,     # always relevant if different
 }
 
+# Per-domain normalization scales for _compute_overall_distance. Raw deltas
+# live in incompatible units (loudness in LU, width/spectral/density in 0-1
+# fractions, pacing in section COUNT), so summing their squares directly lets
+# the large-magnitude domains (loudness, pacing) dominate while sub-unity
+# spectral/width deltas contribute nothing (P2-37). Dividing each delta by a
+# characteristic "one notable step" for its domain converts every term into a
+# comparable, dimensionless number before the Euclidean sum.
+_NORMALIZATION_SCALES: dict[str, float] = {
+    "loudness": 6.0,     # ~6 LU is a clearly audible loudness gap
+    "spectral": 0.1,     # a 0.1 shift in a band's energy fraction is large
+    "width": 0.2,        # 0.2 of the 0-1 stereo-width range is substantial
+    "density": 0.3,      # 0.3 of the 0-1 density range is a big arrangement move
+    "pacing": 2.0,       # a 2-section structural difference is significant
+    "harmonic": 1.0,     # harmonic delta is already a 0/1 indicator
+}
+_DEFAULT_NORMALIZATION_SCALE = 1.0
+
 # When a gap exceeds this fraction of the project value, closing it
 # risks flattening identity.
 _IDENTITY_WARNING_THRESHOLD = 0.6
 
+# ReferenceProfile.loudness_posture is always integrated LUFS (see models.py).
+# The project snapshot may report loudness in a different scale, so we tag it
+# with "loudness_unit" and convert to LUFS here before differencing. The ITU
+# BS.1770 K-weighting has near-unity broadband gain plus a fixed -0.691 dB
+# absolute-calibration offset, so a full-program RMS dBFS ≈ LUFS - 0.691. This
+# is an approximation (it ignores K-weighting's frequency tilt and gating), but
+# it keeps both sides of the loudness delta on the SAME axis — far better than
+# subtracting a plain dBFS RMS from an integrated LUFS (P2-36).
+_RMS_DBFS_TO_LUFS_OFFSET = -0.691
+
+
+def _project_loudness_in_lufs(loudness: float, unit: str) -> float:
+    """Convert a project-snapshot loudness reading to the integrated-LUFS
+    scale used by ReferenceProfile.loudness_posture."""
+    if unit in ("lufs", "integrated_lufs"):
+        return loudness
+    if unit in ("rms_dbfs", "dbfs"):
+        return loudness + _RMS_DBFS_TO_LUFS_OFFSET
+    # Unknown unit: assume it is already on the LUFS axis rather than
+    # corrupting it with an offset we can't justify.
+    return loudness
+
 
 # ── Main analysis ──────────────────────────────────────────────────
 
@@ -50,7 +89,12 @@ def analyze_gaps(
     ref_id = f"{reference.source_type}"
 
     # 1. Loudness gap
-    proj_loudness = project_snapshot.get("loudness", 0.0)
+    # Both sides must be on the integrated-LUFS axis. The reference always is;
+    # the project snapshot declares its unit so we can convert (P2-36).
+    raw_loudness = project_snapshot.get("loudness", 0.0)
+    proj_loudness = _project_loudness_in_lufs(
+        raw_loudness, project_snapshot.get("loudness_unit", "lufs")
+    )
     if reference.loudness_posture != 0.0 or proj_loudness != 0.0:
         delta = proj_loudness - reference.loudness_posture
         gaps.append(GapEntry(
@@ -200,11 +244,22 @@ def _is_identity_risk(project_value: float, delta: float) -> bool:
 
 
 def _compute_overall_distance(gaps: list[GapEntry]) -> float:
-    """Euclidean-like distance across all relevant gap deltas."""
+    """Euclidean distance across relevant gap deltas, normalized per-domain.
+
+    Each delta is divided by a characteristic scale for its domain so that
+    deltas measured in incompatible units (LU, 0-1 fractions, section counts)
+    become dimensionless and comparable before the Euclidean sum (P2-37).
+    """
     relevant = [g for g in gaps if g.relevant]
     if not relevant:
         return 0.0
-    sum_sq = sum(g.delta ** 2 for g in relevant)
+    sum_sq = 0.0
+    for g in relevant:
+        scale = _NORMALIZATION_SCALES.get(g.domain, _DEFAULT_NORMALIZATION_SCALE)
+        if scale <= 0:
+            scale = _DEFAULT_NORMALIZATION_SCALE
+        normalized = g.delta / scale
+        sum_sq += normalized ** 2
     return math.sqrt(sum_sq)
 
 

package/mcp_server/reference_engine/profile_builder.py

@@ -24,10 +24,30 @@ def build_audio_reference_profile(comparison_data: dict) -> ReferenceProfile:
     """
     band_deltas = comparison_data.get("band_deltas", {})
 
-    # Reconstruct approximate reference spectral contour from band deltas.
-    # The deltas are (mix - ref), so ref bands are conceptually the baseline.
+    # The reference profile's band_balance MUST be the reference's OWN
+    # absolute per-band energy — NOT band_deltas (mix - ref), which is a
+    # different quantity entirely (a signed difference, not a level). Using
+    # the deltas here made analyze_gaps compute (proj_band - delta), so an
+    # identical mix produced a spurious gap equal to the project's own band
+    # energy instead of ~0.
+    #
+    # Prefer the absolute reference_band_balance emitted by
+    # compare_to_reference. If only mix bands + deltas are present,
+    # reconstruct ref = mix - delta. Fall back to {} (no spectral contour)
+    # rather than silently treating deltas as levels.
+    ref_band_balance = comparison_data.get("reference_band_balance")
+    if not ref_band_balance:
+        mix_band_balance = comparison_data.get("mix_band_balance")
+        if mix_band_balance and band_deltas:
+            ref_band_balance = {
+                band: round(mix_band_balance.get(band, 0.0) - delta, 6)
+                for band, delta in band_deltas.items()
+            }
+        else:
+            ref_band_balance = {}
+
     spectral_contour: dict = {
-        "band_balance": band_deltas,
+        "band_balance": ref_band_balance,
         "centroid_delta_hz": comparison_data.get("centroid_delta_hz", 0.0),
     }
 
@@ -103,7 +123,9 @@ def build_style_reference_profile(style_tactics: list[dict]) -> ReferenceProfile
     # shape — e.g., Auto Filter at 800Hz low-pass = darker spectrum,
     # Utility Width > 0.6 = wider stereo). Rough but non-empty values
     # are better than zeros for downstream reference-gap analysis.
-    loudness_posture = _derive_loudness_posture(style_tactics)
+    # loudness_posture is contracted to be integrated LUFS, so the [-1,+1]
+    # device-chain posture is mapped onto the LUFS axis (_style_posture_to_lufs).
+    loudness_posture = _style_posture_to_lufs(_derive_loudness_posture(style_tactics))
     spectral_contour = _derive_spectral_contour(style_tactics)
     width_depth = _derive_width_depth(style_tactics)
 
@@ -163,6 +185,27 @@ def _estimate_density_from_patterns(style_tactics: list[dict]) -> list[float]:
 # ── BUG-B50 derivations — style → loudness/spectral/width heuristics ──────
 
 
+# Style profiles infer a dimensionless loudness POSTURE in [-1, +1] from the
+# device chain (limiters/glue → louder, reverb-heavy → quieter). But
+# ReferenceProfile.loudness_posture is contracted to be integrated LUFS — the
+# gap analyzer differences it directly against the project's LUFS (gap_analyzer
+# lines 92-99). So the posture is mapped onto the LUFS axis: -14 LUFS is the
+# streaming-normalization neutral; ±6 LU spans a hot/limited master
+# (+1 → -8 LUFS) to a dynamic/quiet mix (-1 → -20 LUFS). A no-signal posture of
+# 0 lands on the -14 neutral, yielding ~no spurious loudness gap against a
+# typical project — whereas a raw 0.0 would read as a bogus ~14 LU gap.
+_STYLE_LOUDNESS_NEUTRAL_LUFS = -14.0
+_STYLE_LOUDNESS_RANGE_LU = 6.0
+
+
+def _style_posture_to_lufs(posture: float) -> float:
+    """Map a [-1, +1] device-chain loudness posture onto the integrated-LUFS
+    axis that ReferenceProfile.loudness_posture is contracted to carry."""
+    return round(
+        _STYLE_LOUDNESS_NEUTRAL_LUFS + posture * _STYLE_LOUDNESS_RANGE_LU, 2
+    )
+
+
 def _derive_loudness_posture(style_tactics: list[dict]) -> float:
     """Heuristic: compression / saturation / limiter devices imply a
     specific loudness posture. Glue / Ratio>3 → loud, saturator drive

package/mcp_server/reference_engine/tools.py

@@ -50,6 +50,12 @@ def _fetch_project_snapshot(ctx: Context) -> dict:
 
     snapshot: dict = {
         "loudness": 0.0,
+        # Unit of snapshot["loudness"]. The live SpectralCache only exposes a
+        # plain-RMS value, so the best we can derive here is RMS dBFS — NOT
+        # the K-weighted integrated LUFS that ReferenceProfile.loudness_posture
+        # carries. analyze_gaps reads this tag to convert to a common scale
+        # instead of blindly subtracting dBFS from LUFS (P2-36).
+        "loudness_unit": "rms_dbfs",
         "spectral": {},
         "width": 0.0,
         "density": 0.0,

package/mcp_server/runtime/execution_router.py

@@ -22,12 +22,16 @@ Step-result binding:
 
 from __future__ import annotations
 
+import asyncio
 import inspect
+import logging
 from dataclasses import dataclass
 from typing import Any, Awaitable, Callable, Optional
 
 from .remote_commands import BRIDGE_COMMANDS, REMOTE_COMMANDS
 
+logger = logging.getLogger(__name__)
+
 
 # MCP-only tools that exist as Python functions but NOT as TCP handlers.
 # These must be called through direct import, not ableton.send_command().
@@ -66,6 +70,12 @@ MCP_TOOLS: frozenset[str] = frozenset({
     # set_drum_chain_note + insert_device + replace_sample_native. Used by
     # the create_drum_rack_pad semantic move.
     "add_drum_rack_pad",
+    # Routing-correctness (v1.27.2): these have @mcp.tool wrappers that call
+    # the TCP Remote Script / read the SpectralCache in-process. They must
+    # classify as mcp_tool so plan steps take the SAME path as direct callers
+    # — not the M4L JS bridge, and not the "unknown" dead-end.
+    "compressor_set_sidechain",  # was mis-listed in BRIDGE_COMMANDS → JS bridge
+    "get_master_rms",            # was READ_ONLY but unclassified → plan failure
 })
 
 
@@ -227,7 +237,17 @@ async def _execute_step_async(
                 error="Ableton connection unavailable",
             )
         try:
-            result = ableton.send_command(tool, params)
+            # Offload the blocking TCP round-trip to a worker thread so this
+            # shared executor never stalls the event loop (and therefore the
+            # concurrent UDP analyzer bridge) for the duration of the call.
+            # Prefer the real AbletonConnection's async wrapper when present;
+            # fall back to asyncio.to_thread directly for lightweight test
+            # doubles that only implement send_command.
+            send_command_async = getattr(ableton, "send_command_async", None)
+            if callable(send_command_async):
+                result = await send_command_async(tool, params)
+            else:
+                result = await asyncio.to_thread(ableton.send_command, tool, params)
             if isinstance(result, dict) and "error" in result:
                 return ExecutionResult(ok=False, backend=backend, tool=tool, error=result["error"])
             return ExecutionResult(ok=True, backend=backend, tool=tool, result=result)
@@ -385,3 +405,39 @@ async def execute_plan_steps_async(
             break
 
     return results
+
+
+# ── Undo helper ──────────────────────────────────────────────────────────
+
+async def undo_remote_steps(ableton: Any, exec_results: list[ExecutionResult]) -> int:
+    """Undo the remote_command steps from a list of ExecutionResults.
+
+    Only remote_command steps land on Ableton's linear undo stack — bridge
+    (M4L/OSC) and mcp_tool mutations do NOT, so issuing one `undo` per
+    successful step regardless of backend over-undoes and walks back
+    unrelated prior user edits. This counts successful remote_command
+    steps and issues exactly that many `undo` calls via
+    ``ableton.send_command_async``, stopping early if an undo call raises
+    (leaving the rest un-undone rather than risking a cascading error).
+
+    Extracted from the duplicated experiment/engine.py + preview_studio
+    /tools.py undo-count logic (both had drifted into copy-pasted
+    near-identical blocks) so the "count remote_command successes, then
+    undo that many times" rule lives in exactly one place.
+
+    Returns the number of undo calls actually issued (<= the number of
+    successful remote_command steps; less if an undo call raised partway
+    through).
+    """
+    undo_count = sum(
+        1 for r in exec_results if r.ok and r.backend == "remote_command"
+    )
+    issued = 0
+    for _ in range(undo_count):
+        try:
+            await ableton.send_command_async("undo", {})
+            issued += 1
+        except Exception as exc:
+            logger.debug("undo_remote_steps: undo call failed: %s", exc)
+            break
+    return issued

package/mcp_server/runtime/mcp_dispatch.py

@@ -153,6 +153,25 @@ async def _add_drum_rack_pad(params: dict, ctx: Any = None) -> dict:
     return await _call(add_drum_rack_pad, ctx, params)
 
 
+# ── Routing-correctness (v1.27.2) ─────────────────────────────────────────
+#
+# Both have @mcp.tool wrappers in tools/analyzer.py. compressor_set_sidechain
+# was mis-listed in BRIDGE_COMMANDS, so plan steps silently routed to the M4L
+# JS bridge while direct callers used the TCP Remote Script — divergent paths
+# with different error handling. get_master_rms was tagged READ_ONLY but never
+# classified (classify_step returned "unknown"), so plans could not use it at
+# all. Both now dispatch in-process here, matching their direct @mcp.tool path.
+
+async def _compressor_set_sidechain(params: dict, ctx: Any = None) -> dict:
+    from ..tools.analyzer import compressor_set_sidechain
+    return await _call(compressor_set_sidechain, ctx, params)
+
+
+async def _get_master_rms(params: dict, ctx: Any = None) -> dict:
+    from ..tools.analyzer import get_master_rms
+    return await _call(get_master_rms, ctx, params)
+
+
 def build_mcp_dispatch_registry() -> dict[str, Callable]:
     """Return the canonical registry of MCP-only tools for plan execution.
 
@@ -186,4 +205,7 @@ def build_mcp_dispatch_registry() -> dict[str, Callable]:
         "add_session_memory": _add_session_memory,
         # v1.20 — drum rack pad construction (async orchestrator).
         "add_drum_rack_pad": _add_drum_rack_pad,
+        # v1.27.2 — routing-correctness (see adapters above).
+        "compressor_set_sidechain": _compressor_set_sidechain,
+        "get_master_rms": _get_master_rms,
     }

package/mcp_server/runtime/remote_commands.py

@@ -139,9 +139,11 @@ BRIDGE_COMMANDS: frozenset[str] = frozenset({
     "get_params", "get_hidden_params", "get_auto_state", "walk_rack",
     "get_chains_deep", "get_track_cpu", "get_selected", "get_key",
     "get_clip_file_path", "replace_simpler_sample", "get_simpler_slices",
-    "get_simpler_file_path",  # v1.23.3 — closes the v1.12 follow-up that
-                              # left classify_simpler_slices unable to
-                              # auto-resolve the Simpler's sample path
+    # NOTE: get_simpler_file_path is NOT here — it lives in REMOTE_COMMANDS
+    # (the primary Python LOM path since v1.23.3). classify_step checks
+    # REMOTE first, so listing it here too was dead for dispatch. The
+    # backwards-compat bridge call still exists, but analyzer.py invokes it
+    # directly via bridge.send_command(), bypassing classify_step.
     "crop_simpler", "reverse_simpler", "warp_simpler",
     "get_warp_markers", "add_warp_marker", "move_warp_marker",
     "remove_warp_marker", "capture_audio", "capture_stop",
@@ -152,7 +154,10 @@ BRIDGE_COMMANDS: frozenset[str] = frozenset({
     # 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: compressor_set_sidechain is NOT here — its @mcp.tool wrapper calls
+    # the TCP Remote Script ("set_compressor_sidechain", the BUG-A3 Python
+    # path), so it belongs in MCP_TOOLS. Listing it here routed plan steps to
+    # the M4L JS bridge, a divergent path. Moved to execution_router.MCP_TOOLS.
     # 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/runtime/tools.py

@@ -89,7 +89,6 @@ def _probe_flucoma_package() -> bool:
             externals = package_dir / "externals"
             if externals.exists() and any(externals.glob("fluid.*")):
                 return True
-            return True
         return False
     except Exception as exc:  # noqa: BLE001
         logger.debug("_probe_flucoma_package failed: %s", exc)

package/mcp_server/sample_engine/sources.py

@@ -207,8 +207,6 @@ class SpliceSource:
             if key:
                 # Normalize: user might pass "Cm" or "C#", Splice stores "c" or "c#"
                 # Strip minor suffix for comparison — Splice uses chord_type column
-                key_normalized = key.lower().rstrip("m").rstrip("inor")
-                # But proper suffix removal:
                 k = key.lower()
                 for suffix in ("minor", "min"):
                     if k.endswith(suffix):