livepilot 1.14.1 → 1.16.0

package/mcp_server/tools/browser.py

@@ -39,11 +39,61 @@ def get_browser_tree(ctx: Context, category_type: str = "all") -> dict:
 
 
 @mcp.tool()
-def get_browser_items(ctx: Context, path: str) -> dict:
-    """List items at a browser path (e.g., 'instruments/Analog')."""
+def get_browser_items(
+    ctx: Context,
+    path: str,
+    limit: int = 500,
+    offset: int = 0,
+    filter_pattern: Optional[str] = None,
+) -> dict:
+    """List items at a browser path (e.g., 'instruments/Analog').
+
+    BUG-2026-04-22#5 fix — the /drums folder returned 68KB+ of JSON on
+    single calls, blowing past tool token caps. These params give agents
+    a way to page and filter natively without dumping to temp files.
+
+    path:            browser path (e.g., 'drums', 'samples/Packs/Foo')
+    limit:           maximum items returned (default 500, max 5000)
+    offset:          number of items to skip (default 0)
+    filter_pattern:  case-insensitive substring to filter item names by
+                     (applied server-side when possible, client-side fallback)
+    """
     if not path.strip():
         raise ValueError("Path cannot be empty")
-    return _get_ableton(ctx).send_command("get_browser_items", {"path": path})
+    if limit < 1:
+        raise ValueError("limit must be >= 1")
+    limit = min(limit, 5000)
+    if offset < 0:
+        raise ValueError("offset must be >= 0")
+    params: dict = {
+        "path": path,
+        "limit": limit,
+        "offset": offset,
+    }
+    if filter_pattern:
+        params["filter_pattern"] = filter_pattern
+    result = _get_ableton(ctx).send_command("get_browser_items", params)
+
+    # Client-side fallback: if the remote script's handler doesn't know about
+    # limit/offset/filter_pattern yet (older remote-script build), apply the
+    # paging + filter here so the MCP contract still works. Returned payload
+    # keeps `truncated`/`total_before_filter` for observability.
+    if isinstance(result, dict) and "items" in result:
+        items = result.get("items") or []
+        total_before = len(items)
+        if filter_pattern:
+            needle = filter_pattern.lower()
+            items = [i for i in items if needle in str(i.get("name", "")).lower()]
+        total_filtered = len(items)
+        paged = items[offset : offset + limit]
+        result["items"] = paged
+        result["total_before_filter"] = total_before
+        result["total_after_filter"] = total_filtered
+        result["returned"] = len(paged)
+        result["offset"] = offset
+        result["limit"] = limit
+        result["truncated"] = (offset + limit) < total_filtered
+    return result
 
 
 @mcp.tool()
@@ -54,14 +104,21 @@ def search_browser(
     loadable_only: bool = False,
     max_depth: int = 8,
     max_results: int = 100,
+    query: Optional[str] = None,
 ) -> dict:
     """Search the browser tree under a path, optionally filtering by name.
 
-    path:        top-level category to search under. Valid categories:
-                 instruments, audio_effects, midi_effects, sounds, drums,
-                 samples, packs, user_library, plugins, max_for_live, clips
-    max_depth:   how deep to recurse into subfolders (default 8)
-    max_results: maximum number of results to return (default 100)
+    BUG-2026-04-22#4 fix — `query` is now accepted as an alias for
+    `name_filter`, aligning this tool's schema with `search_samples`.
+    Callers passing either keyword work.
+
+    path:         top-level category to search under. Valid categories:
+                  instruments, audio_effects, midi_effects, sounds, drums,
+                  samples, packs, user_library, plugins, max_for_live, clips
+    name_filter:  case-insensitive substring filter on item name
+    query:        alias for name_filter (accepts either)
+    max_depth:    how deep to recurse into subfolders (default 8)
+    max_results:  maximum number of results to return (default 100)
     """
     if not path.strip():
         raise ValueError("Path cannot be empty")
@@ -69,9 +126,10 @@ def search_browser(
         raise ValueError("max_depth must be >= 1")
     if max_results < 1:
         raise ValueError("max_results must be >= 1")
+    effective_filter = name_filter if name_filter is not None else query
     params: dict = {"path": path}
-    if name_filter is not None:
-        params["name_filter"] = name_filter
+    if effective_filter is not None:
+        params["name_filter"] = effective_filter
     if loadable_only:
         params["loadable_only"] = loadable_only
     if max_depth != 8:
@@ -81,13 +139,106 @@ def search_browser(
     return _get_ableton(ctx).send_command("search_browser", params)
 
 
+# Role-aware Simpler defaults — BUG-2026-04-22 #17 + #18.
+# Each role maps to a list of (parameter_name, value) pairs applied after
+# load via set_device_parameter. Trigger Mode polarity per BUG #9:
+# 0 = Trigger (one-shot), 1 = Gate (held). Volume in dB. Root in MIDI pitch.
+_SIMPLER_ROLE_DEFAULTS = {
+    "drum": [
+        ("Snap", 0),
+        ("Volume", 0.0),
+        ("Trigger Mode", 0),  # Trigger / one-shot
+        ("Sample Pitch Coarse", 36),  # C1, matches drum-pad convention
+    ],
+    "melodic": [
+        ("Snap", 1),
+        ("Volume", 0.0),
+        ("Trigger Mode", 1),  # Gate / held
+        ("Sample Pitch Coarse", 60),  # C3
+    ],
+    "texture": [
+        ("Snap", 0),
+        ("Volume", -6.0),
+        ("Trigger Mode", 1),  # Gate
+        ("Sample Pitch Coarse", 60),  # C3
+    ],
+}
+
+
 @mcp.tool()
-def load_browser_item(ctx: Context, track_index: int, uri: str) -> dict:
-    """Load a browser item (instrument/effect) onto a track by URI."""
+def load_browser_item(
+    ctx: Context,
+    track_index: int,
+    uri: str,
+    role: Optional[str] = None,
+) -> dict:
+    """Load a browser item (instrument/effect/sample) onto a track by URI.
+
+    URI grammar — see livepilot/skills/livepilot-devices/references/
+    load_browser_item-uri-grammar.md for the full reference. Three
+    known forms produced by search_browser /
+    get_browser_items / get_browser_tree:
+      - query:Drums#FileId_29738       (pack content)
+      - query:Synths#Operator          (native device by name)
+      - query:UserLibrary#Samples:Splice:Filename.wav  (path-style)
+    Always pass URIs verbatim from search results. Never construct them
+    by hand — guessed names match greedily and can load the wrong item.
+
+    Context-dependent behavior (BUG-2026-04-22 #16):
+      - Empty track: creates a Simpler with the sample loaded.
+      - Track with an instrument: drops the new device after the
+        existing one.
+      - Track with a Drum Rack: the FIRST call creates a chain on
+        note 36; subsequent calls REPLACE that chain instead of
+        appending to the next pad. Use add_drum_rack_pad for
+        pad-by-pad kit construction.
+
+    role (optional, BUG-2026-04-22 #17 + #18): apply role-aware Simpler
+    defaults after load. Skips silently if no Simpler was created (e.g.,
+    when loading a native synth or effect).
+      - "drum"     : Snap=0, Vol=0dB, Trigger Mode=0 (Trigger), root=C1 (36)
+      - "melodic"  : Snap=1, Vol=0dB, Trigger Mode=1 (Gate), root=C3 (60)
+      - "texture"  : Snap=0, Vol=-6dB, Trigger Mode=1 (Gate), root=C3 (60)
+    Omit role to keep Live's raw defaults (Volume=-12dB, Snap=1).
+
+    NOTE on Trigger Mode polarity (BUG-2026-04-22 #9): the value is
+    REVERSED from intuition. Trigger Mode=0 means Trigger (one-shot,
+    drum-style), Trigger Mode=1 means Gate (held, melodic-style).
+    """
     _validate_track_index(track_index)
     if not uri.strip():
         raise ValueError("URI cannot be empty")
-    return _get_ableton(ctx).send_command("load_browser_item", {
+    if role is not None and role not in _SIMPLER_ROLE_DEFAULTS:
+        raise ValueError(
+            f"role must be one of {sorted(_SIMPLER_ROLE_DEFAULTS)}, got {role!r}"
+        )
+
+    ableton = _get_ableton(ctx)
+    result = ableton.send_command("load_browser_item", {
         "track_index": track_index,
         "uri": uri,
     })
+
+    # Post-load: apply role-aware defaults if the loaded device is a Simpler.
+    if role and isinstance(result, dict) and not result.get("error"):
+        device_index = result.get("device_index")
+        device_class = str(result.get("class_name") or result.get("device_name") or "")
+        if device_index is not None and "Simpler" in device_class:
+            applied = []
+            for name, value in _SIMPLER_ROLE_DEFAULTS[role]:
+                try:
+                    ableton.send_command("set_device_parameter", {
+                        "track_index": track_index,
+                        "device_index": int(device_index),
+                        "parameter_name": name,
+                        "value": value,
+                    })
+                    applied.append({"parameter": name, "value": value})
+                except Exception as exc:
+                    # Don't fail the whole load if one default doesn't apply
+                    # (parameter name might not exist on every Simpler variant).
+                    applied.append({"parameter": name, "skipped": str(exc)})
+            result["role"] = role
+            result["role_defaults_applied"] = applied
+
+    return result

package/mcp_server/tools/devices.py

@@ -290,13 +290,17 @@ def set_device_parameter(
 
 
 def _normalize_batch_entry(entry: dict) -> dict:
-    """Accept either the legacy 'name_or_index' shape or the aligned
-    'parameter_index' / 'parameter_name' shape used by set_device_parameter.
-
-    BUG-F4: the sibling tools had inconsistent schemas. Callers writing
-    code against set_device_parameter hit validation errors switching
-    to batch_set_parameters. Now both shapes are accepted and
-    normalized to the Remote Script's expected {name_or_index, value}.
+    """Accept legacy 'name_or_index', aligned 'parameter_index'/'parameter_name',
+    or the 'index'/'name' keys that `get_device_parameters` returns natively.
+
+    BUG-F4 + BUG-2026-04-22#3: the sibling tools had inconsistent schemas.
+    Callers writing code against set_device_parameter hit validation errors
+    switching to batch_set_parameters. The 2026-04-22 bug report flagged
+    that `get_device_parameters` returns entries with `"index": N` but
+    `batch_set_parameters` rejected that key — forcing callers to rename
+    it. We now accept every shape and normalize to the Remote Script's
+    expected `{name_or_index, value}` so `get_device_parameters`'s output
+    can be fed straight back in.
     """
     if "value" not in entry:
         raise ValueError("Each parameter entry must include 'value'")
@@ -304,25 +308,35 @@ def _normalize_batch_entry(entry: dict) -> dict:
     has_legacy = "name_or_index" in entry
     has_index = "parameter_index" in entry
     has_name = "parameter_name" in entry
+    # BUG-2026-04-22#3 aliases
+    has_short_index = "index" in entry
+    has_short_name = "name" in entry
 
-    specified = sum([has_legacy, has_index, has_name])
+    specified = sum([
+        has_legacy, has_index, has_name, has_short_index, has_short_name,
+    ])
     if specified == 0:
         raise ValueError(
             "Each parameter entry must include exactly one of: "
-            "parameter_name, parameter_index, or name_or_index (legacy)"
+            "parameter_name, parameter_index, name, index, or name_or_index"
         )
     if specified > 1:
         raise ValueError(
             "Each parameter entry must include exactly one of "
-            "parameter_name, parameter_index, or name_or_index — not multiple"
+            "parameter_name, parameter_index, name, index, or name_or_index "
+            "— not multiple"
         )
 
     if has_legacy:
         key = entry["name_or_index"]
     elif has_index:
         key = entry["parameter_index"]
-    else:
+    elif has_name:
         key = entry["parameter_name"]
+    elif has_short_index:
+        key = entry["index"]
+    else:
+        key = entry["name"]
 
     # BUG-audit-H3: match set_device_parameter's validation so negative
     # indices are rejected at the MCP layer rather than leaking through to
@@ -543,6 +557,37 @@ def insert_rack_chain(
     })
 
 
+@mcp.tool()
+def rename_chain(
+    ctx: Context,
+    track_index: int,
+    device_index: int,
+    chain_index: int,
+    name: str,
+) -> dict:
+    """Rename a chain inside any Rack device — Instrument, Audio Effect, or Drum (Live 12.3+).
+
+    Works with Drum Racks (the primary use case — naming pads "Kick", "Snare",
+    "Clap", etc.) as well as Instrument/Audio Effect Racks.
+
+    track_index:  track containing the rack
+    device_index: rack device index on the track
+    chain_index:  0-based chain to rename
+    name:         new chain name (non-empty; Live may truncate)
+    """
+    _validate_track_index(track_index)
+    _validate_device_index(device_index)
+    _validate_chain_index(chain_index)
+    if not name or not name.strip():
+        raise ValueError("name cannot be empty")
+    return _get_ableton(ctx).send_command("set_chain_name", {
+        "track_index": track_index,
+        "device_index": device_index,
+        "chain_index": chain_index,
+        "name": name.strip(),
+    })
+
+
 @mcp.tool()
 def set_drum_chain_note(
     ctx: Context,

package/mcp_server/tools/mixing.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import asyncio
 from typing import Optional
 
 from fastmcp import Context
@@ -88,27 +89,31 @@ def set_master_volume(ctx: Context, volume: float) -> dict:
 
 
 @mcp.tool()
-def get_track_meters(
+async def get_track_meters(
     ctx: Context,
     track_index: Optional[int] = None,
     include_stereo: bool = False,
+    samples: int = 1,
+    sample_interval_ms: int = 50,
 ) -> dict:
     """Read real-time output meter levels for tracks.
 
     Returns peak level (0.0-1.0) for each track. Call while playing to
     check levels, detect clipping, or verify a track is producing sound.
 
-    track_index:    specific track (omit for all tracks)
-    include_stereo: include left/right channel meters (adds GUI load)
-
-    BUG-B3: when playback is stopped, `level` reports peak-hold from the
-    last loud moment while `left`/`right` report instantaneous channel
-    levels (which decay to 0). The two fields then visibly disagree, and
-    callers debugging "is my filter killing the signal?" get false alarms.
-    We now tag each response with `is_playing` so callers can interpret
-    the levels correctly, and — when include_stereo=True AND playback is
-    stopped — we mark left/right as `null` instead of 0 so the semantic
-    is explicit.
+    track_index:        specific track (omit for all tracks)
+    include_stereo:     include left/right channel meters (adds GUI load)
+    samples:            number of snapshots to take (default 1). When > 1,
+                        returns peak-over-window for `level`/`left`/`right`
+                        (BUG-2026-04-22#7 fix — single reads are unreliable
+                        because Live samples `level` and `left/right` at
+                        slightly different moments and they can disagree).
+    sample_interval_ms: ms between snapshots when samples > 1 (default 50).
+
+    BUG-B3 (still active): when playback is stopped, `level` reports
+    peak-hold from the last loud moment while `left`/`right` report
+    instantaneous channel levels (decay to 0). We tag responses with
+    `is_playing`; when stopped + stereo requested, left/right → null.
     """
     params: dict = {}
     if track_index is not None:
@@ -116,7 +121,53 @@ def get_track_meters(
     if include_stereo:
         params["include_stereo"] = include_stereo
     ableton = _get_ableton(ctx)
-    result = ableton.send_command("get_track_meters", params)
+
+    # Multi-sample path for BUG-2026-04-22#7 — take N snapshots and return
+    # the max per track per channel. Mathematical-impossibility cases
+    # (level>0 but left=right=0) are resolved by sampling over time.
+    if samples and samples > 1:
+        samples = min(samples, 20)  # hard cap
+        interval = max(0, sample_interval_ms) / 1000.0
+        snapshots: list[dict] = []
+        for i in range(samples):
+            snap = ableton.send_command("get_track_meters", params)
+            if isinstance(snap, dict):
+                snapshots.append(snap)
+            if i < samples - 1 and interval > 0:
+                await asyncio.sleep(interval)
+        if not snapshots:
+            return {"error": "No meter snapshots collected"}
+        # Take the first snapshot's structure and peak-combine across all.
+        result = dict(snapshots[0])
+        # Merge tracks field with peak-maxing
+        if "tracks" in result:
+            merged = {}
+            for snap in snapshots:
+                for t in snap.get("tracks", []):
+                    tid = t.get("index")
+                    if tid is None:
+                        continue
+                    if tid not in merged:
+                        merged[tid] = dict(t)
+                    else:
+                        for fld in ("level", "left", "right"):
+                            cur = merged[tid].get(fld) or 0
+                            new = t.get(fld) or 0
+                            if new > cur:
+                                merged[tid][fld] = new
+            result["tracks"] = list(merged.values())
+        elif include_stereo or track_index is not None:
+            # Single-track response shape
+            for fld in ("level", "left", "right"):
+                vals = [s.get(fld) for s in snapshots if s.get(fld) is not None]
+                if vals:
+                    result[fld] = max(vals)
+        result["samples_collected"] = len(snapshots)
+        result["sample_interval_ms"] = sample_interval_ms
+    else:
+        result = ableton.send_command("get_track_meters", params)
+        if not isinstance(result, dict):
+            return result
 
     # Probe playback state once so we can annotate the response
     try:
@@ -125,8 +176,6 @@ def get_track_meters(
     except Exception:
         is_playing = None  # unknown — leave left/right as reported
 
-    if not isinstance(result, dict):
-        return result
     result["is_playing"] = is_playing
     # When stopped AND stereo was requested, mark l/r as None so they
     # don't look like a killed signal

package/mcp_server/tools/scales.py

@@ -33,15 +33,27 @@ def get_song_scale(ctx: Context) -> dict:
 
 
 @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+).
+def set_song_scale(ctx: Context, root_note, scale_name: str) -> dict:
+    """Set the Song-level Scale Mode root + scale name (Live 12.0+, Live 12.4 compat).
 
-    root_note:   0-11 (C=0, C#=1, ... B=11)
-    scale_name:  must match one of Live's built-in scale names.
+    root_note:   int 0-11 (C=0, C#=1, ... B=11) OR note-name string like
+                 "C#", "F", "Bb". Both are accepted — BUG-2026-04-22#2 fix.
+    scale_name:  case-insensitive — matches Live's built-in scale names.
                  Call list_available_scales() first if unsure.
+
+    Live 12.4 note: Ableton dropped `Song.scale_names` from the Python LOM,
+    which made this tool and list_available_scales raise an INTERNAL error.
+    The remote script now falls back to the documented built-in scale list
+    when the attribute is missing — so both tools work on 12.4+ again.
     """
-    if not 0 <= root_note <= 11:
-        raise ValueError("root_note must be 0-11")
+    if isinstance(root_note, str):
+        if not root_note.strip():
+            raise ValueError("root_note string cannot be empty")
+    elif isinstance(root_note, int):
+        if not 0 <= root_note <= 11:
+            raise ValueError("root_note must be 0-11 (int) or a note name (str)")
+    else:
+        raise ValueError("root_note must be an int 0-11 or a note-name string")
     if not scale_name.strip():
         raise ValueError("scale_name cannot be empty")
     return _get_ableton(ctx).send_command("set_song_scale", {

package/mcp_server/tools/tracks.py

@@ -17,20 +17,30 @@ def _get_ableton(ctx: Context):
     return ctx.lifespan_context["ableton"]
 
 
-def _validate_track_index(track_index: int, allow_return: bool = True):
+MASTER_TRACK_INDEX = -1000  # mirrors remote_script/LivePilot/utils.py
+
+
+def _validate_track_index(track_index: int, allow_return: bool = True, allow_master: bool = True):
     """Validate track index.
 
-    Regular tracks: >= 0. Return tracks: -1 (A), -2 (B), etc.
+    Regular tracks: >= 0. Return tracks: -1 (A), -2 (B), etc. Master: -1000.
     Set allow_return=False for operations that only work on regular tracks
     (e.g., create_scene, set_group_fold).
+    Set allow_master=False for operations that don't make sense on master
+    (e.g., delete_track, set_track_arm).
     """
+    if track_index == MASTER_TRACK_INDEX:
+        if not allow_master:
+            raise ValueError("track_index=-1000 (master) is not supported for this operation")
+        return
     if track_index < 0:
         if not allow_return:
             raise ValueError("track_index must be >= 0 (return tracks not supported for this operation)")
         if track_index < -99:
             raise ValueError(
                 "track_index must be >= 0 for regular tracks, "
-                "or -1..-99 for return tracks (-1=A, -2=B)"
+                "-1..-99 for return tracks (-1=A, -2=B), "
+                "or -1000 for master"
             )
 
 
@@ -41,11 +51,89 @@ def _validate_color_index(color_index: int):
 
 @mcp.tool()
 def get_track_info(ctx: Context, track_index: int) -> dict:
-    """Get detailed info about a track: clips, devices, mixer state."""
+    """Get detailed info about a track: clips, devices, mixer state.
+
+    BUG-2026-04-22#11 FIX: track_index=-1000 (the master-track convention
+    used by set_track_volume, find_and_load_device, etc.) now dispatches
+    to the get_master_track endpoint instead of rejecting. This makes
+    -1000 work consistently across every track-addressing tool.
+    """
     _validate_track_index(track_index)
+    if track_index == MASTER_TRACK_INDEX:
+        return _get_ableton(ctx).send_command("get_master_track")
     return _get_ableton(ctx).send_command("get_track_info", {"track_index": track_index})
 
 
+@mcp.tool()
+def verify_device_alive(
+    ctx: Context,
+    track_index: int,
+    device_index: int,
+) -> dict:
+    """Check whether a loaded device is alive (BUG-2026-04-22 #19).
+
+    Static health check based on get_device_info — no test note required.
+    A device is considered DEAD when:
+      - class_name contains "PluginDevice" (AU/VST) AND parameter_count <= 1
+        (the shell loaded but the DSP engine crashed / wasn't activated)
+      - health_flags contains "opaque_or_failed_plugin"
+
+    Returns: {alive: bool, reason: str, parameter_count: int, class_name: str,
+              health_flags: list, recommendation: str | None}
+
+    The `recommendation` is a one-liner like "delete and load native
+    alternative" when the device is dead. None when alive.
+    """
+    _validate_track_index(track_index)
+    info = _get_ableton(ctx).send_command(
+        "get_device_info", {"track_index": track_index, "device_index": device_index},
+    )
+    if not isinstance(info, dict):
+        return {"alive": False, "reason": f"get_device_info returned non-dict: {info!r}"}
+
+    class_name = str(info.get("class_name", ""))
+    parameter_count = int(info.get("parameter_count", 0))
+    health_flags = list(info.get("health_flags", []))
+
+    if "PluginDevice" in class_name and parameter_count <= 1:
+        return {
+            "alive": False,
+            "reason": (
+                f"plugin_shell_no_dsp — class_name={class_name!r}, "
+                f"parameter_count={parameter_count}. The plugin host loaded "
+                f"the shell but the DSP engine did not activate (common "
+                f"after a crash or unauthorized AU/VST)."
+            ),
+            "parameter_count": parameter_count,
+            "class_name": class_name,
+            "health_flags": health_flags,
+            "recommendation": (
+                "Delete this device and load a native Ableton alternative "
+                "(Wavetable / Operator / Drift for synth, Reverb / Delay / "
+                "Compressor for FX)."
+            ),
+        }
+
+    if "opaque_or_failed_plugin" in health_flags:
+        return {
+            "alive": False,
+            "reason": "health_flags reports opaque_or_failed_plugin",
+            "parameter_count": parameter_count,
+            "class_name": class_name,
+            "health_flags": health_flags,
+            "recommendation": "Delete and replace with a native alternative.",
+        }
+
+    return {
+        "alive": True,
+        "reason": "passes static health checks",
+        "parameter_count": parameter_count,
+        "class_name": class_name,
+        "health_flags": health_flags,
+        "recommendation": None,
+    }
+
+
 @mcp.tool()
 def create_midi_track(
     ctx: Context,

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.14.1",
+  "version": "1.16.0",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 403 tools, 52 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 — 421 tools, 52 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,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.14.1"
+__version__ = "1.16.0"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router
@@ -26,6 +26,7 @@ from . import follow_actions    # noqa: F401  — registers follow action handle
 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 simpler_sample    # noqa: F401  — registers replace_sample_native (12.4+)
 from . import version_detect    # noqa: F401  — version detection