livepilot 1.5.0 → 1.6.2

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,6 +1,6 @@
-# LivePilot v1.5.0 — Architecture & Tool Reference
+# LivePilot v1.6.0 — Architecture & Tool Reference
 
-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.
+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
 
@@ -32,7 +32,7 @@ A flat tool list lets the AI press buttons. LivePilot's three layers give it con
 
 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
+## The 135 Tools — What Each One Does
 
 ### Transport (12) — Playback, tempo, global state, diagnostics
 
@@ -227,6 +227,23 @@ This turns "set EQ band 3 to -4 dB" into "cut 400 Hz by 4 dB, then read the spec
 | `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.5.0 initialized")
+        self.log_message("LivePilot v1.6.1 initialized")
         self.show_message("LivePilot: Listening on port 9878")
 
     def disconnect(self):

package/remote_script/LivePilot/clip_automation.py

@@ -0,0 +1,220 @@
+"""Clip automation envelope handlers.
+
+Provides CRUD access to session clip automation envelopes.
+Uses the same LOM API as arrangement automation (AutomationEnvelope)
+but targets session clips via track.clip_slots[i].clip.
+"""
+
+from .router import register
+from .utils import get_track
+
+
+@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 = get_track(song, track_index)
+    clip_slot = list(track.clip_slots)[clip_index]
+    if not clip_slot.has_clip:
+        return {"error": {"code": "NOT_FOUND",
+                "message": "No clip at slot %d" % clip_index}}
+
+    clip = clip_slot.clip
+    envelopes = []
+
+    # Check mixer parameters: volume, panning, sends
+    mixer = track.mixer_device
+    for param_name, param in [
+        ("Volume", mixer.volume),
+        ("Pan", mixer.panning),
+    ]:
+        env = clip.automation_envelope(param)
+        if env is not None:
+            envelopes.append({
+                "parameter_name": param_name,
+                "parameter_type": "mixer",
+                "has_envelope": True,
+            })
+
+    # Check send parameters
+    sends = list(mixer.sends)
+    for i, send in enumerate(sends):
+        env = clip.automation_envelope(send)
+        if env is not None:
+            envelopes.append({
+                "parameter_name": "Send %s" % chr(65 + i),
+                "parameter_type": "send",
+                "send_index": i,
+                "has_envelope": True,
+            })
+
+    # Check device parameters
+    devices = list(track.devices)
+    for di, device in enumerate(devices):
+        dev_params = list(device.parameters)
+        for pi, param in enumerate(dev_params):
+            try:
+                env = clip.automation_envelope(param)
+                if env is not None:
+                    envelopes.append({
+                        "parameter_name": param.name,
+                        "parameter_type": "device",
+                        "device_index": di,
+                        "device_name": device.name,
+                        "parameter_index": pi,
+                        "has_envelope": True,
+                    })
+            except Exception:
+                pass
+
+    return {
+        "track_index": track_index,
+        "clip_index": clip_index,
+        "clip_name": clip.name,
+        "envelope_count": len(envelopes),
+        "envelopes": envelopes,
+    }
+
+
+@register("set_clip_automation")
+def set_clip_automation(song, params):
+    """Write automation points to a session clip envelope.
+
+    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"]
+    parameter_type = params["parameter_type"]
+    points = params["points"]
+    device_index = params.get("device_index")
+    parameter_index = params.get("parameter_index")
+    send_index = params.get("send_index")
+
+    track = get_track(song, track_index)
+    clip_slot = list(track.clip_slots)[clip_index]
+    if not clip_slot.has_clip:
+        return {"error": {"code": "NOT_FOUND",
+                "message": "No clip at slot %d" % clip_index}}
+
+    clip = clip_slot.clip
+
+    # Resolve the target parameter
+    if parameter_type == "volume":
+        parameter = track.mixer_device.volume
+    elif parameter_type == "panning":
+        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"}}
+        sends = list(track.mixer_device.sends)
+        if send_index >= len(sends):
+            return {"error": {"code": "INDEX_ERROR",
+                    "message": "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"}}
+        devices = list(track.devices)
+        if device_index >= len(devices):
+            return {"error": {"code": "INDEX_ERROR",
+                    "message": "device_index %d out of range" % device_index}}
+        dev_params = list(devices[device_index].parameters)
+        if parameter_index >= len(dev_params):
+            return {"error": {"code": "INDEX_ERROR",
+                    "message": "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"}}
+
+    # Get or create envelope
+    song.begin_undo_step()
+    try:
+        envelope = clip.automation_envelope(parameter)
+        if envelope is None:
+            envelope = clip.create_automation_envelope(parameter)
+
+        # Write points
+        written = 0
+        for pt in points:
+            time = float(pt["time"])
+            value = float(pt["value"])
+            duration = float(pt.get("duration", 0.125))
+            # Clamp value to parameter range
+            value = max(parameter.min, min(parameter.max, value))
+            envelope.insert_step(time, duration, value)
+            written += 1
+    finally:
+        song.end_undo_step()
+
+    return {
+        "track_index": track_index,
+        "clip_index": clip_index,
+        "parameter_name": parameter.name,
+        "parameter_type": parameter_type,
+        "points_written": written,
+    }
+
+
+@register("clear_clip_automation")
+def clear_clip_automation(song, params):
+    """Clear automation envelopes from a session clip.
+
+    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"]
+    parameter_type = params.get("parameter_type")
+
+    track = get_track(song, track_index)
+    clip_slot = list(track.clip_slots)[clip_index]
+    if not clip_slot.has_clip:
+        return {"error": {"code": "NOT_FOUND",
+                "message": "No clip at slot %d" % clip_index}}
+
+    clip = clip_slot.clip
+
+    song.begin_undo_step()
+    try:
+        if parameter_type is None:
+            # Clear all envelopes
+            clip.clear_all_envelopes()
+            return {
+                "track_index": track_index,
+                "clip_index": clip_index,
+                "cleared": "all",
+            }
+
+        # Clear specific parameter
+        if parameter_type == "volume":
+            parameter = track.mixer_device.volume
+        elif parameter_type == "panning":
+            parameter = track.mixer_device.panning
+        elif parameter_type == "send":
+            send_index = params.get("send_index", 0)
+            parameter = list(track.mixer_device.sends)[send_index]
+        elif parameter_type == "device":
+            device_index = params.get("device_index", 0)
+            parameter_index = params.get("parameter_index", 0)
+            device = list(track.devices)[device_index]
+            parameter = list(device.parameters)[parameter_index]
+        else:
+            return {"error": {"code": "INVALID_PARAM",
+                    "message": "Unknown parameter_type"}}
+
+        clip.clear_envelope(parameter)
+    finally:
+        song.end_undo_step()
+
+    return {
+        "track_index": track_index,
+        "clip_index": clip_index,
+        "cleared": parameter_type,
+        "parameter_name": parameter.name,
+    }

package/remote_script/LivePilot/server.py

@@ -52,6 +52,9 @@ WRITE_COMMANDS = frozenset([
     "modify_arrangement_notes", "duplicate_arrangement_notes",
     "transpose_arrangement_notes", "set_arrangement_automation",
     "set_arrangement_clip_name",
+    # clip automation
+    "set_clip_automation",
+    "clear_clip_automation",
 ])