livepilot 1.26.2 → 1.27.1

package/mcp_server/user_corpus/tools.py

@@ -50,6 +50,20 @@ from .plugin_engine.research import (
 )
 
 
+# ─── Inline plugin serialization helper ────────────────────────────────────────
+# corpus_detect_plugins persists the FULL plugin dict (incl. raw sdk_metadata =
+# entire moduleinfo.json / Info.plist) to _inventory.json. The inline MCP
+# response, however, only needs lightweight identity fields — returning the full
+# sdk_metadata for every plugin bloats the payload and duplicates the file.
+# Callers that need the raw metadata read it back from _inventory.json.
+
+
+def _slim_plugin(plugin_dict: dict) -> dict:
+    """Return a copy of a serialized DetectedPlugin without the heavy
+    ``sdk_metadata`` blob, for inline (non-persisted) MCP responses."""
+    return {k: v for k, v in plugin_dict.items() if k != "sdk_metadata"}
+
+
 # ─── Vendor canonicalization helpers (used by corpus_canonicalize_plugins) ───
 # Strips common vendor-suffix words ("DSP", "LLC", "GmbH", etc.) so different
 # spellings of the same vendor ("Valhalla DSP, LLC" + "Valhalladsp") collapse
@@ -390,7 +404,7 @@ def corpus_detect_plugins(
         )
 
     return {
-        "plugins": plugins_serialized,
+        "plugins": [_slim_plugin(p) for p in plugins_serialized],
         "totals": {"all": len(detected), "by_format": by_format},
         "inventory_path": str(inventory_path) if inventory_path else None,
         "search_paths": [str(p) for p, _ in default_plugin_dir()],
@@ -821,6 +835,7 @@ def corpus_research_targets(
 def corpus_emit_synthesis_briefs(
     ctx: Context,
     plugin_ids: list = None,
+    inline_limit: int = 5,
 ) -> dict:
     """Phase 4 — emit sonnet-subagent briefs for plugin identity synthesis.
 
@@ -832,10 +847,18 @@ def corpus_emit_synthesis_briefs(
     ----------
     plugin_ids : list of plugin_ids to emit briefs for. If empty, emits for
                  every plugin in the inventory.
+    inline_limit : maximum number of FULL briefs returned inline (default 5,
+                 matching the 'Cap parallel subagents at ~5' instruction).
+                 Any plugins beyond this cap are returned as lightweight stubs
+                 ({plugin_id, output_path}) in `deferred` so a single call can
+                 never return a multi-MB response over a large inventory. Pass
+                 explicit `plugin_ids` (or a larger inline_limit) to get the
+                 full brief for a specific batch.
 
     Returns
     -------
-    {briefs: [{plugin_id, brief, output_path}, ...], total}
+    {briefs: [{plugin_id, brief, output_path}, ...], deferred: [{plugin_id,
+     output_path}, ...], total, inline_count, inline_limit}
     """
     inventory_path = DEFAULT_OUTPUT_ROOT / "plugins" / "_inventory.json"
     if not inventory_path.exists():
@@ -844,7 +867,9 @@ def corpus_emit_synthesis_briefs(
     all_plugins = inventory.get("plugins", [])
 
     target_ids = set(plugin_ids) if plugin_ids else None
+    cap = inline_limit if inline_limit and inline_limit > 0 else 5
     briefs = []
+    deferred = []
     for plugin_dict in all_plugins:
         pid = plugin_dict.get("plugin_id")
         if target_ids is not None and pid not in target_ids:
@@ -866,21 +891,32 @@ def corpus_emit_synthesis_briefs(
         research_root = DEFAULT_OUTPUT_ROOT / "plugins" / pid / "research"
 
         brief = build_synthesis_brief(plugin, local_manual, research_root if research_root.exists() else None)
-        briefs.append({
-            "plugin_id": pid,
-            "brief": brief,
-            "output_path": brief["output_path"],
-        })
+        if len(briefs) < cap:
+            briefs.append({
+                "plugin_id": pid,
+                "brief": brief,
+                "output_path": brief["output_path"],
+            })
+        else:
+            deferred.append({
+                "plugin_id": pid,
+                "output_path": brief["output_path"],
+            })
 
     return {
         "briefs": briefs,
-        "total": len(briefs),
+        "deferred": deferred,
+        "total": len(briefs) + len(deferred),
+        "inline_count": len(briefs),
+        "inline_limit": cap,
         "instruction": (
             "For each brief: dispatch one sonnet subagent (Agent tool with "
             "subagent_type='general-purpose', model='sonnet') passing the brief "
             "as context. The subagent reads brief['synthesis_inputs'] and writes "
             "the YAML at brief['output_path']. Cap parallel subagents at ~5 to "
-            "avoid main-context bloat."
+            "avoid main-context bloat. Plugins beyond inline_limit are listed in "
+            "'deferred' as stubs — re-call corpus_emit_synthesis_briefs with their "
+            "plugin_ids to get the full briefs for the next batch."
         ),
     }
 

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,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.26.2",
+  "version": "1.27.1",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 465 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",
+  "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",
   "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.26.2"
+__version__ = "1.27.1"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router

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/version_detect.py

@@ -25,6 +25,9 @@ FEATURES = {
     "drum_chain_in_note": (12, 3, 0),
     "stem_separation": (12, 3, 0),
     "device_ab_compare": (12, 3, 0),
+    "link_audio": (12, 4, 0),
+    "stem_time_selection": (12, 4, 0),
+    "stem_merge_selected": (12, 4, 0),
     "replace_sample_native": (12, 4, 0),
     "groove_pool_api": (11, 0, 0),
     "rack_variations_api": (11, 0, 0),

package/requirements.txt

@@ -1,19 +1,19 @@
 # LivePilot MCP Server dependencies
 numpy>=2.4.6
-fastmcp>=3.3.1,<3.4.0  # pinned upper bound — _get_all_tools() accesses private internals
+fastmcp>=3.4.2,<3.5.0  # pinned upper bound — _get_all_tools() accesses private internals
 midiutil>=1.2.1
 pretty_midi>=0.2.11
 # v1.8 Perception Layer (offline analysis)
 pyloudnorm>=0.2.0
-soundfile>=0.13.1
+soundfile>=0.14.0
 scipy>=1.17.1
 mutagen>=1.47.0
 # v1.10.5 Splice online catalog integration — required, not optional.
 # Without these, SpliceGRPCClient silently disables itself and search_samples
 # 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.80.0
-protobuf>=7.35.0
+grpcio>=1.81.1
+protobuf>=7.35.1
 
 # Known benign warning during install:
 #   ERROR: pip's dependency resolver does not currently take into account

package/server.json

@@ -1,17 +1,17 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.dreamrec/livepilot",
-  "description": "465-tool agentic MCP production system for Ableton Live 12 \u2014 56 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": "467-tool agentic MCP production system for Ableton Live 12 \u2014 56 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.26.2",
+  "version": "1.27.1",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "livepilot",
-      "version": "1.26.2",
+      "version": "1.27.1",
       "transport": {
         "type": "stdio"
       }