livepilot 1.10.7 → 1.10.9

package/mcp_server/tools/clips.py

@@ -1,10 +1,13 @@
 """Clip MCP tools — info, create, delete, duplicate, fire, stop, properties, warp.
 
-11 tools matching the Remote Script clips domain.
+11 tools matching the Remote Script clips domain, plus a key-consistency
+diagnostic (BUG-D1) that cross-references filename-encoded keys against
+the analyzer-detected session key.
 """
 
 from __future__ import annotations
 
+import re
 from typing import Optional
 
 from fastmcp import Context
@@ -17,6 +20,72 @@ def _get_ableton(ctx: Context):
     return ctx.lifespan_context["ableton"]
 
 
+# ── Key-token parsing (BUG-D1) ─────────────────────────────────────────
+#
+# Splice filenames encode the key as one of:
+#   _D#min   _Dmin   _Dm       → minor
+#   _Dmaj    _DMaj   _D        → major (trailing nothing or just "maj")
+#   _Eb      _Ebmin   _Dbm     → accidentals accepted as # or b
+#
+# We accept any of those forms and emit a canonical (root, mode) tuple.
+
+# Note → semitone offset from C (C=0, C#=1, D=2, ...)
+_NOTE_TO_SEMI = {
+    "c": 0, "c#": 1, "db": 1, "d": 2, "d#": 3, "eb": 3, "e": 4, "fb": 4,
+    "e#": 5, "f": 5, "f#": 6, "gb": 6, "g": 7, "g#": 8, "ab": 8,
+    "a": 9, "a#": 10, "bb": 10, "b": 11, "cb": 11,
+}
+
+# Match the trailing key token in a filename stem (everything before the
+# extension, underscore-delimited). We anchor to the end of the stem so
+# an earlier "D" in the filename (e.g. "Dabrye_...") doesn't match.
+_KEY_RE = re.compile(
+    r"(?P<root>[A-Ga-g][#b]?)(?P<mode>maj|min|m|Maj|Min)?$",
+    flags=re.IGNORECASE,
+)
+
+
+def _parse_key_from_filename(filename: str) -> Optional[dict]:
+    """Extract key info from a Splice-style filename.
+
+    Returns ``{"root": "D#", "mode": "minor", "semi": 3, "token": "D#min"}``
+    or ``None`` if no recognizable key token is present in the final
+    underscore-segment of the filename stem.
+    """
+    if not filename:
+        return None
+    stem = filename.rsplit(".", 1)[0]
+    last = stem.split("_")[-1]
+    match = _KEY_RE.fullmatch(last)
+    if not match:
+        return None
+    root_raw = match.group("root").lower()
+    mode_raw = (match.group("mode") or "").lower()
+    # Normalize the root to lookup form. Canonicalize B# → C, etc. (rare
+    # but possible in hand-named samples).
+    semi = _NOTE_TO_SEMI.get(root_raw)
+    if semi is None:
+        return None
+    # Without an explicit mode suffix, Splice convention defaults to major.
+    mode = "minor" if mode_raw in ("min", "m") else "major"
+    # Canonical display: capitalize root, preserve #/b.
+    root_display = root_raw[0].upper() + root_raw[1:]
+    return {
+        "root": root_display,
+        "mode": mode,
+        "semi": semi,
+        "token": last,
+    }
+
+
+def _key_to_semi(root: str, mode: str = "major") -> Optional[int]:
+    """Convert a session-reported key like ``"D"`` + ``"minor"`` to 0..11 semis."""
+    if not root:
+        return None
+    semi = _NOTE_TO_SEMI.get(root.strip().lower())
+    return semi
+
+
 def _validate_track_index(track_index: int):
     """Validate track index. Must be >= 0 for regular tracks."""
     if track_index < 0:
@@ -114,7 +183,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():
@@ -265,3 +334,172 @@ def set_clip_warp_mode(
     if warping is not None:
         params["warping"] = warping
     return _get_ableton(ctx).send_command("set_clip_warp_mode", params)
+
+
+@mcp.tool()
+async def check_clip_key_consistency(
+    ctx: Context,
+    track_index: int,
+    clip_index: int,
+) -> dict:
+    """Cross-check a clip's filename-encoded key against the session key (BUG-D1).
+
+    Splice-style sample filenames encode the sample's key (e.g.
+    ``AU_THF2_128_vocal_..._D#min.wav``). This tool parses that token,
+    compares it to the analyzer-detected session key, and — when they
+    disagree — computes the semitone delta needed to realign, returning
+    the exact ``set_clip_pitch(coarse=...)`` call that would correct it.
+
+    Return shape::
+
+        {
+            "track_index": 6,
+            "clip_index": 0,
+            "filename_key": {"root": "D#", "mode": "minor", "token": "D#min"},
+            "session_key": {"root": "D", "mode": "minor"},
+            "status": "mismatch" | "match" | "unknown",
+            "semitone_delta": -1,          # clip needs to shift DOWN 1
+            "recommended_fix": {
+                "tool": "set_clip_pitch",
+                "args": {"track_index": 6, "clip_index": 0, "coarse": -1}
+            },
+            "reason": "Clip is D#min, session is Dm — shift -1 semitone."
+        }
+
+    Returns ``status="unknown"`` (not an error) when:
+      - the clip is MIDI (no audio file path)
+      - the filename has no parseable key token
+      - the analyzer hasn't detected a session key yet
+
+    Requires the M4L bridge for both ``get_clip_file_path`` and
+    ``get_detected_key``. Degrades gracefully without it.
+    """
+    _validate_track_index(track_index)
+    _validate_clip_index(clip_index)
+
+    # 1) Resolve the clip's file path. Relies on the M4L bridge.
+    try:
+        from .analyzer import get_clip_file_path as _get_path
+        # get_clip_file_path is an @mcp.tool, but FastMCP decorators preserve
+        # the underlying function — we can call it directly for composition.
+        path_resp = await _get_path.fn(ctx, track_index, clip_index)
+    except Exception as exc:
+        return {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "status": "unknown",
+            "reason": f"Could not resolve clip file path: {exc}",
+        }
+    if not isinstance(path_resp, dict) or path_resp.get("error"):
+        return {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "status": "unknown",
+            "reason": path_resp.get("error", "No file path available (MIDI clip?)."),
+        }
+    file_path = path_resp.get("path") or path_resp.get("file_path") or ""
+
+    # 2) Parse key token from the filename.
+    import os
+    filename_key = _parse_key_from_filename(os.path.basename(file_path))
+    if filename_key is None:
+        return {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "file_path": file_path,
+            "status": "unknown",
+            "reason": "Filename has no recognizable key token.",
+        }
+
+    # 3) Query the session-detected key (needs the analyzer).
+    try:
+        from .analyzer import get_detected_key as _get_key
+        key_resp = await _get_key.fn(ctx)
+    except Exception as exc:
+        return {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "file_path": file_path,
+            "filename_key": filename_key,
+            "status": "unknown",
+            "reason": f"Analyzer unavailable: {exc}",
+        }
+    if not isinstance(key_resp, dict) or key_resp.get("error") or not key_resp.get("key"):
+        return {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "file_path": file_path,
+            "filename_key": filename_key,
+            "status": "unknown",
+            "reason": key_resp.get(
+                "error", "Session key not yet detected — play 4-8 bars."
+            ),
+        }
+    session_root = str(key_resp.get("key", ""))
+    session_mode = str(key_resp.get("scale", "major")).lower()
+    session_semi = _key_to_semi(session_root)
+
+    # 4) Classify + compute fix.
+    file_semi = filename_key["semi"]
+    if session_semi is None or file_semi is None:
+        return {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "file_path": file_path,
+            "filename_key": filename_key,
+            "session_key": {"root": session_root, "mode": session_mode},
+            "status": "unknown",
+            "reason": "Could not resolve semitone offsets for comparison.",
+        }
+
+    if filename_key["mode"] != session_mode:
+        mode_note = (
+            f" (clip is {filename_key['mode']}, session is {session_mode} — "
+            "mode mismatch is often OK for ambient/background use)"
+        )
+    else:
+        mode_note = ""
+
+    if file_semi == session_semi and filename_key["mode"] == session_mode:
+        return {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "file_path": file_path,
+            "filename_key": filename_key,
+            "session_key": {"root": session_root, "mode": session_mode},
+            "status": "match",
+            "semitone_delta": 0,
+            "recommended_fix": None,
+            "reason": "Clip key matches session.",
+        }
+
+    # Semitone delta: how much the clip should shift to align with the
+    # session root. Choose the smaller magnitude (shift up or down).
+    raw_delta = (session_semi - file_semi) % 12
+    if raw_delta > 6:
+        raw_delta -= 12  # prefer the nearer direction (−1 over +11)
+    delta = raw_delta
+
+    return {
+        "track_index": track_index,
+        "clip_index": clip_index,
+        "file_path": file_path,
+        "filename_key": filename_key,
+        "session_key": {"root": session_root, "mode": session_mode},
+        "status": "mismatch",
+        "semitone_delta": delta,
+        "recommended_fix": {
+            "tool": "set_clip_pitch",
+            "args": {
+                "track_index": track_index,
+                "clip_index": clip_index,
+                "coarse": delta,
+            },
+        },
+        "reason": (
+            f"Clip is {filename_key['root']}{filename_key['mode'][:3]}, "
+            f"session is {session_root}{session_mode[:3]} — "
+            f"shift {delta:+d} semitone{'' if abs(delta) == 1 else 's'}."
+            f"{mode_note}"
+        ),
+    }

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")
 
 
@@ -130,6 +130,61 @@ def get_recent_actions(ctx: Context, limit: int = 20) -> dict:
 
 
 @mcp.tool()
-def get_session_diagnostics(ctx: Context) -> dict:
-    """Analyze the session for potential issues: armed tracks, solo/mute leftovers, unnamed tracks, empty clips/scenes, MIDI tracks without instruments. Returns issues with severity (warning/info) and stats."""
-    return _get_ableton(ctx).send_command("get_session_diagnostics")
+async def get_session_diagnostics(ctx: Context, check_clip_keys: bool = False) -> dict:
+    """Analyze the session for potential issues: armed tracks, solo/mute leftovers, unnamed tracks, empty clips/scenes, MIDI tracks without instruments. Returns issues with severity (warning/info) and stats.
+
+    check_clip_keys: when True, also cross-checks every audio clip's
+        filename-encoded key against the detected session key (BUG-D1 scan).
+        Each mismatch appears as a diagnostic entry with the exact
+        set_clip_pitch call that would correct it. Requires the M4L bridge
+        (uses get_clip_file_path + get_detected_key); skipped gracefully if
+        the bridge is unavailable. Off by default because it round-trips
+        the bridge once per audio clip and can add noticeable latency on
+        large sessions.
+    """
+    result = _get_ableton(ctx).send_command("get_session_diagnostics")
+
+    if not check_clip_keys:
+        return result
+    if not isinstance(result, dict):
+        return result
+
+    # Augment with per-clip key-consistency checks. Each mismatch is added
+    # as a diagnostic with severity="warning"; "unknown" results are
+    # skipped so we don't drown the user in "no key detected yet" noise.
+    from .clips import check_clip_key_consistency  # local import to avoid cycles
+
+    audio_mismatches: list[dict] = []
+    session_info = _get_ableton(ctx).send_command("get_session_info")
+    tracks = (session_info or {}).get("tracks", []) if isinstance(session_info, dict) else []
+    for track in tracks:
+        t_idx = track.get("index")
+        if t_idx is None:
+            continue
+        # We don't know which slots hold audio clips without probing, so
+        # iterate the first N scene slots conservatively. A session with
+        # many scenes would benefit from a scene-count cap; 32 is a
+        # reasonable upper bound for typical production sessions.
+        for clip_idx in range(min(32, len(session_info.get("scenes", []) or []) or 8)):
+            try:
+                check = await check_clip_key_consistency.fn(ctx, t_idx, clip_idx)
+            except Exception:  # noqa: BLE001 — any failure means "skip this clip"
+                continue
+            if not isinstance(check, dict):
+                continue
+            if check.get("status") == "mismatch":
+                audio_mismatches.append({
+                    "severity": "warning",
+                    "category": "clip_key_mismatch",
+                    "track_index": t_idx,
+                    "clip_index": clip_idx,
+                    "message": check.get("reason", ""),
+                    "recommended_fix": check.get("recommended_fix"),
+                })
+
+    if audio_mismatches:
+        issues = result.setdefault("issues", [])
+        issues.extend(audio_mismatches)
+        result["clip_key_mismatch_count"] = len(audio_mismatches)
+
+    return result

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.9",
   "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 — 325 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,11 +5,12 @@ 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.9"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router
 from .server import LivePilotServer
+from . import utils        # noqa: F401  — shared helpers (get_track, get_device)
 from . import transport    # noqa: F401  — registers transport handlers
 from . import tracks       # noqa: F401  — registers track handlers
 from . import clips        # noqa: F401  — registers clip handlers
@@ -36,36 +37,62 @@ from . import version_detect    # noqa: F401  — version detection
 # @register decorators with the updated code). Result: a Control Surface
 # toggle now behaves like a fresh module reload, so live-editing mixing.py
 # / devices.py / etc. and re-toggling is enough — no Ableton restart.
+#
+# Order matters: utils comes first because every handler imports
+# ``from .utils import get_track, get_device``. If utils isn't reloaded
+# first, those re-imports during ``importlib.reload(devices)`` still
+# resolve to the stale ``utils`` module object in ``sys.modules``.
 
 _FIRST_CREATE_INSTANCE = True
 
 _HANDLER_MODULES = (
+    utils,
     transport, tracks, clips, notes, devices, scenes,
     mixing, browser, arrangement, diagnostics,
     clip_automation, version_detect,
 )
 
 
-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 +105,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"])

package/remote_script/LivePilot/browser.py

@@ -287,11 +287,20 @@ def load_browser_item(song, params):
     # and use the subcategory or the full fragment for matching
     if "FileId_" in device_name:
         # URI contains an internal file ID — name-based search won't work.
-        # Try one more URI pass with a much higher iteration limit.
+        # We fall back to one URI walk, but with a TIGHT iteration budget:
+        # this runs synchronously on Ableton's audio/main thread, and the
+        # previous 200 000-node walk could stall audio and GUI for several
+        # seconds on large libraries (documented in CLAUDE.md).
+        #
+        # If the item isn't found inside the budget, we return a clean
+        # STATE_ERROR pointing the caller at search_browser(), which does
+        # the same walk lazily from a cached Python-side index without
+        # hogging the audio thread.
         _iterations[0] = 0
-        DEEP_MAX = 200000
+        DEEP_MAX = 20000        # was 200_000 — 10x reduction
+        DEEP_DEPTH_MAX = 8       # was 12 — shallower depth is usually enough
         def find_by_uri_deep(parent, target_uri, depth=0):
-            if depth > 12 or _iterations[0] > DEEP_MAX:
+            if depth > DEEP_DEPTH_MAX or _iterations[0] > DEEP_MAX:
                 return None
             try:
                 children = list(parent.children)
@@ -326,9 +335,10 @@ def load_browser_item(song, params):
                 }
 
         raise ValueError(
-            "Item '%s' not found in browser (FileId URI — try "
-            "search_browser to find the item, then use find_and_load_device "
-            "with the exact name instead)" % uri
+            "Item '%s' not found inside deep-scan budget (FileId URI). "
+            "Use search_browser(query=...) to locate it without stalling "
+            "Ableton's audio thread, then call load_browser_item with the "
+            "returned URI." % uri
         )
 
     for sep in (":", "/"):

package/remote_script/LivePilot/devices.py

@@ -199,17 +199,22 @@ def toggle_device(song, params):
     track = get_track(song, track_index)
     device = get_device(track, device_index)
 
-    # Find the "Device On" parameter by name (safer than assuming index 0)
+    # Find the "Device On" parameter by name — the previous fallback
+    # blindly assumed parameters[0] was an on/off switch, which for many
+    # devices is actually "Filter Frequency", "Gain", or similar. The
+    # fallback silently mutated an arbitrary parameter while reporting
+    # is_active as if toggling had worked. Now refuse to guess.
     on_param = None
     for p in device.parameters:
         if p.name == "Device On":
             on_param = p
             break
     if on_param is None:
-        # Fallback to parameter 0 for devices that don't use "Device On"
-        if not list(device.parameters):
-            raise ValueError("Device '%s' has no parameters to toggle" % device.name)
-        on_param = device.parameters[0]
+        raise ValueError(
+            "Device '%s' exposes no 'Device On' parameter and cannot be "
+            "toggled programmatically. Use delete_device or disable it "
+            "through the UI." % device.name
+        )
 
     on_param.value = 1.0 if active else 0.0
     return {"name": device.name, "is_active": on_param.value > 0.5}

package/remote_script/LivePilot/notes.py

@@ -155,12 +155,23 @@ def modify_notes(song, params):
     for note in all_notes:
         note_map[note.note_id] = note
 
+    # Two-pass: validate every note_id BEFORE mutating any notes. The previous
+    # one-pass version raised ValueError mid-loop after some notes had already
+    # been mutated in place on the C++ NoteVector — yielding a half-modified
+    # state where the caller saw an error but earlier edits silently stuck
+    # (until apply_note_modifications was called, which it never was in the
+    # error path). Fail-all or apply-all is the safer contract.
+    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 clip: %s. No modifications applied." % missing
+        )
+
     # Apply modifications in-place on the original NoteVector's objects
     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"])