livepilot 1.4.5 → 1.6.1

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 135 MCP tools, device atlas (280+ devices), M4L analyzer (spectrum/RMS/key detection), automation intelligence (16 curve types, 15 recipes), 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 135 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 135 deterministic tools across 12 domains: transport, tracks, clips, MIDI notes, devices, scenes, mixing, browser, arrangement, technique memory, real-time DSP analysis, and automation.
 
 ## 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 (135 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,32 @@ 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`
+
+### Automation (8)
+Clip automation CRUD + intelligent curve generation with 15 built-in recipes.
+
+**Tools:** `get_clip_automation` · `set_clip_automation` · `clear_clip_automation` · `apply_automation_shape` · `apply_automation_recipe` · `get_automation_recipes` · `generate_automation_curve` · `analyze_for_automation`
+
+**Key discipline:**
+
+**The Feedback Loop (MANDATORY for all automation work):**
+1. PERCEIVE: `get_master_spectrum` + `get_track_meters` -> understand current state
+2. DIAGNOSE: What needs to change? Use diagnostic filter technique if unsure
+3. DECIDE: Which parameter, which curve, which recipe?
+4. ACT: `apply_automation_shape` or `apply_automation_recipe`
+5. VERIFY: `get_master_spectrum` again -> did it work?
+6. ADJUST: If not right, `clear_clip_automation` -> try different curve/params
+7. NEVER write automation without reading spectrum first and after
+
+**Rules:**
+- Use `analyze_for_automation` before writing — let spectral data guide decisions
+- Use recipes for common patterns (filter_sweep_up, dub_throw, sidechain_pump)
+- Use `apply_automation_shape` for custom curves with specific math
+- 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
+
 ## Workflow: Building a Beat
 
 1. `get_session_info` — check current state
@@ -120,11 +152,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,10 +263,11 @@ 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 135 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 |
 | `references/ableton-workflow-patterns.md` | Session/Arrangement workflow, song structures by genre, follow actions, clip launch modes, export | Organizing sessions, structuring songs |
 | `references/m4l-devices.md` | Browser organization, MIDI effects, rack systems, device loading patterns | Finding and loading devices, using racks |
 | `references/memory-guide.md` | Qualities template, good/bad examples for each technique type | Saving techniques, writing qualities |
+| `references/automation-atlas.md` | Curve theory, perception-action loop, genre recipes, diagnostic filter technique, spectral mapping | Writing automation, choosing curves, mixing with spectral feedback |

package/plugin/skills/livepilot-core/references/automation-atlas.md

@@ -0,0 +1,272 @@
+# Automation Atlas — LivePilot v1.6
+
+Complete knowledge corpus for musically intelligent automation. Load this reference when working with automation tools.
+
+---
+
+## 1. Curve Theory
+
+### Why exponential for filters
+Filter frequency perception is logarithmic (octaves). 100Hz → 200Hz is the same perceptual distance as 1kHz → 2kHz. An exponential curve in the normalized 0–1 range maps to perceptually even movement across the frequency spectrum. Linear automation on a filter sounds like it's rushing through the highs and crawling through the lows. Use `exponential` with `factor` 2.0–3.0 for filter cutoff.
+
+### Why logarithmic for volume
+Human loudness perception follows a logarithmic curve (Weber-Fechner law). -6dB = half perceived loudness, not half amplitude. A logarithmic fade-in sounds smooth; a linear fade-in sounds like nothing happens then suddenly gets loud. Use `logarithmic` with `factor` 2.5–3.5 for volume fades.
+
+### Why S-curve for crossfades
+Natural acceleration/deceleration. Avoids the "hole in the middle" of linear crossfades where combined energy dips. The smoothstep function (3t² - 2t³) ensures the rate of change is zero at both endpoints, so the transition feels organic. Use `s_curve` for any A→B crossfade.
+
+### Why spike for throws
+Dub production technique — instant send level spike creates a single reflection that decays naturally through the reverb/delay tail. Any other shape creates unnatural sustained reflections. The exponential decay (peak × e^(-decay×t)) models how real acoustic energy dissipates.
+
+### Pan is linear
+Stereo position perception is roughly linear. A pan pot moving at constant speed sounds even. No need for perceptual correction on pan automation.
+
+### Resonance is dangerous
+Filter resonance is non-linear — subtle changes at low values, dramatic and potentially destructive at high values. Self-oscillation begins above ~0.85 on most filters. Never automate resonance above 0.85 without explicit user intent. Use `breathing` recipe with reduced amplitude (0.05–0.10) for subtle resonance movement.
+
+---
+
+## 2. The Perception-Action Loop (5 levels)
+
+**MANDATORY for all automation work.** Never write automation blind — always perceive first.
+
+### Level 1: Reactive
+Single read, single action. The simplest loop.
+1. `get_master_spectrum` → read frequency content
+2. Identify one issue (e.g., "mud below 200Hz")
+3. Apply one automation (e.g., HP filter sweep)
+4. `get_master_spectrum` → verify improvement
+
+### Level 2: Diagnostic
+Multi-step investigation using EQ as a microscope. See Section 3 (Diagnostic Filter Technique).
+
+### Level 3: Verification
+Act → measure → adjust cycle. For every automation written:
+1. Read spectrum BEFORE
+2. Write automation
+3. Read spectrum AFTER
+4. Compare: did the problem frequency range improve?
+5. If not, `clear_clip_automation` → adjust parameters → try again
+6. Log the successful parameters in memory for reuse
+
+### Level 4: Cross-Track
+Solo each track, build spectral map, write complementary automation.
+1. For each track: solo → `get_master_spectrum` → record fingerprint
+2. Find frequency overlaps between tracks (masking)
+3. Write complementary automation: as kick's filter opens, bass's filter narrows
+4. Verify no new masking was introduced
+5. Store the cross-track map in memory
+
+### Level 5: Full Pipeline
+Per-track analysis across entire session.
+1. Run Level 4 for all tracks
+2. Build session-wide spectral map
+3. Write automation considering all interactions
+4. Verify global mix spectrum
+5. Iterate until balanced
+
+---
+
+## 3. Diagnostic Filter Technique
+
+Using EQ Eight as a measurement instrument. Step-by-step:
+
+1. **Load EQ Eight** on target track via `find_and_load_device`
+2. **Configure band 1** as narrow bandpass: Q=8, gain=0dB, frequency=100Hz
+   - Use `set_device_parameter` to set Filter Type to Band Pass, Q to 8.0
+3. **Solo the track** via `set_track_solo`
+4. **Read spectrum** at 100Hz: `get_master_spectrum` → note the `sub` value
+5. **Sweep frequency** through key ranges:
+   - 100Hz, 200Hz, 300Hz, 500Hz, 1kHz, 2kHz, 5kHz, 10kHz
+   - At each: `set_device_parameter` (frequency) → `get_master_spectrum` → record
+6. **Build frequency map**: `{100Hz: 0.18, 200Hz: 0.25, 300Hz: 0.09, ...}`
+7. **Identify problems**: resonance buildup, mud, harshness, dead zones
+8. **Remove diagnostic EQ** — always clean up: `delete_device`
+9. **Un-solo the track**: `set_track_solo` (toggle off)
+10. **Write targeted automation** addressing what was found
+
+### What to look for:
+- **Mud** (200-400Hz): values > 0.20 suggest buildup → HP filter automation
+- **Resonance** (narrow peak in 300-800Hz): ringing → notch filter or gentle sweep
+- **Harshness** (2-5kHz): values > 0.25 suggest brightness → LP filter or shelf automation
+- **Dead zone** (any range with 0.00): frequency hole → boost or different device
+
+---
+
+## 4. Genre Recipes
+
+### Techno
+- `filter_sweep_up` on LP cutoff, 32 bars, factor 2.0 — the classic build
+- `sidechain_pump` on pad volume via Utility gain, 1 beat loop
+- `stutter` on vocals before drop, 0.5 beats, frequency 16
+- `stereo_narrow` on master bus, 8 bars before drop → instant widen at drop
+- Long transitions: combine HP filter + reverb send + stereo width, all exponential
+
+### Dub
+- `dub_throw` on Send A at each snare position, 1 beat duration
+- `tape_stop` on clip transpose for transitions, 0.5 beats
+- `washout` on delay feedback, 4 bars → cut at phrase boundary
+- `breathing` on filter cutoff, 4 bars — everything breathes in dub
+- Tip: never automate delay feedback above 0.85 (infinite feedback risk)
+
+### Ambient
+- `breathing` on filter cutoff, 4 bars, amplitude 0.10 — subtle is key
+- `perlin` noise on reverb mix, 8 bars, amplitude 0.15, seed varies
+- `brownian` drift on wavetable position, 16 bars, volatility 0.05
+- Polyrhythmic automation: 3-beat filter + 5-beat reverb + 7-beat pan = 105-beat cycle
+- Less is more. Ambient automation should be felt, not heard.
+
+### Hip Hop
+- `tape_stop` on clip transpose, 0.5 beats — classic vinyl stop
+- `vinyl_crackle` on Redux bit depth, 16 bars — lo-fi character
+- `sidechain_pump` on bass under kick, 0.5 beat — tight pocket
+- `fade_out` on filter for transitions between sections
+- Keep automation sparse — hip hop is about groove, not modulation
+
+### IDM / Experimental
+- `stutter` on volume, 0.5 beats, frequency 16 — micro-editing
+- `euclidean` on filter cutoff: 5 hits across 8 steps — rhythmic intelligence
+- `stochastic` on grain parameters, narrowing 0.7 — controlled chaos
+- `spring` on filter cutoff for overshoot character
+- Layer multiple polyrhythmic automations for generative evolution
+
+---
+
+## 5. Sound Design Automation
+
+### Wavetable position
+Exponential sweep for timbral morphing over 8–16 bars. The timbral change is often perceptually logarithmic, so exponential automation creates even-sounding evolution.
+
+### Grain size
+Sine modulation at 0.5–2Hz for alive textures. The slow oscillation prevents the grainular artifacts from sounding static. Use `breathing` recipe adapted: center 0.5, amplitude 0.15.
+
+### Reverb decay
+Link inversely to volume: quieter passages get longer tails for natural space. As volume drops, reverb decay increases. Automate both with complementary curves.
+
+### Delay feedback
+Spike for throws (dub technique). NEVER exceed 0.9 on feedback — infinite feedback creates dangerous signal buildup. Use `dub_throw` recipe with peak capped at 0.85.
+
+### Filter resonance
+Subtle sine modulation creates vocal/crying quality. Watch for self-oscillation above 0.85. Use amplitude 0.05–0.10 for subtle character, 0.15–0.25 for expressive.
+
+---
+
+## 6. Arrangement Techniques
+
+### The Build (16–32 bars before drop)
+Combine multiple automations, all exponential:
+1. HP filter: 0→0.6 (remove low end gradually)
+2. Volume: 0.7→1.0 (subtle lift)
+3. Reverb send: 0→0.5 (add wash)
+4. Stereo width: 1.0→0.0 (collapse to mono)
+5. At drop: instant step back to defaults
+
+### The Drop (instant)
+Step automation restoring all build parameters to default values. No curves — immediate snap. Use `steps` curve with a single value at time 0.
+
+### The Strip (8–16 bars)
+Gradual HP filter rise removing elements one by one:
+1. First: HP filter on bass track (removes bass)
+2. Then: HP filter on drums (removes kick)
+3. Then: HP filter on pads (removes mids)
+4. Only high frequencies remain → transition point
+
+### The Crossfade (2–8 bars)
+S-curve volume automation between two sections:
+- Outgoing track: s_curve from 1.0 to 0.0
+- Incoming track: s_curve from 0.0 to 1.0
+- S-curve prevents the energy dip of linear crossfades
+
+---
+
+## 7. Micro-Editing and Humanization
+
+### Velocity vs volume
+Velocity is timbre — it changes how the sound is generated (harder hits, brighter tone). Volume automation is loudness — it changes amplitude after generation. They are different tools.
+
+### Per-note filter accent
+Automate filter cutoff to spike on accented notes. Use `spike` with duration matching the note length. Creates timbral accents without touching velocity.
+
+### Spatial punctuation
+Send spikes on specific hits create spatial depth variation. Snare → reverb throw on beat 2 and 4. Hi-hat → delay throw on off-beats. Use `dub_throw` recipe.
+
+### Humanization via Perlin noise
+Tiny pitch/filter variations make programmed music feel human:
+- `perlin` on detune: amplitude 0.02, frequency 0.5
+- `perlin` on filter cutoff: amplitude 0.05, frequency 0.3
+- Different seeds per track — each voice drifts independently
+
+---
+
+## 8. Polyrhythmic Automation
+
+### The concept
+Unlinked automation envelopes with different loop lengths create long, non-repeating cycles:
+- 4-beat clip loop + 3-beat filter envelope + 5-beat reverb envelope
+- Total cycle: LCM(4, 3, 5) = 60 beats before exact repetition
+- 60 beats ≈ 15 bars at 4/4 — feels evolving, never static
+
+### Prime number rule
+Use prime-number beat lengths for maximum non-repetition:
+- 3, 5, 7, 11, 13 beats
+- LCM of primes = their product (all coprime)
+- 3 × 5 × 7 = 105 beats ≈ 26 bars before exact repeat
+
+### Implementation
+1. Create clip with N-beat loop (your base rhythm)
+2. `apply_automation_shape` with `duration` = M beats (M ≠ N, preferably prime)
+3. The automation loops at M beats, the clip loops at N beats
+4. Add another automation with duration = P beats (another prime)
+5. Total cycle = LCM(N, M, P) beats
+
+### Use cases
+Essential for ambient, installation, generative work. Creates the sense of "always evolving" that distinguishes produced music from loops.
+
+---
+
+## 9. Cross-Track Spectral Mapping
+
+### Process
+1. **Solo each track** one at a time
+2. **Read spectrum**: `get_master_spectrum` → record {sub, low, mid, high, presence, air}
+3. **Build spectral fingerprint** for each track:
+   ```
+   Kick:  sub=0.45, low=0.30, mid=0.05, high=0.02
+   Bass:  sub=0.35, low=0.40, mid=0.15, high=0.03
+   Pad:   sub=0.05, low=0.15, mid=0.35, high=0.25
+   ```
+4. **Find overlaps**: kick and bass both strong in sub/low = masking
+5. **Write complementary automation**: as kick opens, bass narrows
+6. **Verify**: un-solo all, check master spectrum for improvement
+
+### Complementary automation patterns
+- **Kick + Bass**: sidechain pump on bass volume, or complementary filter sweeps
+- **Vocals + Pads**: automate pad filter to duck in vocal frequency range (1–4kHz)
+- **Multiple synths**: different breathing rates (frequency 0.3, 0.5, 0.7) to weave in/out
+
+### Store findings
+Use `memory_learn` to save spectral maps and successful automation combinations. Build a knowledge base about the session's sounds for consistent decisions.
+
+---
+
+## 10. Golden Rules
+
+1. **Always use Utility gain for volume automation** — preserve the mixer fader for mixing. Automate the Utility device's Gain parameter, not track volume.
+
+2. **Exponential for filters, logarithmic for volume** — never linear for either. This is perceptual science, not preference.
+
+3. **Subtle automation (5–15% range) for organic feel; dramatic (full range) for transitions.** Most automation should be felt, not heard. Save the big sweeps for builds and drops.
+
+4. **ALWAYS verify with `get_master_spectrum` after writing automation.** The feedback loop is mandatory, not optional.
+
+5. **Use `clear_clip_automation` before rewriting.** Don't stack conflicting curves — clear first, then write fresh.
+
+6. **Use the diagnostic filter technique before guessing at problem frequencies.** Measurement beats intuition.
+
+7. **Store spectral findings in memory.** Build a knowledge base about this session's sounds. Cross-session awareness makes every future decision better.
+
+8. **Delay feedback NEVER above 0.9.** Infinite feedback creates dangerous signal buildup. Cap at 0.85 for safety, even in experimental contexts.
+
+9. **density 16–32 for most curves.** 16 points per bar gives smooth results for gentle curves. 32 for fast modulations or detailed shapes. Above 64 is rarely worth the overhead.
+
+10. **When in doubt, use a recipe.** The 15 built-in recipes encode production wisdom. Start with the recipe, then customize if needed.

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

@@ -1,20 +1,38 @@
-# LivePilot Architecture & Tool Reference
+# LivePilot v1.6.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 135 MCP tools with a device knowledge corpus, real-time audio analysis, automation intelligence, 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 135 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,48 @@ 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` |
+
+### Automation (8) — Clip automation CRUD + intelligent curve generation
+
+| Tool | What it does | Key params |
+|------|-------------|------------|
+| `get_clip_automation` | Lists all automation envelopes on a session clip | `track_index`, `clip_index` |
+| `set_clip_automation` | Writes automation points to a clip envelope | `track_index`, `clip_index`, `parameter_type`, `points` |
+| `clear_clip_automation` | Clears automation envelopes (specific or all) | `track_index`, `clip_index`, `parameter_type` (optional) |
+| `apply_automation_shape` | Generates and applies a curve to a clip in one call | `track_index`, `clip_index`, `parameter_type`, `curve_type`, `duration`, `density` |
+| `apply_automation_recipe` | Applies a named recipe (filter_sweep_up, dub_throw, etc.) | `track_index`, `clip_index`, `parameter_type`, `recipe`, `duration` |
+| `get_automation_recipes` | Lists all 15 recipes with descriptions and targets | — |
+| `generate_automation_curve` | Previews curve points without writing them | `curve_type`, `duration`, `density`, curve-specific params |
+| `analyze_for_automation` | Spectral analysis + device-aware automation suggestions | `track_index` |
+
+**16 curve types:** linear, exponential, logarithmic, s_curve, sine, sawtooth, spike, square, steps, perlin, brownian, spring, bezier, easing, euclidean, stochastic
+
+**15 recipes:** filter_sweep_up, filter_sweep_down, dub_throw, tape_stop, build_rise, sidechain_pump, fade_in, fade_out, tremolo, auto_pan, stutter, breathing, washout, vinyl_crackle, stereo_narrow
+
 ## Units & Ranges Quick Reference
 
 | Concept | Unit/Range | Notes |

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

@@ -0,0 +1,101 @@
+---
+name: livepilot-release
+description: Release checklist for LivePilot — run before ANY push, publish, or "update everything" request. Covers every file, channel, and artifact that references version numbers, tool counts, or project state.
+---
+
+# LivePilot Release Checklist
+
+Run this checklist EVERY time the user says "update everything", "push", "release", "make sure everything is current", or similar.
+
+## 1. Version Strings (must ALL match)
+
+- [ ] `package.json` → `"version"`
+- [ ] `package-lock.json` → `"version"` (run `npm install --package-lock-only` if stale)
+- [ ] `server.json` → `"version"` (TWO locations: top-level and package)
+- [ ] `plugin/plugin.json` → `"version"`
+- [ ] `mcp_server/__init__.py` → `__version__`
+- [ ] `remote_script/LivePilot/__init__.py` → version in log message
+- [ ] `m4l_device/livepilot_bridge.js` → version in ping response
+- [ ] `CHANGELOG.md` → latest version header
+- [ ] `docs/social-banner.html` → version display
+
+**How to check:** `grep -rn "1\.[0-9]\.[0-9]" package.json server.json plugin/plugin.json mcp_server/__init__.py remote_script/LivePilot/__init__.py m4l_device/livepilot_bridge.js CHANGELOG.md docs/social-banner.html`
+
+## 2. Tool Count (must ALL match)
+
+- [ ] `README.md` — every occurrence
+- [ ] `package.json` → `"description"`
+- [ ] `server.json` → `"description"`
+- [ ] `plugin/plugin.json` → `"description"`
+- [ ] `CLAUDE.md`
+- [ ] `plugin/skills/livepilot-core/SKILL.md` — header and domain breakdown
+- [ ] `plugin/skills/livepilot-core/references/overview.md`
+- [ ] `docs/manual/index.md`
+- [ ] `docs/manual/tool-reference.md`
+- [ ] `docs/TOOL_REFERENCE.md`
+- [ ] `docs/M4L_BRIDGE.md`
+- [ ] `docs/social-banner.html`
+- [ ] `mcp_server/tools/analyzer.py` → module docstring
+- [ ] `tests/test_tools_contract.py` → expected count
+
+**How to check:** `grep -rn "127\|104\|113" --include="*.md" --include="*.json" --include="*.py" --include="*.html" --include="*.js" . | grep -v node_modules | grep -v .git | grep -v __pycache__`
+
+## 3. Domain Count
+
+- [ ] All files above that mention "10 domains" should say "11 domains"
+- [ ] Domain lists should include: transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, analyzer
+
+## 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
+
+- [ ] Repo description matches current tool count and features
+- [ ] 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
+
+- [ ] `~/.claude/plugins/cache/dreamrec-LivePilot/livepilot/` has current version directory
+- [ ] Old version directories removed
+
+## 7. Social/Promotional Assets
+
+- [ ] `docs/social-banner.html` — tool count, version, domain list
+- [ ] `docs/social-banner.png` — regenerated from HTML (must match)
+- [ ] GitHub repo social preview image (Settings > Social preview)
+
+## 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
+
+## 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?
+
+## 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
+
+## Quick Verify Command
+
+Run this one-liner to catch most issues:
+```bash
+echo "=== Versions ===" && grep -h '"version"' package.json server.json 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
+```

package/remote_script/LivePilot/__init__.py

@@ -16,7 +16,8 @@ from . import scenes       # noqa: F401  — registers scene handlers
 from . import mixing       # noqa: F401  — registers mixing handlers
 from . import browser      # noqa: F401  — registers browser handlers
 from . import arrangement  # noqa: F401  — registers arrangement handlers
-from . import diagnostics  # noqa: F401  — registers diagnostics handler
+from . import diagnostics       # noqa: F401  — registers diagnostics handler
+from . import clip_automation   # noqa: F401  — registers clip automation handlers
 
 
 def create_instance(c_instance):
@@ -31,7 +32,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.6.1 initialized")
         self.show_message("LivePilot: Listening on port 9878")
 
     def disconnect(self):