livepilot 1.6.2 → 1.6.4

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## 1.6.4 — Music Theory (March 2026)
+
+**7 new tools (135 -> 142), music21-powered theory analysis on live MIDI clips.**
+
+### Theory Domain (7 tools)
+- `analyze_harmony` — chord-by-chord Roman numeral analysis of session clips
+- `suggest_next_chord` — theory-valid chord continuations with style presets (common_practice, jazz, modal, pop)
+- `detect_theory_issues` — parallel fifths/octaves, out-of-key notes, voice crossing, unresolved dominants
+- `identify_scale` — Krumhansl-Schmuckler key/mode detection with confidence-ranked alternatives
+- `harmonize_melody` — 2 or 4-voice SATB harmonization with smooth voice leading
+- `generate_countermelody` — species counterpoint (1st or 2nd species) against a melody
+- `transpose_smart` — diatonic or chromatic transposition preserving scale relationships
+
+### Architecture
+- Notes-to-Stream bridge: converts LivePilot note dicts → music21 Part objects with quantization (1/32 note grid)
+- Lazy imports: music21 is optional — all 135 core tools work without it installed
+- Key hint parsing: handles "A minor" → lowercase tonic for music21 compatibility
+
+### Dependencies
+- Optional: `pip install 'music21>=9.3'` (not auto-installed — ~50MB with numpy/matplotlib)
+
+## 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)

package/README.md

@@ -12,7 +12,7 @@
 [![GitHub stars](https://img.shields.io/github/stars/dreamrec/LivePilot)](https://github.com/dreamrec/LivePilot/stargazers)
 [![npm](https://img.shields.io/npm/v/livepilot)](https://www.npmjs.com/package/livepilot)
 
-**AI copilot for Ableton Live 12** — 135 MCP tools, a deep device knowledge corpus, real-time audio analysis, and persistent technique memory.
+**AI copilot for Ableton Live 12** — 142 MCP tools, a deep device knowledge corpus, real-time audio analysis, and persistent technique memory.
 
 Most Ableton MCP servers give the AI tools to push buttons. LivePilot gives it three things on top of that:
 
@@ -20,7 +20,7 @@ Most Ableton MCP servers give the AI tools to push buttons. LivePilot gives it t
 - **Perception** — An M4L analyzer that reads the master bus in real-time: 8-band spectrum, RMS/peak metering, pitch tracking, key detection. The AI makes decisions based on what it hears, not just what's configured.
 - **Memory** — A technique library that persists across sessions. The AI remembers how you built that bass sound, what swing you like on hi-hats, which reverb chain worked on vocals. It learns your taste over time.
 
-These three layers sit on top of 135 deterministic MCP tools that cover transport, tracks, clips, MIDI, devices, scenes, mixing, browser, arrangement, and sample manipulation. Every command goes through Ableton's official Live Object Model API — the same interface Ableton's own control surfaces use. Everything is reversible with undo.
+These three layers sit on top of 142 deterministic MCP tools that cover transport, tracks, clips, MIDI, devices, scenes, mixing, browser, arrangement, and sample manipulation. Every command goes through Ableton's official Live Object Model API — the same interface Ableton's own control surfaces use. Everything is reversible with undo.
 
 ---
 
@@ -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
+## 142 Tools Across 13 Domains
 
 | Domain | Tools | What you can do |
 |--------|:-----:|-----------------|
@@ -257,8 +309,10 @@ 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) |
+| **Theory** | 7 | Harmony analysis, Roman numerals, scale identification, chord suggestions, countermelody, SATB harmonization, smart transposition (requires music21) |
 
 <details>
 <summary><strong>Full tool list</strong></summary>
@@ -290,6 +344,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 +391,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 +403,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** | 142 | ~20 | ~35 | ~45 | 322 | ~25 |
 | **Device knowledge** | 280+ devices | -- | -- | -- | -- | -- |
 | **Audio analysis** | Spectrum/RMS/key | -- | -- | -- | Metering | -- |
 | **Technique memory** | Persistent | -- | -- | -- | -- | -- |
@@ -363,6 +420,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 +460,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 142). 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.4"});
             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.4"

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,
@@ -56,6 +56,7 @@ from .tools import arrangement  # noqa: F401, E402
 from .tools import memory       # noqa: F401, E402
 from .tools import analyzer     # noqa: F401, E402
 from .tools import automation   # noqa: F401, E402
+from .tools import theory       # noqa: F401, E402
 
 
 # ---------------------------------------------------------------------------

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