livepilot 1.9.11 → 1.9.12

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
     {
       "name": "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",
-      "version": "1.9.11",
+      "version": "1.9.12",
       "author": {
         "name": "Pilot Studio"
       },

package/AGENTS.md

@@ -1,4 +1,4 @@
-# LivePilot v1.9.11 — Ableton Live 12
+# LivePilot v1.9.12 — Ableton Live 12
 
 ## Project
 - **Repo:** This directory (LivePilot)

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Changelog
 
+## 1.9.12 — Deep Audit: 21 Fixes Across 15 Files (April 2026)
+
+**Full codebase audit — 5 critical, 10 important, 6 doc/test fixes.**
+
+### Critical Fixes
+- Fix(P1): `capture_stop` no longer deadlocks — `cancel_capture_future` removed lock acquisition that blocked behind `send_capture`
+- Fix(P1): `import_midi_to_clip` now distinguishes empty-slot NOT_FOUND from INDEX_ERROR/TIMEOUT instead of swallowing all AbletonConnectionErrors
+- Fix(P1): capture audio files now write to `~/Documents/LivePilot/captures/` (stable path) instead of beside the .amxd preset
+- Fix(P1): `check_flucoma` now uses `Folder.end` to detect FluCoMa — `typelist` check was always true
+- Fix(P1): CI workflow updated to `actions/checkout@v4` + `actions/setup-python@v5` (v6 doesn't exist)
+
+### Safety & Validation
+- Fix(P2): 5 automation tools now validate `track_index >= 0` and `clip_index >= 0` (matching all peer modules)
+- Fix(P2): `cmd_stop_scrub` now checks `cursor_a.id === 0` for empty clip slots (matching all peer bridge functions)
+- Fix(P2): `cmd_get_selected` now resolves return tracks (negative indices) and master track (-1000)
+- Fix(P2): `duplicate_track` uses count-before/after delta for correct group track duplication index
+- Fix(P2): `create_arrangement_clip` locates first clip by `start_time` instead of stale index after trim pass
+- Fix(P2): `get_session_info` reuses already-built lists instead of re-iterating `song.tracks`/`song.scenes`
+- Fix(P2): client disconnect race — socket now closes before clearing `_client_connected` flag
+
+### Tests
+- Fix: transport validation tests now import production `_validate_tempo`/`_validate_time_signature` instead of testing local copies
+- Fix: added `load_sample_to_simpler` to analyzer tool contract (was 28/29)
+- Fix: removed duplicate `test_release_quick_verify_checks_both_plugin_manifests`
+- New: 5 automation negative tests (index validation, parameter_type validation)
+
+### Documentation
+- Fix: `docs/manual/index.md` domain map — Tracks 14→17, Devices 12→15, Scenes 8→12
+- Fix: README perception split — 145+33 → 149+29 (actual analyzer tool count is 29)
+- Fix: M4L_BRIDGE.md command count — 22→28 (6 commands undocumented)
+- Fix: tool-reference.md MIDI docs — `export_clip_midi` and `import_midi_to_clip` parameter tables matched to actual signatures
+
+### Deferred (documented, low-impact)
+- Timed-out commands still execute on main thread (needs cancellation token redesign)
+- Chunked UDP reassembly fragile on packet loss (loopback mitigates)
+- Diatonic transpose octave correction edge case (needs musical test suite)
+- `cmd_map_plugin_param` reports false success (LiveAPI lacks Configure mapping API)
+
+Verification: 145 tests passing (non-fastmcp), 178 tools confirmed, 15 files changed
+
 ## 1.9.11 — Session Diagnostics + Client Conflict Clarity (March 2026)
 
 **Live-tested against the open Ableton set after reloading the updated Remote Script.**
@@ -11,6 +51,13 @@
 - Fix(P2): `--status` and TCP timeout paths now explain when another LivePilot client appears to be connected instead of only reporting a generic timeout
 - Docs: beat/sounddesign/core skill guidance now includes device-health checks, sample-dependent plugin cautions, and pitch-audit discipline from the live stress-test sessions
 - Verification: `292 passed`, `npm pack --dry-run` passed, live set diagnostics succeeded, analyzer bridge streamed on the master track, and conflict reproduction now reports the competing client PID
+- Fix(P1): brownian automation curve reflection loop now has 100-iteration guard with hard clamp fallback — high volatility values could previously hang the server
+- Fix(P1): schema coercion now recurses into array `items` so `list[float]` params benefit from string-to-number widening for MCP clients that serialize as strings
+- Fix(P1): `apply_automation_shape` and `apply_automation_recipe` now validate `parameter_type` and required companion params before sending to Ableton
+- Fix(P2): Remote Script `AssertionError` fallbacks now return STATE_ERROR instead of running LOM calls on the TCP thread during ControlSurface disconnection
+- Fix(P2): M4L bridge ping version corrected to 1.9.11; `check_flucoma` now probes disk for FluCoMa package instead of returning hardcoded `true`
+- Verification: deep audit across 45+ files (3 parallel agents), 292 unit tests + 15 live integration tests against Ableton session, all passing
+
 ## 1.9.10 — Analyzer Capture Finalization + Release Sync (March 2026)
 
 **Live-tested in Ableton after a full analyzer rebuild and master-track validation.**

package/README.md

@@ -1,10 +1,11 @@
-<p align="center">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="docs/assets/banner-dark.svg">
-    <source media="(prefers-color-scheme: light)" srcset="docs/assets/banner-light.svg">
-    <img alt="LivePilot" src="docs/assets/banner-light.svg" width="600">
-  </picture>
-</p>
+```
+██╗     ██╗██╗   ██╗███████╗██████╗ ██╗██╗      ██████╗ ████████╗
+██║     ██║██║   ██║██╔════╝██╔══██╗██║██║     ██╔═══██╗╚══██╔══╝
+██║     ██║██║   ██║█████╗  ██████╔╝██║██║     ██║   ██║   ██║
+██║     ██║╚██╗ ██╔╝██╔══╝  ██╔═══╝ ██║██║     ██║   ██║   ██║
+███████╗██║ ╚████╔╝ ███████╗██║     ██║███████╗╚██████╔╝   ██║
+╚══════╝╚═╝  ╚═══╝  ╚══════╝╚═╝     ╚═╝╚══════╝ ╚═════╝    ╚═╝
+```
 
 <p align="center">
   <a href="https://github.com/dreamrec/LivePilot/actions"><img src="https://img.shields.io/github/actions/workflow/status/dreamrec/LivePilot/ci.yml?style=flat-square&label=CI" alt="CI"></a>
@@ -90,7 +91,7 @@ All three feed into 178 deterministic tools that execute on Ableton's main threa
 | Tracks | 17 | create MIDI/audio/return, delete, duplicate, arm, mute, solo, color, freeze, flatten |
 | Clips | 11 | create, delete, duplicate, fire, stop, loop, launch mode, warp mode, quantize |
 | Notes | 8 | add/get/remove/modify MIDI notes, transpose, duplicate, per-note probability |
-| Devices | 12 | load by name or URI, get/set parameters, batch edit, racks, chains, presets |
+| Devices | 15 | load by name or URI, get/set parameters, batch edit, racks, chains, presets, plugin deep control |
 | Scenes | 12 | create, delete, duplicate, fire, name, color, tempo, scene matrix |
 | Browser | 4 | search library, browse tree, load items, filter by category |
 | Mixing | 11 | volume, pan, sends, routing, meters, return tracks, master, full mix snapshot |
@@ -98,13 +99,13 @@ All three feed into 178 deterministic tools that execute on Ableton's main threa
 
 <br>
 
-### Perception — 32 tools `[M4L]`
+### Perception — 29 tools `[M4L]`
 
 The M4L Analyzer sits on the master track. UDP 9880 carries spectral data
 from Max to the server. OSC 9881 sends commands back.
 
 > [!TIP]
-> All 146 core tools work without the analyzer — it adds 32 more and closes the feedback loop.
+> All 149 core tools work without the analyzer — it adds 29 more and closes the feedback loop.
 
 ```
 SPECTRAL ─────── 8-band frequency decomposition (sub → air)

package/bin/livepilot.js

@@ -95,7 +95,7 @@ function ensureVenv(systemPython, prefixArgs) {
   // Check if venv already exists and has our deps
   if (fs.existsSync(venvPy)) {
     try {
-      execFileSync(venvPy, ["-c", "import fastmcp; import midiutil; import pretty_midi; import numpy; import pyloudnorm; import soundfile; import scipy"], {
+      execFileSync(venvPy, ["-c", "import fastmcp; import midiutil; import pretty_midi; import numpy; import pyloudnorm; import soundfile; import scipy; import mutagen"], {
         encoding: "utf-8",
         timeout: 10000,
         stdio: "pipe",

package/livepilot/.Codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.9.11",
+  "version": "1.9.12",
   "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": {
     "name": "Pilot Studio"

package/livepilot/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.9.11",
+  "version": "1.9.12",
   "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": {
     "name": "Pilot Studio"

package/livepilot/skills/livepilot-core/SKILL.md

@@ -138,8 +138,8 @@ Never skip levels. The user's question determines the entry point, but always st
 ### Transport (12)
 `get_session_info` · `set_tempo` · `set_time_signature` · `start_playback` · `stop_playback` · `continue_playback` · `toggle_metronome` · `set_session_loop` · `undo` · `redo` · `get_recent_actions` · `get_session_diagnostics`
 
-### Tracks (14)
-`get_track_info` · `create_midi_track` · `create_audio_track` · `create_return_track` · `delete_track` · `duplicate_track` · `set_track_name` · `set_track_color` · `set_track_mute` · `set_track_solo` · `set_track_arm` · `stop_track_clips` · `set_group_fold` · `set_track_input_monitoring`
+### Tracks (17)
+`get_track_info` · `create_midi_track` · `create_audio_track` · `create_return_track` · `delete_track` · `duplicate_track` · `set_track_name` · `set_track_color` · `set_track_mute` · `set_track_solo` · `set_track_arm` · `stop_track_clips` · `set_group_fold` · `set_track_input_monitoring` · `freeze_track` · `flatten_track` · `get_freeze_status`
 
 ### Clips (11)
 `get_clip_info` · `create_clip` · `delete_clip` · `duplicate_clip` · `fire_clip` · `stop_clip` · `set_clip_name` · `set_clip_color` · `set_clip_loop` · `set_clip_launch` · `set_clip_warp_mode`
@@ -147,11 +147,11 @@ Never skip levels. The user's question determines the entry point, but always st
 ### Notes (8)
 `add_notes` · `get_notes` · `remove_notes` · `remove_notes_by_id` · `modify_notes` · `duplicate_notes` · `transpose_notes` · `quantize_clip`
 
-### Devices (12)
-`get_device_info` · `get_device_parameters` · `set_device_parameter` · `batch_set_parameters` · `toggle_device` · `delete_device` · `load_device_by_uri` · `find_and_load_device` · `set_simpler_playback_mode` · `get_rack_chains` · `set_chain_volume` · `get_device_presets`
+### Devices (15)
+`get_device_info` · `get_device_parameters` · `set_device_parameter` · `batch_set_parameters` · `toggle_device` · `delete_device` · `load_device_by_uri` · `find_and_load_device` · `set_simpler_playback_mode` · `get_rack_chains` · `set_chain_volume` · `get_device_presets` · `get_plugin_parameters` · `map_plugin_parameter` · `get_plugin_presets`
 
-### Scenes (8)
-`get_scenes_info` · `create_scene` · `delete_scene` · `duplicate_scene` · `fire_scene` · `set_scene_name` · `set_scene_color` · `set_scene_tempo`
+### Scenes (12)
+`get_scenes_info` · `create_scene` · `delete_scene` · `duplicate_scene` · `fire_scene` · `set_scene_name` · `set_scene_color` · `set_scene_tempo` · `get_scene_matrix` · `fire_scene_clips` · `stop_all_clips` · `get_playing_clips`
 
 ### Mixing (11)
 `set_track_volume` · `set_track_pan` · `set_track_send` · `get_return_tracks` · `get_master_track` · `set_master_volume` · `get_track_routing` · `set_track_routing` · `get_track_meters` · `get_master_meters` · `get_mix_snapshot`

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

@@ -1,4 +1,4 @@
-# LivePilot v1.9.11 — Architecture & Tool Reference
+# LivePilot v1.9.12 — Architecture & Tool Reference
 
 Agentic production system for Ableton Live 12. 178 tools across 17 domains. Device atlas (280+ devices), spectral perception (M4L analyzer), technique memory, automation intelligence (16 curve types, 15 recipes), music theory (Krumhansl-Schmuckler, species counterpoint), generative algorithms (Euclidean rhythm, tintinnabuli, phase shift, additive process), neo-Riemannian harmony (PRL transforms, Tonnetz), MIDI file I/O.
 

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

@@ -29,12 +29,12 @@ Run this checklist EVERY time the user says "update everything", "push", "releas
 ## 2. Tool Count (must ALL match)
 
 Current: **178 tools across 17 domains**.
-Core (no M4L): **139**. Analyzer (M4L): **29**. Perception (offline): **4**.
+Core (no M4L): **149**. Analyzer (M4L): **29**. Perception (offline): **4**.
 
 Verify: `grep -rc "@mcp.tool" mcp_server/tools/ | grep -v ":0" | awk -F: '{sum+=$2} END{print sum}'`
 
 Files that reference tool count:
-- [ ] `README.md` — header, PERCEPTION section ("139 core...29 analyzer"), Analyzer table header "(29)", Perception table header "(4)"
+- [ ] `README.md` — header, PERCEPTION section ("149 core...29 analyzer"), Analyzer table header "(29)", Perception table header "(4)"
 - [ ] `package.json` → `"description"` (178 tools, 17 domains)
 - [ ] `server.json` → `"description"`
 - [ ] `livepilot/.Codex-plugin/plugin.json` → `"description"` (primary Codex manifest)
@@ -44,10 +44,10 @@ Files that reference tool count:
 - [ ] `livepilot/skills/livepilot-core/SKILL.md` — "178 tools across 17 domains", Analyzer (29), Perception (4)
 - [ ] `livepilot/skills/livepilot-core/references/overview.md` — "178 tools across 17 domains"
 - [ ] `docs/manual/index.md` — domain table: Analyzer (29), Perception (4)
-- [ ] `docs/manual/getting-started.md` — "139 core tools...29 analyzer"
+- [ ] `docs/manual/getting-started.md` — "149 core tools...29 analyzer"
 - [ ] `docs/manual/tool-reference.md` — all domains present with correct counts
 - [ ] `docs/TOOL_REFERENCE.md` — all domains present
-- [ ] `docs/M4L_BRIDGE.md` — "139 core tools...29 analyzer"
+- [ ] `docs/M4L_BRIDGE.md` — "149 core tools...29 analyzer"
 - [ ] `docs/social-banner.html`
 - [ ] `mcp_server/tools/analyzer.py` → module docstring
 - [ ] `tests/test_tools_contract.py` → expected total count

package/m4l_device/livepilot_bridge.js

@@ -84,7 +84,7 @@ function anything() {
 function dispatch(cmd, args) {
     switch(cmd) {
         case "ping":
-            send_response({"ok": true, "version": "1.9.10"});
+            send_response({"ok": true, "version": "1.9.12"});
             break;
         case "get_params":
             cmd_get_params(args);
@@ -150,7 +150,7 @@ function dispatch(cmd, args) {
             cmd_capture_stop();
             break;
         case "check_flucoma":
-            send_response({"flucoma_available": true, "version": "1.0.9"});
+            cmd_check_flucoma();
             break;
         // ── Phase 2: Clip & Display ──
         case "scrub_clip":
@@ -458,6 +458,22 @@ function cmd_get_chains_deep(args) {
     }
 }
 
+function cmd_check_flucoma() {
+    // Check if FluCoMa externals are installed.
+    // Max JS cannot reliably probe the object search path at runtime,
+    // so we check if the FluCoMa package folder exists on disk.
+    try {
+        var pkg_path = max.appsupportpath + "/Packages/FluidCorpusManipulation";
+        var f = new Folder(pkg_path);
+        var available = !f.end;  // end === true means folder not found
+        f.close();
+        send_response({"flucoma_available": available});
+    } catch (e) {
+        // Can't probe — report unknown rather than lying
+        send_response({"flucoma_available": false, "probe_error": String(e)});
+    }
+}
+
 function cmd_get_track_cpu(args) {
     try {
         var results = [];
@@ -511,6 +527,25 @@ function cmd_get_selected() {
                 break;
             }
         }
+        // Check return tracks if not found in main tracks
+        if (result.selected_track === -1) {
+            cursor_a.goto("live_set");
+            var rtc = cursor_a.getcount("return_tracks");
+            for (var j = 0; j < rtc; j++) {
+                cursor_a.goto("live_set return_tracks " + j);
+                if (cursor_a.get("name").toString() === result.selected_track_name) {
+                    result.selected_track = -(j + 1);  // -1, -2, ... convention
+                    break;
+                }
+            }
+        }
+        // Check master track if still not found
+        if (result.selected_track === -1) {
+            cursor_a.goto("live_set master_track");
+            if (cursor_a.get("name").toString() === result.selected_track_name) {
+                result.selected_track = -1000;  // master convention
+            }
+        }
     } catch(e) {}
 
     // Selected scene
@@ -1067,6 +1102,10 @@ function cmd_stop_scrub(args) {
     var path = build_track_path(track_idx) + " clip_slots " + clip_idx + " clip";
 
     cursor_a.goto(path);
+    if (cursor_a.id === 0) {
+        send_response({"error": "No clip at track " + track_idx + " slot " + clip_idx});
+        return;
+    }
     try {
         cursor_a.call("stop_scrub");
         send_response({"ok": true});
@@ -1165,6 +1204,15 @@ function cmd_capture_audio(args) {
     var duration_ms = parseInt(args[0]) || 10000;
     var requested_name = args[1] ? args[1].toString().trim() : "";
 
+    // Sanitize filename — strip any directory components (defense-in-depth)
+    if (requested_name.length > 0) {
+        requested_name = _safe_filename(requested_name);
+        if (!requested_name || requested_name.length === 0) {
+            send_response({"error": "Invalid capture filename (path traversal blocked)"});
+            return;
+        }
+    }
+
     // Generate a timestamped filename if none provided
     var d = new Date();
     var ts = d.getFullYear() + "_"
@@ -1172,7 +1220,7 @@ function cmd_capture_audio(args) {
         + pad2(d.getDate()) + "_"
         + pad2(d.getHours()) + pad2(d.getMinutes()) + pad2(d.getSeconds());
     capture_filename = requested_name.length > 0 ? requested_name : ("capture_" + ts + ".wav");
-    capture_file_path = _join_path(_get_patcher_dir(), capture_filename);
+    capture_file_path = _join_path(_get_captures_dir(), capture_filename);
 
     // Calculate sample count from duration and current sample rate
     var num_samples = Math.ceil((duration_ms / 1000.0) * current_sample_rate);
@@ -1438,6 +1486,22 @@ function build_device_path(track_idx, device_idx) {
     }
 }
 
+function _get_captures_dir() {
+    // Stable captures directory: ~/Documents/LivePilot/captures/
+    // max.appsupportpath = "/Users/<name>/Library/Application Support/Cycling '74"
+    // Walk up to get home directory
+    try {
+        var support = max.appsupportpath;
+        var parts = support.split("/");
+        // /Users/<name>/Library/... → first 3 parts = /Users/<name>
+        var home = parts.slice(0, 3).join("/");
+        return home + "/Documents/LivePilot/captures/";
+    } catch (e) {
+        // Fallback to patcher directory if home detection fails
+        return _get_patcher_dir();
+    }
+}
+
 function _get_patcher_dir() {
     try {
         var filepath = this.patcher && this.patcher.filepath ? this.patcher.filepath.toString() : "";
@@ -1450,6 +1514,16 @@ function _get_patcher_dir() {
     }
 }
 
+function _safe_filename(name) {
+    // Strip directory components and reject traversal attempts.
+    // This is defense-in-depth — Python should sanitize first.
+    if (!name || name.length === 0) return name;
+    var slash = Math.max(name.lastIndexOf("/"), name.lastIndexOf("\\"));
+    if (slash >= 0) name = name.substring(slash + 1);
+    if (name === "." || name === ".." || name.length === 0) return "";
+    return name;
+}
+
 function _join_path(dir, file) {
     if (!dir) return file;
     var last = dir.charAt(dir.length - 1);

package/mcp_server/__init__.py

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

package/mcp_server/connection.py

@@ -213,7 +213,7 @@ class AbletonConnection:
             raise AbletonConnectionError(f"Failed to send command: {exc}") from exc
 
         # Read until newline, preserving any trailing bytes in _recv_buf
-        buf = getattr(self, "_recv_buf", b"")
+        buf = self._recv_buf
         try:
             while b"\n" not in buf:
                 chunk = self._socket.recv(4096)
@@ -222,6 +222,10 @@ class AbletonConnection:
                     self.disconnect()
                     raise AbletonConnectionError("Connection closed by Ableton")
                 buf += chunk
+                if len(buf) > 10 * 1024 * 1024:  # 10 MB
+                    self._recv_buf = b""
+                    self.disconnect()
+                    raise AbletonConnectionError("Response too large (>10 MB)")
         except socket.timeout as exc:
             self._recv_buf = buf
             self.disconnect()

package/mcp_server/curves.py

@@ -366,11 +366,15 @@ def _brownian(duration: float, density: int, start: float = 0.5,
         step = drift / density + volatility * _det_random(i, seed)
         value += step
         # Soft boundary reflection (bounce off 0/1 until within range)
-        while value > 1.0 or value < 0.0:
+        for _ in range(100):
+            if 0.0 <= value <= 1.0:
+                break
             if value > 1.0:
                 value = 2.0 - value
             if value < 0.0:
                 value = -value
+        else:
+            value = max(0.0, min(1.0, value))
     return points
 
 

package/mcp_server/m4l_bridge.py

@@ -141,6 +141,7 @@ class SpectralReceiver(asyncio.DatagramProtocol):
     def __init__(self, cache: SpectralCache):
         self.cache = cache
         self._chunks: dict[str, dict] = {}  # Reassembly buffer for chunked responses
+        self._chunk_times: dict[str, float] = {}  # Monotonic timestamp per chunk sequence
         self._chunk_id = 0
         self._response_callback: Optional[asyncio.Future] = None
         self._capture_future: Optional[asyncio.Future] = None
@@ -284,6 +285,7 @@ class SpectralReceiver(asyncio.DatagramProtocol):
         key = str(self._chunk_id)
         if key not in self._chunks:
             self._chunks[key] = {"parts": {}, "total": total}
+            self._chunk_times[key] = time.monotonic()
 
         self._chunks[key]["parts"][index] = encoded
 
@@ -293,8 +295,16 @@ class SpectralReceiver(asyncio.DatagramProtocol):
             for i in range(total):
                 full += self._chunks[key]["parts"][i]
             del self._chunks[key]
+            self._chunk_times.pop(key, None)
             self._handle_response(full)
 
+        # Evict incomplete chunk sequences older than 30 seconds
+        now = time.monotonic()
+        stale = [k for k, t in self._chunk_times.items() if now - t > 30.0]
+        for k in stale:
+            self._chunks.pop(k, None)
+            self._chunk_times.pop(k, None)
+
     def _handle_capture_complete(self, encoded: str) -> None:
         """Decode a /capture_complete OSC message and resolve _capture_future."""
         try:
@@ -359,30 +369,37 @@ class M4LBridge:
         if not self.cache.is_connected:
             return {"error": "LivePilot Analyzer not connected. Drop it on the master track."}
 
-        # Cancel any stale capture future before creating a new one
-        if self.receiver and self.receiver._capture_future and not self.receiver._capture_future.done():
-            self.receiver._capture_future.cancel()
+        async with self._cmd_lock:
+            # Cancel any stale capture future before creating a new one
+            if self.receiver and self.receiver._capture_future and not self.receiver._capture_future.done():
+                self.receiver._capture_future.cancel()
 
-        loop = asyncio.get_running_loop()
-        future = loop.create_future()
-        if self.receiver:
-            self.receiver.set_capture_future(future)
+            loop = asyncio.get_running_loop()
+            future = loop.create_future()
+            if self.receiver:
+                self.receiver.set_capture_future(future)
 
-        osc_data = self._build_osc(command, args)
-        self._sock.sendto(osc_data, self._m4l_addr)
+            osc_data = self._build_osc(command, args)
+            self._sock.sendto(osc_data, self._m4l_addr)
 
-        try:
-            result = await asyncio.wait_for(future, timeout=timeout)
-            return result
-        except asyncio.TimeoutError:
-            # Clean up the dangling future
-            if self.receiver:
-                self.receiver._capture_future = None
-            return {"error": "M4L capture timeout — device may be busy or removed"}
+            try:
+                result = await asyncio.wait_for(future, timeout=timeout)
+                return result
+            except asyncio.TimeoutError:
+                # Clean up the dangling future
+                if self.receiver:
+                    self.receiver._capture_future = None
+                return {"error": "M4L capture timeout — device may be busy or removed"}
 
-    def cancel_capture_future(self) -> None:
-        """Cancel any in-progress capture future (called by capture_stop)."""
-        if self.receiver and self.receiver._capture_future and not self.receiver._capture_future.done():
+    async def cancel_capture_future(self) -> None:
+        """Cancel any in-progress capture future (called by capture_stop).
+
+        Does NOT acquire _cmd_lock — send_capture holds it during recording.
+        Cancelling the future causes send_capture's wait_for to raise
+        CancelledError, which releases the lock naturally.
+        """
+        if self.receiver and self.receiver._capture_future \
+                and not self.receiver._capture_future.done():
             self.receiver._capture_future.cancel()
             self.receiver._capture_future = None
 

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.12",
   "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.12"
 
 from _Framework.ControlSurface import ControlSurface
 from .server import LivePilotServer

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,

package/remote_script/LivePilot/devices.py

@@ -3,6 +3,7 @@ LivePilot - Device domain handlers (11 commands).
 """
 
 import Live
+from collections import deque
 
 from .router import register
 from .utils import get_track, get_device
@@ -178,6 +179,8 @@ def toggle_device(song, params):
             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]
 
     on_param.value = 1.0 if active else 0.0
@@ -399,10 +402,10 @@ def find_and_load_device(song, params):
         This ensures raw 'Operator' is found before 'Hello Operator.adg' buried
         in a user_library subfolder."""
         nonlocal iterations
-        # Queue of (item, depth) tuples
-        queue = [(category, 0)]
+        # Queue of (item, depth) tuples — deque for O(1) popleft
+        queue = deque([(category, 0)])
         while queue:
-            item, depth = queue.pop(0)
+            item, depth = queue.popleft()
             if depth > 8:
                 continue
             try:

package/remote_script/LivePilot/server.py

@@ -187,12 +187,12 @@ class LivePilotServer(object):
         except OSError as exc:
             self._log("Client error: %s" % exc)
         finally:
-            with self._client_lock:
-                self._client_connected = False
             try:
                 client.close()
             except OSError:
                 pass
+            with self._client_lock:
+                self._client_connected = False
             self._log("Client disconnected")
 
     def _handle_client(self, client):
@@ -205,6 +205,9 @@ class LivePilotServer(object):
                 if not data:
                     break
                 buf += data.decode("utf-8", errors="replace")
+                if len(buf) > 4 * 1024 * 1024:  # 4 MB
+                    self._log("Client buffer overflow — disconnecting")
+                    break
                 while "\n" in buf:
                     line, buf = buf.split("\n", 1)
                     line = line.strip()
@@ -249,8 +252,14 @@ class LivePilotServer(object):
         try:
             self._cs.schedule_message(0, self._process_next_command)
         except AssertionError:
-            # Already on main thread — process directly
-            self._process_next_command()
+            # ControlSurface is disconnecting — return error instead of
+            # running LOM calls on the TCP thread (which would be unsafe)
+            response_queue.put({
+                "id": request_id,
+                "ok": False,
+                "error": {"code": "STATE_ERROR", "message": "Script is disconnecting"},
+            })
+            return
 
         # Wait for response from main thread
         try:
@@ -296,7 +305,8 @@ class LivePilotServer(object):
             try:
                 self._cs.schedule_message(1, send_response)  # ~100ms
             except AssertionError:
-                send_response()
+                # ControlSurface disconnecting — send result immediately
+                response_queue.put(result)
         else:
             response_queue.put(result)
             # Drain any remaining queued commands
@@ -308,7 +318,9 @@ class LivePilotServer(object):
             try:
                 self._cs.schedule_message(0, self._process_next_command)
             except AssertionError:
-                self._process_next_command()
+                # ControlSurface disconnecting — drop remaining commands
+                # rather than running LOM calls on the wrong thread
+                pass
 
     # ── Socket I/O ───────────────────────────────────────────────────────
 

package/remote_script/LivePilot/tracks.py

@@ -175,9 +175,14 @@ def duplicate_track(song, params):
             "Track index %d out of range (0..%d)"
             % (track_index, len(tracks) - 1)
         )
+    count_before = len(tracks)
     song.duplicate_track(track_index)
-    new_index = track_index + 1
-    return {"index": new_index, "name": list(song.tracks)[new_index].name}
+    all_tracks = list(song.tracks)
+    # For group tracks, Ableton duplicates the group + all children.
+    # The duplicate block starts right after the original group's last child.
+    added = len(all_tracks) - count_before
+    new_index = track_index + added
+    return {"index": new_index, "name": all_tracks[new_index].name}
 
 
 @register("set_track_name")

package/remote_script/LivePilot/transport.py

@@ -53,9 +53,9 @@ def get_session_info(song, params):
         "metronome": song.metronome,
         "record_mode": song.record_mode,
         "session_record": song.session_record,
-        "track_count": len(list(song.tracks)),
-        "return_track_count": len(list(song.return_tracks)),
-        "scene_count": len(list(song.scenes)),
+        "track_count": len(tracks_info),
+        "return_track_count": len(return_tracks_info),
+        "scene_count": len(scenes_info),
         "tracks": tracks_info,
         "return_tracks": return_tracks_info,
         "scenes": scenes_info,

package/requirements.txt

@@ -3,9 +3,11 @@ numpy>=1.24.0
 fastmcp>=3.0.0,<4.0.0
 midiutil>=1.2.1
 pretty_midi>=0.2.10
-opycleid>=0.5.1
 # v1.8 Perception Layer (offline analysis)
 pyloudnorm>=0.1.0
 soundfile>=0.12.0
 scipy>=1.11.0
 mutagen>=1.47.0
+
+# Optional: neo-Riemannian group theory (not required — harmony engine is pure Python)
+# pip install opycleid>=0.5.1