livepilot 1.6.1 → 1.6.3

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 1.6.3 — Audit Hardening (March 2026)
+
+- Fix: cursor aliasing in M4L bridge `walk_device` — nested rack traversal now reads chain/pad counts before recursion clobbers shared cursors
+- Fix: `clip_automation.py` — use `get_clip()` for bounds-checked access, add negative index guards, proper validation in `clear_clip_automation`
+- Fix: `set_clip_loop` crash when `enabled` param omitted
+- Fix: Brownian curve reflection escaping [0,1] for large volatility
+- Fix: division by zero in M4L bridge when `sample_rate=0`
+- Fix: `technique_store.get()` shallow copy allows shared mutation — now uses deepcopy
+- Fix: `asyncio.get_event_loop()` deprecation — use `get_running_loop()` (Python 3.12+)
+- Fix: dead code in `browser.py`, stale tool counts in docs (107 → 115 core)
+- Fix: wrong param name in tool-reference docs (`soloed` → `solo`)
+- Fix: social banner missing "automation" domain (11 → 12)
+- Fix: tautological spring test, dead automation contract test, misleading clips test
+- Add: `livepilot-release` skill registered in plugin.json
+- Add: `__version__` to Remote Script `__init__.py`
+
+## 1.6.2 — Automation Params Fix (March 2026)
+
+- Fix: expose all curve-specific params in `generate_automation_curve` and `apply_automation_shape` MCP tools — `values` (steps), `hits`/`steps` (euclidean), `seed`/`drift`/`volatility` (organic), `damping`/`stiffness` (spring), `control1`/`control2` (bezier), `easing_type`, `narrowing` (stochastic)
+- Fix: `analyze_for_automation` spectral getter used wrong method (`.get_spectrum()` → `.get("spectrum")`)
+
 ## 1.6.1 — Hotfix (March 2026)
 
 - Fix: `clip_automation.py` imported `register` from `utils` instead of `router`, causing Remote Script to fail to load in Ableton (LivePilot disappeared from Control Surface list)

package/README.md

@@ -77,12 +77,64 @@ No other Ableton MCP server does this. Others have tools. LivePilot has tools +
 
 ---
 
+## Automation Intelligence
+
+Most DAW integrations let the AI set a parameter to a value. LivePilot lets the AI write **automation curves** — envelopes that evolve parameters over time inside clips. This is the difference between a static mix and a living one.
+
+### The Curve Engine
+
+16 mathematically precise curve types, organized in 4 categories:
+
+| Category | Curves | What they do |
+|----------|--------|-------------|
+| **Basic Waveforms** | `linear` · `exponential` · `logarithmic` · `s_curve` · `sine` · `sawtooth` · `spike` · `square` · `steps` | The building blocks. Exponential for filter sweeps (perceptually even). Logarithmic for volume fades (matches the ear). Spike for dub throws. Sawtooth for sidechain pumps. |
+| **Organic / Natural** | `perlin` · `brownian` · `spring` | What makes automation feel alive. Perlin noise for drifting textures. Brownian for analog-style parameter wander. Spring for realistic knob movements with overshoot and settle. |
+| **Shape Control** | `bezier` · `easing` | Precision curves for intentional design. Bezier with arbitrary control points. 8 easing types from the animation world: bounce, elastic, back overshoot, ease in/out. |
+| **Algorithmic** | `euclidean` · `stochastic` | Generative intelligence. Euclidean distributes automation events using the Bjorklund algorithm (the same math behind Euclidean rhythms). Stochastic applies Xenakis-inspired controlled randomness within narrowing bounds. |
+
+Every curve generates normalized points (0.0–1.0) that map to any parameter in Ableton — volume, pan, sends, device parameters, anything with an envelope.
+
+### 15 Production Recipes
+
+Named presets for common techniques. One tool call instead of manual point calculation:
+
+| Recipe | Curve | What it does |
+|--------|-------|-------------|
+| `filter_sweep_up` | exponential | LP filter opening over 8-32 bars |
+| `filter_sweep_down` | logarithmic | LP filter closing, mirrors the sweep up |
+| `dub_throw` | spike | Instant send spike for reverb/delay throws |
+| `tape_stop` | exponential | Pitch dropping to zero — steep deceleration |
+| `build_rise` | exponential | Tension build on HP filter + volume + reverb |
+| `sidechain_pump` | sawtooth | Volume ducking per beat — fast duck, slow recovery |
+| `fade_in` / `fade_out` | log / exp | Perceptually smooth volume fades |
+| `tremolo` | sine | Periodic volume oscillation |
+| `auto_pan` | sine | Stereo movement via pan |
+| `stutter` | square | Rapid on/off gating |
+| `breathing` | sine | Subtle filter movement — acoustic instrument feel |
+| `washout` | exponential | Reverb/delay feedback increasing to wash |
+| `vinyl_crackle` | sine | Slow bit reduction for lo-fi character |
+| `stereo_narrow` | exponential | Collapse stereo to mono before drop |
+
+### The Feedback Loop
+
+`analyze_for_automation` reads the spectrum and device chain, then suggests what to automate:
+
+1. **Reads the spectrum** — identifies frequency balance, sub content, dynamic range
+2. **Scans the device chain** — detects filters, reverbs, synths, distortion
+3. **Suggests automation targets** — "Filter detected → automate cutoff for movement", "Heavy sub content → HP filter sweep for builds"
+4. **Recommends recipes** — maps each suggestion to the right named recipe
+
+The AI doesn't just write automation — it knows what to automate based on what it hears.
+
+---
+
 ## What You Can Do
 
 - **Produce** — Create tracks, load instruments from the atlas, program drum patterns, bass lines, chord progressions, and melodies — informed by your saved techniques
 - **Arrange** — Build full song structures in arrangement view with MIDI editing, cue points, automation, and timeline navigation
 - **Design sounds** — Browse Ableton's library, load presets, tweak every device parameter, chain effects, walk nested racks 6 levels deep
 - **Mix with ears** — Set levels, panning, sends, and routing. Read the spectrum, check RMS, detect the key. The analyzer tells the AI what changed, not just what was set
+- **Automate intelligently** — Write clip automation with 16 mathematically precise curve types, apply named recipes (dub throws, filter sweeps, sidechain pumps), get spectral-aware suggestions for what to automate next
 - **Remember and evolve** — Save techniques, build a personal style library, replay past decisions exactly or as variations
 - **Chop samples** — Load audio into Simpler, slice, reverse, crop, warp, and reprogram — all from conversation
 - **Iterate fast** — Transpose, humanize, quantize, duplicate, and reshape patterns through conversation
@@ -244,7 +296,7 @@ npx -y github:dreamrec/LivePilot --status
 
 ---
 
-## 127 Tools Across 11 Domains
+## 135 Tools Across 12 Domains
 
 | Domain | Tools | What you can do |
 |--------|:-----:|-----------------|
@@ -257,6 +309,7 @@ npx -y github:dreamrec/LivePilot --status
 | **Mixing** | 11 | Volume, pan, sends, routing, meters, mix snapshot — return tracks and master fully supported |
 | **Browser** | 4 | Search Ableton's library, browse categories, load presets |
 | **Arrangement** | 19 | Create clips, full MIDI note CRUD, cue points, recording, automation |
+| **Automation** | 8 | Clip envelope CRUD, 16-type curve engine, 15 named recipes, spectral-aware suggestions |
 | **Memory** | 8 | Save, recall, replay, and manage production techniques |
 | **Analyzer** | 20 | Real-time spectral analysis, key detection, sample manipulation, warp markers, device introspection (requires M4L device) |
 
@@ -290,6 +343,9 @@ npx -y github:dreamrec/LivePilot --status
 ### Arrangement (19)
 `get_arrangement_clips` · `create_arrangement_clip` · `add_arrangement_notes` · `get_arrangement_notes` · `remove_arrangement_notes` · `remove_arrangement_notes_by_id` · `modify_arrangement_notes` · `duplicate_arrangement_notes` · `transpose_arrangement_notes` · `set_arrangement_clip_name` · `set_arrangement_automation` · `back_to_arranger` · `jump_to_time` · `capture_midi` · `start_recording` · `stop_recording` · `get_cue_points` · `jump_to_cue` · `toggle_cue_point`
 
+### Automation (8)
+`get_clip_automation` · `set_clip_automation` · `clear_clip_automation` · `apply_automation_shape` · `apply_automation_recipe` · `get_automation_recipes` · `generate_automation_curve` · `analyze_for_automation`
+
 ### Memory (8)
 `memory_learn` · `memory_recall` · `memory_get` · `memory_replay` · `memory_list` · `memory_favorite` · `memory_update` · `memory_delete`
 
@@ -334,7 +390,7 @@ The agent ships with a 2,700-line reference corpus (drum patterns, chord voicing
 
 The LivePilot Analyzer (`LivePilot_Analyzer.amxd`) gives the AI ears. Drop it on the master track and 20 additional tools unlock: 8-band spectral analysis, RMS/peak metering, Krumhansl-Schmuckler key detection, plus deep LOM access for sample manipulation, warp markers, device introspection, and human-readable parameter display values.
 
-All 107 core tools work without it. The analyzer is what turns LivePilot from a remote control into a feedback loop — the AI can set an EQ curve and then read the spectrum to verify the result.
+All 115 core tools work without it. The analyzer is what turns LivePilot from a remote control into a feedback loop — the AI can set an EQ curve and then read the spectrum to verify the result.
 
 ---
 
@@ -346,7 +402,7 @@ There are **15+ MCP servers for Ableton Live** as of March 2026. Here's how the
 
 | | [LivePilot](https://github.com/dreamrec/LivePilot) | [AbletonMCP](https://github.com/ahujasid/ableton-mcp) | [MCP Extended](https://github.com/uisato/ableton-mcp-extended) | [Ableton Copilot](https://github.com/xiaolaa2/ableton-copilot-mcp) | [AbletonBridge](https://github.com/hidingwill/AbletonBridge) | [Producer Pal](https://github.com/adamjmurray/producer-pal) |
 |---|:-:|:-:|:-:|:-:|:-:|:-:|
-| **Tools** | 127 | ~20 | ~35 | ~45 | 322 | ~25 |
+| **Tools** | 135 | ~20 | ~35 | ~45 | 322 | ~25 |
 | **Device knowledge** | 280+ devices | -- | -- | -- | -- | -- |
 | **Audio analysis** | Spectrum/RMS/key | -- | -- | -- | Metering | -- |
 | **Technique memory** | Persistent | -- | -- | -- | -- | -- |
@@ -363,6 +419,8 @@ There are **15+ MCP servers for Ableton Live** as of March 2026. Here's how the
 | Session clips | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | **Arrangement view** | ✅ | — | — | ✅ | ? | ? |
 | **Arrangement automation** | ✅ | — | — | — | ? | — |
+| **Clip automation (envelopes)** | ✅ | — | — | — | — | — |
+| **Automation curve engine** | ✅ | — | — | — | — | — |
 | MIDI notes (add/get) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | **MIDI notes (modify/delete by ID)** | ✅ | — | — | ✅ | ? | — |
 | **Per-note probability** | ✅ | — | — | — | — | — |
@@ -401,7 +459,7 @@ Every server on this list gives the AI tools to control Ableton. LivePilot is th
 
 The practical difference: other servers let the AI set a parameter. LivePilot lets the AI choose the right parameter based on what device is loaded (atlas), verify the result by reading the audio output (analyzer), and remember the technique for next time (memory).
 
-AbletonBridge has more raw tools (322 vs 127). Producer Pal has the easiest install (drag a .amxd). The original AbletonMCP has the community (2.3k stars). LivePilot has the deepest integration — tools that execute, knowledge that informs, perception that verifies, and memory that accumulates.
+AbletonBridge has more raw tools (322 vs 135). Producer Pal has the easiest install (drag a .amxd). The original AbletonMCP has the community (2.3k stars). LivePilot has the deepest integration — tools that execute, knowledge that informs, perception that verifies, and memory that accumulates.
 
 ---
 

package/m4l_device/livepilot_bridge.js

@@ -68,7 +68,7 @@ function anything() {
 function dispatch(cmd, args) {
     switch(cmd) {
         case "ping":
-            send_response({"ok": true, "version": "1.6.0"});
+            send_response({"ok": true, "version": "1.6.3"});
             break;
         case "get_params":
             cmd_get_params(args);
@@ -300,6 +300,8 @@ function cmd_walk_rack(args) {
 function walk_device(path, depth) {
     if (depth > 6) return {"error": "max depth reached"};
 
+    // Read all properties from cursor BEFORE recursing — recursion
+    // overwrites both cursors, so we must capture everything first.
     cursor_a.goto(path);
     var result = {
         name: cursor_a.get("name").toString(),
@@ -310,11 +312,15 @@ function walk_device(path, depth) {
         param_count: cursor_a.getcount("parameters")
     };
 
-    if (result.can_have_chains) {
-        var chain_count = cursor_a.getcount("chains");
+    // Capture chain/pad counts BEFORE recursion clobbers cursors
+    var chain_count = result.can_have_chains ? cursor_a.getcount("chains") : 0;
+    var pad_count = result.can_have_drum_pads ? cursor_a.getcount("drum_pads") : 0;
+
+    if (chain_count > 0) {
         result.chains = [];
         for (var c = 0; c < chain_count; c++) {
             var chain_path = path + " chains " + c;
+            // Re-goto cursor_b each iteration (recursion may have moved it)
             cursor_b.goto(chain_path);
             var chain = {
                 index: c,
@@ -329,10 +335,8 @@ function walk_device(path, depth) {
         }
     }
 
-    if (result.can_have_drum_pads) {
-        var pad_count = cursor_a.getcount("drum_pads");
+    if (pad_count > 0) {
         result.drum_pads = [];
-        // Only report populated pads (up to 128, but most are empty)
         for (var p = 0; p < Math.min(pad_count, 128); p++) {
             var pad_path = path + " drum_pads " + p;
             cursor_b.goto(pad_path);
@@ -686,7 +690,7 @@ function cmd_get_simpler_slices(args) {
         "playback_mode_name": ["Classic", "One-Shot", "Slicing"][playback_mode] || "Unknown",
         "sample_rate": sample_rate,
         "sample_length_frames": length,
-        "sample_length_seconds": length / sample_rate,
+        "sample_length_seconds": sample_rate > 0 ? length / sample_rate : 0,
         "slice_count": slices.length,
         "slices": slices
     });

package/mcp_server/__init__.py

@@ -1,2 +1,2 @@
 """LivePilot MCP Server — bridges MCP protocol to Ableton Live."""
-__version__ = "1.6.1"
+__version__ = "1.6.3"

package/mcp_server/curves.py

@@ -365,11 +365,12 @@ def _brownian(duration: float, density: int, start: float = 0.5,
         points.append({"time": t * duration, "value": value})
         step = drift / density + volatility * _det_random(i, seed)
         value += step
-        # Soft boundary reflection (bounce off 0/1 instead of hard clamp)
-        if value > 1.0:
-            value = 2.0 - value
-        elif value < 0.0:
-            value = -value
+        # Soft boundary reflection (bounce off 0/1 until within range)
+        while value > 1.0 or value < 0.0:
+            if value > 1.0:
+                value = 2.0 - value
+            if value < 0.0:
+                value = -value
     return points
 
 

package/mcp_server/m4l_bridge.py

@@ -234,7 +234,7 @@ class M4LBridge:
             return {"error": "LivePilot Analyzer not connected. Drop it on the master track."}
 
         # Create a future for the response
-        loop = asyncio.get_event_loop()
+        loop = asyncio.get_running_loop()
         future = loop.create_future()
         if self.receiver:
             self.receiver.set_response_future(future)

package/mcp_server/memory/technique_store.py

@@ -1,5 +1,6 @@
 """Persistent JSON store for LivePilot techniques (beat patterns, device chains, etc.)."""
 
+import copy
 import json
 import os
 import threading
@@ -101,7 +102,7 @@ class TechniqueStore:
         with self._lock:
             for t in self._data["techniques"]:
                 if t["id"] == technique_id:
-                    return dict(t)
+                    return copy.deepcopy(t)
         raise ValueError(f"NOT_FOUND: technique '{technique_id}' does not exist")
 
     def search(

package/mcp_server/server.py

@@ -18,7 +18,7 @@ async def lifespan(server):
     m4l = M4LBridge(spectral, receiver)
 
     # Start UDP listener for incoming M4L spectral data (port 9880)
-    loop = asyncio.get_event_loop()
+    loop = asyncio.get_running_loop()
     try:
         transport, _ = await loop.create_datagram_endpoint(
             lambda: receiver,

package/mcp_server/tools/analyzer.py

@@ -1,7 +1,7 @@
 """Analyzer MCP tools — real-time spectral analysis and deep LOM access.
 
 20 tools requiring the LivePilot Analyzer M4L device on the master track.
-These tools are optional — all 107 core tools work without the device.
+These tools are optional — all 115 core tools work without the device.
 """
 
 from __future__ import annotations

package/mcp_server/tools/automation.py

@@ -137,6 +137,26 @@ def apply_automation_shape(
     factor: float = 3.0,
     invert: bool = False,
     time_offset: float = 0.0,
+    # Steps params
+    values: Optional[list[float]] = None,
+    # Euclidean params
+    hits: int = 5,
+    steps: int = 16,
+    # Organic params
+    seed: float = 0.0,
+    drift: float = 0.0,
+    volatility: float = 0.1,
+    damping: float = 0.15,
+    stiffness: float = 8.0,
+    # Bezier params
+    control1: float = 0.0,
+    control2: float = 1.0,
+    control1_time: float = 0.33,
+    control2_time: float = 0.66,
+    # Easing params
+    easing_type: str = "ease_out",
+    # Stochastic params
+    narrowing: float = 0.5,
 ) -> dict:
     """Generate and apply an automation curve to a session clip.
 
@@ -177,6 +197,14 @@ def apply_automation_shape(
         low=low, high=high,
         factor=factor,
         invert=invert,
+        values=values or [],
+        hits=hits, steps=steps,
+        seed=seed, drift=drift, volatility=volatility,
+        damping=damping, stiffness=stiffness,
+        control1=control1, control2=control2,
+        control1_time=control1_time, control2_time=control2_time,
+        easing_type=easing_type,
+        narrowing=narrowing,
     )
 
     # Apply time offset
@@ -293,6 +321,26 @@ def generate_automation_curve(
     high: float = 1.0,
     factor: float = 3.0,
     invert: bool = False,
+    # Steps params
+    values: Optional[list[float]] = None,
+    # Euclidean params
+    hits: int = 5,
+    steps: int = 16,
+    # Organic params
+    seed: float = 0.0,
+    drift: float = 0.0,
+    volatility: float = 0.1,
+    damping: float = 0.15,
+    stiffness: float = 8.0,
+    # Bezier params
+    control1: float = 0.0,
+    control2: float = 1.0,
+    control1_time: float = 0.33,
+    control2_time: float = 0.66,
+    # Easing params
+    easing_type: str = "ease_out",
+    # Stochastic params
+    narrowing: float = 0.5,
 ) -> dict:
     """Generate automation curve points WITHOUT writing them.
 
@@ -312,6 +360,14 @@ def generate_automation_curve(
         low=low, high=high,
         factor=factor,
         invert=invert,
+        values=values or [],
+        hits=hits, steps=steps,
+        seed=seed, drift=drift, volatility=volatility,
+        damping=damping, stiffness=stiffness,
+        control1=control1, control2=control2,
+        control1_time=control1_time, control2_time=control2_time,
+        easing_type=easing_type,
+        narrowing=narrowing,
     )
     return {
         "curve_type": curve_type,
@@ -349,7 +405,8 @@ def analyze_for_automation(
     spectral = ctx.lifespan_context.get("spectral")
     spectrum = {}
     if spectral and spectral.is_connected:
-        spectrum = spectral.get_spectrum()
+        data = spectral.get("spectrum")
+        spectrum = data["value"] if data else {}
 
     # Get meter level
     meters = ableton.send_command("get_track_meters", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.6.1",
+  "version": "1.6.3",
   "mcpName": "io.github.dreamrec/livepilot",
   "description": "AI copilot for Ableton Live 12 — 135 tools, device atlas (280+ devices), real-time audio analysis, automation intelligence, and technique memory",
   "author": "Pilot Studio",

package/plugin/plugin.json

@@ -1,10 +1,11 @@
 {
   "name": "livepilot",
-  "version": "1.6.1",
+  "version": "1.6.3",
   "description": "AI copilot for Ableton Live 12 — 135 tools, device atlas (280+ devices), real-time audio analysis, automation intelligence, and technique memory",
   "author": "Pilot Studio",
   "skills": [
-    "skills/livepilot-core"
+    "skills/livepilot-core",
+    "skills/livepilot-release"
   ],
   "commands": [
     "commands/session.md",

package/plugin/skills/livepilot-core/references/overview.md

@@ -1,4 +1,4 @@
-# LivePilot v1.6.0 — Architecture & Tool Reference
+# LivePilot v1.6.3 — Architecture & Tool Reference
 
 LivePilot is an agentic production system for Ableton Live 12. It combines 135 MCP tools with a device knowledge corpus, real-time audio analysis, automation intelligence, and persistent technique memory.
 

package/plugin/skills/livepilot-release/SKILL.md

@@ -38,12 +38,12 @@ Run this checklist EVERY time the user says "update everything", "push", "releas
 - [ ] `mcp_server/tools/analyzer.py` → module docstring
 - [ ] `tests/test_tools_contract.py` → expected count
 
-**How to check:** `grep -rn "127\|104\|113" --include="*.md" --include="*.json" --include="*.py" --include="*.html" --include="*.js" . | grep -v node_modules | grep -v .git | grep -v __pycache__`
+**How to check:** `grep -rn "127\|128\|129\|130\|131\|132\|133\|134" --include="*.md" --include="*.json" --include="*.py" --include="*.html" --include="*.js" . | grep -v node_modules | grep -v .git | grep -v __pycache__`
 
 ## 3. Domain Count
 
-- [ ] All files above that mention "10 domains" should say "11 domains"
-- [ ] Domain lists should include: transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, analyzer
+- [ ] All files above that mention "11 domains" should say "12 domains"
+- [ ] Domain lists should include: transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, automation, memory, analyzer
 
 ## 4. npm Registry
 

package/remote_script/LivePilot/__init__.py

@@ -5,6 +5,8 @@ Entry point for the ControlSurface. Ableton calls create_instance(c_instance)
 when this script is selected in Preferences > Link, Tempo & MIDI.
 """
 
+__version__ = "1.6.3"
+
 from _Framework.ControlSurface import ControlSurface
 from .server import LivePilotServer
 from . import transport    # noqa: F401  — registers transport handlers
@@ -32,7 +34,7 @@ class LivePilot(ControlSurface):
         ControlSurface.__init__(self, c_instance)
         self._server = LivePilotServer(self)
         self._server.start()
-        self.log_message("LivePilot v1.6.1 initialized")
+        self.log_message("LivePilot v1.6.3 initialized")
         self.show_message("LivePilot: Listening on port 9878")
 
     def disconnect(self):

package/remote_script/LivePilot/browser.py

@@ -100,7 +100,6 @@ def _search_recursive(item, name_filter, loadable_only, results, depth, max_dept
                 entry["uri"] = None
             results.append(entry)
         if child.is_folder:
-            before = len(results)
             _search_recursive(
                 child, name_filter, loadable_only, results, depth + 1, max_depth,
                 max_results

package/remote_script/LivePilot/clip_automation.py

@@ -6,7 +6,7 @@ but targets session clips via track.clip_slots[i].clip.
 """
 
 from .router import register
-from .utils import get_track
+from .utils import get_track, get_clip
 
 
 @register("get_clip_automation")
@@ -16,12 +16,7 @@ def get_clip_automation(song, params):
     clip_index = params["clip_index"]
 
     track = get_track(song, track_index)
-    clip_slot = list(track.clip_slots)[clip_index]
-    if not clip_slot.has_clip:
-        return {"error": {"code": "NOT_FOUND",
-                "message": "No clip at slot %d" % clip_index}}
-
-    clip = clip_slot.clip
+    clip = get_clip(song, track_index, clip_index)
     envelopes = []
 
     # Check mixer parameters: volume, panning, sends
@@ -94,12 +89,7 @@ def set_clip_automation(song, params):
     send_index = params.get("send_index")
 
     track = get_track(song, track_index)
-    clip_slot = list(track.clip_slots)[clip_index]
-    if not clip_slot.has_clip:
-        return {"error": {"code": "NOT_FOUND",
-                "message": "No clip at slot %d" % clip_index}}
-
-    clip = clip_slot.clip
+    clip = get_clip(song, track_index, clip_index)
 
     # Resolve the target parameter
     if parameter_type == "volume":
@@ -111,7 +101,7 @@ def set_clip_automation(song, params):
             return {"error": {"code": "INVALID_PARAM",
                     "message": "send_index required for send automation"}}
         sends = list(track.mixer_device.sends)
-        if send_index >= len(sends):
+        if send_index < 0 or send_index >= len(sends):
             return {"error": {"code": "INDEX_ERROR",
                     "message": "send_index %d out of range" % send_index}}
         parameter = sends[send_index]
@@ -120,11 +110,11 @@ def set_clip_automation(song, params):
             return {"error": {"code": "INVALID_PARAM",
                     "message": "device_index and parameter_index required"}}
         devices = list(track.devices)
-        if device_index >= len(devices):
+        if device_index < 0 or device_index >= len(devices):
             return {"error": {"code": "INDEX_ERROR",
                     "message": "device_index %d out of range" % device_index}}
         dev_params = list(devices[device_index].parameters)
-        if parameter_index >= len(dev_params):
+        if parameter_index < 0 or parameter_index >= len(dev_params):
             return {"error": {"code": "INDEX_ERROR",
                     "message": "parameter_index %d out of range" % parameter_index}}
         parameter = dev_params[parameter_index]
@@ -173,12 +163,7 @@ def clear_clip_automation(song, params):
     parameter_type = params.get("parameter_type")
 
     track = get_track(song, track_index)
-    clip_slot = list(track.clip_slots)[clip_index]
-    if not clip_slot.has_clip:
-        return {"error": {"code": "NOT_FOUND",
-                "message": "No clip at slot %d" % clip_index}}
-
-    clip = clip_slot.clip
+    clip = get_clip(song, track_index, clip_index)
 
     song.begin_undo_step()
     try:
@@ -197,13 +182,30 @@ def clear_clip_automation(song, params):
         elif parameter_type == "panning":
             parameter = track.mixer_device.panning
         elif parameter_type == "send":
-            send_index = params.get("send_index", 0)
-            parameter = list(track.mixer_device.sends)[send_index]
+            send_index = params.get("send_index")
+            if send_index is None:
+                return {"error": {"code": "INVALID_PARAM",
+                        "message": "send_index required for send automation"}}
+            sends = list(track.mixer_device.sends)
+            if send_index < 0 or send_index >= len(sends):
+                return {"error": {"code": "INDEX_ERROR",
+                        "message": "send_index %d out of range" % send_index}}
+            parameter = sends[send_index]
         elif parameter_type == "device":
-            device_index = params.get("device_index", 0)
-            parameter_index = params.get("parameter_index", 0)
-            device = list(track.devices)[device_index]
-            parameter = list(device.parameters)[parameter_index]
+            device_index = params.get("device_index")
+            parameter_index = params.get("parameter_index")
+            if device_index is None or parameter_index is None:
+                return {"error": {"code": "INVALID_PARAM",
+                        "message": "device_index and parameter_index required"}}
+            devices = list(track.devices)
+            if device_index < 0 or device_index >= len(devices):
+                return {"error": {"code": "INDEX_ERROR",
+                        "message": "device_index %d out of range" % device_index}}
+            dev_params = list(devices[device_index].parameters)
+            if parameter_index < 0 or parameter_index >= len(dev_params):
+                return {"error": {"code": "INDEX_ERROR",
+                        "message": "parameter_index %d out of range" % parameter_index}}
+            parameter = dev_params[parameter_index]
         else:
             return {"error": {"code": "INVALID_PARAM",
                     "message": "Unknown parameter_type"}}

package/remote_script/LivePilot/clips.py

@@ -147,7 +147,8 @@ def set_clip_loop(song, params):
     clip_index = int(params["clip_index"])
     clip = get_clip(song, track_index, clip_index)
 
-    clip.looping = bool(params["enabled"])
+    if "enabled" in params:
+        clip.looping = bool(params["enabled"])
     if "start" in params:
         clip.loop_start = float(params["start"])
     if "end" in params: