livepilot 1.27.0 → 1.27.2

package/mcp_server/project_brain/tools.py

@@ -84,17 +84,41 @@ def build_project_brain(ctx: Context) -> dict:
         except Exception as exc:
             logger.debug("build_project_brain failed: %s", exc)
 
-    # 5b. Build notes_map for role inference.
-    # Shape: {section_id: {track_index: [notes]}}. Without this, role_graph
-    # falls back to "assume all tracks active in every section" which destroys
-    # section-scoped role confidence.
+    # 5b/5c. Single combined grid sweep for notes (role inference) and clip
+    # automation envelopes. Previously these were two separate
+    # N_tracks x N_scenes loops, each issuing a remote round-trip per slot —
+    # including empty slots. We now consult the get_scene_matrix presence grid
+    # (already fetched at step 3 as clip_matrix) and skip slots that are
+    # positively empty, collapsing both sweeps into one pass over the grid.
     #
     # BUG-E1: section_id must match what build_section_graph_from_scenes emits.
     # The composition engine emits `sec_{i:02d}` using the RAW enumerate index
     # of the scene — it skips unnamed scenes (gap-preserving), so e.g. scenes
     # ["Intro", "", "Verse"] become sections sec_00 and sec_02, not sec_01.
-    # Our notes_map must mirror that or keys won't align.
+    # Both maps mirror that or keys won't align.
+    #
+    # clips_scanned is the denominator for coverage_pct (BUG-D2): it counts
+    # the slots we actually probed for envelopes. Slots skipped as empty are
+    # not counted, so coverage_pct stays "fraction of present clips automated".
+    def _slot_is_empty(s_idx: int, t_idx: int) -> bool:
+        """True only when the presence grid positively reports no clip.
+
+        Unknown / out-of-range / malformed cells return False so we still
+        issue the round-trip (safe fallback — never skip on ambiguity).
+        """
+        try:
+            cell = clip_matrix[s_idx][t_idx]
+        except (IndexError, TypeError, KeyError):
+            return False
+        if not isinstance(cell, dict):
+            return False
+        if cell.get("has_clip"):
+            return False
+        return cell.get("state") in ("empty", "missing")
+
     notes_map: dict[str, dict[int, list[dict]]] = {}
+    clip_automation: list[dict] = []
+    clips_scanned = 0
     try:
         for scene_idx, scene in enumerate(scenes or []):
             scene_name = str(scene.get("name", "")).strip()
@@ -105,6 +129,11 @@ def build_project_brain(ctx: Context) -> dict:
             per_track: dict[int, list[dict]] = {}
             for track in tracks:
                 t_idx = track.get("index", 0)
+                if _slot_is_empty(scene_idx, t_idx):
+                    continue  # no clip in this slot — skip both round-trips
+                clips_scanned += 1
+
+                # Notes for role inference.
                 try:
                     notes_resp = ableton.send_command("get_notes", {
                         "track_index": t_idx,
@@ -115,39 +144,9 @@ def build_project_brain(ctx: Context) -> dict:
                         if notes:
                             per_track[t_idx] = notes
                 except Exception as exc:
-                    logger.debug("build_project_brain failed: %s", exc)
-                    # Individual note fetch failing is fine — continue with others
-                    continue
-            if per_track:
-                notes_map[section_id] = per_track
-    except Exception as exc:
-        logger.debug("build_project_brain failed: %s", exc)
-        # Overall failure: empty map, degrade to "all tracks active" fallback
-        notes_map = {}
+                    logger.debug("build_project_brain notes fetch failed: %s", exc)
 
-    # 5c. Scan clip automation across the session (BUG-E2).
-    # Device-parameter is_automated flags only reflect whether a parameter
-    # is mapped somewhere — they don't reveal clip envelopes. Ableton's
-    # automation actually lives on each clip (session + arrangement). We
-    # walk every clip slot that has a clip and ask get_clip_automation, then
-    # aggregate into a flat list keyed by section.
-    #
-    # clips_scanned is the denominator for coverage_pct (BUG-D2) — it
-    # counts how many (track, scene) slots we probed, regardless of
-    # whether an envelope came back. Without this, a session with zero
-    # automation would be indistinguishable from a session where we
-    # failed to probe, which is exactly the ambiguity BUG-D2 flagged.
-    clip_automation: list[dict] = []
-    clips_scanned = 0
-    try:
-        for scene_idx, scene in enumerate(scenes or []):
-            scene_name = str(scene.get("name", "")).strip()
-            if not scene_name:
-                continue
-            section_id = f"sec_{scene_idx:02d}"
-            for track in tracks:
-                t_idx = track.get("index", 0)
-                clips_scanned += 1
+                # Clip automation envelopes (BUG-E2).
                 try:
                     auto_resp = ableton.send_command("get_clip_automation", {
                         "track_index": t_idx,
@@ -156,22 +155,27 @@ def build_project_brain(ctx: Context) -> dict:
                 except Exception as exc:
                     # No clip in slot, or remote script rejected — skip
                     logger.debug("build_project_brain automation skip: %s", exc)
-                    continue
-                if not isinstance(auto_resp, dict):
-                    continue
-                envs = auto_resp.get("envelopes") or []
-                for env in envs:
-                    clip_automation.append({
-                        "section_id": section_id,
-                        "track_index": t_idx,
-                        "track_name": track.get("name", ""),
-                        "clip_index": scene_idx,
-                        "parameter_name": env.get("parameter_name", ""),
-                        "parameter_type": env.get("parameter_type", ""),
-                        "device_name": env.get("device_name"),
-                    })
+                    auto_resp = None
+                if isinstance(auto_resp, dict):
+                    for env in (auto_resp.get("envelopes") or []):
+                        clip_automation.append({
+                            "section_id": section_id,
+                            "track_index": t_idx,
+                            "track_name": track.get("name", ""),
+                            "clip_index": scene_idx,
+                            "parameter_name": env.get("parameter_name", ""),
+                            "parameter_type": env.get("parameter_type", ""),
+                            "device_name": env.get("device_name"),
+                        })
+
+            if per_track:
+                notes_map[section_id] = per_track
     except Exception as exc:
-        logger.debug("build_project_brain automation scan failed: %s", exc)
+        logger.debug("build_project_brain grid sweep failed: %s", exc)
+        # Overall failure: empty maps, degrade to "all tracks active" fallback
+        notes_map = {}
+        clip_automation = []
+        clips_scanned = 0
 
     # 6. Probe capabilities (direct SpectralCache access, not TCP)
     analyzer_ok = False

package/mcp_server/reference_engine/tools.py

@@ -71,14 +71,18 @@ def _fetch_project_snapshot(ctx: Context) -> dict:
 
             spec_data = spectral.get("spectrum")
             if spec_data:
-                snapshot["spectral"] = {"bands": spec_data["value"]}
+                # gap_analyzer.analyze_gaps reads proj_spectral["band_balance"]
+                # and the reference profile stores its bands under the same
+                # key, so the project spectrum MUST go under band_balance too
+                # (writing it under "bands" made every band read as 0.0).
+                snapshot["spectral"] = {"band_balance": spec_data["value"]}
                 key_data = spectral.get("key")
                 if key_data:
                     snapshot["spectral"]["detected_key"] = key_data["value"]
     except Exception as exc:
         logger.debug("_fetch_project_snapshot failed: %s", exc)
 
-    # Try to get session info for pacing / density
+    # Try to get session info for pacing / density / stereo width
     try:
         session_info = ableton.send_command("get_session_info", {})
         track_count = session_info.get("track_count", 0)
@@ -86,6 +90,22 @@ def _fetch_project_snapshot(ctx: Context) -> dict:
         # Rough density estimate
         snapshot["density"] = min(1.0, track_count / 20.0)
         snapshot["pacing"] = [{"label": f"scene_{i}", "bars": 8} for i in range(scene_count)]
+
+        # Estimate project stereo width from track pans (mirrors the
+        # pan-spread estimate in translation_engine/tools.py). Without this,
+        # snapshot["width"] stayed 0.0 and the width gap always reported the
+        # full reference width.
+        tracks = session_info.get("tracks", [])
+        if tracks:
+            def _get_pan(t: dict) -> float:
+                mixer = t.get("mixer")
+                if isinstance(mixer, dict):
+                    return abs(mixer.get("panning", 0.0))
+                return abs(t.get("pan", 0.0))
+
+            pan_values = [_get_pan(t) for t in tracks if not t.get("muted", False)]
+            if pan_values:
+                snapshot["width"] = min(1.0, sum(pan_values) / max(len(pan_values), 1))
     except Exception as exc:
         logger.debug("_fetch_project_snapshot failed: %s", exc)
 

package/mcp_server/runtime/execution_router.py

@@ -66,6 +66,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
 })
 
 

package/mcp_server/runtime/live_version.py

@@ -6,6 +6,7 @@ responses and exposes feature flags for tool routing.
 
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass
 
 
@@ -19,21 +20,39 @@ class LiveVersionCapabilities:
 
     @classmethod
     def from_version_string(cls, version_str: str) -> LiveVersionCapabilities:
-        """Parse '12.3.6' into a capabilities instance."""
-        parts = version_str.split(".")
-        major = int(parts[0]) if len(parts) > 0 else 12
-        minor = int(parts[1]) if len(parts) > 1 else 0
-        patch = int(parts[2]) if len(parts) > 2 else 0
+        """Parse '12.3.6' into a capabilities instance.
+
+        Tolerant of malformed input: extracts the leading integer of each
+        dotted component and falls back to the conservative floor
+        (major=12, minor=0, patch=0) for missing or non-numeric components.
+        Mirrors the Remote Script's degrade-to-(12,0,0) contract
+        (remote_script/LivePilot/version_detect.py) so a junk live_version
+        string never crashes get_capability_state / get_session_kernel /
+        --doctor.
+        """
+        def _component(parts: list[str], index: int, default: int) -> int:
+            if index >= len(parts):
+                return default
+            match = re.match(r"\s*(\d+)", parts[index])
+            return int(match.group(1)) if match else default
+
+        parts = (version_str or "").split(".")
+        major = _component(parts, 0, 12)
+        minor = _component(parts, 1, 0)
+        patch = _component(parts, 2, 0)
         return cls(major=major, minor=minor, patch=patch)
 
     @classmethod
     def from_session_info(cls, session_info: dict) -> LiveVersionCapabilities:
         """Extract version from get_session_info response.
 
-        Looks for 'live_version' field. Falls back to 12.0.0 if absent
-        (pre-upgrade Remote Script).
+        Looks for 'live_version' field. Falls back to 12.0.0 if absent,
+        null, or empty (pre-upgrade Remote Script). Uses a falsy-guard
+        rather than a key-presence default so a present-but-empty value
+        degrades to the conservative floor, aligning with the sibling
+        readers in runtime/tools.py and runtime/capability_probe.py.
         """
-        version_str = session_info.get("live_version", "12.0.0")
+        version_str = session_info.get("live_version") or "12.0.0"
         return cls.from_version_string(version_str)
 
     @property

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/safety_kernel.py

@@ -56,6 +56,15 @@ CONFIRM_REQUIRED_ACTIONS: set[str] = {
     "replace_simpler_sample",
 }
 
+# Names that LOOK read-only by prefix but actually mutate session state.
+# These must NOT be classified as read-only — they are intersected against
+# the prefix matcher below so a mutating verb never slips through a read
+# prefix (e.g. ``find_and_load_device`` starts with ``find_`` but loads a
+# device, a real mutation routed through REMOTE_COMMANDS).
+_MUTATING_OVERRIDES: set[str] = {
+    "find_and_load_device",
+}
+
 # Read-only prefixes — any action starting with one of these is a read.
 _READ_ONLY_PREFIXES = (
     "get_",
@@ -203,6 +212,8 @@ _WIDE_SCOPE_THRESHOLD = 5   # tracks
 
 def is_read_only_action(action: str) -> bool:
     """Return True if *action* is a non-mutating read/query."""
+    if action in _MUTATING_OVERRIDES:
+        return False
     if action in SAFE_ACTIONS:
         return True
     return action.startswith(_READ_ONLY_PREFIXES)

package/mcp_server/sample_engine/critics.py

@@ -301,9 +301,13 @@ def run_vibe_fit_critic(
             recommendation="No taste evidence yet — neutral score",
         )
 
-    # Compute energy proxy from sample characteristics (0.0 - 1.0)
-    # brightness and transient_density are both 0.0-1.0 range
-    energy = (profile.brightness + profile.transient_density) / 2.0
+    # Compute energy proxy from sample characteristics (0.0 - 1.0).
+    # brightness is already a 0.0-1.0 fraction, but transient_density is peaks
+    # PER SECOND (unbounded). Normalize it through a saturating curve before
+    # averaging so a busy break does not pin the proxy to 1.0 for every sample.
+    # ~12 peaks/s (busy 16ths) maps to ~1.0.
+    transient_norm = max(0.0, min(1.0, profile.transient_density / 12.0))
+    energy = (profile.brightness + transient_norm) / 2.0
     energy = max(0.0, min(1.0, energy))
 
     # Compare against novelty_band as taste proxy

package/mcp_server/sample_engine/slice_workflow.py

@@ -12,8 +12,9 @@ from __future__ import annotations
 
 import hashlib
 
-# Simpler maps slices to MIDI notes starting at C3 (60)
-SLICE_BASE_NOTE = 60
+# Simpler maps slices to MIDI notes starting at C1 (36): slice N -> pitch 36+N.
+# Notes at 60+ (C3) trigger no slice and produce silence.
+SLICE_BASE_NOTE = 36
 
 
 def plan_slice_steps(

package/mcp_server/sample_engine/tools.py

@@ -6,6 +6,7 @@ direct Splice online catalog hunt/download via the gRPC client.
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import os
 from typing import Optional
@@ -57,7 +58,11 @@ async def analyze_sample(
         return {"error": "Could not determine file path — provide file_path directly"}
 
     source = "session_clip" if track_index is not None else "filesystem"
-    profile = build_profile_from_filename(file_path, source=source)
+    # Offload audio decode + numpy FFT off the event loop (heavy CPU/IO).
+    loop = asyncio.get_running_loop()
+    profile = await loop.run_in_executor(
+        None, build_profile_from_filename, file_path, source
+    )
     return profile.to_dict()
 
 
@@ -86,6 +91,11 @@ def evaluate_sample_fit(
     song_key = None
     session_tempo = 120.0
     existing_roles: list[str] = []
+    # Map track index -> name so the key-detection loop below can look a
+    # track's name up by its real index. existing_roles is a *packed*
+    # list (unnamed/errored tracks are skipped), so indexing it by track
+    # index misaligns names with the clip that produced the notes.
+    track_names_by_index: dict[int, str] = {}
 
     try:
         ableton = ctx.lifespan_context["ableton"]
@@ -100,6 +110,7 @@ def evaluate_sample_fit(
                 name = track_info.get("name", "").lower()
                 if name:
                     existing_roles.append(name)
+                    track_names_by_index[i] = name
             except Exception as exc:
                 logger.debug("get_track_info(%d) skipped: %s", i, exc)
                 continue
@@ -147,9 +158,7 @@ def evaluate_sample_fit(
                 ) else []
                 if not notes:
                     continue
-                track_name = (
-                    existing_roles[i] if i < len(existing_roles) else ""
-                )
+                track_name = track_names_by_index.get(i, "")
                 if harmonic_score(notes, track_name) >= 0.3:
                     harmonic_pool.extend(notes)
 
@@ -189,7 +198,11 @@ def evaluate_sample_fit(
         recommended_intent=intent,
         surgeon_plan=surgeon_plan,
         alchemist_plan=alchemist_plan,
-        warnings=[c.recommendation for c in critics.values() if c.score < 0.5],
+        warnings=[
+            c.recommendation
+            for c in critics.values()
+            if getattr(c, "available", True) and c.score < 0.5
+        ],
     )
     return report.to_dict()
 
@@ -316,12 +329,16 @@ async def search_samples(
         if not used_grpc:
             splice = SpliceSource()
             if splice.enabled:
-                splice_results = splice.search(
-                    query=query,
-                    max_results=max_results,
-                    key=key,
-                    bpm_min=bpm_min,
-                    bpm_max=bpm_max,
+                # Offload blocking SQLite query off the event loop.
+                splice_results = await asyncio.get_running_loop().run_in_executor(
+                    None,
+                    lambda: splice.search(
+                        query=query,
+                        max_results=max_results,
+                        key=key,
+                        bpm_min=bpm_min,
+                        bpm_max=bpm_max,
+                    ),
                 )
                 for candidate in splice_results:
                     d = candidate.to_dict()
@@ -335,12 +352,16 @@ async def search_samples(
             browser = BrowserSource()
             for category in browser.DEFAULT_CATEGORIES:
                 try:
-                    search_result = ableton.send_command("search_browser", {
-                        "path": category,
-                        "name_filter": query,
-                        "loadable_only": True,
-                        "max_results": max_results,
-                    })
+                    # Offload blocking TCP round-trip off the event loop.
+                    search_result = await asyncio.get_running_loop().run_in_executor(
+                        None,
+                        lambda: ableton.send_command("search_browser", {
+                            "path": category,
+                            "name_filter": query,
+                            "loadable_only": True,
+                            "max_results": max_results,
+                        }),
+                    )
                     raw = search_result.get("results", [])
                     parsed = browser.parse_results(raw, category)
                     for candidate in parsed:
@@ -359,7 +380,10 @@ async def search_samples(
             "~/Music", "~/Documents/Samples",
             "~/Documents/LivePilot/downloads",
         ])
-        fs_results = fs.search(query, max_results=max_results)
+        # Offload blocking recursive filesystem scan off the event loop.
+        fs_results = await asyncio.get_running_loop().run_in_executor(
+            None, lambda: fs.search(query, max_results=max_results)
+        )
         for candidate in fs_results:
             d = candidate.to_dict()
             d["source_priority"] = 3
@@ -1049,10 +1073,18 @@ async def splice_download_sample(
     if copy_to_user_library:
         dest_dir = os.path.expanduser(_SPLICE_USER_LIB_DEST)
         try:
-            os.makedirs(dest_dir, exist_ok=True)
             dest_path = os.path.join(dest_dir, os.path.basename(local_path))
-            if not os.path.exists(dest_path):
-                shutil.copy2(local_path, dest_path)
+
+            def _copy_into_user_library():
+                os.makedirs(dest_dir, exist_ok=True)
+                if not os.path.exists(dest_path):
+                    shutil.copy2(local_path, dest_path)
+
+            # Offload the blocking filesystem copy off the event loop,
+            # mirroring the run_in_executor used in splice_preview_sample.
+            await asyncio.get_running_loop().run_in_executor(
+                None, _copy_into_user_library
+            )
             response["user_library_path"] = dest_path
             # URI format Ableton uses for user_library samples
             response["browser_uri"] = (

package/mcp_server/server.py

@@ -362,7 +362,7 @@ def _get_all_tools():
     to the next path rather than exploding.
 
     WARNING: Accesses FastMCP private internals. Pinned to
-    fastmcp>=3.3.1,<3.4.0 in requirements.txt. The startup self-test
+    fastmcp>=3.4.2,<3.5.0 in requirements.txt. The startup self-test
     (_assert_tool_registry_accessible) will fail loudly if every probe
     returns empty — better than silently returning [] and disabling
     schema coercion.

package/mcp_server/song_brain/builder.py

@@ -566,7 +566,23 @@ def detect_identity_drift(
         drift.drift_score += 0.2 * len(lost)
 
     # Energy arc shift
-    if before.energy_arc and after.energy_arc:
+    # Align on section_id rather than list position: inserting/removing/
+    # renaming-to-empty a scene shifts energy_arc indices (the BUG-B12 skip
+    # drops empty sections), so a positional diff fabricates drift on every
+    # section after the change. Diffing the shared section_ids compares like
+    # with like and is stable under reordering/insertion.
+    before_energy = {s.section_id: s.energy_level for s in before.section_purposes}
+    after_energy = {s.section_id: s.energy_level for s in after.section_purposes}
+    shared_ids = before_energy.keys() & after_energy.keys()
+    if shared_ids:
+        diff = sum(
+            abs(before_energy[sid] - after_energy[sid]) for sid in shared_ids
+        ) / len(shared_ids)
+        drift.energy_arc_shift = round(diff, 3)
+        drift.drift_score += diff * 0.2
+    elif before.energy_arc and after.energy_arc:
+        # Fallback for snapshots that carry energy_arc but no section_purposes
+        # (e.g. older brains): keep the legacy positional comparison.
         min_len = min(len(before.energy_arc), len(after.energy_arc))
         if min_len > 0:
             diff = sum(

package/mcp_server/sound_design/tools.py

@@ -408,7 +408,7 @@ def _cross_engine_hint_for_track(
         return None
     track_issues = [
         i for i in mix_issues
-        if getattr(i, "track_index", None) == track_index
+        if track_index in (getattr(i, "affected_tracks", []) or [])
     ]
     if not track_issues:
         return None

package/mcp_server/splice_client/http_bridge.py

@@ -45,6 +45,7 @@ import logging
 import os
 import ssl
 import urllib.error
+import urllib.parse
 import urllib.request
 from dataclasses import dataclass, field
 from typing import Any, Optional
@@ -89,6 +90,10 @@ class SpliceHTTPConfig:
     user_agent: str = "LivePilot/1.16 (+splice-http-bridge)"
     timeout_sec: float = 30.0
     max_retries: int = 2
+    # Opt-in escape hatch: when True, the bearer-token host guard in
+    # SpliceHTTPBridge._request is bypassed so a custom (non-splice.com)
+    # base_url may receive the session token. Defaults off.
+    allow_unverified_endpoints: bool = False
     # Whether any of the above values came from user config (file or env)
     # rather than the built-in defaults. Used by `is_user_configured`.
     _user_configured: bool = False
@@ -135,6 +140,7 @@ class SpliceHTTPConfig:
                                     "splice.json: %s must be an integer", key,
                                 )
                     if data.get("allow_unverified_endpoints"):
+                        instance.allow_unverified_endpoints = True
                         loaded_from_file = True
             except (OSError, json.JSONDecodeError) as exc:
                 logger.warning(
@@ -161,6 +167,9 @@ class SpliceHTTPConfig:
                         "Env %s has invalid value: %s", env_name, exc,
                     )
 
+        if os.environ.get("SPLICE_ALLOW_UNVERIFIED_ENDPOINTS") == "1":
+            instance.allow_unverified_endpoints = True
+
         instance._user_configured = (
             loaded_from_file
             or env_configured
@@ -406,6 +415,23 @@ class SpliceHTTPError(Exception):
         }
 
 
+def _is_trusted_splice_host(url: str) -> bool:
+    """True only for HTTPS URLs on a splice.com-owned host.
+
+    Gates attaching the rotating session bearer token: a poisoned base_url
+    (custom config file or SPLICE_API_BASE_URL env) must not be able to
+    exfiltrate the token to an attacker-controlled endpoint.
+    """
+    try:
+        parsed = urllib.parse.urlparse(url)
+    except (ValueError, AttributeError):
+        return False
+    if parsed.scheme != "https":
+        return False
+    host = (parsed.hostname or "").lower()
+    return host == "splice.com" or host.endswith(".splice.com")
+
+
 class SpliceHTTPBridge:
     """Low-level HTTPS client for Splice cloud APIs.
 
@@ -442,10 +468,26 @@ class SpliceHTTPBridge:
 
         url = self.config.base_url.rstrip("/") + path
         if query:
-            import urllib.parse
             qs = urllib.parse.urlencode(query)
             url = f"{url}?{qs}"
 
+        # Token-exfil guard: only attach the Splice session bearer when the
+        # destination is a splice.com-owned HTTPS host. A poisoned base_url
+        # (custom config/env) otherwise leaks the rotating session token to an
+        # attacker-controlled endpoint. Explicit opt-in via
+        # allow_unverified_endpoints / SPLICE_ALLOW_UNVERIFIED_ENDPOINTS=1.
+        if not _is_trusted_splice_host(url) and not self.config.allow_unverified_endpoints:
+            raise SpliceHTTPError(
+                code="UNTRUSTED_ENDPOINT",
+                message=(
+                    f"Refusing to send the Splice session token to non-Splice host "
+                    f"'{self.config.base_url}'. Set allow_unverified_endpoints in "
+                    f"~/.livepilot/splice.json (or SPLICE_ALLOW_UNVERIFIED_ENDPOINTS=1) "
+                    f"to override."
+                ),
+                endpoint=path,
+            )
+
         data_bytes = None
         headers = {
             "Authorization": f"Bearer {token}",