livepilot 1.9.14 → 1.9.16

package/mcp_server/translation_engine/tools.py

@@ -0,0 +1,108 @@
+"""Translation Engine MCP tools — 2 tools for playback robustness.
+
+Each tool fetches data from Ableton via the shared connection,
+then delegates to pure-computation critics.
+"""
+
+from __future__ import annotations
+
+from mcp.server.fastmcp import Context
+
+from ..server import mcp
+from .critics import build_translation_report, run_all_translation_critics
+
+
+# ── Helpers ─────────────────────────────────────────────────────────
+
+
+def _fetch_translation_data(ctx: Context) -> dict:
+    """Fetch mix snapshot data needed for translation analysis.
+
+    Builds snapshot from real available data:
+    - Spectrum from SpectralCache (direct access, not TCP)
+    - Stereo width estimated from track pan values
+    - Foreground detection from role inference
+    """
+    ableton = ctx.lifespan_context["ableton"]
+
+    # Get spectral data directly from SpectralCache
+    spectrum_bands = {}
+    try:
+        spectral = ctx.lifespan_context.get("spectral")
+        if spectral and spectral.is_connected:
+            spec_data = spectral.get("spectrum")
+            if spec_data and isinstance(spec_data["value"], dict):
+                spectrum_bands = spec_data["value"]
+    except Exception:
+        pass
+
+    # Estimate stereo width from track pans via session info
+    stereo_width = 0.0
+    center_strength = 0.5
+    has_foreground = True
+    foreground_masked = False
+    try:
+        session_info = ableton.send_command("get_session_info", {})
+        tracks = session_info.get("tracks", [])
+        if tracks:
+            # Pan may be at top level or nested under mixer.panning
+            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:
+                # Wider pans = more stereo width
+                stereo_width = min(1.0, sum(pan_values) / max(len(pan_values), 1))
+                # Center strength = proportion of tracks near center
+                center_count = sum(1 for p in pan_values if p < 0.15)
+                center_strength = center_count / max(len(pan_values), 1)
+
+            # Simple foreground detection: at least one unmuted, non-quiet track
+            has_foreground = any(not t.get("muted", False) for t in tracks)
+    except Exception:
+        pass
+
+    return {
+        "stereo_width": stereo_width,
+        "center_strength": center_strength,
+        "sub_energy": spectrum_bands.get("sub", 0.0),
+        "low_energy": spectrum_bands.get("low", 0.0),
+        "low_mid_energy": spectrum_bands.get("low_mid", 0.0),
+        "high_energy": spectrum_bands.get("high", 0.0),
+        "presence_energy": spectrum_bands.get("presence", 0.0),
+        "has_foreground": has_foreground,
+        "foreground_masked": foreground_masked,
+    }
+
+
+# ── MCP Tools ───────────────────────────────────────────────────────
+
+
+@mcp.tool()
+def check_translation(ctx: Context) -> dict:
+    """Check playback robustness — mono safety, small speakers, harshness.
+
+    Returns a full translation report with robustness classification
+    (robust/fragile/critical), boolean safety flags, and suggested
+    corrective moves.
+    """
+    mix_snapshot = _fetch_translation_data(ctx)
+    report = build_translation_report(mix_snapshot)
+    return report.to_dict()
+
+
+@mcp.tool()
+def get_translation_issues(ctx: Context) -> dict:
+    """Get just the translation issues without the full report.
+
+    Lighter than check_translation — returns only detected issues
+    from the 5 playback robustness critics.
+    """
+    mix_snapshot = _fetch_translation_data(ctx)
+    issues = run_all_translation_critics(mix_snapshot)
+    return {
+        "issues": [i.to_dict() for i in issues],
+        "issue_count": len(issues),
+    }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.9.14",
+  "version": "1.9.16",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 178 tools, 17 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
+  "description": "Agentic production system for Ableton Live 12 — 236 tools, 32 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
   "author": "Pilot Studio",
   "license": "MIT",
   "type": "commonjs",

package/remote_script/LivePilot/__init__.py

@@ -5,7 +5,7 @@ Entry point for the ControlSurface. Ableton calls create_instance(c_instance)
 when this script is selected in Preferences > Link, Tempo & MIDI.
 """
 
-__version__ = "1.9.14"
+__version__ = "1.9.16"
 
 from _Framework.ControlSurface import ControlSurface
 from .server import LivePilotServer

package/remote_script/LivePilot/arrangement.py

@@ -352,6 +352,12 @@ def modify_arrangement_notes(song, params):
             note.velocity = float(mod["velocity"])
         if "probability" in mod:
             note.probability = float(mod["probability"])
+        if "mute" in mod:
+            note.mute = bool(mod["mute"])
+        if "velocity_deviation" in mod:
+            note.velocity_deviation = float(mod["velocity_deviation"])
+        if "release_velocity" in mod:
+            note.release_velocity = float(mod["release_velocity"])
         modified_count += 1
 
     song.begin_undo_step()
@@ -523,10 +529,20 @@ def set_arrangement_automation(song, params):
 
     # No fallback — direct envelope creation is the only safe approach.
     # Session-clip duplication can silently create overlapping clips.
+    #
+    # Known limitation: clips created via create_arrangement_clip
+    # (duplicate_clip_to_arrangement) often cannot have envelopes
+    # created programmatically. Workaround: record automation by
+    # arming the track and playing back with parameter changes,
+    # or use session-clip automation (set_clip_automation) and then
+    # record the session performance to arrangement.
     raise ValueError(
         "Cannot create automation envelope for parameter '%s' on this "
-        "arrangement clip. Direct envelope access is not supported for "
-        "this parameter type or Live version."
+        "arrangement clip. This is a known Live API limitation for "
+        "programmatically-created arrangement clips. Workarounds: "
+        "(1) use set_clip_automation on a session clip instead, "
+        "(2) record automation by arming the track during playback, "
+        "or (3) use the M4L bridge for deeper LOM envelope access."
         % parameter.name
     )
 
@@ -547,7 +563,9 @@ def transpose_arrangement_notes(song, params):
     clip = arr_clips[clip_index]
 
     from_time = float(params.get("from_time", 0.0))
-    time_span = float(params.get("time_span", clip.length))
+    # Default span covers from from_time to end of clip, not the full clip length
+    default_span = max(0.0, clip.length - from_time) if clip.length > 0 else 32768.0
+    time_span = float(params.get("time_span", default_span))
 
     all_notes = clip.get_notes_extended(0, 128, from_time, time_span)
 

package/remote_script/LivePilot/clips.py

@@ -50,6 +50,11 @@ def create_clip(song, params):
         raise ValueError("Clip length must be > 0")
 
     clip_slot = get_clip_slot(song, track_index, clip_index)
+    if clip_slot.has_clip:
+        raise ValueError(
+            "Clip slot %d on track %d already has a clip. "
+            "Delete it first with delete_clip." % (clip_index, track_index)
+        )
     clip_slot.create_clip(length)
     clip = clip_slot.clip
 
@@ -147,12 +152,23 @@ def set_clip_loop(song, params):
     clip_index = int(params["clip_index"])
     clip = get_clip(song, track_index, clip_index)
 
-    # Set end before start to avoid Live's loop_start < loop_end clamping.
-    # Expanding the window first ensures the left edge can move freely.
-    if "end" in params:
-        clip.loop_end = float(params["end"])
-    if "start" in params:
-        clip.loop_start = float(params["start"])
+    # Conditional ordering to avoid Live's loop_start < loop_end clamping.
+    # When expanding the window, set the expanding edge first.
+    # When shrinking, set the contracting edge first.
+    new_end = float(params["end"]) if "end" in params else None
+    new_start = float(params["start"]) if "start" in params else None
+
+    if new_end is not None and new_end > clip.loop_end:
+        # Expanding right — set end first so start can move freely
+        clip.loop_end = new_end
+        if new_start is not None:
+            clip.loop_start = new_start
+    else:
+        # Shrinking or only changing start — set start first
+        if new_start is not None:
+            clip.loop_start = new_start
+        if new_end is not None:
+            clip.loop_end = new_end
     if "enabled" in params:
         clip.looping = bool(params["enabled"])
 

package/remote_script/LivePilot/notes.py

@@ -172,6 +172,12 @@ def modify_notes(song, params):
             note.velocity = float(mod["velocity"])
         if "probability" in mod:
             note.probability = float(mod["probability"])
+        if "mute" in mod:
+            note.mute = bool(mod["mute"])
+        if "velocity_deviation" in mod:
+            note.velocity_deviation = float(mod["velocity_deviation"])
+        if "release_velocity" in mod:
+            note.release_velocity = float(mod["release_velocity"])
         modified_count += 1
 
     # Pass the original NoteVector back — Boost.Python requires the C++ type
@@ -273,7 +279,9 @@ def transpose_notes(song, params):
         clip = get_clip(song, track_index, clip_index)
 
     from_time = float(params.get("from_time", 0.0))
-    time_span = float(params.get("time_span", clip.length))
+    # Default span covers from from_time to end of clip, not the full clip length
+    default_span = max(0.0, clip.length - from_time) if clip.length > 0 else 32768.0
+    time_span = float(params.get("time_span", default_span))
 
     # Get notes — returns C++ NoteVector that must be passed back intact
     all_notes = clip.get_notes_extended(0, 128, from_time, time_span)

package/remote_script/LivePilot/server.py

@@ -162,12 +162,12 @@ class LivePilotServer(object):
                             pass
                         continue
                     self._client_connected = True
-                self._client_thread = threading.Thread(
-                    target=self._run_client_session,
-                    args=(client, addr),
-                )
-                self._client_thread.daemon = True
-                self._client_thread.start()
+                    self._client_thread = threading.Thread(
+                        target=self._run_client_session,
+                        args=(client, addr),
+                    )
+                    self._client_thread.daemon = True
+                    self._client_thread.start()
             except socket.timeout:
                 continue
             except OSError: