livepilot 1.27.0 → 1.27.2

package/mcp_server/wonder_mode/tools.py

@@ -17,13 +17,20 @@ from . import engine
 logger = logging.getLogger(__name__)
 
 
-def _build_synth_profiles_for_wonder(ctx, request_text: str, diagnosis: dict) -> list:
+def _build_synth_profiles_for_wonder(
+    ctx, request_text: str, diagnosis: dict, session_info: dict | None = None
+) -> list:
     """Build SynthProfile objects for every track holding a native synth.
 
     Wires the synthesis_brain producer into enter_wonder_mode's runtime
     flow — without this helper, ``propose_synth_branches`` is registered
     but unreachable from the MCP surface.
 
+    ``session_info``: optional pre-fetched get_session_info payload. When
+    a non-empty dict is supplied the helper reuses it instead of issuing
+    its own round-trip on the single-client TCP socket. Callers should
+    always thread the shared payload to avoid redundant fetches.
+
     Returns a list of SynthProfile objects (possibly empty). All errors
     are swallowed and logged — missing devices, disconnected Ableton,
     unsupported devices all land as "no synth branches" rather than
@@ -39,11 +46,16 @@ def _build_synth_profiles_for_wonder(ctx, request_text: str, diagnosis: dict) ->
     if ableton is None:
         return []
 
-    try:
-        session = ableton.send_command("get_session_info", {})
-    except Exception as exc:
-        logger.debug("session fetch for synth profiles failed: %s", exc)
-        return []
+    # Reuse the pre-fetched session payload when available; only fall back
+    # to a fresh round-trip when called without one.
+    if isinstance(session_info, dict) and session_info and "error" not in session_info:
+        session = session_info
+    else:
+        try:
+            session = ableton.send_command("get_session_info", {})
+        except Exception as exc:
+            logger.debug("session fetch for synth profiles failed: %s", exc)
+            return []
     if not isinstance(session, dict) or "error" in session:
         return []
 
@@ -164,21 +176,35 @@ def _get_ledger_entries(ctx: Context) -> list[dict]:
         return []
 
 
-def _get_stuckness_report(ctx: Context, song_brain: dict) -> dict | None:
-    """Run stuckness detection on recent actions if available."""
+def _get_stuckness_report(
+    ctx: Context,
+    song_brain: dict,
+    action_ledger: list[dict] | None = None,
+    session_info: dict | None = None,
+) -> dict | None:
+    """Run stuckness detection on recent actions if available.
+
+    ``action_ledger`` and ``session_info`` may be supplied pre-fetched by
+    the caller. enter_wonder_mode already fetches both once at the top of
+    the flow, so threading them here avoids a duplicate ledger read and a
+    redundant get_session_info round-trip on the single-client TCP socket.
+    """
     try:
         from ..stuckness_detector.detector import detect_stuckness
-        action_ledger = _get_ledger_entries(ctx)
+        if action_ledger is None:
+            action_ledger = _get_ledger_entries(ctx)
         if not action_ledger:
             return None
-        # Pass session_info if available for better accuracy
-        session_info = {}
-        try:
-            ableton = ctx.lifespan_context.get("ableton")
-            if ableton:
-                session_info = ableton.send_command("get_session_info", {})
-        except Exception as exc:
-            logger.warning("session_info fetch for stuckness failed: %s", exc)
+        # Reuse the pre-fetched session payload; only round-trip if the
+        # caller did not supply one.
+        if session_info is None:
+            session_info = {}
+            try:
+                ableton = ctx.lifespan_context.get("ableton")
+                if ableton:
+                    session_info = ableton.send_command("get_session_info", {})
+            except Exception as exc:
+                logger.warning("session_info fetch for stuckness failed: %s", exc)
         report = detect_stuckness(
             action_history=action_ledger,
             session_info=session_info,
@@ -218,7 +244,24 @@ def enter_wonder_mode(
     taste_graph = _get_taste_graph(ctx)
     active_constraints = _get_active_constraints()
     action_ledger = _get_ledger_entries(ctx)
-    stuckness_report = _get_stuckness_report(ctx, song_brain)
+
+    # Single get_session_info round-trip for the whole flow. The Remote
+    # Script is single-client on TCP 9878, so each redundant fetch is a
+    # serialized round-trip — fetch once and thread the payload into the
+    # stuckness report, the kernel dict, and the synth-profile builder.
+    session_info: dict = {}
+    try:
+        ableton = ctx.lifespan_context.get("ableton")
+        if ableton:
+            session_info = ableton.send_command("get_session_info", {})
+    except Exception as exc:
+        logger.warning("session_info fetch failed: %s", exc)
+    if not isinstance(session_info, dict) or "error" in session_info:
+        session_info = {}
+
+    stuckness_report = _get_stuckness_report(
+        ctx, song_brain, action_ledger=action_ledger, session_info=session_info
+    )
 
     # 1. Build diagnosis
     diagnosis = build_diagnosis(
@@ -249,14 +292,8 @@ def enter_wonder_mode(
             # Graceful degradation — analytical variants still work
             logger.warning("sample opportunity search failed: %s", exc)
 
-    # 1c. Get session info for kernel
-    session_info = {}
-    try:
-        ableton = ctx.lifespan_context.get("ableton")
-        if ableton:
-            session_info = ableton.send_command("get_session_info", {})
-    except Exception as exc:
-        logger.warning("session_info fetch for kernel failed: %s", exc)
+    # 1c. session_info for the kernel was already fetched once above and
+    # threaded into the stuckness report — reuse it here, no extra round-trip.
 
     # 2. Generate variants (legacy path)
     result = engine.generate_wonder_variants(
@@ -291,7 +328,9 @@ def enter_wonder_mode(
     # track that holds a native synth. Lets propose_synth_branches reach
     # the runtime — without this the producer is dark despite being
     # registered in the conductor.
-    synth_profiles = _build_synth_profiles_for_wonder(ctx, request_text, diag_dict)
+    synth_profiles = _build_synth_profiles_for_wonder(
+        ctx, request_text, diag_dict, session_info=session_info
+    )
 
     # Composer branches fire when the base conductor routes to
     # composition — otherwise we'd be emitting composition scaffolding

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.27.0",
+  "version": "1.27.2",
   "mcpName": "io.github.dreamrec/livepilot",
   "description": "Agentic production system for Ableton Live 12 — 467 tools, 56 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.27.0"
+__version__ = "1.27.2"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router
@@ -98,22 +98,28 @@ def _force_reload_handlers(cs=None):
         except Exception:
             pass
 
+    failures = []
+
     try:
         importlib.reload(router)
     except Exception as exc:
-        _log("reload(router) FAILED — %s: %s" % (type(exc).__name__, exc))
+        msg = "reload(router) FAILED — %s: %s" % (type(exc).__name__, exc)
+        _log(msg)
+        failures.append(("LivePilot.router", "%s: %s" % (type(exc).__name__, exc)))
 
     try:
         importlib.reload(utils)
     except Exception as exc:
-        _log("reload(utils) FAILED — %s: %s" % (type(exc).__name__, exc))
+        msg = "reload(utils) FAILED — %s: %s" % (type(exc).__name__, exc)
+        _log(msg)
+        failures.append(("LivePilot.utils", "%s: %s" % (type(exc).__name__, exc)))
 
     # Invalidate caches so iter_modules sees newly-added files even if
     # an importer cached the previous directory listing.
     importlib.invalidate_caches()
     pkg = _sys.modules.get("LivePilot")
     if pkg is None or getattr(pkg, "__path__", None) is None:
-        return
+        return {"discovered": 0, "reloaded": 0, "first_imported": 0, "failures": failures}
 
     discovered = reloaded = first_imported = 0
     for _finder, modname, _is_pkg in pkgutil.iter_modules(pkg.__path__):
@@ -130,8 +136,9 @@ def _force_reload_handlers(cs=None):
                 importlib.import_module(full_name)
                 first_imported += 1
         except Exception as exc:
-            _log("reload(%s) FAILED — %s: %s" % (
-                full_name, type(exc).__name__, exc))
+            msg = "reload(%s) FAILED — %s: %s" % (full_name, type(exc).__name__, exc)
+            _log(msg)
+            failures.append((full_name, "%s: %s" % (type(exc).__name__, exc)))
 
     # reload_handlers_cmd lives in __init__.py (not a handler module),
     # so the step-3 loop does not cover it. Re-register manually.
@@ -140,15 +147,21 @@ def _force_reload_handlers(cs=None):
     _log("reload complete — %d discovered (%d reloaded, %d first-imported)" % (
         discovered, reloaded, first_imported))
 
+    return {"discovered": discovered, "reloaded": reloaded,
+            "first_imported": first_imported, "failures": failures}
+
 
 def reload_handlers_cmd(song, params):
     """TCP-accessible reload trigger. Lets automation refresh handlers
     without a UI Control Surface toggle — the core dev-loop improvement.
-    Returns the handler count so the caller can assert before/after."""
-    _force_reload_handlers(cs=None)
+    Returns the handler count so the caller can assert before/after.
+    Returns any reload failures so the caller can detect silent errors."""
+    result = _force_reload_handlers(cs=None)
+    failures = result.get("failures", []) if isinstance(result, dict) else []
     return {
         "reloaded": True,
         "handler_count": len(router._handlers),
+        "errors": [{"module": m, "error": e} for m, e in failures],
     }
 
 

package/remote_script/LivePilot/server.py

@@ -346,9 +346,14 @@ class LivePilotServer(object):
         else:
             timeout = 10
 
-        # Per-command response queue
+        # Per-command response queue + cancellation flag. The flag is shared
+        # between this TCP thread and the main thread that dequeues the item:
+        # if we time out below, we set it so _process_next_command skips the
+        # (now-abandoned) dispatch instead of mutating Live after the client
+        # has already been told the command timed out (phantom write).
         response_queue = queue.Queue()
-        self._command_queue.put((command, response_queue))
+        cancelled = threading.Event()
+        self._command_queue.put((command, response_queue, cancelled))
 
         # Schedule processing on Ableton's main thread
         try:
@@ -385,6 +390,13 @@ class LivePilotServer(object):
         try:
             resp = response_queue.get(timeout=timeout)
         except queue.Empty:
+            # Mark the queued command as abandoned. If it hasn't been dequeued
+            # yet (or is awaiting its settle hop), _process_next_command sees
+            # the flag and skips router.dispatch — preventing a write that the
+            # client was just told timed out from executing on Live's main
+            # thread later. If dispatch already happened, setting the flag is
+            # a harmless no-op.
+            cancelled.set()
             resp = {
                 "id": request_id,
                 "ok": False,
@@ -399,10 +411,18 @@ class LivePilotServer(object):
         """Called on Ableton's main thread via schedule_message.
         Processes one command from the queue."""
         try:
-            command, response_queue = self._command_queue.get_nowait()
+            command, response_queue, cancelled = self._command_queue.get_nowait()
         except queue.Empty:
             return
 
+        # The TCP thread already gave up on this command (timed out) and told
+        # the client so. Do NOT dispatch it — running the write now would be a
+        # phantom mutation. Nobody is waiting on response_queue, so just keep
+        # the main-thread pump alive by draining whatever is left.
+        if cancelled.is_set():
+            self._drain_queue()
+            return
+
         cmd_type = command.get("type", "")
         is_write = is_write_command(cmd_type)
 

package/remote_script/LivePilot/tracks.py

@@ -91,12 +91,18 @@ def get_track_info(song, params):
     if track.is_foldable:
         result["fold_state"] = bool(track.fold_state)
 
-    # Regular tracks have arm and input type; return tracks get null values
+    # Regular tracks expose arm + input type; Group/Return/Master tracks raise
+    # RuntimeError on these LOM properties. hasattr() does NOT catch it (Live
+    # raises rather than omitting the attribute), so a Group track at a positive
+    # index used to crash get_track_info. Guard each access — mirrors the
+    # transport.py get_session_info fix (commit 4aec8e6, closing PR #35).
     if track_index >= 0:
-        result["arm"] = track.arm
-        result["has_midi_input"] = track.has_midi_input
-        result["has_audio_input"] = track.has_audio_input
-        result["current_monitoring_state"] = track.current_monitoring_state
+        for _prop in ("arm", "has_midi_input", "has_audio_input",
+                      "current_monitoring_state"):
+            try:
+                result[_prop] = getattr(track, _prop)
+            except Exception:
+                result[_prop] = None
     else:
         result["arm"] = None
         result["has_midi_input"] = None

package/requirements.txt

@@ -13,7 +13,7 @@ mutagen>=1.47.0
 # falls back to the SQLite sounds.db which only returns locally downloaded
 # samples (see docs/2026-04-14-bugs-discovered.md — P0-2).
 grpcio>=1.81.1
-protobuf>=7.35.0
+protobuf>=7.35.1
 
 # Known benign warning during install:
 #   ERROR: pip's dependency resolver does not currently take into account

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/dreamrec/LivePilot",
     "source": "github"
   },
-  "version": "1.27.0",
+  "version": "1.27.2",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "livepilot",
-      "version": "1.27.0",
+      "version": "1.27.1",
       "transport": {
         "type": "stdio"
       }