livepilot 1.27.1 → 1.27.3

package/mcp_server/composer/develop/apply.py

@@ -73,7 +73,7 @@ async def _back_to_arranger(ctx: Any) -> dict:
     if ableton is None:
         return {"ok": False}
     try:
-        return ableton.send_command("back_to_arranger", {})
+        return await ableton.send_command_async("back_to_arranger", {})
     except Exception as exc:
         logger.warning("apply_develop: back_to_arranger failed: %s", exc)
         return {"ok": False}
@@ -148,10 +148,10 @@ async def apply_develop_plan(ctx: Context, plan: dict) -> dict:
     plan_tempo = plan.get("tempo")
     if plan_tempo is not None:
         try:
-            session = ableton.send_command("get_session_info", {})
+            session = await ableton.send_command_async("get_session_info", {})
             current_tempo = float(session.get("tempo", 0.0))
             if abs(current_tempo - float(plan_tempo)) > 0.01:
-                ableton.send_command("set_tempo", {"tempo": float(plan_tempo)})
+                await ableton.send_command_async("set_tempo", {"tempo": float(plan_tempo)})
         except Exception as exc:
             logger.warning("apply_develop: tempo set failed: %s", exc)
 
@@ -171,27 +171,27 @@ async def apply_develop_plan(ctx: Context, plan: dict) -> dict:
         try:
             # Optional sample swap (sample-trigger layers only)
             if sample_uri:
-                ableton.send_command(
+                await ableton.send_command_async(
                     "load_browser_item",
                     {"track_index": track_index, "uri": sample_uri},
                 )
                 sample_swaps += 1
 
             # Create clip
-            ableton.send_command(
+            await ableton.send_command_async(
                 "create_clip",
                 {"track_index": track_index, "clip_index": scene_index, "length": clip_length},
             )
 
             # Add notes (skip if empty — empty clip is a valid drum-dropout pattern)
             if notes:
-                ableton.send_command(
+                await ableton.send_command_async(
                     "add_notes",
                     {"track_index": track_index, "clip_index": scene_index, "notes": notes},
                 )
 
             # Name the clip
-            ableton.send_command(
+            await ableton.send_command_async(
                 "set_clip_name",
                 {"track_index": track_index, "clip_index": scene_index, "name": name},
             )

package/mcp_server/composer/fast/apply.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import time
 
@@ -22,13 +23,13 @@ def _is_drum_role(role: str) -> bool:
     return role.lower() in DRUM_ROLES
 
 
-def _detect_silent_load(ableton, track_index: int, device_index: int = 0) -> tuple:
+async def _detect_silent_load(ableton, track_index: int, device_index: int = 0) -> tuple:
     """Detect if the loaded device is silently misconfigured (empty container).
 
     Returns (is_silent: bool, reason: str).
     """
     try:
-        device_info = ableton.send_command("get_device_info", {
+        device_info = await ableton.send_command_async("get_device_info", {
             "track_index": track_index, "device_index": device_index,
         })
     except Exception:
@@ -44,7 +45,7 @@ def _detect_silent_load(ableton, track_index: int, device_index: int = 0) -> tup
     # Simpler with Sample Length near zero
     if class_name == "OriginalSimpler":
         try:
-            params_resp = ableton.send_command("get_device_parameters", {
+            params_resp = await ableton.send_command_async("get_device_parameters", {
                 "track_index": track_index, "device_index": device_index,
             })
             for p in params_resp.get("parameters", []):
@@ -60,7 +61,7 @@ def _detect_silent_load(ableton, track_index: int, device_index: int = 0) -> tup
     return False, ""
 
 
-def _apply_drum_role_repair(ableton, track_index: int, device_index: int = 0) -> dict:
+async def _apply_drum_role_repair(ableton, track_index: int, device_index: int = 0) -> dict:
     """Apply role-default repair to a drum-role layer's instrument.
 
     Defense in depth: load_browser_item's role='drum' silently fails to
@@ -83,7 +84,7 @@ def _apply_drum_role_repair(ableton, track_index: int, device_index: int = 0) ->
     """
     # Detect device class so we apply class-appropriate params
     try:
-        device_info = ableton.send_command("get_device_info", {
+        device_info = await ableton.send_command_async("get_device_info", {
             "track_index": track_index, "device_index": device_index,
         })
         class_name = device_info.get("class_name", "")
@@ -99,14 +100,19 @@ def _apply_drum_role_repair(ableton, track_index: int, device_index: int = 0) ->
         ])
 
     try:
-        result = ableton.send_command("batch_set_parameters", {
+        result = await ableton.send_command_async("batch_set_parameters", {
             "track_index": track_index,
             "device_index": device_index,
             "parameters": params_to_set,
         })
+        # P2-50: batch_set_parameters no longer raises on a per-entry failure —
+        # it returns {"ok": bool, "failed": M, ...}. Reflect the actual outcome
+        # instead of hardcoding applied=True (default True keeps pre-P2-50
+        # Remote Scripts that omit "ok" working).
         return {
-            "applied": True,
+            "applied": bool(result.get("ok", True)),
             "device_class": class_name,
+            "failed": result.get("failed", 0),
             "params": result.get("parameters", []),
         }
     except Exception as exc:
@@ -189,14 +195,14 @@ async def apply_fast_plan(
         logger.debug("fast apply: preflight failed (bridge unavailable): %s", exc)
 
     # Pre-flight: where do new tracks go, and which scene?
-    session = ableton.send_command("get_session_info", {})
+    session = await ableton.send_command_async("get_session_info", {})
     starting_track_count = int(session.get("track_count", 0))
     scene_count = int(session.get("scene_count", 0))
 
     # Optional tempo override
     if plan.get("tempo"):
         try:
-            ableton.send_command("set_tempo", {"tempo": float(plan["tempo"])})
+            await ableton.send_command_async("set_tempo", {"tempo": float(plan["tempo"])})
         except Exception as exc:
             logger.debug("apply: set_tempo failed: %s", exc)
 
@@ -216,7 +222,7 @@ async def apply_fast_plan(
     # returns ("A-Reverb") instead of remembering integer send indices.
     return_name_to_send_index: dict[str, int] = {}
     try:
-        returns_resp = ableton.send_command("get_return_tracks", {}) or {}
+        returns_resp = await ableton.send_command_async("get_return_tracks", {}) or {}
         for i, rt in enumerate(returns_resp.get("return_tracks", []) or []):
             name = (rt.get("name") or "").strip()
             if name:
@@ -243,7 +249,7 @@ async def apply_fast_plan(
 
         new_track_idx = starting_track_count + len(new_track_indices)
         try:
-            ableton.send_command("create_midi_track", {"index": -1, "name": track_name})
+            await ableton.send_command_async("create_midi_track", {"index": -1, "name": track_name})
         except Exception as exc:
             logger.warning("apply: create_midi_track(%s) failed: %s", track_name, exc)
             layer_results.append({
@@ -263,14 +269,14 @@ async def apply_fast_plan(
                 load_params: dict = {"track_index": new_track_idx, "uri": uri}
                 if simpler_role:
                     load_params["role"] = simpler_role
-                ableton.send_command("load_browser_item", load_params)
+                await ableton.send_command_async("load_browser_item", load_params)
                 loaded = True
             except Exception as exc:
                 logger.debug("apply: load_browser_item(%s, %s) failed: %s", new_track_idx, uri, exc)
 
             if loaded:
                 # v1.24 Phase 4 Task 18b: detect empty containers post-load
-                is_silent, silent_reason = _detect_silent_load(ableton, new_track_idx, device_index=0)
+                is_silent, silent_reason = await _detect_silent_load(ableton, new_track_idx, device_index=0)
                 if is_silent:
                     silent_load_warning = silent_reason
                     logger.warning(
@@ -282,7 +288,7 @@ async def apply_fast_plan(
                 # load_browser_item role='drum' silently skips Vol/Snap/root fixes
                 # when the track already has FX. Re-apply deterministically.
                 if _is_drum_role(role):
-                    role_repair = _apply_drum_role_repair(ableton, new_track_idx, device_index=0)
+                    role_repair = await _apply_drum_role_repair(ableton, new_track_idx, device_index=0)
                     if not role_repair.get("applied"):
                         logger.debug(
                             "apply: drum role repair failed for track %s: %s",
@@ -301,7 +307,7 @@ async def apply_fast_plan(
         clip_length_beats = max(bars * 4, int(max_end) + 1) if notes else bars * 4
 
         try:
-            ableton.send_command("create_clip", {
+            await ableton.send_command_async("create_clip", {
                 "track_index": new_track_idx,
                 "clip_index": target_scene,
                 "length": float(clip_length_beats),
@@ -317,7 +323,7 @@ async def apply_fast_plan(
         notes_added = 0
         if notes:
             try:
-                ableton.send_command("add_notes", {
+                await ableton.send_command_async("add_notes", {
                     "track_index": new_track_idx,
                     "clip_index": target_scene,
                     "notes": notes,
@@ -336,7 +342,7 @@ async def apply_fast_plan(
             if not device_name:
                 continue
             try:
-                ins_resp = ableton.send_command("insert_device", {
+                ins_resp = await ableton.send_command_async("insert_device", {
                     "track_index": new_track_idx,
                     "device_name": device_name,
                 }) or {}
@@ -346,7 +352,7 @@ async def apply_fast_plan(
                 if device_index is not None:
                     for pname, pvalue in (fx.get("params") or {}).items():
                         try:
-                            ableton.send_command("set_device_parameter", {
+                            await ableton.send_command_async("set_device_parameter", {
                                 "track_index": new_track_idx,
                                 "device_index": int(device_index),
                                 "parameter_name": str(pname),
@@ -396,7 +402,7 @@ async def apply_fast_plan(
                 })
                 continue
             try:
-                ableton.send_command("set_track_send", {
+                await ableton.send_command_async("set_track_send", {
                     "track_index": new_track_idx,
                     "send_index": int(send_index),
                     "value": value,
@@ -446,7 +452,7 @@ async def apply_fast_plan(
     # Fire the scene
     fired = False
     try:
-        ableton.send_command("fire_scene", {"scene_index": target_scene})
+        await ableton.send_command_async("fire_scene", {"scene_index": target_scene})
         fired = True
     except Exception as exc:
         logger.warning("apply: fire_scene(%s) failed: %s", target_scene, exc)
@@ -454,7 +460,7 @@ async def apply_fast_plan(
     # Final fresh-project cleanup: delete the leftover default track if
     # the brief left one in place to satisfy Ableton's "≥1 track" guard.
     final_cleanup_actions: list[str] = []
-    new_session = ableton.send_command("get_session_info", {})
+    new_session = await ableton.send_command_async("get_session_info", {})
     final_tracks = new_session.get("tracks", []) or []
     # If track 0 is still default-named and empty, AND we just added new
     # tracks, prune it now (we have ≥2 tracks total, safe to delete).
@@ -462,9 +468,9 @@ async def apply_fast_plan(
         first = final_tracks[0]
         if fast_compose.is_default_track_name(first.get("name", "")):
             try:
-                ti0 = ableton.send_command("get_track_info", {"track_index": 0})
+                ti0 = await ableton.send_command_async("get_track_info", {"track_index": 0})
                 if fast_compose.track_is_empty(ti0):
-                    ableton.send_command("delete_track", {"track_index": 0})
+                    await ableton.send_command_async("delete_track", {"track_index": 0})
                     final_cleanup_actions.append("deleted_leftover_default_track")
                     # All track indices shift down by 1
                     new_track_indices = [i - 1 for i in new_track_indices]

package/mcp_server/composer/fast/brief_builder.py

@@ -1402,8 +1402,12 @@ def build_creative_brief(
             "   — those are filtered out before the brief reaches you.\n"
             "5. **TIER-1: Fire each search in `recommended_searches` BEFORE designing\n"
             "   that role.** Each entry gives you a (tool, query) pair — call the named\n"
-            "   Ableton Knowledge MCP tool. Most queries hit the Live manual or video\n"
-            "   tutorials; capture 1 useful snippet per role and apply it.\n"
+            "   Ableton Knowledge MCP tool with the `mcp__Ableton_Knowledge__` prefix\n"
+            "   (e.g. search_live_manual → mcp__Ableton_Knowledge__search_live_manual).\n"
+            "   Most queries hit the Live manual or video tutorials; capture 1 useful\n"
+            "   snippet per role and apply it. The Ableton Knowledge MCP is OPTIONAL —\n"
+            "   if any mcp__Ableton_Knowledge__* tool is unavailable or returns nothing,\n"
+            "   skip it and proceed using the creative guidance alone.\n"
             "6. **TIER-2: If `reference_artist` is set**, also fire each search in\n"
             "   `reference_searches` and design USING that artist's signature techniques.\n"
             "7. For each layer: pick ONE uri from instruments_by_role[role], design\n"

package/mcp_server/composer/framework/atlas_resolver.py

@@ -541,8 +541,23 @@ class AtlasResolver:
     @staticmethod
     def _to_candidate(dev: dict, score: float, reasoning: str, *, source: str) -> AtlasCandidate:
         char_tags = list(dev.get("character_tags") or dev.get("tags") or [])
+        uri = dev.get("uri") or ""
+        # LIVE#3: M4L pack instruments carry a bogus `query:Synths#<Name>` atlas
+        # URI that load_browser_item can't resolve. Clear it for every resolver
+        # consumer (compose-full design / atlas_explore included) and note the
+        # preset fallback. Lazy import of the canonical ID set keeps a single
+        # source of truth without a module-load circular import.
+        try:
+            from mcp_server.atlas.tools import _M4L_PACK_SYNTH_IDS
+            if (dev.get("id") or "").lower() in _M4L_PACK_SYNTH_IDS and uri.startswith("query:Synths#"):
+                uri = ""
+                hint = ("M4L pack instrument — not directly loadable via "
+                        "query:Synths#; resolve via search_browser(path='sounds').")
+                reasoning = (reasoning + " | " + hint) if reasoning else hint
+        except Exception:
+            pass
         return AtlasCandidate(
-            uri=dev.get("uri") or "",
+            uri=uri,
             name=dev.get("name") or "",
             source=source,
             score=score,

package/mcp_server/composer/full/apply.py

@@ -329,7 +329,7 @@ async def apply_full_plan(
         )
 
     # ── Detect + clean default tracks ──────────────────────────────────
-    session = ableton.send_command("get_session_info", {})
+    session = await ableton.send_command_async("get_session_info", {})
     starting_track_count = int(session.get("track_count", 0))
 
     fresh_project = fast_compose.detect_fresh_project(session)
@@ -337,7 +337,7 @@ async def apply_full_plan(
         candidates: list[int] = []
         for i in range(starting_track_count):
             try:
-                ti = ableton.send_command("get_track_info", {"track_index": i})
+                ti = await ableton.send_command_async("get_track_info", {"track_index": i})
                 if fast_compose.track_is_empty(ti):
                     candidates.append(i)
             except Exception as exc:
@@ -350,7 +350,7 @@ async def apply_full_plan(
             deleted = 0
             for idx in deletable:
                 try:
-                    ableton.send_command("delete_track", {"track_index": idx})
+                    await ableton.send_command_async("delete_track", {"track_index": idx})
                     deleted += 1
                 except Exception as exc:
                     logger.debug("full apply: delete_track(%s) failed: %s", idx, exc)
@@ -414,18 +414,22 @@ async def apply_full_plan(
                 result = await _load_sample(ctx, **resolved_params)
             elif tool_name in ("create_midi_track", "create_audio_track"):
                 # Track the index so postflight can set monitoring on them
-                result = ableton.send_command(tool_name, resolved_params) or {}
+                result = await ableton.send_command_async(tool_name, resolved_params) or {}
                 if ok and isinstance(result, dict):
-                    track_idx = result.get("track_index")
+                    # create_midi_track/create_audio_track return {"index": N}
+                    # from the real Remote Script, not {"track_index": N} —
+                    # fall back to the legacy key for any mock that still
+                    # uses it.
+                    track_idx = result.get("index", result.get("track_index"))
                     if track_idx is not None:
                         created_track_indices.append(int(track_idx))
             elif tool_name in _FULL_PLAN_TCP_TOOLS:
                 # Direct Remote-Script TCP command
-                result = ableton.send_command(tool_name, resolved_params) or {}
+                result = await ableton.send_command_async(tool_name, resolved_params) or {}
             else:
                 # Unknown tool — try generic TCP send (most LivePilot tools
                 # have a 1:1 Remote-Script handler with the same name).
-                result = ableton.send_command(tool_name, resolved_params) or {}
+                result = await ableton.send_command_async(tool_name, resolved_params) or {}
         except Exception as exc:
             ok = False
             err_msg = str(exc)
@@ -456,14 +460,14 @@ async def apply_full_plan(
     # invalidate the indices below.
     final_cleanup_actions: list[str] = []
     try:
-        post_session = ableton.send_command("get_session_info", {})
+        post_session = await ableton.send_command_async("get_session_info", {})
         tracks = post_session.get("tracks", []) or []
         if tracks and len(tracks) > 1:
             default_indices: list[int] = []
             for i, t in enumerate(tracks):
                 if fast_compose.is_default_track_name(t.get("name", "")):
                     try:
-                        ti = ableton.send_command("get_track_info", {"track_index": i})
+                        ti = await ableton.send_command_async("get_track_info", {"track_index": i})
                         if fast_compose.track_is_empty(ti):
                             default_indices.append(i)
                     except Exception as exc:
@@ -475,7 +479,7 @@ async def apply_full_plan(
                 if len(tracks) - len(final_cleanup_actions) <= 1:
                     break
                 try:
-                    ableton.send_command("delete_track", {"track_index": idx})
+                    await ableton.send_command_async("delete_track", {"track_index": idx})
                     final_cleanup_actions.append(f"deleted_leftover_default_track_at_{idx}")
                 except Exception as exc:
                     logger.debug("full apply: final cleanup delete_track(%s) failed: %s", idx, exc)
@@ -620,7 +624,7 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
         if ab is None:
             return {"ok": False}
         try:
-            return ab.send_command(
+            return await ab.send_command_async(
                 "set_track_input_monitoring",
                 {"track_index": track_index, "state": state},
             )
@@ -646,7 +650,7 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
     fresh_cleanup_actions: list[str] = []
     try:
         from ..fast.brief_builder import detect_fresh_project, is_default_track_name
-        session_preflight = ableton.send_command("get_session_info", {})
+        session_preflight = await ableton.send_command_async("get_session_info", {})
         if detect_fresh_project(session_preflight):
             # Delete default tracks in REVERSE order to keep indices stable.
             # Ableton requires at least 1 track — keep the lowest-indexed default.
@@ -662,7 +666,7 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
             if len(default_indices) > 1:
                 for idx in default_indices[:-1]:
                     try:
-                        ableton.send_command("delete_track", {"track_index": idx})
+                        await ableton.send_command_async("delete_track", {"track_index": idx})
                         fresh_cleanup_actions.append(f"deleted_default_track_{idx}")
                     except Exception as exc:
                         logger.debug("apply_full_v2: delete_track(%d) failed: %s", idx, exc)
@@ -674,15 +678,15 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
     plan_key = plan.get("key")
     if plan_tempo is not None:
         try:
-            session = ableton.send_command("get_session_info", {})
+            session = await ableton.send_command_async("get_session_info", {})
             current_tempo = float(session.get("tempo", 0.0))
             if abs(current_tempo - float(plan_tempo)) > 0.01:
-                ableton.send_command("set_tempo", {"tempo": float(plan_tempo)})
+                await ableton.send_command_async("set_tempo", {"tempo": float(plan_tempo)})
         except Exception as exc:
             logger.warning("apply_full_v2: tempo set failed: %s", exc)
     if plan_key:
         try:
-            ableton.send_command("set_song_scale", {"root_note": plan_key})
+            await ableton.send_command_async("set_song_scale", {"root_note": plan_key})
         except Exception as exc:
             logger.debug("apply_full_v2: set_song_scale skipped: %s", exc)
 
@@ -702,7 +706,7 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
         track_index = track_spec.get("track_index")
         if track_index is None:
             try:
-                result = ableton.send_command(
+                result = await ableton.send_command_async(
                     "create_midi_track",
                     {"index": -1, "name": track_spec.get("role", "")},
                 )
@@ -733,7 +737,7 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
         instrument = track_spec.get("instrument") or {}
         if instrument.get("uri"):
             try:
-                ableton.send_command(
+                await ableton.send_command_async(
                     "load_browser_item",
                     {"track_index": track_index, "uri": instrument["uri"]},
                 )
@@ -754,7 +758,7 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
         track_role = track_spec.get("role", "")
         if _is_drum_role(track_role):
             try:
-                _apply_drum_role_repair(ableton, track_index, device_index=0)
+                await _apply_drum_role_repair(ableton, track_index, device_index=0)
             except Exception as exc:
                 logger.debug(
                     "apply_full_v2: drum_role_repair failed for track %s: %s",
@@ -769,7 +773,7 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
             if not device_name:
                 continue
             try:
-                ins_resp = ableton.send_command("insert_device", {
+                ins_resp = await ableton.send_command_async("insert_device", {
                     "track_index": track_index,
                     "device_name": device_name,
                 }) or {}
@@ -778,7 +782,7 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
                 if device_index is None:
                     # Fallback: query track and take the last device
                     try:
-                        track_info = ableton.send_command(
+                        track_info = await ableton.send_command_async(
                             "get_track_info", {"track_index": track_index}
                         )
                         device_index = len(track_info.get("devices", [])) - 1
@@ -786,7 +790,7 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
                         pass
                 for param_name, param_value in (effect_spec.get("params") or {}).items():
                     try:
-                        ableton.send_command("set_device_parameter", {
+                        await ableton.send_command_async("set_device_parameter", {
                             "track_index": track_index,
                             "device_index": int(device_index),
                             "parameter_name": str(param_name),
@@ -811,7 +815,9 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
             return_name = (send_spec.get("return_name") or "").strip()
             value = send_spec.get("value")
             send_index = send_spec.get("send_index")
-            if return_name is None and send_index is None:
+            # return_name is always a str (post-.strip()), never None — the
+            # real "no destination given" case is an empty string.
+            if not return_name and send_index is None:
                 continue
             try:
                 value = float(value or 0.0)
@@ -819,7 +825,7 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
                 continue
             if send_index is None and return_name:
                 try:
-                    session_info = ableton.send_command("get_session_info", {})
+                    session_info = await ableton.send_command_async("get_session_info", {})
                     return_tracks = session_info.get("return_tracks", []) or []
                     for i, rt in enumerate(return_tracks):
                         if (rt.get("name") or "").lower() == return_name.lower():
@@ -840,7 +846,7 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
                 })
                 continue
             try:
-                ableton.send_command("set_track_send", {
+                await ableton.send_command_async("set_track_send", {
                     "track_index": track_index,
                     "send_index": int(send_index),
                     "value": value,
@@ -922,18 +928,18 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
             slot = vi
             variant_id_to_slot[variant["id"]] = slot
             try:
-                ableton.send_command("create_clip", {
+                await ableton.send_command_async("create_clip", {
                     "track_index": track_index,
                     "clip_index": slot,
                     "length": 4.0,
                 })
                 if variant.get("notes"):
-                    ableton.send_command("add_notes", {
+                    await ableton.send_command_async("add_notes", {
                         "track_index": track_index,
                         "clip_index": slot,
                         "notes": variant["notes"],
                     })
-                ableton.send_command("set_clip_name", {
+                await ableton.send_command_async("set_clip_name", {
                     "track_index": track_index,
                     "clip_index": slot,
                     "name": variant["id"],
@@ -996,7 +1002,7 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
             # NEW FLOW: create ONE native arrangement clip spanning the full
             # section. Replaces create_arrangement_clip (session-clip duplication).
             try:
-                native_resp = ableton.send_command("create_native_arrangement_clip", {
+                native_resp = await ableton.send_command_async("create_native_arrangement_clip", {
                     "track_index": track_index,
                     "start_time": section_start_beats,
                     "length": section_length_beats,
@@ -1022,7 +1028,7 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
                 # clip start — same coordinate space the agent used).
                 if variant_notes:
                     try:
-                        ableton.send_command("add_arrangement_notes", {
+                        await ableton.send_command_async("add_arrangement_notes", {
                             "track_index": track_index,
                             "clip_index": new_clip_index,
                             "notes": variant_notes,
@@ -1038,7 +1044,7 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
                 # full section length (e.g. a 4-beat kick loops 16× in a 64-beat
                 # verse section without requiring 64 beats of notes).
                 try:
-                    ableton.send_command("set_clip_loop", {
+                    await ableton.send_command_async("set_clip_loop", {
                         "track_index": track_index,
                         "clip_index": new_clip_index,
                         "enabled": True,
@@ -1101,7 +1107,7 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
     # would survive cleanup.
     try:
         from ..fast.brief_builder import is_default_track_name as _is_default_track_name
-        session_post = ableton.send_command("get_session_info", {})
+        session_post = await ableton.send_command_async("get_session_info", {})
         all_tracks = session_post.get("tracks", [])
         # Skip tracks we just created — only target leftover/zombie tracks
         compose_track_indices = set(applied_track_indices)
@@ -1120,7 +1126,7 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
             # Indicates a leftover from a previous compose run that the
             # default-name detector missed.
             try:
-                track_info = ableton.send_command("get_track_info", {"track_index": idx})
+                track_info = await ableton.send_command_async("get_track_info", {"track_index": idx})
                 devices = track_info.get("devices", []) or []
                 clip_slots = track_info.get("clip_slots", []) or []
                 has_instrument = any(
@@ -1140,7 +1146,7 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
         # Delete in reverse-index order so indices stay stable
         for idx in sorted(candidate_indices, reverse=True):
             try:
-                ableton.send_command("delete_track", {"track_index": idx})
+                await ableton.send_command_async("delete_track", {"track_index": idx})
                 fresh_cleanup_actions.append(f"postflight_deleted_track_{idx}")
             except Exception as exc:
                 logger.debug("apply_full_v2: postflight delete_track(%s) failed: %s", idx, exc)