livepilot 1.23.4 → 1.23.6

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## v1.23.6 — 2026-04-30
+
+### Fixed
+
+- **`ensure_analyzer_on_master` cold-start disambiguation.** On a fresh Live boot the User Library browser cache is uncached, and `find_and_load_device("LivePilot_Analyzer")` can exceed the 20s recv timeout while BFS-ing the user library tree. The previous catch-block surfaced `status="install_required"` even though the .amxd is sitting at the canonical install path — sending the agent into a reinstall loop. New `_analyzer_amxd_installed_at_user_library()` filesystem check disambiguates: when the .amxd is present at `~/Music/Ableton/User Library/Presets/Audio Effects/Max Audio Effect/`, the tool now returns `status="cache_cold"` with a retry hint instead. Genuine missing-.amxd path still returns `install_required` correctly. (`mcp_server/tools/analyzer.py`)
+- **`set_compressor_sidechain` diagnostic depth.** When `_find_sidechain_surface` returns None on Compressor2 (Live 12.3.6+), the raised error now includes `class=...` + `canonical_parent.class=...` + a widened child-attribute walk (`input_routings`, `routing_inputs` added to the probe). Lets the next live failure leave a tighter trail so the actual Compressor2 LOM shape can be confirmed in one round trip rather than a separate probe session. No behavior change for legacy Compressor (I) or the two known Compressor2 hypotheses. (`remote_script/LivePilot/mixing.py`)
+- **`atlas_demo_story` production_decision class-name leak.** `harmonic-foundation` and `rhythmic-driver` role branches fell back to `primary_cls` when `user_name` was empty — producing useless prose like "InstrumentGroupDevice chosen as harmonic spine." Both branches now use `primary_uname or t_name or primary_cls`, matching the texture-role fallback that was already correct. (`mcp_server/atlas/demo_story.py`)
+- **`atlas_extract_chain` Macro N labeling on M4L devices.** The rack-device path already resolved producer-named macros via `resolve_preset_for_device`, but the M4L (.amxd) device path emitted raw `Macro N`. Now both paths cross-reference the preset sidecar — PitchLoop89's "Spectral Stretch" gets the proper name instead of "Macro 2" so `set_device_parameter` resolves at execution time. (`mcp_server/atlas/extract_chain.py`)
+- **Bundled atlas stats refresh.** `stats.enriched_devices` was stale at `87` (from a v1.21.x scan); the actual `enriched=True` flag count had grown to `135`. Recounted in place. No tool consumes the field with semantically-different behavior, but the stale stat had drifted past the soft-warn threshold's intent. (`mcp_server/atlas/device_atlas.json`)
+
+### Docs / drift
+
+- **`docs/M4L_BRIDGE.md`**: amxd ping reference and bridge-cmd count corrected — was `version: "1.23.1"` and "30 commands" from prior releases; now `1.23.6` and `32`.
+- **`livepilot/skills/livepilot-core/references/genre-vocabularies.md`**: added Synthwave / Retrowave / Outrun entry to match the 15-genre claim in CLAUDE.md/AGENTS.md (file had 14; the YAML packet at `concepts/genres/synthwave.yaml` had been the source-of-truth for v1.18+).
+
+### Tests
+
+- `tests/test_ensure_analyzer_on_master.py` — 2 new tests under `TestColdBrowserCacheDisambiguation` covering the cache-cold branch (`.amxd` present → cache_cold) and the install-required branch (`.amxd` absent → install_required). Existing `test_returns_install_required_when_device_not_in_browser` updated to monkeypatch the new path-check helper so it exercises the genuinely-not-installed path regardless of dev-machine state.
+- Total: **3409 passing**, 1 skipped, 0 failed (up from 3407 in v1.23.5).
+
+### Audit notes
+
+A full read-only audit pass against `BUGS.md` + `BUGS_TESTING_2026-04-30.md` confirmed that 14 of the bugs documented in those files were already fixed in v1.23.4's `bugfixes-2026-04-26` commit batch but never marked closed in the testing doc. No-ops here, but worth noting that the 38-bug list in the testing file is now ~5 genuinely-open items.
+
+## v1.23.5 — 2026-04-30
+
+### Fixed (Remote Script reliability — credit: PR #35 reporter)
+
+Two production-blocking bugs in the Remote Script that ship into the Ableton process. Reported by @juancarlosaxtro-hash in [PR #35](https://github.com/dreamrec/LivePilot/pull/35); reimplemented cleanly here with regression tests because the originally-submitted patch contained Python indentation errors that broke `transport.py` parse.
+
+- **TCP server now replaces stale clients instead of rejecting new connections.** Previously, when the MCP server restarted uncleanly (e.g. user relaunched Claude Desktop), the Remote Script's `recv()` loop didn't notice the disconnect for up to a second. During that window, the legitimate reconnect attempt was rejected with `STATE_ERROR("Another client is already connected")` — often requiring a full Ableton restart to recover. New behavior: when the accept loop sees a new connection while one is "active", it closes the stale socket from the accept loop, joins the old client thread (with 2 s timeout, OUTSIDE the lock so the thread's `finally` block can acquire it), then accepts the new connection. Single-client architecture means a new connection is proof the old one is dead. New `_current_client` field tracks the active socket so the accept loop can kick it; the `_run_client_session` finally only nulls `_current_client` if it still points at the closing client (the accept loop may have already replaced it). (`remote_script/LivePilot/server.py`)
+- **`get_session_info` no longer crashes on Group tracks.** `song.tracks` includes Group tracks, which raise a `RuntimeError` on `arm` / `has_midi_input` / `has_audio_input` access. `hasattr()` returns `True` regardless because Live's LOM doesn't use `AttributeError` — only try/except on the actual access works. Without the guard, any session with a Group track failed the entire session-info call with *"Main and Return Tracks have no 'Arm' state!"* Surgical try/except around the three LOM-fragile properties only; other fields (`name`, `color_index`, `mute`, `solo`) populate normally; the fragile ones return `None` on Group tracks. (`remote_script/LivePilot/transport.py`)
+
+### Tests
+- `tests/test_remote_server_single_client.py` — rewrote `test_second_client_gets_explicit_state_error` → `test_second_client_replaces_stale_connection` for the new kick-stale semantics.
+- `tests/test_remote_transport_group_tracks.py` — new file, 4 tests covering normal-track baseline, mixed Group+normal sessions, all-Group edge case, and non-fragile-field preservation. Hermetic loader stubs the Ableton-only `Live` module + `version_detect` helpers; autouse fixture restores `sys.modules` to prevent test pollution.
+- Total: **3407 passing**, 1 skipped, 0 failed (up from 3403 in v1.23.4).
+
+### CI green check
+- All 9 jobs green on commit `4aec8e6` (run `25174868624`): metadata-drift, js-entrypoint, amxd-freeze-drift, python-tests × {macos, ubuntu, windows} × {3.11, 3.12}.
+
 ## v1.23.4 — 2026-04-30
 
 ### Fixed (2026-04-30 live-test wave — 38 bugs surfaced, 36 fixed, 2 deferred to v1.23.5)

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.4";
+var VERSION = "1.23.6";
 
 // ── State ──────────────────────────────────────────────────────────────────
 

package/mcp_server/__init__.py

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

package/mcp_server/atlas/demo_story.py

@@ -608,19 +608,25 @@ def demo_story(
         primary_uname = primary_device.get("user_name") or ""
         nonzero = _count_nonzero_macros(devices)
 
+        # BUG-E5: when user_name is empty AND primary device is a Group/Rack
+        # device, primary_cls reads as "InstrumentGroupDevice" /
+        # "AudioEffectGroupDevice" — useless prose like "InstrumentGroupDevice
+        # chosen as harmonic spine". Fall back to track name first, then class.
+        primary_label = primary_uname or t_name or primary_cls or "<unknown>"
+
         if t_type == "ReturnTrack":
             prod_decision = (
-                f"{primary_cls} shared return — applies uniformly across all sends."
+                f"{primary_label} shared return — applies uniformly across all sends."
             )
         elif role == "harmonic-foundation":
             prod_decision = (
-                f"{primary_uname or primary_cls} chosen as harmonic spine; "
+                f"{primary_label} chosen as harmonic spine; "
                 f"{nonzero} macro(s) committed to specific values, "
                 "suggesting deliberate timbral targeting."
             )
         elif role == "rhythmic-driver":
             prod_decision = (
-                f"Drum rack '{primary_uname or primary_cls}' provides rhythmic drive. "
+                f"Drum rack '{primary_label}' provides rhythmic drive. "
                 f"{nonzero} non-default macro values indicate custom tuning."
             )
         elif role == "texture":

package/mcp_server/atlas/device_atlas.json

@@ -15,7 +15,7 @@
     "max_for_live": 523,
     "clips": 1000,
     "current_project": 60,
-    "enriched_devices": 87
+    "enriched_devices": 135
   },
   "devices": [
     {

package/mcp_server/atlas/extract_chain.py

@@ -492,18 +492,33 @@ def _emit_execution_steps(
             "device_index": device_index,
         })
         if fidelity != "structure-only" and macros:
+            # BUG-E2#1 (M4L path): producer-named macros on devices like
+            # PitchLoop89 ("Spectral Stretch") get raw "Macro N" labels here
+            # unless we cross-reference the preset sidecar — same as the rack
+            # path at line ~395. Without name resolution, set_device_parameter
+            # by name silently NOT-FOUNDs at execution time.
+            m4l_macro_names: dict[int, str] = {}
+            if uname and pack_name:
+                m4l_match = resolve_preset_for_device(pack_name, cls, uname)
+                m4l_macro_names = m4l_match.get("macro_names") or {}
             macro_subset = (
                 _get_nonzero_macros(macros)
                 if fidelity == "exact"
                 else _top_k_macros_by_deviation(macros, k=5)
             )
             for m in macro_subset:
+                resolved_name = m4l_macro_names.get(m["index"]) or f"Macro {m['index'] + 1}"
+                source_tag = (
+                    "als-parse+adg-parse"
+                    if resolved_name != f"Macro {m['index'] + 1}"
+                    else "als-parse"
+                )
                 steps.append({
                     "action": "set_device_parameter",
                     "device_index": device_index,
-                    "parameter_name": f"Macro {m['index'] + 1}",
+                    "parameter_name": resolved_name,
                     "value": round(_safe_float(m.get("value", "0")), 2),
-                    "comment": f"M4L macro {m['index'] + 1} [SOURCE: als-parse]",
+                    "comment": f"M4L macro {m['index'] + 1} [SOURCE: {source_tag}]",
                 })
         return steps, warnings
 

package/mcp_server/tools/analyzer.py

@@ -2003,6 +2003,31 @@ def _load_analyzer_impl(ctx, track_index: int, device_name: str,
     )
 
 
+def _analyzer_amxd_installed_at_user_library() -> bool:
+    """BUG-T#1: distinguish cold-browser-cache from genuinely-not-installed.
+
+    On a fresh Live boot the User Library browser tree is uncached, and
+    find_and_load_device can exceed the recv_timeout while doing the deep
+    BFS for ``LivePilot_Analyzer.amxd``. The catch-block then surfaces
+    ``install_required`` even though the .amxd is sitting at the canonical
+    install path. This helper does a cheap filesystem check so the caller
+    can return ``cache_cold`` (retry hint) instead of misleading the agent
+    into a reinstall loop.
+
+    Returns True iff a file named ``LivePilot_Analyzer.amxd`` exists under
+    the User Library Max Audio Effect directory.
+    """
+    from pathlib import Path
+    try:
+        path = (Path.home()
+                / "Music" / "Ableton" / "User Library"
+                / "Presets" / "Audio Effects" / "Max Audio Effect"
+                / f"{_ANALYZER_DEVICE_NAME}.amxd")
+        return path.is_file()
+    except Exception:
+        return False
+
+
 @mcp.tool()
 def ensure_analyzer_on_master(ctx: Context) -> dict:
     """Idempotent pre-flight: load LivePilot_Analyzer on master if missing.
@@ -2077,8 +2102,28 @@ def ensure_analyzer_on_master(ctx: Context) -> dict:
             allow_duplicate=False,
         )
     except Exception as exc:
-        # Typical path: device not in browser (user hasn't installed via
-        # install_m4l_device yet).
+        # BUG-T#1: distinguish two failure modes that look identical here:
+        #   (a) genuinely not installed — install_m4l_device path is right
+        #   (b) installed but Ableton's browser cache is cold (first call
+        #       after Live boot can exceed recv_timeout while BFS-ing the
+        #       User Library tree). In (b), pointing the agent at
+        #       install_m4l_device is wrong — the file is already there.
+        if _analyzer_amxd_installed_at_user_library():
+            return {
+                "status": "cache_cold",
+                "error": str(exc),
+                "hint": (
+                    "LivePilot_Analyzer.amxd is installed at "
+                    "~/Music/Ableton/User Library/Presets/Audio Effects/"
+                    "Max Audio Effect/, but the browser search timed out — "
+                    "Ableton's User Library cache is typically cold on the "
+                    "first call after a fresh Live boot. Retry "
+                    "ensure_analyzer_on_master once; the second call usually "
+                    "completes in <1s. If it keeps timing out, click any "
+                    "User Library entry in Ableton's browser to warm the "
+                    "cache, then retry."
+                ),
+            }
         return {
             "status": "install_required",
             "error": str(exc),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.23.4",
+  "version": "1.23.6",
   "mcpName": "io.github.dreamrec/livepilot",
   "description": "Agentic production system for Ableton Live 12 \u2014 453 tools, 54 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",

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.4"
+__version__ = "1.23.6"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router

package/remote_script/LivePilot/mixing.py

@@ -371,11 +371,17 @@ def _find_sidechain_surface(device):
 
 
 def _collect_routing_diagnostic(device):
-    """Return a CSV of routing/sidechain attrs on device + likely children.
+    """Return a structured trail of routing/sidechain attrs on device + likely children.
 
     Used as a breadcrumb in the error message when _find_sidechain_surface
     returns None, so the first failing call tells us what the current Live
     build actually exposes without a separate probe session.
+
+    BUG-A3 v2 (2026-04-30): the diagnostic now includes class_name and the
+    canonical_parent class so the next live-probe operator can immediately
+    tell whether they're looking at a Compressor / Compressor2 / something
+    else. Also widens the child-name search to include Live 12.x patterns
+    (input_routings, routing_inputs).
     """
     def _attrs(obj, prefix):
         try:
@@ -388,8 +394,23 @@ def _collect_routing_diagnostic(device):
             return []
         return [prefix + n for n in names]
 
+    parts = []
+    try:
+        parts.append("class=%s" % device.class_name)
+    except Exception:
+        pass
+    try:
+        cp = getattr(device, "canonical_parent", None)
+        if cp is not None:
+            parts.append("canonical_parent.class=%s" % type(cp).__name__)
+    except Exception:
+        pass
+
     found = list(_attrs(device, "device."))
-    for child_name in ("sidechain_input", "input", "sidechain", "routing"):
+    # Probe widened in v2 to include Live 12.x patterns. Order is
+    # least-to-most exotic so legacy shapes take precedence.
+    for child_name in ("sidechain_input", "input", "sidechain", "routing",
+                       "input_routings", "routing_inputs"):
         try:
             child = getattr(device, child_name, None)
         except Exception:
@@ -397,7 +418,12 @@ def _collect_routing_diagnostic(device):
         if child is None:
             continue
         found.extend(_attrs(child, "device.%s." % child_name))
-    return ", ".join(found) if found else "<none>"
+
+    if found:
+        parts.append("attrs=[%s]" % ", ".join(found))
+    else:
+        parts.append("attrs=<none>")
+    return " | ".join(parts) if parts else "<none>"
 
 
 @register("set_compressor_sidechain")

package/remote_script/LivePilot/server.py

@@ -86,6 +86,12 @@ class LivePilotServer(object):
         self._command_queue = queue.Queue()
         self._client_lock = threading.Lock()
         self._client_connected = False
+        # Track the active client socket so we can close it from the accept
+        # loop when a new connection arrives. See _server_loop's kick-stale
+        # flow — without this, an unclean MCP-server restart leaves the
+        # Remote Script in a state where new connections get rejected until
+        # the old socket times out (often requiring an Ableton restart).
+        self._current_client = None
 
     # ── Public API ───────────────────────────────────────────────────────
 
@@ -138,30 +144,35 @@ class LivePilotServer(object):
         while self._running:
             try:
                 client, addr = self._server_socket.accept()
+                # Single-client design: a new connection means the previous one
+                # is dead. Close the stale socket and join its thread (outside
+                # the lock so the thread's finally block can acquire it), then
+                # accept the new connection. Without this, the server could
+                # reject reconnections for up to 1s after an unclean MCP-server
+                # restart — the old recv() loop hadn't yet observed EOF.
+                stale_thread = None
+                stale_client = None
+                with self._client_lock:
+                    if self._client_connected and self._current_client is not None:
+                        stale_client = self._current_client
+                        stale_thread = self._client_thread
+                        self._log(
+                            "Replacing stale client with new connection from %s:%d" % addr
+                        )
+                if stale_client is not None:
+                    try:
+                        stale_client.close()
+                    except OSError:
+                        pass
+                if stale_thread is not None and stale_thread.is_alive():
+                    # 2s is generous — the old recv() unblocks the moment we
+                    # close the socket above, then the thread's finally block
+                    # acquires the lock, resets _client_connected, and exits.
+                    stale_thread.join(timeout=2)
+
                 with self._client_lock:
-                    if self._client_connected:
-                        # Reject concurrent clients with an explicit message
-                        self._log("Rejected client from %s:%d (another client is connected)" % addr)
-                        try:
-                            reject = json.dumps({
-                                "id": "system",
-                                "ok": False,
-                                "error": {
-                                    "code": "STATE_ERROR",
-                                    "message": "Another client is already connected. "
-                                               "LivePilot accepts one client at a time. "
-                                               "Disconnect the current client first."
-                                }
-                            }) + "\n"
-                            client.sendall(reject.encode("utf-8"))
-                        except OSError:
-                            pass
-                        try:
-                            client.close()
-                        except OSError:
-                            pass
-                        continue
                     self._client_connected = True
+                    self._current_client = client
                     self._client_thread = threading.Thread(
                         target=self._run_client_session,
                         args=(client, addr),
@@ -194,6 +205,11 @@ class LivePilotServer(object):
                 pass
             with self._client_lock:
                 self._client_connected = False
+                # Only clear _current_client if it still points at us — the
+                # accept loop may have already replaced us with a new client
+                # (in which case _current_client is the new socket).
+                if self._current_client is client:
+                    self._current_client = None
             self._log("Client disconnected")
 
     def _handle_client(self, client):

package/remote_script/LivePilot/transport.py

@@ -11,16 +11,26 @@ def get_session_info(song, params):
     """Return comprehensive session state."""
     tracks_info = []
     for i, track in enumerate(song.tracks):
-        tracks_info.append({
+        track_data = {
             "index": i,
             "name": track.name,
             "color_index": track.color_index,
-            "has_midi_input": track.has_midi_input,
-            "has_audio_input": track.has_audio_input,
             "mute": track.mute,
             "solo": track.solo,
-            "arm": track.arm,
-        })
+        }
+        # Group tracks (and any Return tracks that leak into song.tracks)
+        # don't expose `arm` / `has_midi_input` / `has_audio_input`. The
+        # Live Object Model raises a RuntimeError on access — and crucially
+        # `hasattr()` returns True regardless, so we must use try/except.
+        try:
+            track_data["arm"] = track.arm
+            track_data["has_midi_input"] = track.has_midi_input
+            track_data["has_audio_input"] = track.has_audio_input
+        except Exception:
+            track_data["arm"] = None
+            track_data["has_midi_input"] = None
+            track_data["has_audio_input"] = None
+        tracks_info.append(track_data)
 
     return_tracks_info = []
     for i, track in enumerate(song.return_tracks):

package/server.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/dreamrec/LivePilot",
     "source": "github"
   },
-  "version": "1.23.4",
+  "version": "1.23.6",
   "packages": [
     {
       "registryType": "npm",