livepilot 1.8.2 → 1.8.4

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
     {
       "name": "livepilot",
       "description": "Agentic production system for Ableton Live 12 — 168 tools, 17 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
-      "version": "1.8.1",
+      "version": "1.8.4",
       "author": {
         "name": "Pilot Studio"
       },

package/AGENTS.md

@@ -0,0 +1,46 @@
+# LivePilot v1.8.4 — Ableton Live 12
+
+## Project
+- **Repo:** This directory (LivePilot)
+- **Type:** Agentic MCP production system for Ableton Live 12
+- **Three layers:** Device Atlas (knowledge) + M4L Analyzer (perception) + Technique Memory (learning)
+- **Sister projects:** TDPilot (TouchDesigner), ComfyPilot (ComfyUI)
+- **Design spec:** `docs/specs/2026-03-17-livepilot-design.md`
+
+## Architecture
+- **Remote Script** (`remote_script/LivePilot/`): Runs inside Ableton's Python, ControlSurface base class, TCP socket on port 9878
+- **MCP Server** (`mcp_server/`): Python FastMCP server, validates inputs, sends commands to Remote Script
+- **M4L Bridge** (`m4l_device/`): Max for Live Audio Effect on master track, UDP/OSC bridge for deep LOM access
+  - UDP 9880: M4L -> Server (spectral data, responses)
+  - OSC 9881: Server -> M4L (commands)
+  - `livepilot_bridge.js`: 22 bridge commands for LiveAPI access
+  - `SpectralCache`: thread-safe, time-expiring data cache (5s max age)
+  - Bridge is optional — all core tools work without it
+- **Plugin** (`livepilot/`): Codex plugin (marketplace-compatible: `.Codex-plugin/plugin.json`)
+- **Installer** (`installer/`): Auto-detects Ableton path, copies Remote Script
+
+## Key Rules
+- ALL Live Object Model (LOM) calls must execute on Ableton's main thread via schedule_message queue
+- Live 12 minimum — use modern note API (add_new_notes, get_notes_extended, apply_note_modifications)
+- 168 tools across 17 domains: transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, analyzer, automation, theory, generative, harmony, midi_io, perception
+- JSON over TCP, newline-delimited, port 9878
+- Structured errors with codes: INDEX_ERROR, NOT_FOUND, INVALID_PARAM, STATE_ERROR, TIMEOUT, INTERNAL
+
+## M4L Bridge Notes
+- OSC addresses must be sent WITHOUT leading `/` — Max `udpreceive` passes `/` as part of messagename
+- `str_for_value` requires `call()` not `get()` (it's a function)
+- `get()` in Max JS LiveAPI always returns arrays
+- `warp_markers` is a dict property returning JSON string — use `JSON.parse()`
+- `SimplerDevice.slices` lives on the `sample` child, not the device
+- `replace_sample` only works on Simplers with existing samples
+- Max freezes JS from search path cache, not source directory — copy to `~/Documents/Max 8/`
+
+## Binary Patching Workflow (.amxd)
+When modifying .amxd attributes that Max editor won't persist (e.g., `openinpresentation`):
+1. Find the byte sequence in the .amxd binary
+2. Replace with same-byte-count alternative (file size must not change)
+3. Test by loading in Ableton
+4. Structure: 24-byte `ampf` header + `ptch` chunk + `mx@c` header + JSON patcher + frozen deps
+
+## Tool Count
+Currently 168 tools. If adding/removing tools, update: README.md, package.json description, livepilot/.Codex-plugin/plugin.json, server.json, livepilot/skills/livepilot-core/SKILL.md, livepilot/skills/livepilot-core/references/overview.md, AGENTS.md, CHANGELOG.md, tests/test_tools_contract.py, docs/manual/index.md, docs/manual/tool-reference.md

package/CHANGELOG.md

@@ -1,11 +1,30 @@
 # Changelog
 
-## 1.8.2 — FluCoMa Wiring + Analyzer Fix (March 2026)
+## 1.8.4 — Bug Fix Audit (March 2026)
+
+**5 bugs fixed (2 P1, 3 P2), verified live in Ableton.**
+
+### P1 — Safety-Critical
+- Fix: `create_arrangement_clip` no longer hangs Ableton when `loop_length` is zero or negative — validation at MCP + Remote Script layers
+- Fix: `import_midi_to_clip` now preserves the MIDI file's beat grid instead of scaling by session tempo — a 60 BPM MIDI imported at 120 BPM no longer doubles note positions
+
+### P2 — Correctness
+- Fix: `create_arrangement_clip` now sets `loop_end` on duplicated clips when `loop_length < source_length`, with documented LOM limitation for arrangement clip resizing
+- Fix: `--status` / `--doctor` CLI commands no longer report success for error responses — only resolves true on valid pong
+- Fix: `import_midi_to_clip` with `create_clip=True` now checks for existing clips before creating — clears notes if occupied, creates if empty
+
+### Tests
+- 2 new tests for MIDI tempo independence (`test_midi_io.py::TestImportTempoIndependence`)
+- 255 total tests passing
+
+## 1.8.3 — FluCoMa Wiring + Analyzer Fix (March 2026)
 
 - Fix: wire 6 FluCoMa DSP objects into LivePilot_Analyzer.maxpat (spectral shape, mel bands, chroma, loudness, onset, novelty)
 - Fix: onset/novelty Python handlers now accept 1 arg (fluid.onsetfeature~/noveltyfeature~ output single float)
-- Fix: rebuild .amxd with FluCoMa objects + binary patch openinpresentation
+- Fix: restore .amxd after binary corruption — .amxd must be rebuilt via Max editor, not programmatic JSON editing
+- Fix: panel z-order in .maxpat — move background panel first in boxes array so multislider renders on top
 - FluCoMa perception tools now fully functional when FluCoMa package is installed
+- Note: after installing, rebuild .amxd from .maxpat via Max editor (see BUILD_GUIDE.md)
 
 ## 1.8.1 — Patch (March 2026)
 

package/README.md

@@ -12,7 +12,6 @@ An agentic production system for Ableton Live 12.
 168 tools. Device atlas. Spectral perception. Technique memory.
 Neo-Riemannian harmony. Euclidean rhythm. Species counterpoint.
 
-It doesn't assist — it produces.
 
 <br>
 
@@ -96,7 +95,7 @@ Every tool maps directly to an LOM call — no abstraction, no guessing.
 The M4L Analyzer sits on the master track. UDP 9880 carries spectral data
 from Max to the server. OSC 9881 sends commands back.
 
-All 135 core tools work without it — the analyzer adds 20 more
+All 139 core tools work without it — the analyzer adds 29 more
 and closes the feedback loop.
 
 <br>
@@ -673,7 +672,7 @@ Check memory before creative decisions. Verify every mutation.
 
 <br>
 
-### Analyzer (20) `[M4L]`
+### Analyzer (29) `[M4L]`
 
 | Tool | Description |
 |------|-------------|
@@ -697,6 +696,26 @@ Check memory before creative decisions. Verify every mutation.
 | `remove_warp_marker` | Remove warp marker |
 | `scrub_clip` | Preview at beat position |
 | `stop_scrub` | Stop preview |
+| `get_spectral_shape` | 7 spectral descriptors via FluCoMa |
+| `get_mel_spectrum` | 40-band mel spectrum |
+| `get_chroma` | 12 pitch class energies |
+| `get_onsets` | Real-time onset detection |
+| `get_novelty` | Spectral novelty for section boundaries |
+| `get_momentary_loudness` | EBU R128 momentary LUFS + peak |
+| `check_flucoma` | Verify FluCoMa installation |
+| `capture_audio` | Record master output to WAV |
+| `capture_stop` | Cancel in-progress capture |
+
+<br>
+
+### Perception (4)
+
+| Tool | Description |
+|------|-------------|
+| `analyze_loudness` | Integrated LUFS, true peak, LRA, streaming compliance |
+| `analyze_spectrum_offline` | Spectral centroid, rolloff, flatness, 5-band balance |
+| `compare_to_reference` | Mix vs reference: loudness + spectral delta |
+| `read_audio_metadata` | Format, duration, sample rate, tags |
 
 <br>
 
@@ -753,11 +772,10 @@ Check memory before creative decisions. Verify every mutation.
 ## Coming
 
 ```
-□  Real-time DSP analysis via LOM meters
-□  M4L bridge expansion — deeper LiveAPI access
-□  Arrangement view — clip placement, tempo automation
-□  Audio clip manipulation — stretch, slice, resample
 □  Plugin parameter mapping — VST/AU deep control
+□  Audio track freeze/flatten automation
+□  Clip launch scene matrix operations
+□  Multi-track arrangement templates
 ```
 
 <br>

package/bin/livepilot.js

@@ -70,7 +70,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"], {
+      execFileSync(venvPy, ["-c", "import fastmcp; import midiutil; import pretty_midi; import numpy; import pyloudnorm; import soundfile; import scipy"], {
         encoding: "utf-8",
         timeout: 10000,
         stdio: "pipe",
@@ -127,10 +127,12 @@ function checkStatus() {
     sock.on("data", (chunk) => {
       buf += chunk.toString();
       if (buf.includes("\n")) {
+        let ok = false;
         try {
           const resp = JSON.parse(buf.split("\n")[0]);
           if (resp.ok === true && resp.result && resp.result.pong) {
             console.log("  Ableton Live: connected on %s:%d", HOST, PORT);
+            ok = true;
           } else {
             console.log("  Ableton Live: unexpected response:", JSON.stringify(resp));
           }
@@ -138,7 +140,7 @@ function checkStatus() {
           console.log("  Ableton Live: invalid response");
         }
         sock.destroy();
-        resolve(true);
+        resolve(ok);
       }
     });
 

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

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Agentic production system for Ableton Live 12 — 168 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

@@ -149,8 +149,8 @@ Never skip levels. The user's question determines the entry point, but always st
 ### Memory (8)
 `memory_learn` · `memory_recall` · `memory_get` · `memory_replay` · `memory_list` · `memory_favorite` · `memory_update` · `memory_delete`
 
-### Analyzer (20) — requires LivePilot Analyzer M4L device on master track
-`get_master_spectrum` · `get_master_rms` · `get_detected_key` · `get_hidden_parameters` · `get_automation_state` · `walk_device_tree` · `get_clip_file_path` · `replace_simpler_sample` · `load_sample_to_simpler` · `get_simpler_slices` · `crop_simpler` · `reverse_simpler` · `warp_simpler` · `get_warp_markers` · `add_warp_marker` · `move_warp_marker` · `remove_warp_marker` · `scrub_clip` · `stop_scrub` · `get_display_values`
+### Analyzer (29) — requires LivePilot Analyzer M4L device on master track
+`get_master_spectrum` · `get_master_rms` · `get_detected_key` · `get_hidden_parameters` · `get_automation_state` · `walk_device_tree` · `get_clip_file_path` · `replace_simpler_sample` · `load_sample_to_simpler` · `get_simpler_slices` · `crop_simpler` · `reverse_simpler` · `warp_simpler` · `get_warp_markers` · `add_warp_marker` · `move_warp_marker` · `remove_warp_marker` · `scrub_clip` · `stop_scrub` · `get_display_values` · `get_spectral_shape` · `get_mel_spectrum` · `get_chroma` · `get_onsets` · `get_novelty` · `get_momentary_loudness` · `check_flucoma` · `capture_audio` · `capture_stop`
 
 ### Automation (8)
 Clip automation CRUD + intelligent curve generation with 15 built-in recipes.
@@ -175,6 +175,14 @@ Clip automation CRUD + intelligent curve generation with 15 built-in recipes.
 - Clear existing automation before rewriting: `clear_clip_automation` first
 - Load `references/automation-atlas.md` for curve theory, genre recipes, diagnostic technique, and cross-track spectral mapping
 
+### Perception (4) — offline audio analysis, no Ableton connection required
+`analyze_loudness` · `analyze_spectrum_offline` · `compare_to_reference` · `read_audio_metadata`
+
+**Key discipline:**
+- These work on any local audio file — no Ableton connection needed
+- Use `compare_to_reference` for A/B mix comparisons against reference tracks
+- Use `analyze_loudness` to check streaming compliance (Spotify, Apple Music, YouTube targets)
+
 ### Theory (7)
 Music theory analysis — built-in pure Python engine, zero external dependencies.
 

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

@@ -1,4 +1,4 @@
-# LivePilot v1.8.0 — Architecture & Tool Reference
+# LivePilot v1.8.4 — Architecture & Tool Reference
 
 Agentic production system for Ableton Live 12. 168 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.
 
@@ -202,7 +202,7 @@ This turns "set EQ band 3 to -4 dB" into "cut 400 Hz by 4 dB, then read the spec
 | `memory_update` | Updates name, tags, or qualities | `technique_id`, `name`, `tags`, `qualities` |
 | `memory_delete` | Removes technique (backs up first) | `technique_id` |
 
-### Analyzer (20) — Real-time DSP analysis (requires LivePilot Analyzer M4L device on master track)
+### Analyzer (29) — Real-time DSP analysis (requires LivePilot Analyzer M4L device on master track)
 
 | Tool | What it does | Key params |
 |------|-------------|------------|

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

@@ -13,43 +13,56 @@ Run this checklist EVERY time the user says "update everything", "push", "releas
 - [ ] `package-lock.json` → `"version"` (run `npm install --package-lock-only` if stale)
 - [ ] `server.json` → `"version"` (TWO locations: top-level and package)
 - [ ] `livepilot/.claude-plugin/plugin.json` → `"version"`
+- [ ] `.claude-plugin/marketplace.json` → `"version"` in plugins array
 - [ ] `mcp_server/__init__.py` → `__version__`
-- [ ] `remote_script/LivePilot/__init__.py` → version in log message
+- [ ] `remote_script/LivePilot/__init__.py` → `__version__` (log message auto-uses it)
 - [ ] `m4l_device/livepilot_bridge.js` → version in ping response
+- [ ] `CLAUDE.md` → header line
+- [ ] `livepilot/skills/livepilot-core/references/overview.md` → header line
 - [ ] `CHANGELOG.md` → latest version header
 - [ ] `docs/social-banner.html` → version display
+- [ ] `docs/M4L_BRIDGE.md` → ping response example
 
-**How to check:** `grep -rn "1\.[0-9]\.[0-9]" package.json server.json livepilot/.claude-plugin/plugin.json mcp_server/__init__.py remote_script/LivePilot/__init__.py m4l_device/livepilot_bridge.js CHANGELOG.md docs/social-banner.html`
+**How to check:** `grep -rn "1\.[0-9]\.[0-9]" package.json server.json livepilot/.claude-plugin/plugin.json .claude-plugin/marketplace.json mcp_server/__init__.py remote_script/LivePilot/__init__.py m4l_device/livepilot_bridge.js CHANGELOG.md CLAUDE.md livepilot/skills/livepilot-core/references/overview.md docs/social-banner.html docs/M4L_BRIDGE.md`
 
 ## 2. Tool Count (must ALL match)
 
-- [ ] `README.md` — every occurrence
-- [ ] `package.json` → `"description"`
+Current: **168 tools across 17 domains**.
+Core (no M4L): **139**. 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)"
+- [ ] `package.json` → `"description"` (168 tools, 17 domains)
 - [ ] `server.json` → `"description"`
 - [ ] `livepilot/.claude-plugin/plugin.json` → `"description"`
-- [ ] `CLAUDE.md`
-- [ ] `livepilot/skills/livepilot-core/SKILL.md` — header and domain breakdown
-- [ ] `livepilot/skills/livepilot-core/references/overview.md`
-- [ ] `docs/manual/index.md`
-- [ ] `docs/manual/tool-reference.md`
-- [ ] `docs/TOOL_REFERENCE.md`
-- [ ] `docs/M4L_BRIDGE.md`
+- [ ] `.claude-plugin/marketplace.json` → `"description"`
+- [ ] `CLAUDE.md` → "168 tools across 17 domains"
+- [ ] `livepilot/skills/livepilot-core/SKILL.md` — "168 tools across 17 domains", Analyzer (29), Perception (4)
+- [ ] `livepilot/skills/livepilot-core/references/overview.md` — "168 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/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/social-banner.html`
 - [ ] `mcp_server/tools/analyzer.py` → module docstring
-- [ ] `tests/test_tools_contract.py` → expected count
+- [ ] `tests/test_tools_contract.py` → expected total count
 
-**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__`
+**How to check:** `grep -rn "168\|139\|135\|127\|115\|107" --include="*.md" --include="*.json" --include="*.py" --include="*.html" . | grep -v node_modules | grep -v .git | grep -v __pycache__ | grep -v CHANGELOG`
 
 ## 3. Domain Count
 
-- [ ] 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
+Current: **17 domains**: transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, analyzer, automation, theory, generative, harmony, midi_io, perception.
+
+- [ ] All files that mention domain count say "17 domains"
+- [ ] Domain lists include ALL 17 (especially perception — it's the newest and most often omitted)
 
 ## 4. npm Registry
 
 - [ ] `npm view livepilot version` matches local version
 - [ ] If not: `npm publish`
-- [ ] Verify badge will update: badge URL in README.md points to shields.io/npm/v/livepilot
 
 ## 5. GitHub
 
@@ -57,9 +70,6 @@ Run this checklist EVERY time the user says "update everything", "push", "releas
 - [ ] Topics are current (should include: ai, mcp, ableton, livepilot, max-for-live, audio-analysis)
 - [ ] Latest release matches current version (`gh release list`)
 - [ ] Release notes are current
-- [ ] Old stale releases cleaned up
-- [ ] Git tags: only relevant versions exist (`git tag -l`)
-- [ ] No co-author or unwanted metadata in commit messages
 
 ## 6. Plugin Cache
 
@@ -74,28 +84,26 @@ Run this checklist EVERY time the user says "update everything", "push", "releas
 
 ## 8. Documentation Content
 
-- [ ] `README.md` — features match current capabilities
-- [ ] `docs/manual/getting-started.md` — install instructions current, mentions M4L Analyzer
-- [ ] `docs/manual/tool-reference.md` — all tools listed
-- [ ] `docs/M4L_BRIDGE.md` — architecture accurate
-- [ ] `docs/TOOL_REFERENCE.md` — all tools listed with correct params
+- [ ] `README.md` — features match current capabilities, "Coming" section is accurate
+- [ ] `docs/manual/getting-started.md` — install instructions current
+- [ ] `docs/manual/tool-reference.md` — all 17 domains listed, all 168 tools present
+- [ ] `docs/TOOL_REFERENCE.md` — all 17 domains present
+- [ ] `docs/M4L_BRIDGE.md` — architecture accurate, core tool count correct
 
 ## 9. Derived Artifacts
 
 - [ ] `m4l_device/LivePilot_Analyzer.amxd` — frozen JS matches source? All commands present?
-- [ ] Distributable zip on Desktop — rebuilt with latest?
-- [ ] Private backup repo — synced and pushed?
-- [ ] `LivePilot-v*.INSTALL.txt` — updated?
+- [ ] If `livepilot_bridge.js` changed → amxd needs rebuilding in Max editor
 
 ## 10. Code Consistency
 
 - [ ] `@mcp.tool()` count matches documented tool count: `grep -r "@mcp.tool" mcp_server/tools/ | wc -l`
 - [ ] No dead imports or unused code in recently changed files
 - [ ] Remote script version matches MCP server version
+- [ ] All tests pass: `python3 -m pytest tests/ -v`
 
 ## Quick Verify Command
 
-Run this one-liner to catch most issues:
 ```bash
-echo "=== Versions ===" && grep -h '"version"' package.json server.json livepilot/.claude-plugin/plugin.json | head -5 && grep __version__ mcp_server/__init__.py && echo "=== Tool count ===" && grep -rc "@mcp.tool" mcp_server/tools/ | tail -1 && echo "=== npm ===" && npm view livepilot version 2>/dev/null && echo "=== GitHub release ===" && gh release list --limit 1 && echo "=== Tags ===" && git tag -l
+echo "=== Versions ===" && grep -h '"version"' package.json server.json livepilot/.claude-plugin/plugin.json .claude-plugin/marketplace.json | head -6 && grep __version__ mcp_server/__init__.py remote_script/LivePilot/__init__.py && echo "=== Tool count ===" && grep -rc "@mcp.tool" mcp_server/tools/ | grep -v ":0" | awk -F: '{sum+=$2} END{print "Total:", sum}' && echo "=== Tests ===" && python3 -m pytest tests/ -q 2>&1 | tail -1
 ```

package/m4l_device/livepilot_bridge.js

@@ -83,7 +83,7 @@ function anything() {
 function dispatch(cmd, args) {
     switch(cmd) {
         case "ping":
-            send_response({"ok": true, "version": "1.8.2"});
+            send_response({"ok": true, "version": "1.8.4"});
             break;
         case "get_params":
             cmd_get_params(args);

package/mcp_server/__init__.py

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

package/mcp_server/m4l_bridge.py

@@ -97,6 +97,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_id = 0
         self._response_callback: Optional[asyncio.Future] = None
         self._capture_future: Optional[asyncio.Future] = None
 
@@ -106,8 +107,9 @@ class SpectralReceiver(asyncio.DatagramProtocol):
     def datagram_received(self, data: bytes, addr: tuple) -> None:
         try:
             self._parse_osc(data)
-        except Exception:
-            pass  # Malformed packet, ignore
+        except Exception as exc:
+            import sys
+            print(f"LivePilot: malformed OSC packet from {addr}: {exc}", file=sys.stderr)
 
     def _parse_osc(self, data: bytes) -> None:
         """Parse a minimal OSC message (address + typed args)."""
@@ -227,12 +229,15 @@ class SpectralReceiver(asyncio.DatagramProtocol):
             result = json.loads(decoded)
             if self._response_callback and not self._response_callback.done():
                 self._response_callback.set_result(result)
-        except Exception:
-            pass
+        except Exception as exc:
+            import sys
+            print(f"LivePilot: failed to decode bridge response: {exc}", file=sys.stderr)
 
     def _handle_chunk(self, index: int, total: int, encoded: str) -> None:
         """Reassemble chunked responses."""
-        key = str(total)  # Simple key — assumes one response at a time
+        if index == 0:
+            self._chunk_id += 1
+        key = str(self._chunk_id)
         if key not in self._chunks:
             self._chunks[key] = {"parts": {}, "total": total}
 
@@ -254,8 +259,9 @@ class SpectralReceiver(asyncio.DatagramProtocol):
             result = json.loads(decoded)
             if self._capture_future and not self._capture_future.done():
                 self._capture_future.set_result(result)
-        except Exception:
-            pass
+        except Exception as exc:
+            import sys
+            print(f"LivePilot: failed to decode capture response: {exc}", file=sys.stderr)
 
     def set_response_future(self, future: asyncio.Future) -> None:
         """Set a future to be resolved with the next response."""
@@ -278,29 +284,31 @@ class M4LBridge:
         self.receiver = receiver
         self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         self._m4l_addr = ("127.0.0.1", 9881)
+        self._cmd_lock = asyncio.Lock()
 
     async def send_command(self, command: str, *args: Any, timeout: float = 5.0) -> dict:
         """Send an OSC command to the M4L device and wait for the response."""
         if not self.cache.is_connected:
             return {"error": "LivePilot Analyzer not connected. Drop it on the master track."}
 
-        # Create a future for the response
-        loop = asyncio.get_running_loop()
-        future = loop.create_future()
-        if self.receiver:
-            self.receiver.set_response_future(future)
-
-        # Build and send OSC message (no leading / — Max udpreceive
-        # passes messagename with / intact to JS, breaking dispatch)
-        osc_data = self._build_osc(command, args)
-        self._sock.sendto(osc_data, self._m4l_addr)
-
-        # Wait for response with timeout
-        try:
-            result = await asyncio.wait_for(future, timeout=timeout)
-            return result
-        except asyncio.TimeoutError:
-            return {"error": "M4L bridge timeout — device may be busy or removed"}
+        async with self._cmd_lock:
+            # Create a future for the response
+            loop = asyncio.get_running_loop()
+            future = loop.create_future()
+            if self.receiver:
+                self.receiver.set_response_future(future)
+
+            # Build and send OSC message (no leading / — Max udpreceive
+            # passes messagename with / intact to JS, breaking dispatch)
+            osc_data = self._build_osc(command, args)
+            self._sock.sendto(osc_data, self._m4l_addr)
+
+            # Wait for response with timeout
+            try:
+                result = await asyncio.wait_for(future, timeout=timeout)
+                return result
+            except asyncio.TimeoutError:
+                return {"error": "M4L bridge timeout — device may be busy or removed"}
 
     async def send_capture(self, command: str, *args: Any, timeout: float = 35.0) -> dict:
         """Send a capture command to the M4L device and wait for /capture_complete."""

package/mcp_server/memory/technique_store.py

@@ -114,7 +114,7 @@ class TechniqueStore:
     ) -> list[dict]:
         """Search techniques. Returns summaries (no payload)."""
         with self._lock:
-            results = list(self._data["techniques"])
+            results = copy.deepcopy(self._data["techniques"])
 
         # filter by type
         if type_filter:
@@ -156,7 +156,7 @@ class TechniqueStore:
             )
 
         with self._lock:
-            results = list(self._data["techniques"])
+            results = copy.deepcopy(self._data["techniques"])
 
         if type_filter:
             results = [t for t in results if t["type"] == type_filter]

package/mcp_server/server.py

@@ -29,7 +29,16 @@ def _kill_port_holder(port: int) -> None:
         for pid_str in out.splitlines():
             pid = int(pid_str)
             if pid != my_pid:
-                os.kill(pid, signal.SIGTERM)
+                # Only kill if it looks like a Python/LivePilot process
+                try:
+                    cmdline = subprocess.check_output(
+                        ["ps", "-p", str(pid), "-o", "command="],
+                        text=True, timeout=2,
+                    ).strip()
+                    if "mcp_server" in cmdline or "livepilot" in cmdline.lower():
+                        os.kill(pid, signal.SIGTERM)
+                except (subprocess.CalledProcessError, FileNotFoundError):
+                    pass  # Can't verify — don't kill
     except (subprocess.CalledProcessError, FileNotFoundError, ValueError):
         pass  # lsof not found or no process — nothing to kill
 
@@ -139,6 +148,12 @@ def _get_all_tools():
     # FastMCP 3.x: mcp._local_provider._components (dict of key -> Tool)
     if hasattr(mcp, "_local_provider") and hasattr(mcp._local_provider, "_components"):
         return list(mcp._local_provider._components.values())
+    import sys
+    print(
+        "LivePilot: WARNING — could not access FastMCP tool registry, "
+        "string-to-number schema coercion will not work",
+        file=sys.stderr,
+    )
     return []
 
 

package/mcp_server/tools/_perception_engine.py

@@ -63,7 +63,8 @@ def _normalize_to_lufs(
     gain_linear = 10 ** (gain_db / 20.0)
     data, sr = _load_audio(file_path)
     normalized = np.clip(data * gain_linear, -1.0, 1.0)
-    tmp_path = tempfile.mktemp(suffix=".wav")
+    tmp_fd, tmp_path = tempfile.mkstemp(suffix=".wav")
+    os.close(tmp_fd)
     try:
         sf.write(tmp_path, normalized, sr)
     except Exception:
@@ -155,7 +156,7 @@ def compute_loudness(file_path: str, detail: str = "summary") -> dict[str, Any]:
 
     # Streaming compliance
     meets_streaming = {
-        name: integrated_lufs >= (target - 1.0)  # ±1 LU tolerance
+        name: abs(integrated_lufs - target) <= 1.0  # ±1 LU tolerance
         for name, target in STREAMING_TARGETS.items()
     }
 

package/mcp_server/tools/analyzer.py

@@ -284,9 +284,15 @@ async def load_sample_to_simpler(
         "uri": uri,
     })
 
-    # Step 2: Replace with the desired sample via M4L bridge
+    # Step 2: Find the newly created device (it's at the end of the chain)
+    track_info = ableton.send_command("get_track_info", {"track_index": track_index})
+    actual_device_index = len(track_info.get("devices", [])) - 1
+    if actual_device_index < 0:
+        actual_device_index = 0
+
+    # Step 3: Replace with the desired sample via M4L bridge
     result = await bridge.send_command(
-        "replace_simpler_sample", track_index, device_index, file_path
+        "replace_simpler_sample", track_index, actual_device_index, file_path
     )
     if "error" in result:
         return result

package/mcp_server/tools/arrangement.py

@@ -11,6 +11,7 @@ from typing import Any, Optional
 from fastmcp import Context
 
 from ..server import mcp
+from .notes import _validate_note
 
 
 def _get_ableton(ctx: Context):
@@ -104,7 +105,13 @@ def create_arrangement_clip(
     length:          total clip length in beats on the timeline
     loop_length:     pattern length to loop within the clip (e.g. 8.0 for an
                      8-beat pattern inside a 128-beat section). Defaults to
-                     the source clip's length.
+                     the source clip's length. Must be > 0.
+
+    When loop_length < source clip length, overlapping copies are placed
+    every loop_length beats. Ableton's "later clip takes priority" rule
+    ensures correct playback. Each copy's internal loop region is set to
+    loop_length beats. For best results, use loop_length >= source length.
+
     name:            optional clip display name
     color_index:     optional 0-69 Ableton color
 
@@ -124,6 +131,8 @@ def create_arrangement_clip(
         "length": length,
     }
     if loop_length is not None:
+        if loop_length <= 0:
+            raise ValueError("loop_length must be > 0")
         params["loop_length"] = loop_length
     if name:
         params["name"] = name
@@ -154,6 +163,8 @@ def add_arrangement_notes(
     _validate_clip_index(clip_index)
     if isinstance(notes, str):
         notes = json.loads(notes)
+    for note in notes:
+        _validate_note(note)
     return _get_ableton(ctx).send_command("add_arrangement_notes", {
         "track_index": track_index,
         "clip_index": clip_index,

package/mcp_server/tools/automation.py

@@ -23,7 +23,9 @@ def _ensure_list(v: Any) -> list:
     if isinstance(v, str):
         import json
         return json.loads(v)
-    return list(v)
+    if isinstance(v, list):
+        return v
+    return [v]
 
 
 @mcp.tool()
@@ -482,7 +484,7 @@ def analyze_for_automation(
         "track_index": track_index,
         "track_name": track_info.get("name", ""),
         "device_count": len(devices),
-        "current_level": meters.get("tracks", [{}])[0].get("level", 0),
+        "current_level": (meters.get("tracks") or [{}])[0].get("level", 0) if meters.get("tracks") else 0,
         "spectrum": spectrum,
         "suggestions": suggestions,
     }

package/mcp_server/tools/harmony.py

@@ -226,10 +226,10 @@ def suggest_chromatic_mediants(
 
     mediants = harmony.get_chromatic_mediants(root_pc, quality)
 
-    chord_pcs = set(harmony.chord_to_midi(root_pc, quality))
+    chord_pcs = {p % 12 for p in harmony.chord_to_midi(root_pc, quality)}
     formatted = {}
     for key, (r, q) in mediants.items():
-        mediant_pcs = set(harmony.chord_to_midi(r, q))
+        mediant_pcs = {p % 12 for p in harmony.chord_to_midi(r, q)}
         common = len(chord_pcs & mediant_pcs)
         formatted[key] = {
             "chord": harmony.chord_to_str(r, q),

package/mcp_server/tools/midi_io.py

@@ -59,6 +59,27 @@ def _validate_midi_path(file_path: str) -> Path:
     return p
 
 
+def _midi_notes_to_beats(pm) -> list[dict]:
+    """Convert pretty_midi notes to beat-position dicts using the file's own tempo map.
+
+    Uses time_to_tick/resolution to preserve the MIDI file's beat grid,
+    regardless of the current Ableton session tempo.
+    """
+    notes_raw = []
+    for inst in pm.instruments:
+        for n in inst.notes:
+            start_beat = round(pm.time_to_tick(n.start) / pm.resolution, 3)
+            end_beat = round(pm.time_to_tick(n.end) / pm.resolution, 3)
+            dur_beat = round(end_beat - start_beat, 3)
+            notes_raw.append({
+                "pitch": n.pitch,
+                "start_time": start_beat,
+                "duration": max(dur_beat, 0.001),
+                "velocity": n.velocity,
+            })
+    return notes_raw
+
+
 # -- Tool 1: export_clip_midi ------------------------------------------------
 
 @mcp.tool()
@@ -127,8 +148,10 @@ def import_midi_to_clip(
 ) -> dict:
     """Load a .mid file into a session clip.
 
-    Reads MIDI, converts timing to beats using session tempo, and writes
-    notes into the target clip slot. Creates the clip if needed.
+    Reads MIDI, converts timing to beats using the file's own tempo map,
+    and writes notes into the target clip slot. When create_clip=True
+    (default), creates a new clip if the slot is empty; if a clip already
+    exists, clears its notes before importing.
     """
     pretty_midi = _require_pretty_midi()
     ableton = _get_ableton(ctx)
@@ -136,20 +159,8 @@ def import_midi_to_clip(
     path = _validate_midi_path(file_path)
     pm = pretty_midi.PrettyMIDI(str(path))
 
-    session = ableton.send_command("get_session_info", {})
-    tempo = float(session.get("tempo", 120.0))
-
-    notes_raw = []
-    for inst in pm.instruments:
-        for n in inst.notes:
-            start_beat = round(n.start * (tempo / 60.0), 3)
-            dur_beat = round((n.end - n.start) * (tempo / 60.0), 3)
-            notes_raw.append({
-                "pitch": n.pitch,
-                "start_time": start_beat,
-                "duration": max(dur_beat, 0.001),
-                "velocity": n.velocity,
-            })
+    # Convert using the MIDI file's own tempo map (not session tempo)
+    notes_raw = _midi_notes_to_beats(pm)
 
     seen = set()
     notes = []
@@ -165,11 +176,24 @@ def import_midi_to_clip(
                          default=4.0)
 
     if create_clip:
-        ableton.send_command("create_clip", {
-            "track_index": track_index,
-            "clip_index": clip_index,
-            "length": round(duration_beats, 2),
-        })
+        # Check if clip already exists — only create if the slot is empty
+        try:
+            ableton.send_command("get_clip_info", {
+                "track_index": track_index,
+                "clip_index": clip_index,
+            })
+            # Clip exists — clear its notes before importing
+            ableton.send_command("remove_notes", {
+                "track_index": track_index,
+                "clip_index": clip_index,
+            })
+        except Exception:
+            # No clip in slot — create one
+            ableton.send_command("create_clip", {
+                "track_index": track_index,
+                "clip_index": clip_index,
+                "length": round(duration_beats, 2),
+            })
 
     if notes:
         ableton.send_command("add_notes", {
@@ -178,10 +202,13 @@ def import_midi_to_clip(
             "notes": notes,
         })
 
+    tempo_changes = pm.get_tempo_changes()
+    midi_tempo = float(tempo_changes[1][0]) if len(tempo_changes[1]) > 0 else 120.0
+
     return {
         "note_count": len(notes),
         "duration_beats": round(duration_beats, 4),
-        "tempo_source": tempo,
+        "midi_tempo": midi_tempo,
     }
 
 

package/mcp_server/tools/notes.py

@@ -135,6 +135,10 @@ def remove_notes(
     """Remove all MIDI notes in a pitch/time region. Use undo to revert. Defaults remove ALL notes in the clip."""
     _validate_track_index(track_index)
     _validate_clip_index(clip_index)
+    if not 0 <= from_pitch <= 127:
+        raise ValueError("from_pitch must be 0-127")
+    if pitch_span < 1 or pitch_span > 128:
+        raise ValueError("pitch_span must be 1-128")
     params = {
         "track_index": track_index,
         "clip_index": clip_index,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "mcpName": "io.github.dreamrec/livepilot",
   "description": "Agentic production system for Ableton Live 12 — 168 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.8.2"
+__version__ = "1.8.4"
 
 from _Framework.ControlSurface import ControlSurface
 from .server import LivePilotServer
@@ -34,7 +34,7 @@ class LivePilot(ControlSurface):
         ControlSurface.__init__(self, c_instance)
         self._server = LivePilotServer(self)
         self._server.start()
-        self.log_message("LivePilot v1.8.1 initialized")
+        self.log_message("LivePilot v%s initialized" % __version__)
         self.show_message("LivePilot: Listening on port 9878")
 
     def disconnect(self):

package/remote_script/LivePilot/arrangement.py

@@ -61,6 +61,8 @@ def create_arrangement_clip(song, params):
 
     # Use loop_length as the repeat unit (defaults to source clip length)
     loop_length = float(params.get("loop_length", source_length))
+    if loop_length <= 0:
+        raise ValueError("loop_length must be > 0")
 
     name = str(params.get("name", ""))
     color_index = params.get("color_index")
@@ -86,6 +88,21 @@ def create_arrangement_clip(song, params):
                         c.name = name
                     if color_index is not None:
                         c.color_index = int(color_index)
+
+                    # When loop_length < source_length, set the internal
+                    # loop region so only loop_length beats of content play.
+                    # Arrangement clip timeline length is read-only in the
+                    # LOM, but overlapping clips are handled by Ableton
+                    # (later clips take priority), so playback is correct.
+                    remaining = end_pos - pos
+                    target_len = min(loop_length, remaining)
+                    if target_len < source_length:
+                        try:
+                            c.looping = True
+                            c.loop_start = 0.0
+                            c.loop_end = target_len
+                        except (AttributeError, RuntimeError):
+                            pass
                     break
 
             clip_count += 1

package/remote_script/LivePilot/clip_automation.py

@@ -12,8 +12,8 @@ from .utils import get_track, get_clip
 @register("get_clip_automation")
 def get_clip_automation(song, params):
     """List automation envelopes on a session clip."""
-    track_index = params["track_index"]
-    clip_index = params["clip_index"]
+    track_index = int(params["track_index"])
+    clip_index = int(params["clip_index"])
 
     track = get_track(song, track_index)
     clip = get_clip(song, track_index, clip_index)
@@ -80,8 +80,8 @@ def set_clip_automation(song, params):
     parameter_type: "device", "volume", "panning", "send"
     points: [{time, value, duration?}] — time relative to clip start
     """
-    track_index = params["track_index"]
-    clip_index = params["clip_index"]
+    track_index = int(params["track_index"])
+    clip_index = int(params["clip_index"])
     parameter_type = params["parameter_type"]
     points = params["points"]
     device_index = params.get("device_index")
@@ -98,29 +98,23 @@ def set_clip_automation(song, params):
         parameter = track.mixer_device.panning
     elif parameter_type == "send":
         if send_index is None:
-            return {"error": {"code": "INVALID_PARAM",
-                    "message": "send_index required for send automation"}}
+            raise ValueError("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}}
+            raise IndexError("send_index %d out of range" % send_index)
         parameter = sends[send_index]
     elif parameter_type == "device":
         if device_index is None or parameter_index is None:
-            return {"error": {"code": "INVALID_PARAM",
-                    "message": "device_index and parameter_index required"}}
+            raise ValueError("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}}
+            raise IndexError("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}}
+            raise IndexError("parameter_index %d out of range" % parameter_index)
         parameter = dev_params[parameter_index]
     else:
-        return {"error": {"code": "INVALID_PARAM",
-                "message": "parameter_type must be device/volume/panning/send"}}
+        raise ValueError("parameter_type must be device/volume/panning/send")
 
     # Get or create envelope
     song.begin_undo_step()
@@ -158,8 +152,8 @@ def clear_clip_automation(song, params):
     If parameter_type is provided, clears only that parameter's envelope.
     If omitted, clears ALL envelopes on the clip.
     """
-    track_index = params["track_index"]
-    clip_index = params["clip_index"]
+    track_index = int(params["track_index"])
+    clip_index = int(params["clip_index"])
     parameter_type = params.get("parameter_type")
 
     track = get_track(song, track_index)
@@ -184,31 +178,25 @@ def clear_clip_automation(song, params):
         elif parameter_type == "send":
             send_index = params.get("send_index")
             if send_index is None:
-                return {"error": {"code": "INVALID_PARAM",
-                        "message": "send_index required for send automation"}}
+                raise ValueError("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}}
+                raise IndexError("send_index %d out of range" % send_index)
             parameter = sends[send_index]
         elif parameter_type == "device":
             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"}}
+                raise ValueError("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}}
+                raise IndexError("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}}
+                raise IndexError("parameter_index %d out of range" % parameter_index)
             parameter = dev_params[parameter_index]
         else:
-            return {"error": {"code": "INVALID_PARAM",
-                    "message": "Unknown parameter_type"}}
+            raise ValueError("Unknown parameter_type")
 
         clip.clear_envelope(parameter)
     finally:

package/remote_script/LivePilot/tracks.py

@@ -101,7 +101,8 @@ def get_track_info(song, params):
         result["arm"] = None
         result["has_midi_input"] = None
         result["has_audio_input"] = None
-        result["is_return_track"] = True
+        result["is_return_track"] = track_index != -1000
+        result["is_master_track"] = track_index == -1000
 
     return result