livepilot 1.9.11 → 1.9.13

package/mcp_server/memory/technique_store.py

@@ -26,10 +26,26 @@ class TechniqueStore:
         if base_dir is None:
             base_dir = os.path.join(os.path.expanduser("~"), ".livepilot", "memory")
         self._base_dir = Path(base_dir)
-        self._base_dir.mkdir(parents=True, exist_ok=True)
         self._file = self._base_dir / "techniques.json"
         self._lock = threading.Lock()
-
+        self._initialized = False
+        self._data: dict = {"version": 1, "techniques": []}
+
+    def _ensure_initialized(self) -> None:
+        """Lazily create directory and load data on first access.
+
+        Deferred so that a read-only HOME doesn't crash the entire MCP
+        server at import time — memory tools just return errors instead.
+        """
+        if self._initialized:
+            return
+        try:
+            self._base_dir.mkdir(parents=True, exist_ok=True)
+        except OSError as exc:
+            raise RuntimeError(
+                f"Cannot create memory directory {self._base_dir}: {exc}. "
+                "Memory tools are unavailable."
+            ) from exc
         if self._file.exists():
             try:
                 with open(self._file, "r") as f:
@@ -41,6 +57,7 @@ class TechniqueStore:
         else:
             self._data = {"version": 1, "techniques": []}
             self._flush()
+        self._initialized = True
 
     # ── persistence ──────────────────────────────────────────────
 
@@ -64,6 +81,7 @@ class TechniqueStore:
         tags: Optional[list[str]] = None,
     ) -> dict:
         """Create a new technique. Returns {id, name, type, summary}."""
+        self._ensure_initialized()
         if type not in VALID_TYPES:
             raise ValueError(
                 f"INVALID_PARAM: type must be one of {sorted(VALID_TYPES)}, got '{type}'"
@@ -99,6 +117,7 @@ class TechniqueStore:
 
     def get(self, technique_id: str) -> dict:
         """Return full technique by id."""
+        self._ensure_initialized()
         with self._lock:
             for t in self._data["techniques"]:
                 if t["id"] == technique_id:
@@ -113,6 +132,9 @@ class TechniqueStore:
         limit: int = 10,
     ) -> list[dict]:
         """Search techniques. Returns summaries (no payload)."""
+        self._ensure_initialized()
+        if limit < 0:
+            raise ValueError("INVALID_PARAM: limit must be >= 0")
         with self._lock:
             results = copy.deepcopy(self._data["techniques"])
 
@@ -150,6 +172,9 @@ class TechniqueStore:
         limit: int = 20,
     ) -> list[dict]:
         """List techniques as compact summaries."""
+        self._ensure_initialized()
+        if limit < 0:
+            raise ValueError("INVALID_PARAM: limit must be >= 0")
         if sort_by not in VALID_SORT_FIELDS:
             raise ValueError(
                 f"INVALID_PARAM: sort_by must be one of {sorted(VALID_SORT_FIELDS)}, got '{sort_by}'"
@@ -179,6 +204,7 @@ class TechniqueStore:
         rating: Optional[int] = None,
     ) -> dict:
         """Set favorite flag and/or rating."""
+        self._ensure_initialized()
         if rating is not None and (rating < 0 or rating > 5):
             raise ValueError("INVALID_PARAM: rating must be between 0 and 5")
 
@@ -200,6 +226,7 @@ class TechniqueStore:
         qualities: Optional[dict] = None,
     ) -> dict:
         """Update technique fields. Qualities are merged (lists replaced)."""
+        self._ensure_initialized()
         with self._lock:
             t = self._find(technique_id)
             if name is not None:
@@ -216,6 +243,7 @@ class TechniqueStore:
 
     def delete(self, technique_id: str) -> dict:
         """Delete technique after creating a timestamped backup."""
+        self._ensure_initialized()
         with self._lock:
             t = self._find(technique_id)
             # backup

package/mcp_server/server.py

@@ -119,12 +119,20 @@ from .tools import perception   # noqa: F401, E402
 
 def _coerce_schema_property(prop: dict) -> None:
     """Widen a single JSON Schema property to also accept strings."""
-    if prop.get("type") in ("integer", "number"):
+    if prop.get("type") in ("integer", "number") and "anyOf" not in prop:
         original_type = prop.pop("type")
         prop["anyOf"] = [{"type": original_type}, {"type": "string"}]
     elif "anyOf" in prop:
+        # Skip if this anyOf was already coerced (contains both a numeric and string type)
+        variant_types = {v.get("type") for v in prop["anyOf"] if isinstance(v, dict)}
+        if "string" in variant_types and variant_types & {"integer", "number"}:
+            return
         for variant in prop["anyOf"]:
-            _coerce_schema_property(variant)
+            if isinstance(variant, dict):
+                _coerce_schema_property(variant)
+    # Recurse into array items so list[int]/list[float] params also accept strings
+    if "items" in prop and isinstance(prop["items"], dict):
+        _coerce_schema_property(prop["items"])
 
 
 def _get_all_tools():

package/mcp_server/tools/analyzer.py

@@ -590,7 +590,18 @@ async def capture_audio(
     if source not in ("master",):
         raise ValueError(f"Unsupported source '{source}'. Valid: 'master'")
 
+    # Sanitize filename — strip directory components to prevent path traversal
+    if filename:
+        safe_name = os.path.basename(filename)
+        if not safe_name or safe_name != filename:
+            raise ValueError(
+                f"Filename must not contain path separators or '..' segments: {filename!r}"
+            )
+        filename = safe_name
+
     bridge = _get_m4l(ctx)
+    # Ensure captures directory exists before sending to bridge
+    os.makedirs(CAPTURE_DIR, exist_ok=True)
     duration_ms = duration_seconds * 1000
     result = await bridge.send_capture(
         "capture_audio",
@@ -613,7 +624,7 @@ async def capture_stop(ctx: Context) -> dict:
     _require_analyzer(cache)
     bridge = _get_m4l(ctx)
     # Cancel the capture future so send_capture doesn't hang forever
-    bridge.cancel_capture_future()
+    await bridge.cancel_capture_future()
     return await bridge.send_command("capture_stop")
 
 

package/mcp_server/tools/arrangement.py

@@ -162,7 +162,10 @@ def add_arrangement_notes(
     _validate_track_index(track_index)
     _validate_clip_index(clip_index)
     if isinstance(notes, str):
-        notes = json.loads(notes)
+        try:
+            notes = json.loads(notes)
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"Invalid JSON in notes parameter: {exc}") from exc
     for note in notes:
         _validate_note(note)
     return _get_ableton(ctx).send_command("add_arrangement_notes", {
@@ -206,7 +209,10 @@ def set_arrangement_automation(
     if parameter_type == "send" and send_index is None:
         raise ValueError("send_index required for parameter_type='send'")
     if isinstance(points, str):
-        points = json.loads(points)
+        try:
+            points = json.loads(points)
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"Invalid JSON in points parameter: {exc}") from exc
     if not points:
         raise ValueError("points list cannot be empty")
     params: dict = {
@@ -352,7 +358,10 @@ def remove_arrangement_notes_by_id(
     _validate_track_index(track_index)
     _validate_clip_index(clip_index)
     if isinstance(note_ids, str):
-        note_ids = json.loads(note_ids)
+        try:
+            note_ids = json.loads(note_ids)
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"Invalid JSON in note_ids parameter: {exc}") from exc
     if not note_ids:
         raise ValueError("note_ids list cannot be empty")
     return _get_ableton(ctx).send_command("remove_arrangement_notes_by_id", {
@@ -374,7 +383,10 @@ def modify_arrangement_notes(
     _validate_track_index(track_index)
     _validate_clip_index(clip_index)
     if isinstance(modifications, str):
-        modifications = json.loads(modifications)
+        try:
+            modifications = json.loads(modifications)
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"Invalid JSON in modifications parameter: {exc}") from exc
     if not modifications:
         raise ValueError("modifications list cannot be empty")
     for mod in modifications:
@@ -407,7 +419,10 @@ def duplicate_arrangement_notes(
     _validate_track_index(track_index)
     _validate_clip_index(clip_index)
     if isinstance(note_ids, str):
-        note_ids = json.loads(note_ids)
+        try:
+            note_ids = json.loads(note_ids)
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"Invalid JSON in note_ids parameter: {exc}") from exc
     if not note_ids:
         raise ValueError("note_ids list cannot be empty")
     return _get_ableton(ctx).send_command("duplicate_arrangement_notes", {

package/mcp_server/tools/automation.py

@@ -43,6 +43,10 @@ def get_clip_automation(
     parameter name, and type (mixer/send/device). Use this to see
     what's already automated before writing new curves.
     """
+    if track_index < 0:
+        raise ValueError("track_index must be >= 0")
+    if clip_index < 0:
+        raise ValueError("clip_index must be >= 0")
     return _get_ableton(ctx).send_command("get_clip_automation", {
         "track_index": track_index,
         "clip_index": clip_index,
@@ -72,6 +76,17 @@ def set_clip_automation(
     Tip: Use apply_automation_shape to generate points from curves/recipes
     instead of calculating points manually.
     """
+    if track_index < 0:
+        raise ValueError("track_index must be >= 0")
+    if clip_index < 0:
+        raise ValueError("clip_index must be >= 0")
+    if parameter_type not in ("device", "volume", "panning", "send"):
+        raise ValueError("parameter_type must be 'device', 'volume', 'panning', or 'send'")
+    if parameter_type == "device":
+        if device_index is None or parameter_index is None:
+            raise ValueError("device_index and parameter_index required for parameter_type='device'")
+    if parameter_type == "send" and send_index is None:
+        raise ValueError("send_index required for parameter_type='send'")
     params: dict = {
         "track_index": track_index,
         "clip_index": clip_index,
@@ -102,11 +117,22 @@ def clear_clip_automation(
     If parameter_type is omitted, clears ALL envelopes.
     If provided, clears only that parameter's envelope.
     """
+    if track_index < 0:
+        raise ValueError("track_index must be >= 0")
+    if clip_index < 0:
+        raise ValueError("clip_index must be >= 0")
     params: dict = {
         "track_index": track_index,
         "clip_index": clip_index,
     }
     if parameter_type is not None:
+        if parameter_type not in ("device", "volume", "panning", "send"):
+            raise ValueError("parameter_type must be 'device', 'volume', 'panning', or 'send'")
+        if parameter_type == "device":
+            if device_index is None or parameter_index is None:
+                raise ValueError("device_index and parameter_index required for parameter_type='device'")
+        if parameter_type == "send" and send_index is None:
+            raise ValueError("send_index required for parameter_type='send'")
         params["parameter_type"] = parameter_type
     if device_index is not None:
         params["device_index"] = device_index
@@ -190,6 +216,19 @@ def apply_automation_shape(
     - Throws: use spike with short duration (1-2 beats)
     - Tremolo/pan: use sine with frequency in musical divisions
     """
+    # Validate indices and parameter_type (same rules as set_clip_automation)
+    if track_index < 0:
+        raise ValueError("track_index must be >= 0")
+    if clip_index < 0:
+        raise ValueError("clip_index must be >= 0")
+    if parameter_type not in ("device", "volume", "panning", "send"):
+        raise ValueError("parameter_type must be 'device', 'volume', 'panning', or 'send'")
+    if parameter_type == "device":
+        if device_index is None or parameter_index is None:
+            raise ValueError("device_index and parameter_index required for parameter_type='device'")
+    if parameter_type == "send" and send_index is None:
+        raise ValueError("send_index required for parameter_type='send'")
+
     # Generate the curve
     points = generate_curve(
         curve_type=curve_type,
@@ -272,6 +311,19 @@ def apply_automation_recipe(
     - vinyl_crackle: slow bit reduction movement
     - stereo_narrow: collapse to mono before drop
     """
+    # Validate indices and parameter_type (same rules as set_clip_automation)
+    if track_index < 0:
+        raise ValueError("track_index must be >= 0")
+    if clip_index < 0:
+        raise ValueError("clip_index must be >= 0")
+    if parameter_type not in ("device", "volume", "panning", "send"):
+        raise ValueError("parameter_type must be 'device', 'volume', 'panning', or 'send'")
+    if parameter_type == "device":
+        if device_index is None or parameter_index is None:
+            raise ValueError("device_index and parameter_index required for parameter_type='device'")
+    if parameter_type == "send" and send_index is None:
+        raise ValueError("send_index required for parameter_type='send'")
+
     points = generate_from_recipe(recipe, duration=duration, density=density)
 
     if time_offset > 0:

package/mcp_server/tools/devices.py

@@ -180,12 +180,11 @@ def _postflight_loaded_device(ctx: Context, result: dict) -> dict:
 
 def _validate_track_index(track_index: int):
     if track_index < 0 and track_index != MASTER_TRACK_INDEX:
-        if track_index < -100:
+        if not (-99 <= track_index <= -1):
             raise ValueError(
                 "track_index must be >= 0 for regular tracks, "
-                "negative for return tracks (-1=A, -2=B), or -1000 for master"
+                "-1..-99 for return tracks (-1=A, -2=B), or -1000 for master"
             )
-        # Negative values -1..-99 are valid return track indices
 
 
 def _validate_device_index(device_index: int):

package/mcp_server/tools/generative.py

@@ -94,6 +94,10 @@ def layer_euclidean_rhythms(
     for layer in layers:
         p = int(layer["pulses"])
         s = int(layer["steps"])
+        if s < 1 or s > 64:
+            raise ValueError(f"steps must be between 1 and 64, got {s}")
+        if p < 0 or p > s:
+            raise ValueError(f"pulses must be between 0 and steps ({s}), got {p}")
         rot = int(layer.get("rotation", 0))
         pitch = int(layer["pitch"])
         vel = int(layer.get("velocity", 100))

package/mcp_server/tools/midi_io.py

@@ -51,6 +51,22 @@ def _output_dir() -> Path:
     return d
 
 
+def _safe_output_path(directory: Path, filename: str) -> Path:
+    """Join *filename* to *directory* with path-traversal containment.
+
+    Strips directory components (``../../evil.mid`` → ``evil.mid``),
+    resolves the result, and verifies it is still inside *directory*.
+    Raises ``ValueError`` on any escape attempt.
+    """
+    safe_name = Path(filename).name          # strip directory components
+    if not safe_name:
+        raise ValueError(f"Invalid filename: {filename!r}")
+    out = (directory / safe_name).resolve()
+    if not str(out).startswith(str(directory.resolve())):
+        raise ValueError(f"Filename escapes output directory: {filename!r}")
+    return out
+
+
 def _validate_midi_path(file_path: str) -> Path:
     p = Path(file_path)
     if not p.exists():
@@ -112,7 +128,7 @@ def export_clip_midi(
     if not filename.endswith((".mid", ".midi")):
         filename += ".mid"
 
-    out_path = _output_dir() / filename
+    out_path = _safe_output_path(_output_dir(), filename)
 
     midi = MIDIFile(1)
     midi.addTempo(0, 0, tempo)
@@ -185,9 +201,11 @@ def import_midi_to_clip(
                 "clip_index": clip_index,
             })
             slot_has_clip = True
-        except AbletonConnectionError:
-            # Slot is empty — no clip to clear
-            pass
+        except AbletonConnectionError as exc:
+            msg = str(exc)
+            if "NOT_FOUND" not in msg and "STATE_ERROR" not in msg:
+                raise  # propagate INDEX_ERROR, TIMEOUT, connection failures
+            # Slot is empty (NOT_FOUND) or no clip (STATE_ERROR)
 
         if slot_has_clip:
             # Clip exists — clear its notes before importing

package/mcp_server/tools/theory.py

@@ -669,7 +669,14 @@ def transpose_smart(
 
     source_tonic = source_key["tonic"]
     target_tonic = target["tonic"]
-    semitone_shift = target_tonic - source_tonic
+    # Compute nearest-path semitone shift (never more than ±6)
+    raw_shift = target_tonic - source_tonic
+    if raw_shift > 6:
+        semitone_shift = raw_shift - 12
+    elif raw_shift < -6:
+        semitone_shift = raw_shift + 12
+    else:
+        semitone_shift = raw_shift
 
     if mode == "chromatic":
         transposed = []

package/mcp_server/tools/transport.py

@@ -23,21 +23,31 @@ def get_session_info(ctx: Context) -> dict:
     return _get_ableton(ctx).send_command("get_session_info")
 
 
+def _validate_tempo(tempo: float) -> None:
+    """Validate tempo is within Ableton's accepted range."""
+    if not 20 <= tempo <= 999:
+        raise ValueError("Tempo must be between 20 and 999 BPM")
+
+
+def _validate_time_signature(numerator: int, denominator: int) -> None:
+    """Validate time signature components."""
+    if numerator < 1 or numerator > 99:
+        raise ValueError("Numerator must be between 1 and 99")
+    if denominator not in (1, 2, 4, 8, 16):
+        raise ValueError("Denominator must be 1, 2, 4, 8, or 16")
+
+
 @mcp.tool()
 def set_tempo(ctx: Context, tempo: float) -> dict:
     """Set the song tempo in BPM (20-999)."""
-    if not 20 <= tempo <= 999:
-        raise ValueError("Tempo must be between 20 and 999 BPM")
+    _validate_tempo(tempo)
     return _get_ableton(ctx).send_command("set_tempo", {"tempo": tempo})
 
 
 @mcp.tool()
 def set_time_signature(ctx: Context, numerator: int, denominator: int) -> dict:
     """Set the time signature (e.g., 4/4, 3/4, 6/8)."""
-    if numerator < 1 or numerator > 99:
-        raise ValueError("Numerator must be between 1 and 99")
-    if denominator not in (1, 2, 4, 8, 16):
-        raise ValueError("Denominator must be 1, 2, 4, 8, or 16")
+    _validate_time_signature(numerator, denominator)
     return _get_ableton(ctx).send_command("set_time_signature", {
         "numerator": numerator,
         "denominator": denominator,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.9.11",
+  "version": "1.9.13",
   "mcpName": "io.github.dreamrec/livepilot",
   "description": "Agentic production system for Ableton Live 12 — 178 tools, 17 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
   "author": "Pilot Studio",

package/remote_script/LivePilot/__init__.py

@@ -5,7 +5,7 @@ Entry point for the ControlSurface. Ableton calls create_instance(c_instance)
 when this script is selected in Preferences > Link, Tempo & MIDI.
 """
 
-__version__ = "1.9.11"
+__version__ = "1.9.13"
 
 from _Framework.ControlSurface import ControlSurface
 from .server import LivePilotServer
@@ -34,8 +34,8 @@ class LivePilot(ControlSurface):
         ControlSurface.__init__(self, c_instance)
         self._server = LivePilotServer(self)
         self._server.start()
-        self.log_message("LivePilot v%s initialized" % __version__)
-        self.show_message("LivePilot: Listening on port 9878")
+        self.log_message("LivePilot v%s starting..." % __version__)
+        self.show_message("LivePilot v%s starting..." % __version__)
 
     def disconnect(self):
         """Called by Ableton when the script is unloaded."""

package/remote_script/LivePilot/arrangement.py

@@ -85,29 +85,19 @@ def create_arrangement_clip(song, params):
         first_clip_index = None
 
         while pos < end_pos:
-            # Snapshot clip IDs before duplication to identify the new one
-            old_ids = set(id(c) for c in track.arrangement_clips)
-
             track.duplicate_clip_to_arrangement(source_clip, pos)
 
-            # Find the NEW clip (not in old_ids) at the target position
+            # Find the new clip by position (id()-based detection is unreliable
+            # because CPython can reuse addresses of GC'd LOM wrappers)
             arr_clips = list(track.arrangement_clips)
             new_clip = None
             new_clip_idx = None
             for i, c in enumerate(arr_clips):
-                if id(c) not in old_ids and abs(c.start_time - pos) < 0.01:
+                if abs(c.start_time - pos) < 0.01:
                     new_clip = c
                     new_clip_idx = i
                     break
 
-            # Fallback: if id-based detection fails, match by position
-            if new_clip is None:
-                for i, c in enumerate(arr_clips):
-                    if abs(c.start_time - pos) < 0.01:
-                        new_clip = c
-                        new_clip_idx = i
-                        break
-
             if new_clip is not None:
                 if first_clip_index is None:
                     first_clip_index = new_clip_idx
@@ -158,20 +148,24 @@ def create_arrangement_clip(song, params):
     finally:
         song.end_undo_step()
 
-    # Re-read to get accurate final state
+    # Re-read to get accurate final state — locate by start_time, not stored
+    # index, because the trim pass (remove_notes_extended) can shift indices.
     arr_clips = list(track.arrangement_clips)
-    if first_clip_index is None or first_clip_index >= len(arr_clips):
+    first_clip = None
+    for c in arr_clips:
+        if abs(c.start_time - start_time) < 0.01:
+            first_clip = c
+            break
+    if first_clip is None:
         raise ValueError("Failed to place any clips in arrangement")
-    first_clip = arr_clips[first_clip_index]
 
     return {
         "track_index": track_index,
-        "clip_index": first_clip_index,
         "start_time": start_time,
         "length": length,
         "clip_count": clip_count,
         "source_length": source_length,
-        "name": first_clip.name if first_clip else "",
+        "name": first_clip.name,
     }
 
 

package/remote_script/LivePilot/browser.py

@@ -76,13 +76,19 @@ def _navigate_path(browser, path):
     return current
 
 
+_MAX_SEARCH_ITERATIONS = 100000
+
+
 def _search_recursive(item, name_filter, loadable_only, results, depth, max_depth,
-                      max_results=100):
-    """Recursively search browser children."""
+                      max_results=100, _counter=None):
+    """Recursively search browser children with iteration cap."""
+    if _counter is None:
+        _counter = [0]  # mutable counter shared across recursion
     if depth > max_depth or len(results) >= max_results:
         return
     for child in item.children:
-        if len(results) >= max_results:
+        _counter[0] += 1
+        if _counter[0] > _MAX_SEARCH_ITERATIONS or len(results) >= max_results:
             return
         match = True
         if name_filter and name_filter.lower() not in child.name.lower():
@@ -102,7 +108,7 @@ def _search_recursive(item, name_filter, loadable_only, results, depth, max_dept
         if child.is_folder:
             _search_recursive(
                 child, name_filter, loadable_only, results, depth + 1, max_depth,
-                max_results
+                max_results, _counter
             )
             if len(results) >= max_results:
                 return
@@ -125,12 +131,17 @@ def get_browser_tree(song, params):
 
     result = []
     for name, item in categories.items():
-        children = list(item.children)
-        child_names = [c.name for c in children[:20]]
+        # Count lazily without materializing the full children list
+        children_preview = []
+        count = 0
+        for c in item.children:
+            count += 1
+            if len(children_preview) < 20:
+                children_preview.append(c.name)
         result.append({
             "name": name,
-            "children_count": len(children),
-            "children_preview": child_names,
+            "children_count": count,
+            "children_preview": children_preview,
         })
     return {"categories": result}
 

package/remote_script/LivePilot/clip_automation.py

@@ -20,16 +20,17 @@ def get_clip_automation(song, params):
     envelopes = []
 
     # Check mixer parameters: volume, panning, sends
+    # Use the specific parameter_type that set/clear accept (not generic "mixer")
     mixer = track.mixer_device
-    for param_name, param in [
-        ("Volume", mixer.volume),
-        ("Pan", mixer.panning),
+    for param_name, param_type, param in [
+        ("Volume", "volume", mixer.volume),
+        ("Pan", "panning", mixer.panning),
     ]:
         env = clip.automation_envelope(param)
         if env is not None:
             envelopes.append({
                 "parameter_name": param_name,
-                "parameter_type": "mixer",
+                "parameter_type": param_type,
                 "has_envelope": True,
             })
 

package/remote_script/LivePilot/clips.py

@@ -147,12 +147,14 @@ def set_clip_loop(song, params):
     clip_index = int(params["clip_index"])
     clip = get_clip(song, track_index, clip_index)
 
-    if "enabled" in params:
-        clip.looping = bool(params["enabled"])
-    if "start" in params:
-        clip.loop_start = float(params["start"])
+    # Set end before start to avoid Live's loop_start < loop_end clamping.
+    # Expanding the window first ensures the left edge can move freely.
     if "end" in params:
         clip.loop_end = float(params["end"])
+    if "start" in params:
+        clip.loop_start = float(params["start"])
+    if "enabled" in params:
+        clip.looping = bool(params["enabled"])
 
     return {
         "track_index": track_index,
@@ -199,11 +201,17 @@ def set_clip_warp_mode(song, params):
             "3=Re-Pitch, 4=Complex, 6=Complex Pro" % mode
         )
 
-    if "warping" in params:
-        clip.warping = bool(params["warping"])
+    # Enable warping first so warp_mode assignment is accepted by Live,
+    # then disable afterwards if requested.
+    enable_warping = params.get("warping")
+    if enable_warping is not None and bool(enable_warping):
+        clip.warping = True
 
     clip.warp_mode = mode
 
+    if enable_warping is not None and not bool(enable_warping):
+        clip.warping = False
+
     return {
         "track_index": track_index,
         "clip_index": clip_index,