livepilot 1.10.8 → 1.12.2

package/mcp_server/tools/scales.py

@@ -0,0 +1,126 @@
+"""Song-level scale tools (Live 12.0+ Scale Mode).
+
+4 tools matching the Remote Script scales domain.
+"""
+
+from __future__ import annotations
+
+from fastmcp import Context
+
+from ..server import mcp
+
+
+def _get_ableton(ctx: Context):
+    """Extract AbletonConnection from lifespan context."""
+    return ctx.lifespan_context["ableton"]
+
+
+@mcp.tool()
+def get_song_scale(ctx: Context) -> dict:
+    """Read Live's current Scale Mode state (Live 12.0+).
+
+    Returns:
+        root_note:          0-11 (C=0, C#=1, ... B=11)
+        scale_mode:         bool — is Scale Mode currently enabled
+        scale_name:         e.g. "Major", "Minor Pentatonic", "Dorian"
+        scale_intervals:    tuple of semitone offsets from root_note
+        available_scales:   all scale names Live knows about
+
+    Prefer this over our own `identify_scale` detector when you want
+    the user's actual Live selection rather than an audio-detected key.
+    """
+    return _get_ableton(ctx).send_command("get_song_scale", {})
+
+
+@mcp.tool()
+def set_song_scale(ctx: Context, root_note: int, scale_name: str) -> dict:
+    """Set the Song-level Scale Mode root + scale name (Live 12.0+).
+
+    root_note:   0-11 (C=0, C#=1, ... B=11)
+    scale_name:  must match one of Live's built-in scale names.
+                 Call list_available_scales() first if unsure.
+    """
+    if not 0 <= root_note <= 11:
+        raise ValueError("root_note must be 0-11")
+    if not scale_name.strip():
+        raise ValueError("scale_name cannot be empty")
+    return _get_ableton(ctx).send_command("set_song_scale", {
+        "root_note": root_note,
+        "scale_name": scale_name,
+    })
+
+
+@mcp.tool()
+def set_song_scale_mode(ctx: Context, enabled: bool) -> dict:
+    """Enable or disable Scale Mode on the current set (Live 12.0+).
+
+    When enabled, Live's MIDI input and some devices become scale-aware.
+    """
+    return _get_ableton(ctx).send_command("set_song_scale_mode", {
+        "enabled": enabled,
+    })
+
+
+@mcp.tool()
+def list_available_scales(ctx: Context) -> dict:
+    """Return Live's built-in scale names (Live 12.0+).
+
+    Use before set_song_scale() to validate names or offer the user
+    a list. Returns e.g. ["Major", "Minor", "Dorian", "Mixolydian", ...].
+    """
+    return _get_ableton(ctx).send_command("list_available_scales", {})
+
+
+@mcp.tool()
+def get_tuning_system(ctx: Context) -> dict:
+    """Read the current Tuning System state (Live 12.1+).
+
+    Exposes Ableton's microtonal tuning: name, pseudo-octave size
+    (in cents), note range, reference pitch (Hz), and per-degree
+    cent offsets from 12-TET.
+
+    Use for maqam, just intonation, or any non-12-TET workflow.
+    """
+    return _get_ableton(ctx).send_command("get_tuning_system", {})
+
+
+@mcp.tool()
+def set_tuning_reference_pitch(ctx: Context, reference_pitch: float) -> dict:
+    """Set the Tuning System's reference pitch in Hz (Live 12.1+).
+
+    Default is 440.0. Common alternatives: 432.0 (A432), 415.3 (Baroque).
+    """
+    if reference_pitch <= 0:
+        raise ValueError("reference_pitch must be > 0 Hz")
+    return _get_ableton(ctx).send_command("set_tuning_reference_pitch", {
+        "reference_pitch": reference_pitch,
+    })
+
+
+@mcp.tool()
+def set_tuning_note(ctx: Context, degree: int, cent_offset: float) -> dict:
+    """Adjust the cent offset for a single scale degree (Live 12.1+).
+
+    degree:      0-based scale-degree index (length depends on the
+                 loaded tuning system — call get_tuning_system() first
+                 to see the note_tunings array length).
+    cent_offset: cents from 12-TET. Examples:
+                   -13.686 -> pure minor third
+                    +1.955 -> pure major third (third harmonic)
+    """
+    if degree < 0:
+        raise ValueError("degree must be >= 0")
+    return _get_ableton(ctx).send_command("set_tuning_note", {
+        "degree": degree,
+        "cent_offset": cent_offset,
+    })
+
+
+@mcp.tool()
+def reset_tuning_system(ctx: Context) -> dict:
+    """Reset all per-degree tuning offsets to 12-TET (Live 12.1+).
+
+    Clears all per-note microtonal offsets. Doesn't change the
+    tuning system's name or reference pitch — just the offsets.
+    """
+    return _get_ableton(ctx).send_command("reset_tuning_system", {})

package/mcp_server/tools/take_lanes.py

@@ -0,0 +1,135 @@
+"""Take Lanes tools (Live 12.0 UI / 12.2 API).
+
+6 tools matching the Remote Script take_lanes domain:
+- get_take_lanes / get_take_lane_clips — read-only introspection
+  (works on any Live 12.x).
+- create_take_lane / set_take_lane_name — mutation ops (12.2+).
+- create_audio_clip_on_take_lane / create_midi_clip_on_take_lane —
+  programmatic lane-scoped clip creation (12.2+).
+
+Take lanes are alternative clip rows stacked under an arrangement
+track — they let you audition or comp multiple passes of the same
+part without occupying extra tracks. Live 12.0 shipped the UI;
+scripting access to create/rename lanes and attach clips to them
+landed in Live 12.2.
+"""
+
+from __future__ import annotations
+
+from fastmcp import Context
+
+from ..server import mcp
+
+
+def _get_ableton(ctx: Context):
+    """Extract AbletonConnection from lifespan context."""
+    return ctx.lifespan_context["ableton"]
+
+
+@mcp.tool()
+def get_take_lanes(ctx: Context, track_index: int) -> dict:
+    """List all take lanes on a track (Live 12.0+).
+
+    Returns {lanes: [{index, name, is_frozen, clip_count}]}. Works
+    on any Live 12.x — pure introspection, no version gate. Returns
+    an empty list on tracks that don't expose take_lanes.
+    """
+    return _get_ableton(ctx).send_command("get_take_lanes", {
+        "track_index": track_index,
+    })
+
+
+@mcp.tool()
+def create_take_lane(ctx: Context, track_index: int) -> dict:
+    """Create a new take lane on a track (Live 12.2+).
+
+    Returns {lane_index, name}. Raises if the Live version predates
+    12.2 or if the specific build doesn't expose Track.create_take_lane.
+    """
+    return _get_ableton(ctx).send_command("create_take_lane", {
+        "track_index": track_index,
+    })
+
+
+@mcp.tool()
+def set_take_lane_name(
+    ctx: Context,
+    track_index: int,
+    lane_index: int,
+    name: str,
+) -> dict:
+    """Rename an existing take lane (Live 12.2+).
+
+    Returns {name} — the name after the update (Live may normalize
+    whitespace or reject duplicates in some builds).
+    """
+    return _get_ableton(ctx).send_command("set_take_lane_name", {
+        "track_index": track_index,
+        "lane_index": lane_index,
+        "name": name,
+    })
+
+
+@mcp.tool()
+def create_audio_clip_on_take_lane(
+    ctx: Context,
+    track_index: int,
+    lane_index: int,
+    start_time: float,
+    length: float,
+) -> dict:
+    """Create an arrangement audio clip on a specific take lane (Live 12.2+).
+
+    start_time / length are in beats. length must be > 0. The track
+    must be an audio track; Live raises on MIDI tracks. Returns
+    {ok, track_index, lane_index, start_time, length}.
+    """
+    if length <= 0:
+        raise ValueError("length must be > 0")
+    return _get_ableton(ctx).send_command("create_audio_clip_on_take_lane", {
+        "track_index": track_index,
+        "lane_index": lane_index,
+        "start_time": start_time,
+        "length": length,
+    })
+
+
+@mcp.tool()
+def create_midi_clip_on_take_lane(
+    ctx: Context,
+    track_index: int,
+    lane_index: int,
+    start_time: float,
+    length: float,
+) -> dict:
+    """Create an arrangement MIDI clip on a specific take lane (Live 12.2+).
+
+    start_time / length are in beats. length must be > 0. The track
+    must be a MIDI track; Live raises on audio tracks. Returns
+    {ok, track_index, lane_index, start_time, length}.
+    """
+    if length <= 0:
+        raise ValueError("length must be > 0")
+    return _get_ableton(ctx).send_command("create_midi_clip_on_take_lane", {
+        "track_index": track_index,
+        "lane_index": lane_index,
+        "start_time": start_time,
+        "length": length,
+    })
+
+
+@mcp.tool()
+def get_take_lane_clips(
+    ctx: Context,
+    track_index: int,
+    lane_index: int,
+) -> dict:
+    """List the arrangement clips on a specific take lane (Live 12.0+).
+
+    Returns {clips: [{name, start_time, length, is_midi_clip}]}. Pure
+    introspection — no version gate.
+    """
+    return _get_ableton(ctx).send_command("get_take_lane_clips", {
+        "track_index": track_index,
+        "lane_index": lane_index,
+    })

package/mcp_server/tools/tracks.py

@@ -1,6 +1,6 @@
 """Track MCP tools — create, delete, rename, mute, solo, arm, group fold, monitor, freeze, flatten.
 
-17 tools matching the Remote Script tracks domain.
+20 tools matching the Remote Script tracks domain.
 """
 
 from __future__ import annotations
@@ -92,9 +92,24 @@ def create_return_track(ctx: Context) -> dict:
 
 @mcp.tool()
 def delete_track(ctx: Context, track_index: int) -> dict:
-    """Delete a track by index. Use undo to revert if needed."""
+    """Delete a track by index. Use undo to revert if needed.
+
+    Ableton requires at least one track in the session. Attempting to
+    delete the last remaining track raises ValueError with actionable
+    guidance rather than surfacing Ableton's misleading default
+    STATE_ERROR text (BUG-F3).
+    """
     _validate_track_index(track_index)
-    return _get_ableton(ctx).send_command("delete_track", {"track_index": track_index})
+    ableton = _get_ableton(ctx)
+    session_info = ableton.send_command("get_session_info")
+    track_count = session_info.get("track_count") if session_info else None
+    if track_count is not None and track_count <= 1:
+        raise ValueError(
+            "Cannot delete track: Ableton requires at least one track "
+            "in the session. Add another track first, or rename the "
+            "current track if you want a clean slate."
+        )
+    return ableton.send_command("delete_track", {"track_index": track_index})
 
 
 @mcp.tool()
@@ -231,3 +246,31 @@ def get_freeze_status(ctx: Context, track_index: int) -> dict:
     return _get_ableton(ctx).send_command("get_freeze_status", {
         "track_index": track_index,
     })
+
+
+# ── Track long-tail primitives ──────────────────────────────────────────
+
+
+@mcp.tool()
+def jump_in_session_clip(ctx: Context, track_index: int, beats: float) -> dict:
+    """Jump playhead within a running session clip, in beats from start."""
+    _validate_track_index(track_index, allow_return=False)
+    return _get_ableton(ctx).send_command("jump_in_session_clip", {
+        "track_index": track_index,
+        "beats": beats,
+    })
+
+
+@mcp.tool()
+def get_track_performance_impact(ctx: Context, track_index: int) -> dict:
+    """Read a track's CPU performance impact metric."""
+    _validate_track_index(track_index)
+    return _get_ableton(ctx).send_command("get_track_performance_impact", {
+        "track_index": track_index,
+    })
+
+
+@mcp.tool()
+def get_appointed_device(ctx: Context) -> dict:
+    """Return the Blue Hand (appointed/focused) device location as (track_index, device_index, track_name, device_name)."""
+    return _get_ableton(ctx).send_command("get_appointed_device", {})

package/mcp_server/tools/transport.py

@@ -1,6 +1,6 @@
 """Transport MCP tools — playback, tempo, metronome, loop, undo/redo, action log, diagnostics.
 
-12 tools matching the Remote Script transport domain.
+21 tools matching the Remote Script transport domain.
 """
 
 from __future__ import annotations
@@ -130,6 +130,122 @@ def get_recent_actions(ctx: Context, limit: int = 20) -> dict:
 
 
 @mcp.tool()
-def get_session_diagnostics(ctx: Context) -> dict:
-    """Analyze the session for potential issues: armed tracks, solo/mute leftovers, unnamed tracks, empty clips/scenes, MIDI tracks without instruments. Returns issues with severity (warning/info) and stats."""
-    return _get_ableton(ctx).send_command("get_session_diagnostics")
+async def get_session_diagnostics(ctx: Context, check_clip_keys: bool = False) -> dict:
+    """Analyze the session for potential issues: armed tracks, solo/mute leftovers, unnamed tracks, empty clips/scenes, MIDI tracks without instruments. Returns issues with severity (warning/info) and stats.
+
+    check_clip_keys: when True, also cross-checks every audio clip's
+        filename-encoded key against the detected session key (BUG-D1 scan).
+        Each mismatch appears as a diagnostic entry with the exact
+        set_clip_pitch call that would correct it. Requires the M4L bridge
+        (uses get_clip_file_path + get_detected_key); skipped gracefully if
+        the bridge is unavailable. Off by default because it round-trips
+        the bridge once per audio clip and can add noticeable latency on
+        large sessions.
+    """
+    result = _get_ableton(ctx).send_command("get_session_diagnostics")
+
+    if not check_clip_keys:
+        return result
+    if not isinstance(result, dict):
+        return result
+
+    # Augment with per-clip key-consistency checks. Each mismatch is added
+    # as a diagnostic with severity="warning"; "unknown" results are
+    # skipped so we don't drown the user in "no key detected yet" noise.
+    from .clips import check_clip_key_consistency  # local import to avoid cycles
+
+    audio_mismatches: list[dict] = []
+    session_info = _get_ableton(ctx).send_command("get_session_info")
+    tracks = (session_info or {}).get("tracks", []) if isinstance(session_info, dict) else []
+    for track in tracks:
+        t_idx = track.get("index")
+        if t_idx is None:
+            continue
+        # We don't know which slots hold audio clips without probing, so
+        # iterate the first N scene slots conservatively. A session with
+        # many scenes would benefit from a scene-count cap; 32 is a
+        # reasonable upper bound for typical production sessions.
+        for clip_idx in range(min(32, len(session_info.get("scenes", []) or []) or 8)):
+            try:
+                check = await check_clip_key_consistency.fn(ctx, t_idx, clip_idx)
+            except Exception:  # noqa: BLE001 — any failure means "skip this clip"
+                continue
+            if not isinstance(check, dict):
+                continue
+            if check.get("status") == "mismatch":
+                audio_mismatches.append({
+                    "severity": "warning",
+                    "category": "clip_key_mismatch",
+                    "track_index": t_idx,
+                    "clip_index": clip_idx,
+                    "message": check.get("reason", ""),
+                    "recommended_fix": check.get("recommended_fix"),
+                })
+
+    if audio_mismatches:
+        issues = result.setdefault("issues", [])
+        issues.extend(audio_mismatches)
+        result["clip_key_mismatch_count"] = len(audio_mismatches)
+
+    return result
+
+
+# ── Song / Transport long-tail primitives ─────────────────────────────
+
+
+@mcp.tool()
+def tap_tempo(ctx: Context) -> dict:
+    """Tap the tempo (one tap). Live averages consecutive taps to set BPM."""
+    return _get_ableton(ctx).send_command("tap_tempo", {})
+
+
+@mcp.tool()
+def nudge_tempo(ctx: Context, direction: str) -> dict:
+    """Nudge tempo up or down by Live's internal nudge delta. direction: 'up' or 'down'."""
+    if direction not in ("up", "down"):
+        raise ValueError("direction must be 'up' or 'down'")
+    return _get_ableton(ctx).send_command("nudge_tempo", {"direction": direction})
+
+
+@mcp.tool()
+def set_exclusive_arm(ctx: Context, enabled: bool) -> dict:
+    """Enable/disable exclusive arm mode (only one track armed at a time)."""
+    return _get_ableton(ctx).send_command("set_exclusive_arm", {"enabled": enabled})
+
+
+@mcp.tool()
+def set_exclusive_solo(ctx: Context, enabled: bool) -> dict:
+    """Enable/disable exclusive solo mode (only one track soloed at a time)."""
+    return _get_ableton(ctx).send_command("set_exclusive_solo", {"enabled": enabled})
+
+
+@mcp.tool()
+def capture_and_insert_scene(ctx: Context) -> dict:
+    """Capture currently-playing clips and insert them as a new scene. Distinct from capture_midi."""
+    return _get_ableton(ctx).send_command("capture_and_insert_scene", {})
+
+
+@mcp.tool()
+def set_count_in_duration(ctx: Context, bars: int) -> dict:
+    """Set pre-record count-in duration (0-4 bars)."""
+    if not 0 <= bars <= 4:
+        raise ValueError("bars must be 0-4")
+    return _get_ableton(ctx).send_command("set_count_in_duration", {"bars": bars})
+
+
+@mcp.tool()
+def get_link_state(ctx: Context) -> dict:
+    """Read Ableton Link + count-in state (enabled, start/stop sync, tempo follower, is_counting_in)."""
+    return _get_ableton(ctx).send_command("get_link_state", {})
+
+
+@mcp.tool()
+def set_link_enabled(ctx: Context, enabled: bool) -> dict:
+    """Enable or disable Ableton Link (network tempo synchronization)."""
+    return _get_ableton(ctx).send_command("set_link_enabled", {"enabled": enabled})
+
+
+@mcp.tool()
+def force_link_beat_time(ctx: Context, beat_time: float) -> dict:
+    """Force Ableton Link to a specific beat time (if supported by this Live version)."""
+    return _get_ableton(ctx).send_command("force_link_beat_time", {"beat_time": beat_time})

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.10.8",
+  "version": "1.12.2",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 324 tools, 45 domains. Device atlas (1305 devices), sample engine (Splice + browser + filesystem), auto-composition, spectral perception, technique memory, creative intelligence (12 engines)",
+  "description": "Agentic production system for Ableton Live 12 — 398 tools, 51 domains. Device atlas (1305 devices), sample engine (Splice + browser + filesystem), auto-composition, spectral perception, technique memory, creative intelligence (12 engines)",
   "author": "Pilot Studio",
   "license": "BSL-1.1",
   "type": "commonjs",

package/remote_script/LivePilot/__init__.py

@@ -5,21 +5,26 @@ Entry point for the ControlSurface. Ableton calls create_instance(c_instance)
 when this script is selected in Preferences > Link, Tempo & MIDI.
 """
 
-__version__ = "1.10.8"
+__version__ = "1.12.2"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router
 from .server import LivePilotServer
+from . import utils        # noqa: F401  — shared helpers (get_track, get_device)
 from . import transport    # noqa: F401  — registers transport handlers
 from . import tracks       # noqa: F401  — registers track handlers
 from . import clips        # noqa: F401  — registers clip handlers
 from . import notes        # noqa: F401  — registers note handlers
 from . import devices      # noqa: F401  — registers device handlers
 from . import scenes       # noqa: F401  — registers scene handlers
+from . import scales       # noqa: F401  — registers song scale handlers (12.0+)
 from . import mixing       # noqa: F401  — registers mixing handlers
 from . import browser      # noqa: F401  — registers browser handlers
 from . import arrangement  # noqa: F401  — registers arrangement handlers
 from . import diagnostics       # noqa: F401  — registers diagnostics handler
+from . import follow_actions    # noqa: F401  — registers follow action handlers (12.0+, 12.2+)
+from . import grooves           # noqa: F401  — registers groove pool handlers (11+)
+from . import take_lanes        # noqa: F401  — registers take lane handlers (12.0+ read, 12.2+ write)
 from . import clip_automation   # noqa: F401  — registers clip automation handlers
 from . import version_detect    # noqa: F401  — version detection
 
@@ -36,13 +41,19 @@ from . import version_detect    # noqa: F401  — version detection
 # @register decorators with the updated code). Result: a Control Surface
 # toggle now behaves like a fresh module reload, so live-editing mixing.py
 # / devices.py / etc. and re-toggling is enough — no Ableton restart.
+#
+# Order matters: utils comes first because every handler imports
+# ``from .utils import get_track, get_device``. If utils isn't reloaded
+# first, those re-imports during ``importlib.reload(devices)`` still
+# resolve to the stale ``utils`` module object in ``sys.modules``.
 
 _FIRST_CREATE_INSTANCE = True
 
 _HANDLER_MODULES = (
-    transport, tracks, clips, notes, devices, scenes,
-    mixing, browser, arrangement, diagnostics,
-    clip_automation, version_detect,
+    utils,
+    transport, tracks, clips, notes, devices, scenes, scales,
+    mixing, browser, arrangement, diagnostics, follow_actions,
+    grooves, take_lanes, clip_automation, version_detect,
 )
 
 

package/remote_script/LivePilot/clips.py

@@ -305,3 +305,65 @@ def set_clip_warp_mode(song, params):
         "warp_mode": clip.warp_mode,
         "warping": clip.warping,
     }
+
+
+@register("get_clip_scale")
+def get_clip_scale(song, params):
+    """Read a clip's per-clip scale override (Live 12.0+).
+
+    Per-clip scale is independent of Song.scale_* and lets each clip
+    carry its own key/mode.
+    """
+    from .version_detect import has_feature
+    if not has_feature("song_scale_api"):
+        raise RuntimeError("Per-clip scale requires Live 12.0+.")
+    clip_slot = get_clip_slot(song, int(params["track_index"]), int(params["clip_index"]))
+    if not clip_slot.has_clip:
+        raise ValueError("Clip slot is empty")
+    clip = clip_slot.clip
+    return {
+        "root_note": int(clip.root_note),
+        "scale_mode": bool(clip.scale_mode),
+        "scale_name": str(clip.scale_name),
+    }
+
+
+@register("set_clip_scale")
+def set_clip_scale(song, params):
+    """Set a clip's per-clip scale override (Live 12.0+)."""
+    from .version_detect import has_feature
+    if not has_feature("song_scale_api"):
+        raise RuntimeError("Per-clip scale requires Live 12.0+.")
+    clip_slot = get_clip_slot(song, int(params["track_index"]), int(params["clip_index"]))
+    if not clip_slot.has_clip:
+        raise ValueError("Clip slot is empty")
+    clip = clip_slot.clip
+    root = int(params["root_note"])
+    if not 0 <= root <= 11:
+        raise ValueError("root_note must be 0-11 (C=0, C#=1, ... B=11)")
+    scale_name = str(params["scale_name"])
+    # scale_name validation against Song.scale_names — clip uses the same list
+    available = list(song.scale_names)
+    if scale_name not in available:
+        raise ValueError(
+            "Unknown scale '%s'. Available: %s" % (scale_name, ", ".join(available))
+        )
+    clip.root_note = root
+    clip.scale_name = scale_name
+    return {
+        "root_note": int(clip.root_note),
+        "scale_name": str(clip.scale_name),
+    }
+
+
+@register("set_clip_scale_mode")
+def set_clip_scale_mode(song, params):
+    """Enable/disable Scale Mode on a single clip (Live 12.0+)."""
+    from .version_detect import has_feature
+    if not has_feature("song_scale_api"):
+        raise RuntimeError("Per-clip scale requires Live 12.0+.")
+    clip_slot = get_clip_slot(song, int(params["track_index"]), int(params["clip_index"]))
+    if not clip_slot.has_clip:
+        raise ValueError("Clip slot is empty")
+    clip_slot.clip.scale_mode = bool(params["enabled"])
+    return {"scale_mode": bool(clip_slot.clip.scale_mode)}