livepilot 1.23.2 → 1.23.3

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## v1.23.3 — 2026-04-25
+
+### Fixed
+- **`classify_simpler_slices` now classifies slices when `file_path` is omitted (the v1.12 follow-up, finally closed).** The tool's docstring promotes "Always run this before programming drum patterns on a sliced break", but the file_path lookup had been a no-op since v1.11 — wrapped in `try/except` with the comment *"Bridge command may not exist yet"* and a fallback error message *"v1.12 follow-up"*. End-to-end verification against Ableton 12.4 + a Splice sliced break ("ff_mch_122_drum_loop_first_perc.wav"): all 23 slices get correct `label` (KICK/SNARE/HAT/ghost) + spectral breakdown, no manual `file_path` argument needed.
+- **Pivot from M4L bridge to Remote Script TCP** for the file-path lookup. The bridge round-trip surfaced a chunked-response correlation issue under live testing (the second successive `bridge.send_command` returned the *previous* command's payload). The Remote Script handler reads `device.sample.file_path` directly via Live's Python LOM — no UDP packets, no chunk reassembly, no ambiguity. Implementation:
+  - `remote_script/LivePilot/simpler_sample.py` — adds `@register("get_simpler_file_path")` handler. Resolves the SimplerDevice (with Drum Rack chain support via optional `chain_index` / `nested_device_index`), reads `device.sample.file_path`, returns `{file_path, track_index, device_index, name, ...}`.
+  - `mcp_server/runtime/remote_commands.py` — registers `get_simpler_file_path` in `REMOTE_COMMANDS` (TCP path, primary). The pre-existing entry in `BRIDGE_COMMANDS` stays for forward-compat — `execution_router.classify_step` puts REMOTE_COMMANDS first, so plans route TCP, but the bridge case is still callable as a fallback.
+  - `mcp_server/tools/analyzer.py::classify_simpler_slices` — Remote Script TCP call is primary; M4L bridge `bridge.send_command("get_simpler_file_path", …)` is the fallback path. Surfaces the Remote Script's specific error verbatim (e.g. "Simpler.sample.file_path is empty — sample may be embedded") instead of the generic v1.12 message.
+  - `m4l_device/livepilot_bridge.js` — `case "get_simpler_file_path"` + `cmd_get_simpler_file_path()` remain in the .amxd freeze for the fallback path.
+- **ff29381 (carried forward)**: `insert_rack_chain` returns `chain_index` so `add_drum_rack_pad` no longer clobbers chain 0 on the second pad. Live-verified against an empty Drum Rack on Ableton 12.4 — three sequential `insert_rack_chain` calls (`chain_index=0`, then `1`, then `0` with `chain_count=3` after position-0 insert).
+
+### Improved
+- **CI freshness gate is now source-of-truth-aligned.** The `amxd-freeze-drift` job in `.github/workflows/ci.yml` previously grepped for `"version": "X.Y.Z"` (the runtime ping JSON form), which only landed in the .amxd via post-export binary patching. Since the v1.20-era refactor to `"version": VERSION` (variable reference), every release needed manual byte-patching to satisfy this gate. Now greps for `var VERSION = "X.Y.Z"` — the source-of-truth declaration in `bridge.js` that always survives a Max freeze. No more binary-patching hack required for plain version bumps.
+
+### Bridge surface
+- 31 → 32 cases (`get_simpler_file_path` added — used as forward-compat fallback only; primary path is Remote Script TCP).
+- ⚠️ Re-freeze required for the .amxd. New freeze at `m4l_device/LivePilot_Analyzer.amxd` (md5 changed) — distributed to `~/Music/Ableton/User Library/Presets/Audio Effects/Max Audio Effect/` and `~/Documents/Max 9/Library/`. Workflow memory `feedback_amxd_edit_via_maxpat.md` updated to clarify the project-folder JS (`~/Documents/Max 9/Max for Live Devices/<DeviceName> Project/code/livepilot_bridge.js`) is the authoritative path Max freezes from — NOT the user search path `~/Documents/Max 9/Code/`.
+
+### Remote Script
+- 191 → 193 handlers. `+1` for `get_simpler_file_path` (this release). The other +1 came from a prior session's reload-handler registration count.
+
+### Tests
+- `test_bugfixes_2026_04_25.py` (locks the `chain_index` contract from ff29381) — passes.
+- `test_analyzer_tools.py::test_classify_simpler_slices_returns_error_when_no_file_path` — updated to reflect the v1.23.3 error contract: when both Remote Script and bridge fall back, the Remote Script's specific error (e.g. "Simpler.sample.file_path is empty") is surfaced verbatim.
+- Full suite: 3180 passed, 1 skipped, 0 failed.
+
+### Live-test verification log (Ableton 12.4)
+- `classify_simpler_slices(track=4, device=0)` on a 23-slice WAV drum break with no `file_path` argument → returns full classification (KICK/HAT/ghost labels + spectral % per slice). ✓
+- `classify_simpler_slices` with explicit `file_path` argument → bypasses lookup, classifies normally. ✓
+- `insert_rack_chain` end-to-end on empty Drum Rack → `chain_index` derivation correct in all 3 branches (append-on-empty, append-on-N, position-0-on-N). ✓
+
 ## v1.23.2 — 2026-04-25
 
 ### Fixed

package/README.md

@@ -103,7 +103,7 @@ Most MCP servers are tool collections — they execute commands. LivePilot is an
 
 **MCP Server** (`mcp_server/`) — Python FastMCP server. Validates inputs, routes commands to the Remote Script over TCP, manages the M4L bridge, runs the atlas, sample engine, composer, and all intelligence engines. This is what your AI client connects to.
 
-**M4L Bridge** (`m4l_device/`) — Optional Max for Live Audio Effect on the master track. Provides deep LOM access through Max's LiveAPI that the ControlSurface API can't reach. UDP 9880 (M4L to server) carries spectral data and LiveAPI responses. OSC 9881 (server to M4L) sends commands. The 38 spectral/analyzer tools strictly require the bridge; device and sample tools that call the bridge also have graceful fallbacks, so core functionality works without it. Backed by 31 bridge commands for hidden parameters, Simpler internals, warp markers, display values, and Simpler warp / Compressor sidechain writes that live on child objects Python can't reach.
+**M4L Bridge** (`m4l_device/`) — Optional Max for Live Audio Effect on the master track. Provides deep LOM access through Max's LiveAPI that the ControlSurface API can't reach. UDP 9880 (M4L to server) carries spectral data and LiveAPI responses. OSC 9881 (server to M4L) sends commands. The 38 spectral/analyzer tools strictly require the bridge; device and sample tools that call the bridge also have graceful fallbacks, so core functionality works without it. Backed by 32 bridge commands for hidden parameters, Simpler internals, warp markers, display values, and Simpler warp / Compressor sidechain writes that live on child objects Python can't reach.
 
 **Device Atlas** (`mcp_server/atlas/`) — In-memory indexed JSON database. 5264 devices with browser URIs (bundled baseline), 120 enriched with YAML sonic intelligence profiles (mood, genre, texture, recommended chains). 7 indexes: by_id, by_name, by_uri, by_category, by_tag, by_genre, by_pack. Reverse-index `device_techniques_index.json` powers `atlas_techniques_for_device` (146 cross-references across 58 devices). The AI never hallucinates a device name or preset — it always resolves against the atlas first. **v1.22.0+**: run `scan_full_library` after install to index YOUR packs + User Library + plugins into `~/.livepilot/atlas/device_atlas.json` — your personal atlas overrides the baseline and survives npm updates.
 
@@ -202,7 +202,7 @@ Every engine follows: **measure before → act → measure after → compare**.
 
 <br>
 
-### M4L Bridge — 38 analyzer tools `[optional]`, 31 bridge commands
+### M4L Bridge — 38 analyzer tools `[optional]`, 32 bridge commands
 
 The M4L Analyzer sits on the master track. UDP 9880 carries spectral data to the server. OSC 9881 sends commands back. The `ensure_analyzer_on_master` pre-flight (v1.20.3) loads the analyzer idempotently on first use — call it once at session start and forget about it.
 

package/m4l_device/livepilot_bridge.js

@@ -34,7 +34,7 @@ outlets = 2; // 0: to udpsend (responses), 1: to buffer~/status
 // Single source of truth for the bridge version — bumped alongside the
 // rest of the release manifest. Surfaced in the UI via messnamed("livepilot_version", ...)
 // so the frozen .amxd visibly reports which build it was last exported from.
-var VERSION = "1.23.2";
+var VERSION = "1.23.3";
 
 // ── State ──────────────────────────────────────────────────────────────────
 
@@ -142,6 +142,9 @@ function dispatch(cmd, args) {
         case "get_simpler_slices":
             cmd_get_simpler_slices(args);
             break;
+        case "get_simpler_file_path":
+            cmd_get_simpler_file_path(args);
+            break;
         case "crop_simpler":
             cmd_simpler_action(args, "crop");
             break;
@@ -975,6 +978,41 @@ function cmd_get_simpler_slices(args) {
     });
 }
 
+function cmd_get_simpler_file_path(args) {
+    // Resolves the absolute file path of a Simpler's loaded sample.
+    // Mirrors cmd_get_clip_file_path's shape so analyzer.py can route both
+    // through the same response handler. Closes the v1.12 follow-up that
+    // left classify_simpler_slices unable to do its primary job
+    // (returning slice geometry without classification labels) when
+    // file_path wasn't passed explicitly.
+    var track_idx = parseInt(args[0]);
+    var device_idx = parseInt(args[1]);
+    var path = build_device_path(track_idx, device_idx);
+
+    cursor_a.goto(path);
+    if (cursor_a.get("class_name").toString() !== "OriginalSimpler") {
+        send_response({"error": "Not a Simpler device"});
+        return;
+    }
+
+    try {
+        cursor_b.goto(path + " sample");
+        var sample_path = cursor_b.get("file_path").toString();
+        if (!sample_path || sample_path === "0") {
+            send_response({"error": "Simpler has no sample loaded"});
+            return;
+        }
+        send_response({
+            "track": track_idx,
+            "device": device_idx,
+            "file_path": _to_posix_path(sample_path),
+            "name": cursor_a.get("name").toString()
+        });
+    } catch(e) {
+        send_response({"error": "Failed to read Simpler sample path: " + e.message});
+    }
+}
+
 function cmd_simpler_action(args, action) {
     var track_idx = parseInt(args[0]);
     var device_idx = parseInt(args[1]);

package/mcp_server/__init__.py

@@ -1,2 +1,2 @@
 """LivePilot MCP Server — bridges MCP protocol to Ableton Live."""
-__version__ = "1.23.2"
+__version__ = "1.23.3"

package/mcp_server/runtime/remote_commands.py

@@ -122,6 +122,13 @@ REMOTE_COMMANDS: frozenset[str] = frozenset({
     "ping",
     # Live 12.4+ native Simpler sample replacement (Collaborative tier)
     "replace_sample_native",
+    # v1.23.3: read Simpler.sample.file_path directly via Python LOM —
+    # primary path for classify_simpler_slices' auto-resolution. Beats
+    # the M4L bridge round-trip (which had a chunked-response correlation
+    # issue in live testing). The bridge case `get_simpler_file_path`
+    # remains as a forward-compat fallback in case Remote Script is
+    # somehow stale.
+    "get_simpler_file_path",
 })
 
 # M4L bridge commands — routed through TCP but handled by livepilot_bridge.js
@@ -130,6 +137,9 @@ 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
     "crop_simpler", "reverse_simpler", "warp_simpler",
     "get_warp_markers", "add_warp_marker", "move_warp_marker",
     "remove_warp_marker", "capture_audio", "capture_stop",

package/mcp_server/tools/analyzer.py

@@ -1018,10 +1018,11 @@ async def classify_simpler_slices(
 
     Parameters:
       track_index, device_index: the Simpler to analyze
-      file_path: (optional) explicit WAV path. If omitted, attempts
-        lookup via the bridge. Bridge-native resolution is limited in
-        v1.11 — when the sample lives in the Core Library, pass the
-        absolute path explicitly.
+      file_path: (optional) explicit WAV path. If omitted, the bridge
+        resolves it automatically via ``get_simpler_file_path``
+        (v1.23.3+). Pass explicitly only when running against an .amxd
+        freeze that predates the case (returns the bridge error string
+        in that case so the caller knows to re-freeze).
 
     Returns: dict with ``slices`` list. Each slice entry has:
       index, frame, seconds, midi_pitch (36+index), label, peak, rms,
@@ -1045,25 +1046,54 @@ async def classify_simpler_slices(
     if enriched is None:
         return {"error": "Bridge returned no slice data"}
 
-    # 2. Resolve file path
+    # 2. Resolve file path via Remote Script TCP path (v1.23.3+ — closes
+    # the v1.12 follow-up). Reads ``device.sample.file_path`` directly
+    # via Python LOM, more reliable than the M4L bridge UDP round-trip
+    # (which surfaced a chunked-response correlation issue under live
+    # testing). The bridge case `get_simpler_file_path` is still
+    # registered as a forward-compat fallback for environments where
+    # Remote Script is unavailable.
     wav_path = file_path
+    resolve_error: str | None = None
     if not wav_path:
-        try:
-            file_info = await bridge.send_command(
-                "get_simpler_file_path", track_index, device_index
-            )
-            if isinstance(file_info, dict):
-                wav_path = file_info.get("file_path")
-        except Exception:  # noqa: BLE001 — bridge command may not exist yet
-            wav_path = None
+        ableton = ctx.request_context.lifespan_context.get("ableton")
+        if ableton is not None:
+            try:
+                rs_resp = ableton.send_command(
+                    "get_simpler_file_path",
+                    {"track_index": track_index, "device_index": device_index},
+                )
+                if isinstance(rs_resp, dict):
+                    wav_path = rs_resp.get("file_path")
+                    resolve_error = rs_resp.get("error")
+            except Exception as exc:  # noqa: BLE001
+                resolve_error = f"remote_script unreachable: {exc}"
+                wav_path = None
+        else:
+            resolve_error = "no ableton TCP connection"
+
+        # Fallback: try the M4L bridge if Remote Script didn't yield a path.
+        # Useful if a stale Remote Script install lacks the new handler
+        # (the user can call reload_handlers to refresh without restart).
+        if not wav_path:
+            try:
+                bridge_resp = await bridge.send_command(
+                    "get_simpler_file_path", track_index, device_index
+                )
+                if isinstance(bridge_resp, dict):
+                    bridge_path = bridge_resp.get("file_path")
+                    if bridge_path:
+                        wav_path = bridge_path
+                        resolve_error = None
+            except Exception:  # noqa: BLE001 — defensive
+                pass
 
     if not wav_path:
         return {
             **enriched,
             "error": (
-                "No file_path available — pass file_path= explicitly. "
-                "Bridge-based lookup for Simpler sample paths is a v1.12 "
-                "follow-up."
+                resolve_error
+                or "No file_path available — pass file_path= explicitly."
             ),
         }
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.23.2",
+  "version": "1.23.3",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 433 tools, 53 domains, 44 semantic moves. Device atlas (5264 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, technique memory, 12 creative intelligence engines",
+  "description": "Agentic production system for Ableton Live 12 \u2014 433 tools, 53 domains, 44 semantic moves. Device atlas (5264 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, technique memory, 12 creative intelligence 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.23.2"
+__version__ = "1.23.3"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router

package/remote_script/LivePilot/devices.py

@@ -618,11 +618,20 @@ def insert_rack_chain(song, params):
         song.end_undo_step()
 
     chain_count = len(list(device.chains))
+    # BUG-2026-04-25: callers (notably add_drum_rack_pad) expect
+    # `chain_index` in the response so they can target the new chain in
+    # subsequent set_drum_chain_note + insert_device calls. Without it,
+    # the caller falls back to chain_index=0 and overwrites/clobbers the
+    # first chain. For position=-1 (append), the new chain lives at
+    # chain_count - 1; for explicit position N (0-indexed), the new
+    # chain lives at N (insert_chain shifts later chains right).
+    new_chain_index = position if 0 <= position < chain_count else chain_count - 1
     result = {
         "inserted": True,
         "track_index": track_index,
         "device_index": device_index,
         "chain_count": chain_count,
+        "chain_index": new_chain_index,
     }
     if assigned_note is not None:
         result["assigned_pad_note"] = assigned_note

package/remote_script/LivePilot/simpler_sample.py

@@ -184,3 +184,101 @@ def replace_sample_native(song, params):
         "method": "native_12_4",
         "live_version": version_string(),
     }
+
+
+@register("get_simpler_file_path")
+def get_simpler_file_path(song, params):
+    """Read the absolute file path of a Simpler's currently-loaded sample.
+
+    Closes the v1.12 follow-up that left ``classify_simpler_slices`` unable
+    to auto-resolve the WAV path: previously the call routed through the
+    M4L bridge ``get_simpler_file_path`` case (added in v1.23.3 JS) but
+    Live's M4L UDP response correlation produced wrong-data on the second
+    successive bridge call (a chunked-response edge case under
+    investigation in the bridge wire protocol). The Remote Script reads
+    ``device.sample.file_path`` directly via Python LOM — no UDP, no Max
+    JS, no chunk reassembly, no ambiguity.
+
+    params dict keys:
+        track_index (int): 0-based index into song.tracks.
+        device_index (int): 0-based index into track.devices.
+        chain_index (int|None): optional, for nested Drum Rack chains.
+        nested_device_index (int|None): optional, position inside the chain.
+
+    Returns on success:
+        file_path (str): absolute filesystem path of the loaded sample.
+        track_index, device_index, chain_index, nested_device_index: echoed.
+        name (str): Simpler device name (typically the sample filename).
+
+    Returns on error:
+        error (str): human-readable message.
+        code (str): STATE_ERROR | INDEX_ERROR | INVALID_PARAM.
+    """
+    try:
+        track_index = int(params["track_index"])
+        device_index = int(params["device_index"])
+    except (KeyError, TypeError, ValueError) as exc:
+        return {
+            "error": "Invalid params: " + str(exc),
+            "code": "INVALID_PARAM",
+        }
+
+    chain_index = params.get("chain_index")
+    nested_device_index = params.get("nested_device_index")
+    if chain_index is not None:
+        try:
+            chain_index = int(chain_index)
+        except (TypeError, ValueError):
+            return {
+                "error": "chain_index must be an integer if provided",
+                "code": "INVALID_PARAM",
+            }
+    if nested_device_index is not None:
+        try:
+            nested_device_index = int(nested_device_index)
+        except (TypeError, ValueError):
+            return {
+                "error": "nested_device_index must be an integer if provided",
+                "code": "INVALID_PARAM",
+            }
+
+    device, err = _resolve_simpler_device(
+        song, track_index, device_index, chain_index, nested_device_index,
+    )
+    if err is not None:
+        return err
+
+    class_name = getattr(device, "class_name", "")
+    if class_name != "OriginalSimpler":
+        return {
+            "error": "Device at resolved path is " + class_name + ", not Simpler",
+            "code": "INVALID_PARAM",
+        }
+
+    sample = getattr(device, "sample", None)
+    if sample is None:
+        return {
+            "error": "Simpler has no sample loaded (device.sample is None)",
+            "code": "STATE_ERROR",
+        }
+
+    file_path = getattr(sample, "file_path", None)
+    if not file_path:
+        return {
+            "error": (
+                "Simpler.sample.file_path is empty — sample may be embedded "
+                "in the Set or otherwise lacks a filesystem path."
+            ),
+            "code": "STATE_ERROR",
+        }
+
+    name = getattr(device, "name", "")
+
+    return {
+        "file_path": str(file_path),
+        "track_index": track_index,
+        "device_index": device_index,
+        "chain_index": chain_index,
+        "nested_device_index": nested_device_index,
+        "name": str(name),
+    }

package/server.json

@@ -1,12 +1,12 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.dreamrec/livepilot",
-  "description": "433-tool agentic MCP production system for Ableton Live 12 — 53 domains, 44 semantic moves, device atlas (5264 devices), Splice intelligence (gRPC + GraphQL), 9-band spectral perception auto-loaded, Creative Director skill, technique memory, 12 creative engines",
+  "description": "433-tool agentic MCP production system for Ableton Live 12 \u2014 53 domains, 44 semantic moves, device atlas (5264 devices), Splice intelligence (gRPC + GraphQL), 9-band spectral perception auto-loaded, Creative Director skill, technique memory, 12 creative engines",
   "repository": {
     "url": "https://github.com/dreamrec/LivePilot",
     "source": "github"
   },
-  "version": "1.23.2",
+  "version": "1.23.3",
   "packages": [
     {
       "registryType": "npm",