livepilot 1.10.7 → 1.10.8

package/mcp_server/semantic_moves/mix_compilers.py

@@ -282,6 +282,173 @@ def _compile_reduce_repetition(move: SemanticMove, kernel: dict) -> CompiledPlan
     )
 
 
+def _compile_make_kick_bass_lock(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'make_kick_bass_lock': carve space between kick and bass.
+
+    Strategy: reduce bass level slightly (clears sub for kick), verify both
+    tracks remain active. Sidechain compressor insertion is left as a future
+    step — it requires device selection + parameter mapping that varies too
+    much across projects to hardcode safely.
+    """
+    steps: list[CompiledStep] = []
+    warnings: list[str] = []
+    descriptions: list[str] = []
+
+    bass_tracks = resolvers.find_tracks_by_role(kernel, ["bass"])
+    kick_tracks = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
+
+    if not bass_tracks:
+        warnings.append("No bass track found — cannot lock kick and bass")
+    if not kick_tracks:
+        warnings.append("No kick/drum track found — reference track missing")
+
+    steps.append(CompiledStep(
+        tool="get_master_spectrum",
+        params={},
+        description="Read current sub/low balance before carving",
+        verify_after=False,
+    ))
+
+    if bass_tracks:
+        bass = bass_tracks[0]
+        idx = bass["index"]
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": idx, "volume": 0.60},
+            description=f"Pull {bass['name']} to 0.60 to clear sub for kick",
+        ))
+        descriptions.append(f"Pull {bass['name']} to 0.60")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify kick and bass both still producing audio",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        before_reads=[{"tool": "get_master_spectrum", "params": {}}],
+        after_reads=[
+            {"tool": "get_master_spectrum", "params": {}},
+            {"tool": "get_track_meters", "params": {"include_stereo": True}},
+        ],
+        risk_level="low",
+        summary="; ".join(descriptions) if descriptions else "No kick/bass changes compiled",
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
+    )
+
+
+def _compile_create_buildup_tension(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'create_buildup_tension': pull harmony back, raise perc energy.
+
+    We apply volume moves as the minimal, reversible tension-builder. Filter
+    rises and send ramps belong in an automation recipe — we issue a tension
+    gesture template step if the gesture engine is available, otherwise fall
+    back to direct volume changes only.
+    """
+    steps: list[CompiledStep] = []
+    warnings: list[str] = []
+    descriptions: list[str] = []
+
+    perc_tracks = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
+    harmony_tracks = resolvers.find_tracks_by_role(kernel, ["chords", "pad"])
+
+    if not perc_tracks and not harmony_tracks:
+        warnings.append("No percussion or harmony tracks found — cannot build tension")
+
+    # Raise perc for energy
+    for pt in perc_tracks[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": pt["index"], "volume": 0.78},
+            description=f"Push {pt['name']} to 0.78 for rising energy",
+        ))
+        descriptions.append(f"Push {pt['name']} to 0.78")
+
+    # Pull harmony slightly to amplify perc contrast
+    for ht in harmony_tracks[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": ht["index"], "volume": 0.35},
+            description=f"Pull {ht['name']} to 0.35 to create harmonic vacuum before drop",
+        ))
+        descriptions.append(f"Pull {ht['name']} to 0.35")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify tension steps did not silence any track",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        before_reads=[{"tool": "get_emotional_arc", "params": {}}],
+        after_reads=[
+            {"tool": "get_emotional_arc", "params": {}},
+            {"tool": "get_track_meters", "params": {"include_stereo": True}},
+        ],
+        risk_level="medium",
+        summary="; ".join(descriptions) if descriptions else "No tracks to ratchet",
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
+    )
+
+
+def _compile_smooth_scene_handoff(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'smooth_scene_handoff': reduce master volume briefly around the handoff.
+
+    Without knowing which two scenes are involved, the compiler can only do a
+    conservative energy dip using master volume. A future version should take
+    scene indices via kernel.intent_context and apply targeted crossfades.
+    """
+    steps: list[CompiledStep] = []
+    warnings: list[str] = []
+    descriptions: list[str] = []
+
+    # Minimal approach — gentle master dip the agent can reverse easily.
+    steps.append(CompiledStep(
+        tool="get_master_meters",
+        params={},
+        description="Record current master level for handoff reference",
+        verify_after=False,
+    ))
+
+    steps.append(CompiledStep(
+        tool="set_master_volume",
+        params={"volume": 0.78},
+        description="Gentle master dip for transition",
+    ))
+    descriptions.append("Master dip to 0.78")
+
+    steps.append(CompiledStep(
+        tool="get_master_meters",
+        params={},
+        description="Verify master dip applied without clipping",
+    ))
+
+    warnings.append(
+        "Scene-aware handoff (from_scene/to_scene) not yet compiled — "
+        "this is a conservative energy-dip fallback"
+    )
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        before_reads=[{"tool": "get_emotional_arc", "params": {}}],
+        after_reads=[{"tool": "get_emotional_arc", "params": {}}],
+        risk_level="low",
+        summary="; ".join(descriptions),
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
+    )
+
+
 # ── Register all compilers ──────────────────────────────────────────────────
 
 register_compiler("make_punchier", _compile_make_punchier)
@@ -289,3 +456,6 @@ register_compiler("tighten_low_end", _compile_tighten_low_end)
 register_compiler("widen_stereo", _compile_widen_stereo)
 register_compiler("darken_without_losing_width", _compile_darken_mix)
 register_compiler("reduce_repetition_fatigue", _compile_reduce_repetition)
+register_compiler("make_kick_bass_lock", _compile_make_kick_bass_lock)
+register_compiler("create_buildup_tension", _compile_create_buildup_tension)
+register_compiler("smooth_scene_handoff", _compile_smooth_scene_handoff)

package/mcp_server/semantic_moves/mix_moves.py

@@ -92,7 +92,7 @@ REDUCE_REPETITION = SemanticMove(
     ],
     verification_plan=[
         {"tool": "get_track_meters", "check": "all tracks still producing audio", "backend": "remote_command"},
-        {"tool": "capture_audio", "check": "LRA > 2 LU (dynamic range should increase)", "backend": "mcp_tool"},
+        {"tool": "capture_audio", "check": "LRA > 2 LU (dynamic range should increase)", "backend": "bridge_command"},
     ],
 )
 

package/mcp_server/semantic_moves/models.py

@@ -24,6 +24,10 @@ class SemanticMove:
     plan_template: list = field(default_factory=list)  # [{tool, params, description}] — static metadata, NOT runtime truth
     verification_plan: list = field(default_factory=list)  # [{tool, check}]
     confidence: float = 0.7
+    # analytical_only: move is intentionally metadata-only — no compiler is
+    # expected. Surfaces in discovery/wonder_mode but never executes. Set this
+    # to True for moves that are deliberate "hints" rather than orphan-by-bug.
+    analytical_only: bool = False
 
     def to_dict(self) -> dict:
         return {
@@ -36,6 +40,7 @@ class SemanticMove:
             "required_capabilities": self.required_capabilities,
             "plan_template_steps": len(self.plan_template),
             "confidence": self.confidence,
+            "analytical_only": self.analytical_only,
         }
 
     def to_full_dict(self) -> dict:

package/mcp_server/semantic_moves/tools.py

@@ -229,10 +229,21 @@ async def apply_semantic_move(
     # explore mode — execute through the async router
     from ..runtime.execution_router import execute_plan_steps_async
 
-    step_dicts = [
-        {"tool": step.tool, "params": step.params, "description": step.description}
-        for step in plan.steps
-    ]
+    # Propagate the optional backend annotation through to the router so a
+    # compiler that's certain about a step's backend (e.g. bridge_command for
+    # capture_audio) can short-circuit classify_step(). Steps without backend
+    # fall back to the classifier as before.
+    def _step_to_dict(step):
+        d = {
+            "tool": step.tool,
+            "params": step.params,
+            "description": step.description,
+        }
+        if getattr(step, "backend", None):
+            d["backend"] = step.backend
+        return d
+
+    step_dicts = [_step_to_dict(step) for step in plan.steps]
     bridge = ctx.lifespan_context.get("m4l")
     mcp_registry = ctx.lifespan_context.get("mcp_dispatch", {})
     exec_results = await execute_plan_steps_async(

package/mcp_server/server.py

@@ -2,6 +2,7 @@
 
 from contextlib import asynccontextmanager
 import asyncio
+import logging
 import os
 import subprocess
 
@@ -10,6 +11,12 @@ from fastmcp import FastMCP, Context  # noqa: F401
 from .connection import AbletonConnection
 from .m4l_bridge import SpectralCache, SpectralReceiver, M4LBridge
 
+# Logger must be defined before any function uses it — several module-level
+# helpers below (e.g. _master_has_livepilot_analyzer) call logger.debug on
+# the import-time code path, so defining logger later raised NameError when
+# those helpers fired from a tool module's module-level init.
+logger = logging.getLogger(__name__)
+
 
 def _identify_port_holder(port: int) -> str | None:
     """Identify which process holds the given UDP port (for logging only).
@@ -264,9 +271,6 @@ from .device_forge import tools as device_forge_tools          # noqa: F401, E40
 from .sample_engine import tools as sample_engine_tools        # noqa: F401, E402
 from .atlas import tools as atlas_tools                        # noqa: F401, E402
 from .composer import tools as composer_tools                  # noqa: F401, E402
-import logging
-
-logger = logging.getLogger(__name__)
 
 # ---------------------------------------------------------------------------
 # Schema coercion patch — accept strings for numeric parameters

package/mcp_server/services/singletons.py

@@ -0,0 +1,68 @@
+"""Thread-safe singleton helpers.
+
+The server has several subsystems (atlas, corpus, sample-engine indexes)
+that are loaded lazily into module-level globals via a check-then-set
+pattern. Under FastMCP's async concurrency that pattern races: two
+handlers can both observe ``None`` and both construct the (expensive)
+object. Most of the time the GIL hides the race, but when it doesn't you
+get redundant I/O and, worse, one thread's half-parsed state overwriting
+the other's completed state.
+
+This module provides a small helper that wraps a factory in a lock and
+optionally tracks an on-disk mtime for cache invalidation. Use it in
+place of hand-rolled ``_instance = None`` patterns.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from threading import Lock
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+
+
+class Singleton:
+    """Lazy, thread-safe singleton with optional mtime-based reload.
+
+    Example:
+        atlas_holder = Singleton(_load_atlas)
+
+        def get_atlas():
+            return atlas_holder.get(reload_if_newer=atlas_path)
+
+        def on_atlas_rebuild():
+            atlas_holder.invalidate()
+    """
+
+    def __init__(self, factory: Callable[[], T]):
+        self._factory = factory
+        self._instance: T | None = None
+        self._mtime: float | None = None
+        self._lock = Lock()
+
+    def get(self, *, reload_if_newer: Path | None = None) -> T:
+        with self._lock:
+            if self._instance is None:
+                self._instance = self._factory()
+                if reload_if_newer is not None:
+                    try:
+                        self._mtime = reload_if_newer.stat().st_mtime
+                    except OSError:
+                        self._mtime = None
+                return self._instance
+
+            if reload_if_newer is not None:
+                try:
+                    current = reload_if_newer.stat().st_mtime
+                except OSError:
+                    return self._instance
+                if self._mtime is None or current > self._mtime:
+                    self._instance = self._factory()
+                    self._mtime = current
+            return self._instance
+
+    def invalidate(self) -> None:
+        """Discard the cached instance. Next .get() will re-run the factory."""
+        with self._lock:
+            self._instance = None
+            self._mtime = None

package/mcp_server/splice_client/client.py

@@ -27,6 +27,16 @@ _SPLICE_APP_SUPPORT = os.path.expanduser(
 # Credit safety floor — never drain below this
 CREDIT_HARD_FLOOR = 5
 
+# Per-call gRPC timeouts. The previous implementation passed no timeout, so
+# a hung Splice process could block the MCP event loop until gRPC's default
+# (often infinite) deadline fired. Keep generous enough for cold searches
+# but bounded enough that a dead socket fails the tool call, not the server.
+SEARCH_TIMEOUT = 10.0
+INFO_TIMEOUT = 5.0
+CREDITS_TIMEOUT = 5.0
+SYNC_TIMEOUT = 30.0
+DOWNLOAD_TRIGGER_TIMEOUT = 5.0
+
 
 def _try_import_grpc():
     """Import grpcio lazily — graceful degradation if not installed."""
@@ -148,7 +158,7 @@ class SpliceGRPCClient:
                 Page=page,
                 Purchased=purchased,
             )
-            response = await self.stub.SearchSamples(request)
+            response = await self.stub.SearchSamples(request, timeout=SEARCH_TIMEOUT)
             return self._parse_search_response(response)
         except Exception as exc:
             logger.warning(f"Splice search failed: {exc}")
@@ -213,7 +223,8 @@ class SpliceGRPCClient:
         try:
             # Trigger download
             await self.stub.DownloadSample(
-                pb2.DownloadSampleRequest(FileHash=file_hash)
+                pb2.DownloadSampleRequest(FileHash=file_hash),
+                timeout=DOWNLOAD_TRIGGER_TIMEOUT,
             )
             # Wait for file to appear on disk
             return await self._wait_for_download(file_hash, timeout)
@@ -226,11 +237,16 @@ class SpliceGRPCClient:
     ) -> Optional[str]:
         """Poll SampleInfo until LocalPath is populated."""
         pb2 = self._pb2
-        deadline = asyncio.get_event_loop().time() + timeout
-        while asyncio.get_event_loop().time() < deadline:
+        # asyncio.get_event_loop() is deprecated when called inside an
+        # already-running coroutine on Python 3.10+. Use get_running_loop()
+        # which is the documented replacement.
+        loop = asyncio.get_running_loop()
+        deadline = loop.time() + timeout
+        while loop.time() < deadline:
             try:
                 response = await self.stub.SampleInfo(
-                    pb2.SampleInfoRequest(FileHash=file_hash)
+                    pb2.SampleInfoRequest(FileHash=file_hash),
+                    timeout=INFO_TIMEOUT,
                 )
                 if response.Sample.LocalPath:
                     return response.Sample.LocalPath
@@ -250,7 +266,8 @@ class SpliceGRPCClient:
         pb2 = self._pb2
         try:
             response = await self.stub.SampleInfo(
-                pb2.SampleInfoRequest(FileHash=file_hash)
+                pb2.SampleInfoRequest(FileHash=file_hash),
+                timeout=INFO_TIMEOUT,
             )
             s = response.Sample
             return SpliceSample(
@@ -282,7 +299,8 @@ class SpliceGRPCClient:
         pb2 = self._pb2
         try:
             response = await self.stub.ValidateLogin(
-                pb2.ValidateLoginRequest()
+                pb2.ValidateLoginRequest(),
+                timeout=CREDITS_TIMEOUT,
             )
             return SpliceCredits(
                 credits=response.User.Credits,
@@ -315,7 +333,10 @@ class SpliceGRPCClient:
             return False
         pb2 = self._pb2
         try:
-            await self.stub.SyncSounds(pb2.SyncSoundsRequest())
+            await self.stub.SyncSounds(
+                pb2.SyncSoundsRequest(),
+                timeout=SYNC_TIMEOUT,
+            )
             return True
         except Exception as exc:
             logger.debug("sync_sounds failed: %s", exc)

package/mcp_server/tools/analyzer.py

@@ -6,13 +6,20 @@ These tools are optional — all core tools work without the device.
 
 from __future__ import annotations
 
+import logging
 import os
+import re  # used below in filename parsing helpers
 from typing import Optional
 
 from fastmcp import Context
 
 from ..server import mcp, _identify_port_holder
 
+# Logger must be defined before any helper that uses it — _require_analyzer
+# below calls logger.debug on an exception path, so defining the logger later
+# in the file risked NameError under unusual import orderings.
+logger = logging.getLogger(__name__)
+
 CAPTURE_DIR = os.path.expanduser("~/Documents/LivePilot/captures")
 
 
@@ -277,12 +284,6 @@ async def get_clip_file_path(
     bridge = _get_m4l(ctx)
     return await bridge.send_command("get_clip_file_path", track_index, clip_index)
 
-import os  # for filename parsing in smart-defaults helper
-import re
-import logging
-
-logger = logging.getLogger(__name__)
-
 # ── Sample loading helpers (P0-1, P1-1, P2-6 fixes) ────────────────────────
 #
 # Critical bug 2026-04-14 (see docs/2026-04-14-bugs-discovered.md):

package/mcp_server/tools/clips.py

@@ -114,7 +114,7 @@ def stop_clip(ctx: Context, track_index: int, clip_index: int) -> dict:
 
 @mcp.tool()
 def set_clip_name(ctx: Context, track_index: int, clip_index: int, name: str) -> dict:
-    """Rename a clip."""
+    """Rename a clip in the Session view. The new name appears on the clip slot and in Device Chain displays."""
     _validate_track_index(track_index)
     _validate_clip_index(clip_index)
     if not name.strip():

package/mcp_server/tools/midi_io.py

@@ -144,6 +144,16 @@ def export_clip_midi(
     else:
         out_path = _safe_output_path(_output_dir(), filename)
 
+    # Extension guard: after path resolution, confirm the final file really
+    # has a MIDI extension. Blocks a model-supplied path like
+    # "/etc/cron.d/evil" that accidentally drops its extension through the
+    # resolve() step, or a caller that passed "evil.mid/../evil".
+    if out_path.suffix.lower() not in {".mid", ".midi"}:
+        raise ValueError(
+            f"Refusing to write non-MIDI file: {out_path}. "
+            f"export_clip_midi requires a .mid or .midi extension."
+        )
+
     midi = MIDIFile(1)
     midi.addTempo(0, 0, tempo)
 

package/mcp_server/tools/tracks.py

@@ -106,7 +106,7 @@ def duplicate_track(ctx: Context, track_index: int) -> dict:
 
 @mcp.tool()
 def set_track_name(ctx: Context, track_index: int, name: str) -> dict:
-    """Rename a track."""
+    """Rename a track. The new name appears in both the Session and Arrangement views and survives session save."""
     _validate_track_index(track_index)
     if not name.strip():
         raise ValueError("Track name cannot be empty")

package/mcp_server/tools/transport.py

@@ -62,7 +62,7 @@ def start_playback(ctx: Context) -> dict:
 
 @mcp.tool()
 def stop_playback(ctx: Context) -> dict:
-    """Stop playback."""
+    """Stop playback — halts the session transport and the arrangement cursor returns to its last position."""
     return _get_ableton(ctx).send_command("stop_playback")
 
 

package/mcp_server/translation_engine/tools.py

@@ -6,11 +6,19 @@ then delegates to pure-computation critics.
 
 from __future__ import annotations
 
+import logging
+
 from fastmcp import Context
 
 from ..server import mcp
 from .critics import build_translation_report, run_all_translation_critics
 
+# Logger defined at module top: _fetch_translation_data below calls
+# logger.debug on an exception path. The previous version buried the logger
+# definition inside a docstring mid-file, which meant the name was never
+# actually bound at module level — any exception path would raise NameError.
+logger = logging.getLogger(__name__)
+
 
 # ── Helpers ─────────────────────────────────────────────────────────
 
@@ -97,10 +105,6 @@ def get_translation_issues(ctx: Context) -> dict:
 
     Lighter than check_translation — returns only detected issues
     from the 5 playback robustness critics.
-import logging
-
-logger = logging.getLogger(__name__)
-
     """
     mix_snapshot = _fetch_translation_data(ctx)
     issues = run_all_translation_critics(mix_snapshot)

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.10.7",
+  "version": "1.10.8",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 323 tools, 45 domains. Device atlas (1305 devices), sample engine (Splice + browser + filesystem), auto-composition, spectral perception, technique memory, creative intelligence (12 engines)",
+  "description": "Agentic production system for Ableton Live 12 — 324 tools, 45 domains. Device atlas (1305 devices), sample engine (Splice + browser + filesystem), auto-composition, spectral perception, technique memory, creative intelligence (12 engines)",
   "author": "Pilot Studio",
   "license": "BSL-1.1",
   "type": "commonjs",
@@ -43,5 +43,27 @@
   ],
   "engines": {
     "node": ">=18.0.0"
-  }
+  },
+  "files": [
+    "bin/**/*.js",
+    "installer/**/*.js",
+    "mcp_server/**/*.py",
+    "mcp_server/**/*.json",
+    "mcp_server/**/*.yaml",
+    "mcp_server/**/*.md",
+    "mcp_server/**/*.db",
+    "remote_script/**/*.py",
+    "m4l_device/LivePilot_Analyzer.amxd",
+    "m4l_device/LivePilot_Analyzer.adv",
+    "m4l_device/livepilot_bridge.js",
+    "m4l_device/BUILD_GUIDE.md",
+    "requirements.txt",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "server.json",
+    "!**/__pycache__/**",
+    "!**/*.pyc",
+    "!**/.DS_Store"
+  ]
 }

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.10.7"
+__version__ = "1.10.8"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router
@@ -46,26 +46,46 @@ _HANDLER_MODULES = (
 )
 
 
-def _force_reload_handlers():
+def _force_reload_handlers(cs=None):
     """Force Python to re-read the handler modules from disk.
 
     Called on every create_instance() except the first, so edits to
     handler files take effect via Control Surface toggle without
     restarting Ableton. Order matters: router first (clears _handlers),
     then each handler module (re-registers its @register decorators).
+
+    When ``cs`` is provided, reload exceptions are logged through the
+    ControlSurface so a SyntaxError / NameError in an edited handler is
+    surfaced in Live's status log instead of silently swallowed. The
+    previous ``except Exception: pass`` turned any bad handler into a
+    silent NOT_FOUND at dispatch time with no hint that reload had failed.
     """
     import importlib
+    def _log(msg):
+        if cs is None:
+            return
+        try:
+            cs.log_message("[LivePilot] " + msg)
+        except Exception:
+            pass
+
     try:
         importlib.reload(router)
-    except Exception:
-        pass
+    except Exception as exc:
+        _log("reload(router) FAILED — %s: %s. Handlers will be "
+             "stale until Ableton restart." % (type(exc).__name__, exc))
     for mod in _HANDLER_MODULES:
         try:
             importlib.reload(mod)
-        except Exception:
-            # Don't block Ableton startup on a single bad reload —
-            # the stale version will still work for that handler
-            pass
+        except Exception as exc:
+            # Don't block Ableton startup on a single bad reload, but do
+            # tell the user what happened — the stale handler will keep
+            # serving the OLD code until a full restart.
+            _log("reload(%s) FAILED — %s: %s. Handler is stale." % (
+                getattr(mod, "__name__", "?"),
+                type(exc).__name__,
+                exc,
+            ))
 
 
 def create_instance(c_instance):
@@ -78,7 +98,7 @@ def create_instance(c_instance):
     """
     global _FIRST_CREATE_INSTANCE
     if not _FIRST_CREATE_INSTANCE:
-        _force_reload_handlers()
+        _force_reload_handlers(cs=c_instance)
     _FIRST_CREATE_INSTANCE = False
     return LivePilot(c_instance)
 

package/remote_script/LivePilot/arrangement.py

@@ -407,11 +407,21 @@ def modify_arrangement_notes(song, params):
     for note in all_notes:
         note_map[note.note_id] = note
 
+    # Two-pass: validate all note_ids BEFORE mutating any notes. See the
+    # identical fix in notes.py:modify_notes — partial mid-loop mutation on
+    # the C++ NoteVector was leaving the clip in a half-modified state that
+    # never got committed.
+    missing = [int(mod["note_id"]) for mod in modifications
+               if int(mod["note_id"]) not in note_map]
+    if missing:
+        raise ValueError(
+            "Note IDs not found in arrangement clip: %s. "
+            "No modifications applied." % missing
+        )
+
     modified_count = 0
     for mod in modifications:
         note_id = int(mod["note_id"])
-        if note_id not in note_map:
-            raise ValueError("Note ID %d not found in clip" % note_id)
         note = note_map[note_id]
         if "pitch" in mod:
             note.pitch = int(mod["pitch"])