livepilot 1.4.4 → 1.5.0

package/plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "livepilot",
-  "version": "1.4.4",
-  "description": "AI copilot for Ableton Live 12 — 104 MCP tools for music production, sound design, and mixing",
+  "version": "1.5.0",
+  "description": "AI copilot for Ableton Live 12 — 127 tools, device atlas (280+ devices), real-time audio analysis, and technique memory",
   "author": "Pilot Studio",
   "skills": [
     "skills/livepilot-core"

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

@@ -1,11 +1,17 @@
 ---
 name: livepilot-core
-description: Core discipline for controlling Ableton Live 12 through LivePilot's 104 MCP tools. Use whenever working with Ableton Live through MCP tools.
+description: Core discipline for controlling Ableton Live 12 through LivePilot's 127 MCP tools, device atlas (280+ devices), M4L analyzer (spectrum/RMS/key detection), and technique memory. Use whenever working with Ableton Live through MCP tools.
 ---
 
 # LivePilot Core — Ableton Live 12 AI Copilot
 
-LivePilot gives you 104 MCP tools to control Ableton Live 12 in real-time: transport, tracks, clips, MIDI notes, devices, scenes, mixing, browser, arrangement, and technique memory.
+LivePilot is an agentic production system for Ableton Live 12. It combines 127 MCP tools with three layers of intelligence:
+
+- **Device Atlas** — A structured knowledge corpus of 280+ instruments, 139 drum kits, and 350+ impulse responses. Consult the atlas before loading any device. It contains real browser URIs, preset names, and sonic descriptions. Never guess a device name — look it up.
+- **M4L Analyzer** — Real-time audio analysis on the master bus (8-band spectrum, RMS/peak, key detection). Use it to verify mixing decisions, detect frequency problems, and find the key before writing harmonic content.
+- **Technique Memory** — Persistent storage for production decisions. Consult `memory_recall` before creative tasks to understand the user's taste. Save techniques when the user likes something. The memory shapes future decisions without constraining them.
+
+These layers sit on top of 127 deterministic tools across 11 domains: transport, tracks, clips, MIDI notes, devices, scenes, mixing, browser, arrangement, technique memory, and real-time DSP analysis.
 
 ## Golden Rules
 
@@ -58,7 +64,7 @@ LivePilot gives you 104 MCP tools to control Ableton Live 12 in real-time: trans
 - MIDI track with no instrument loaded
 - Notes programmed but clip not fired
 
-## Tool Domains (104 total)
+## Tool Domains (127 total)
 
 ### 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`
@@ -78,8 +84,8 @@ LivePilot gives you 104 MCP tools to control Ableton Live 12 in real-time: trans
 ### Scenes (8)
 `get_scenes_info` · `create_scene` · `delete_scene` · `duplicate_scene` · `fire_scene` · `set_scene_name` · `set_scene_color` · `set_scene_tempo`
 
-### Mixing (8)
-`set_track_volume` · `set_track_pan` · `set_track_send` · `get_return_tracks` · `get_master_track` · `set_master_volume` · `get_track_routing` · `set_track_routing`
+### 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`
 
 ### Browser (4)
 `get_browser_tree` · `get_browser_items` · `search_browser` · `load_browser_item`
@@ -90,6 +96,9 @@ LivePilot gives you 104 MCP tools to control Ableton Live 12 in real-time: trans
 ### 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`
+
 ## Workflow: Building a Beat
 
 1. `get_session_info` — check current state
@@ -120,11 +129,43 @@ LivePilot gives you 104 MCP tools to control Ableton Live 12 in real-time: trans
 ## Workflow: Mixing
 
 1. `get_session_info` — see all tracks and current levels
-2. `set_track_volume` / `set_track_pan` — set levels and stereo position
-3. `set_track_send` — route to return tracks for shared effects
-4. `get_return_tracks` — check return track setup
-5. `set_master_volume` — final output level
-6. `set_track_routing` — configure input/output routing
+2. `get_mix_snapshot` — one-call overview of all levels, panning, routing, mute/solo
+3. `set_track_volume` / `set_track_pan` — set levels and stereo position
+4. `set_track_send` — route to return tracks for shared effects
+5. `get_return_tracks` — check return track setup
+6. `set_master_volume` — final output level
+7. `set_track_routing` — configure input/output routing
+8. `get_track_meters` / `get_master_meters` — check real-time output levels
+
+### With LivePilot Analyzer (M4L device on master):
+9. `get_master_spectrum` — check frequency balance across 8 bands (sub → air)
+10. `get_master_rms` — true RMS and peak levels
+11. `get_detected_key` — detect musical key before writing harmonies/bass
+12. `get_hidden_parameters` — see ALL device params including hidden ones
+13. `get_automation_state` — check which params have automation before overwriting
+14. `walk_device_tree` — inspect nested racks and drum pads
+15. `get_display_values` — human-readable parameter values ("440 Hz", "-6 dB")
+
+## Workflow: Sample Chopping
+
+1. Resample your beat to an audio track (set input to Resampling, arm, record)
+2. `get_clip_file_path` — get the audio file path of the recorded clip
+3. Load Simpler on a new MIDI track (with any sample pre-loaded)
+4. `replace_simpler_sample` — load the resampled audio into Simpler
+5. `set_simpler_playback_mode` — set to Slice mode
+6. `get_simpler_slices` — see all auto-detected slice points
+7. Program MIDI patterns targeting slice indices
+8. Use `reverse_simpler` / `crop_simpler` / `warp_simpler` for transformations
+9. `get_master_spectrum` — verify the result through the analyzer
+
+## Workflow: Time Manipulation
+
+1. `get_warp_markers` — see current timing map of an audio clip
+2. `add_warp_marker` — pin key beats (downbeats, snare hits)
+3. `move_warp_marker` — stretch/compress specific segments for tempo effects
+4. `scrub_clip` / `stop_scrub` — preview specific positions
+5. `get_master_spectrum` — verify the result sounds right
+6. `remove_warp_marker` — clean up if needed
 
 ## Live 12 Note API
 
@@ -199,7 +240,7 @@ Deep production knowledge lives in `references/`. Consult these when making crea
 
 | File | What's inside | When to consult |
 |------|--------------|-----------------|
-| `references/overview.md` | All 104 tools mapped with params, units, ranges | Quick lookup for any tool |
+| `references/overview.md` | All 127 tools mapped with params, units, ranges | Quick lookup for any tool |
 | `references/midi-recipes.md` | Drum patterns by genre, chord voicings, scales, hi-hat techniques, humanization, polymetrics | Programming MIDI notes, building beats |
 | `references/sound-design.md` | Stock instruments/effects, parameter recipes for bass/pad/lead/pluck, device chain patterns | Loading and configuring devices |
 | `references/mixing-patterns.md` | Gain staging, parallel compression, sidechain, EQ by instrument, bus processing, stereo width | Setting volumes, panning, adding effects |

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

@@ -1,20 +1,38 @@
-# LivePilot Architecture & Tool Reference
+# LivePilot v1.5.0 — Architecture & Tool Reference
 
-LivePilot is an MCP server that controls Ableton Live 12 in real-time through 104 tools across 10 domains. This document maps every tool to what it actually does in Ableton, so you know exactly which tool to reach for.
+LivePilot is an agentic production system for Ableton Live 12. It combines 127 MCP tools with a device knowledge corpus, real-time audio analysis, and persistent technique memory.
 
 ## Architecture
 
 ```
-Claude Code  ──MCP──►  FastMCP Server  ──TCP/9878──►  Remote Script (inside Ableton)
+AI Client  ──MCP──►  FastMCP Server  ──TCP/9878──►  Remote Script (inside Ableton)
                         (validates)                    (executes on main thread)
+                            │
+                            ├── Device Atlas (280+ devices, 139 kits, 350+ IRs)
+                            ├── M4L Analyzer ──UDP/OSC──► LivePilot_Analyzer.amxd
+                            └── Technique Memory (~/.livepilot/memory/)
 ```
 
 - **MCP Server** validates inputs (ranges, types) before sending
 - **Remote Script** runs inside Ableton's Python environment, executes on the main thread via `schedule_message`
+- **Device Atlas** provides structured knowledge of Ableton's device library — real names, real URIs, sonic descriptions
+- **M4L Analyzer** reads the master bus in real-time: 8-band spectrum, RMS/peak, pitch tracking, Krumhansl-Schmuckler key detection
+- **Technique Memory** persists production decisions across sessions as typed, searchable, replayable data structures
 - **Protocol**: JSON over TCP, newline-delimited. Every command gets a response.
 - **Thread safety**: All Live Object Model (LOM) access happens on Ableton's main thread
 
-## The 104 Tools — What Each One Does
+## The Agentic Difference
+
+A flat tool list lets the AI press buttons. LivePilot's three layers give it context:
+
+1. **Before loading a device** — the agent consults the atlas to find a real preset, not a hallucinated name
+2. **Before writing harmonic content** — the agent reads the detected key from the analyzer
+3. **Before making creative decisions** — the agent checks technique memory for the user's style preferences
+4. **After every mixing move** — the agent reads the spectrum to verify the result
+
+This turns "set EQ band 3 to -4 dB" into "cut 400 Hz by 4 dB, then read the spectrum to confirm the mud is actually reduced."
+
+## The 127 Tools — What Each One Does
 
 ### Transport (12) — Playback, tempo, global state, diagnostics
 
@@ -122,7 +140,7 @@ Claude Code  ──MCP──►  FastMCP Server  ──TCP/9878──►  Remote
 | `set_scene_color` | Sets scene color | `scene_index`, `color_index` (0-69) |
 | `set_scene_tempo` | Sets tempo that triggers when scene fires | `scene_index`, `tempo` (20-999 BPM) |
 
-### Mixing (8) — Levels, panning, routing
+### Mixing (11) — Levels, panning, routing, metering
 
 | Tool | What it does | Key params |
 |------|-------------|------------|
@@ -134,6 +152,9 @@ Claude Code  ──MCP──►  FastMCP Server  ──TCP/9878──►  Remote
 | `set_master_volume` | Sets master output level | `volume` (0.0-1.0) |
 | `get_track_routing` | Returns input/output routing config | `track_index` |
 | `set_track_routing` | Configures input/output routing | `track_index`, routing params |
+| `get_track_meters` | Returns real-time output levels for a track | `track_index` |
+| `get_master_meters` | Returns real-time output levels for the master | — |
+| `get_mix_snapshot` | Returns all levels, panning, routing, mute/solo state for entire session | — |
 
 ### Browser (4) — Finding and loading presets/devices
 
@@ -181,6 +202,31 @@ Claude Code  ──MCP──►  FastMCP Server  ──TCP/9878──►  Remote
 | `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)
+
+| Tool | What it does | Key params |
+|------|-------------|------------|
+| `get_master_spectrum` | 8-band spectral analysis of master output | — |
+| `get_master_rms` | True RMS and peak amplitude levels | — |
+| `get_detected_key` | Detects musical key (Krumhansl-Schmuckler) | — |
+| `get_hidden_parameters` | All device parameters including hidden ones | `track_index`, `device_index` |
+| `get_automation_state` | Parameters with active automation | `track_index`, `device_index` |
+| `walk_device_tree` | Recursive device tree (racks, drum pads, 6 levels) | `track_index`, `device_index` |
+| `get_clip_file_path` | Audio file path on disk | `track_index`, `clip_index` |
+| `replace_simpler_sample` | Replace sample in Simpler | `track_index`, `device_index`, `file_path` |
+| `load_sample_to_simpler` | Bootstrap Simpler and load sample (full workflow) | `track_index`, `file_path` |
+| `get_simpler_slices` | Slice points from Simpler | `track_index`, `device_index` |
+| `crop_simpler` | Crop sample to active region | `track_index`, `device_index` |
+| `reverse_simpler` | Reverse sample | `track_index`, `device_index` |
+| `warp_simpler` | Warp sample to N beats | `track_index`, `device_index`, `beats` |
+| `get_warp_markers` | All warp markers (beat_time + sample_time) | `track_index`, `clip_index` |
+| `add_warp_marker` | Add warp marker | `track_index`, `clip_index`, `beat_time` |
+| `move_warp_marker` | Move warp marker | `track_index`, `clip_index`, `old_beat`, `new_beat` |
+| `remove_warp_marker` | Remove warp marker | `track_index`, `clip_index`, `beat_time` |
+| `scrub_clip` | Preview audio at position | `track_index`, `clip_index`, `beat_time` |
+| `stop_scrub` | Stop preview | `track_index`, `clip_index` |
+| `get_display_values` | Human-readable parameter values ("440 Hz", "-6 dB") | `track_index`, `device_index` |
+
 ## Units & Ranges Quick Reference
 
 | Concept | Unit/Range | Notes |

package/remote_script/LivePilot/__init__.py

@@ -31,7 +31,7 @@ class LivePilot(ControlSurface):
         ControlSurface.__init__(self, c_instance)
         self._server = LivePilotServer(self)
         self._server.start()
-        self.log_message("LivePilot v1.0.0 initialized")
+        self.log_message("LivePilot v1.5.0 initialized")
         self.show_message("LivePilot: Listening on port 9878")
 
     def disconnect(self):

package/remote_script/LivePilot/mixing.py

@@ -1,5 +1,5 @@
 """
-LivePilot - Mixing domain handlers (8 commands).
+LivePilot - Mixing domain handlers (11 commands).
 """
 
 from .router import register
@@ -114,6 +114,95 @@ def get_track_routing(song, params):
     return result
 
 
+@register("get_track_meters")
+def get_track_meters(song, params):
+    """Read output meter levels for one or all tracks.
+
+    Returns peak level (0.0-1.0) for each track. When track_index is
+    provided, returns a single track. Otherwise returns all tracks.
+
+    The 'level' value is the hold-peak of max(L, R). It's cheap to read.
+    The 'left'/'right' values add GUI load — only included when
+    include_stereo=True.
+    """
+    include_stereo = bool(params.get("include_stereo", False))
+    track_index = params.get("track_index")
+
+    def read_meters(track, idx):
+        entry = {
+            "index": idx,
+            "name": track.name,
+            "level": track.output_meter_level,
+        }
+        if include_stereo:
+            entry["left"] = track.output_meter_left
+            entry["right"] = track.output_meter_right
+        return entry
+
+    if track_index is not None:
+        track = get_track(song, int(track_index))
+        return {"tracks": [read_meters(track, int(track_index))]}
+
+    tracks = []
+    for i, track in enumerate(song.tracks):
+        tracks.append(read_meters(track, i))
+    return {"tracks": tracks}
+
+
+@register("get_master_meters")
+def get_master_meters(song, params):
+    """Read output meter levels for the master track."""
+    master = song.master_track
+    result = {
+        "level": master.output_meter_level,
+        "left": master.output_meter_left,
+        "right": master.output_meter_right,
+    }
+    return result
+
+
+@register("get_mix_snapshot")
+def get_mix_snapshot(song, params):
+    """Get a complete snapshot of the mix: all track levels, volumes, pans,
+    mute/solo states, and master meters. One call to assess the full mix."""
+    tracks = []
+    for i, track in enumerate(song.tracks):
+        tracks.append({
+            "index": i,
+            "name": track.name,
+            "meter_level": track.output_meter_level,
+            "volume": track.mixer_device.volume.value,
+            "pan": track.mixer_device.panning.value,
+            "mute": track.mute,
+            "solo": track.solo,
+            "has_audio_output": track.has_audio_output,
+        })
+    returns = []
+    for i, track in enumerate(song.return_tracks):
+        returns.append({
+            "index": i,
+            "name": track.name,
+            "meter_level": track.output_meter_level,
+            "volume": track.mixer_device.volume.value,
+            "pan": track.mixer_device.panning.value,
+            "mute": track.mute,
+            "solo": track.solo,
+        })
+    master = song.master_track
+    return {
+        "tracks": tracks,
+        "return_tracks": returns,
+        "master": {
+            "level": master.output_meter_level,
+            "left": master.output_meter_left,
+            "right": master.output_meter_right,
+            "volume": master.mixer_device.volume.value,
+        },
+        "is_playing": song.is_playing,
+        "tempo": song.tempo,
+    }
+
+
 @register("set_track_routing")
 def set_track_routing(song, params):
     """Set input/output routing for a track by display name."""

package/.mcp.json

@@ -1,9 +0,0 @@
-{
-  "mcpServers": {
-    "livepilot": {
-      "command": "node",
-      "args": ["bin/livepilot.js"],
-      "cwd": "/Users/visansilviugeorge/Desktop/LivePilot"
-    }
-  }
-}

package/plugin/.mcp.json

@@ -1,8 +0,0 @@
-{
-  "mcpServers": {
-    "LivePilot": {
-      "command": "npx",
-      "args": ["livepilot"]
-    }
-  }
-}