livepilot 1.1.2 → 1.2.1

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 1.2.1 — 2026-03-17
+
+### Fixes
+- Remove 3 tools that don't work in Live 12's ControlSurface API: `create_group_track`, `freeze_track`, `flatten_track`
+- Fix `set_scene_name` — now allows empty string to clear scene name
+- Fix `set_scene_tempo` — removed invalid "0 to clear" (Live 12 range is 20-999 BPM)
+- All 96 tools live-tested against Ableton Live 12
+
+## 1.2.0 — 2026-03-17
+
+### New Tools (+5, total 96)
+- **`set_group_fold`** — fold/unfold a group track to show/hide children
+- **`set_track_input_monitoring`** — set input monitoring state (In/Auto/Off)
+- **`set_clip_warp_mode`** — set warp mode for audio clips (Beats/Tones/Texture/Re-Pitch/Complex/Complex Pro)
+- **`set_scene_color`** — set scene color (0-69)
+- **`set_scene_tempo`** — set per-scene tempo that triggers on launch (20-999 BPM)
+
+### Removed Tools (-3)
+- **`create_group_track`** — removed due to Live 12 API limitations
+- **`freeze_track`** — removed due to Live 12 API limitations
+- **`flatten_track`** — removed due to Live 12 API limitations
+
+### Enhancements
+- `get_clip_info` now returns `is_midi_clip`, `is_audio_clip`, and audio warp fields (`warping`, `warp_mode`)
+- `get_track_info` now returns `is_foldable`, `is_grouped`, `fold_state`, and `current_monitoring_state`
+
+### Fixes
+- `set_scene_name` now allows empty string to clear scene name
+
 ## 1.1.2 — 2026-03-17
 
 ### Fixes

package/LivePilot audit report.md

@@ -0,0 +1,87 @@
+# Deep audit of the **LivePilot** repository and comparison with other AI‑enabled DAW assistants
+
+## Overview of LivePilot
+
+**LivePilot** is an open‑source Model Context Protocol (MCP) server and companion plug‑in that connects large language models to *Ableton Live 12*.  The project’s goal is to act as an **AI co‑pilot** for music production, sound design and mixing.
+
+* **Purpose and capabilities:** The README explains that LivePilot exposes **91 tools across nine domains** (transport, tracks, clips, notes, devices, scenes, mixing, browser and arrangement)【665853537458845†L43-L70】.  It allows a user to create tracks, program MIDI patterns, load instruments, adjust mixing parameters and even build full song structures via natural‑language requests【665853537458845†L15-L21】.  The tool set covers nearly every aspect of a typical Ableton workflow: starting/stopping playback, setting tempo, creating MIDI or audio tracks, renaming and coloring them, creating/duplicating clips, reading and editing MIDI notes, loading devices and presets, changing levels/pans/sends, browsing Ableton’s library, editing arrangement clips and automation【665853537458845†L43-L70】.  Each tool maps directly to an Ableton Live API call; the manual notes that there is **no abstraction layer** – commands are deterministic and reversible【608977690485721†L23-L27】.
+* **Architecture:** A natural‑language prompt is processed by the AI client (e.g., Claude Code or Cursor) and sent over the MCP to the **LivePilot server** (Python with `fastmcp`)【665853537458845†L90-L97】.  The server validates inputs and forwards them via a single‑client TCP connection to a **Remote Script** that runs inside Ableton’s Python environment【665853537458845†L90-L97】.  The Remote Script executes commands on Ableton’s main thread (the same thread as the GUI), ensuring thread‑safe access to the Live Object Model【608977690485721†L29-L34】.  Installation is streamlined via `npx -y github:dreamrec/LivePilot --install`, which copies the Remote Script to Ableton’s user library and sets up the MCP server【665853537458845†L22-L29】.
+* **Plugin and producer agent:** LivePilot includes a Claude Code plug‑in that provides slash commands (`/session`, `/beat`, `/mix`, `/sounddesign`) and an **autonomous producer agent** that can build complete tracks from high‑level descriptions (“Make me a 126 BPM rominimal track…”)【665853537458845†L82-L89】.  The core skill packaged with the plug‑in teaches the AI how to use LivePilot effectively – checking session state before issuing commands, verifying the results after writes and avoiding common mistakes【692402510651097†L69-L81】.
+* **Documentation and user guidance:** The manual is comprehensive.  It explains installation, connectivity, examples of natural‑language sessions, the details of each tool, production workflows, MIDI programming guidelines, sound design recipes, mixing tips and troubleshooting【608977690485721†L40-L47】.  The getting‑started guide shows how to connect the server, then suggests an example conversation (“What’s in my session?” → “Set the tempo to 120 and create a MIDI track called DRUMS” → “Search for a drum kit and load it onto the DRUMS track” → “Create an 8‑beat clip and program a basic house kick pattern…”)【692402510651097†L39-L51】.
+* **Compatibility:** LivePilot supports Ableton Live 12 (any edition) and requires Python 3.10 or newer and Node.js 18+【665853537458845†L96-L102】.  Arrangement‑related tools work only in Live 12, while loading stock instruments and Max for Live devices requires the Suite edition【665853537458845†L96-L102】.  CLI commands such as `--status`, `--doctor`, `--install` and `--version` simplify installation and diagnostics【665853537458845†L103-L106】.
+
+### Project structure and quality
+
+Because the repository cannot be cloned from the restricted environment, we rely on the README and manual to infer its structure.  The repository contains at least the following components:
+
+1. **Remote script (`remote_script/LivePilot`)** – a Python package that subclasses Ableton’s `ControlSurface` class and implements the command queue and handlers.  It is installed into Ableton’s User Remote Scripts folder by the `--install` command【692402510651097†L18-L23】.
+2. **MCP server (`mcp_server`)** – a Python server built on the `fastmcp` framework.  It validates input parameters (ranges and types) before passing them to the remote script【608977690485721†L29-L34】.  Using a single TCP client avoids concurrency issues, because Ableton’s Live Object Model is not thread‑safe【665853537458845†L90-L97】.
+3. **CLI (JavaScript)** – the `npx` entry point uses Node.js to bootstrap the Python server and perform installation tasks.  The minimal `requirements.txt` lists `fastmcp` as the only runtime dependency【45077298533394†L0-L2】.
+4. **Docs and tests:** The repo contains a `docs/manual` folder with Markdown documentation, and it mentions a `tests` directory (run by `pytest`)【665853537458845†L110-L111】.
+
+While we cannot inspect individual functions, the combination of Python and Node indicates a hybrid architecture.  Using `fastmcp` suggests asynchronous I/O and structured validation.  The repository emphasises deterministic operations and explicit `undo` functionality【692402510651097†L63-L67】, which points to careful state management.  Including a detailed manual and CLI indicates strong attention to developer experience.
+
+## Comparison with other AI‑enabled Ableton assistants
+
+The AI‑DAW landscape has seen several community‑driven MCP servers that integrate language models with Ableton Live.  Below is a comparison of LivePilot with four notable open‑source alternatives and one machine‑learning plugin collection (Magenta Studio).  Star counts are ignored; only features matter.  All projects implement the MCP for connecting an AI client to Ableton, but they differ in language, feature set and design philosophy.
+
+### Feature comparison
+
+The table summarises the core capabilities (✓ = present, – = absent or not mentioned).  Note: only keywords/phrases are used in the cells; long prose is kept in the explanation below.
+
+| Tool/Project | Track & Session management | MIDI/Clip editing | Device/Effect control | Arrangement & automation | Mixing & routing | Browser search | Voice/audio generation | State rollback/Undo | Low‑latency/UDP | Autonomous agent |
+|---|---|---|---|---|---|---|---|---|---|---|
+| **LivePilot (dreamrec)** | create/delete/duplicate tracks, rename, color, mute, solo, arm【665853537458845†L45-L61】 | add/get/modify/duplicate/transpose/quantize notes【665853537458845†L62-L66】 | load instruments/effects, tweak parameters, rack chains, get presets【665853537458845†L66-L69】 | arrangement clip creation & full MIDI note CRUD, cue points, recording, timeline navigation【665853537458845†L74-L81】 | set volume, pan, sends; routing & return tracks; master control【665853537458845†L72-L74】 | search Ableton library & load presets【665853537458845†L72-L75】 | – (not in current version) | deterministic operations with undo/redo commands【692402510651097†L63-L67】 | – | built‑in producer agent via plugin【665853537458845†L82-L89】 |
+| **Ableton Copilot MCP (xiaolaa2)** | create/delete/duplicate/rename MIDI, audio & return tracks; set tempo, time signature and scale【477631886601640†L155-L160】 | add/remove/replace/duplicate notes, filter by pitch, transpose, adjust clip properties【477631886601640†L161-L166】 | browse library, load specific audio effects/instruments/VSTs, modify parameters, record audio into clips【477631886601640†L167-L171】 | – (no dedicated arrangement API mentioned) | – | – | – | robust state management with snapshot & rollback support【477631886601640†L173-L177】 | – | – |
+| **AbletonMCP (ahujasid)** | create/modify MIDI & audio tracks, load and configure remote script【260789399880945†L10-L16】 | create & edit MIDI clips; add notes【260789399880945†L14-L16】【260789399880945†L61-L63】 | select/load instruments & effects from Ableton’s browser【260789399880945†L13-L16】【260789399880945†L61-L63】 | – | basic playback/transport control【260789399880945†L15-L16】 | – | – | – (standard `undo` only) | – | – |
+| **Ableton Live MCP Server (Simon‑Kansara)** | generic track & session control via OSC【308870449054950†L16-L19】 | – | – | – | – | – | – | – | uses UDP/OSC for communication (requires separate daemon)【308870449054950†L30-L34】 | – |
+| **Ableton MCP Extended (uisato)** | comprehensive session & track management including group/folding states【795384148544515†L29-L35】 | create/rename clips; add/delete/transpose/quantize notes; batch edits【795384148544515†L35-L37】 | load instruments/effects; set & batch‑set parameters【795384148544515†L38-L41】 | automation/envelope editing; high‑performance mode using UDP for real‑time control【795384148544515†L41-L54】【795384148544515†L82-L87】 | volume, panning, mute, solo, sends【795384148544515†L29-L35】 | browse Ableton library and import audio files【795384148544515†L44-L46】 | voice/text‑to‑speech integration via ElevenLabs; custom voice & SFX【795384148544515†L47-L50】 | – (standard `undo` not emphasised) | ultra‑low latency via UDP server【795384148544515†L82-L87】 | – |
+| **Magenta Studio (Google)** | – | generates melodies/drums, extends or transforms patterns using ML models【262161962734483†L63-L84】 | – | – | – | – | – | – | – | – |
+
+### Discussion
+
+#### Breadth of control
+
+LivePilot stands out for its broad coverage of Ableton’s API.  It not only performs basic track and session operations but also supports **arrangement view editing** (creating arrangement clips, moving between cue points, starting/stopping recording, editing automation)【665853537458845†L74-L81】.  Most competitors focus on session view; for example, Ableton Copilot MCP’s documentation highlights track/clip manipulation and device control but does not mention arrangement or automation【477631886601640†L155-L171】.  AbletonMCP Extended adds some automation editing and envelope functionality【795384148544515†L41-L46】 but still doesn’t provide the same comprehensive list of arrangement tools.
+
+#### Mixing and browser integration
+
+LivePilot provides dedicated mixing tools (volume, pan, sends, routing, return tracks and master volume)【665853537458845†L72-L74】 and separate browser tools to search the entire Ableton library and load presets【665853537458845†L72-L75】.  The other projects have limited mixing commands; AbletonMCP Extended includes volume/panning/mute/solo and send control【795384148544515†L29-L35】, but others do not emphasise mixing.  Browser search appears in LivePilot and Extended; it is absent from Copilot MCP.
+
+#### Safety and robustness
+
+LivePilot emphasises deterministic operations and encourages the AI to verify the session state after every write.  The `undo` tool is exposed, making all destructive operations reversible【692402510651097†L63-L67】.  Ableton Copilot MCP goes further with **state rollback**; it snapshots the project state and can undo groups of operations, which is a robust safety net for complex tasks【477631886601640†L173-L177】.  Competitors built on Python sockets generally rely on Ableton’s own undo (a single step), so LivePilot’s explicit undo tool is a strength but could be improved by adopting a snapshot approach.
+
+#### Advanced features
+
+* **Autonomous agent:** LivePilot’s Claude plug‑in includes a **producer agent** that builds complete tracks from high‑level descriptions【665853537458845†L82-L89】.  None of the other open‑source projects advertise an autonomous composition agent, although some AI‑first DAW assistants outside the MCP ecosystem (e.g., commercial “Studio Co‑Pilot” or online generative services) may offer similar features.
+* **Voice and audio generation:** Ableton MCP Extended uniquely integrates ElevenLabs for voice/speech generation and allows direct import of generated audio into Ableton sessions【795384148544515†L47-L50】.  LivePilot lacks this type of generative audio; adding a similar feature could broaden its creative scope.
+* **Low‑latency control:** The Extended project includes a UDP server for ultra‑low‑latency parameter control【795384148544515†L82-L87】.  LivePilot uses a single TCP connection for thread safety【665853537458845†L90-L97】; while stable, it may introduce latency for real‑time performance.  Offering a high‑performance mode or MIDI mapping could appeal to live performers.
+* **State management:** Ableton Copilot MCP’s snapshot‑based rollback system is a notable innovation【477631886601640†L173-L177】.  LivePilot currently supports standard undo/redo but not multi‑step rollback; implementing such a feature would increase safety.
+* **Extensibility:** Both LivePilot and Ableton MCP Extended provide frameworks for creating custom tools.  LivePilot’s skill file teaches the AI how to interact correctly【692402510651097†L69-L81】, and the Extended project demonstrates building custom controllers (XY mouse controller)【795384148544515†L82-L87】.
+
+#### Installation and user experience
+
+LivePilot provides a simple `npx` installer and CLI commands to install, check status and run diagnostics【665853537458845†L22-L27】【665853537458845†L103-L106】.  Ableton Copilot MCP similarly offers one‑line installation via `npx @xiaolaa2/ableton-copilot-mcp --install-scripts`【477631886601640†L213-L216】.  AbletonMCP and Extended require cloning or using `uv` and copying remote scripts manually【260789399880945†L21-L34】【795384148544515†L56-L66】, which is less streamlined.  LivePilot’s documentation is thorough and includes a manual covering workflows, whereas competitors often rely on README‑level documentation or blog posts.
+
+### Strengths and areas for improvement
+
+#### Strengths of LivePilot
+
+1. **Comprehensive toolset:** With 91 tools covering transport, track management, clip operations, note editing, devices, scenes, mixing, browser search and arrangement, LivePilot offers the broadest feature coverage among existing MCP servers【665853537458845†L43-L70】.
+2. **Natural‑language workflows:** The manual demonstrates how to use conversation to build beats, search for instruments, program MIDI patterns and mix tracks【692402510651097†L39-L51】.  This conversational approach, combined with the producer agent, makes LivePilot accessible to users with minimal technical knowledge.
+3. **Deterministic operations and safety:** By mapping tools directly to Ableton’s API and exposing undo/redo, LivePilot aims to provide predictable outcomes and a clear safety net【608977690485721†L23-L27】【692402510651097†L63-L67】.
+4. **Developer experience:** The `npx` installer, CLI commands (`--status`, `--doctor`), cross‑platform support (macOS and Windows) and extensive manual contribute to a polished user experience【665853537458845†L103-L106】.
+5. **Plugin & agent integration:** The Claude plug‑in adds slash commands and an autonomous producer agent that can compose full tracks from high‑level prompts【665853537458845†L82-L89】.  This is unique among open‑source MCP servers.
+
+#### Areas for improvement
+
+1. **State rollback and history:** Competing projects like Ableton Copilot MCP implement snapshot‑based rollback【477631886601640†L173-L177】.  Incorporating multi‑step undo or versioned snapshots in LivePilot would improve safety during complex editing.
+2. **Voice and audio generation:** Ableton MCP Extended integrates ElevenLabs for text‑to‑speech and can import generated vocals or sound effects【795384148544515†L47-L50】.  Adding optional integration with generative audio tools (e.g., ElevenLabs, OpenAI TTS) could expand LivePilot’s creative capabilities.
+3. **Low‑latency control:** The Extended project’s UDP server provides ultra‑low‑latency parameter control【795384148544515†L82-L87】.  LivePilot could explore a similar performance mode or integration with hardware controllers to better serve live performers.
+4. **Simplify cross‑language architecture:** LivePilot uses Node.js to bootstrap a Python server; although this is hidden from the user, consolidating components or providing a purely Python installation could reduce complexity and dependency on Node.
+5. **Community engagement:** Many competing projects have active communities and Discord servers (e.g., AbletonMCP invites feedback on Discord【260789399880945†L8-L9】).  Building a community around LivePilot would encourage contributions, gather feedback and accelerate development.
+
+## Conclusion
+
+LivePilot is an ambitious and well‑documented project that aims to be a **comprehensive AI co‑pilot** for Ableton Live 12.  Its strength lies in its broad tool coverage, polished installation experience, deterministic operations and the inclusion of a plug‑in with an autonomous producer agent.  Compared with other MCP servers, LivePilot covers more domains (especially arrangement and mixing) and provides a more polished user experience.  Competing projects offer innovations such as state rollback, voice/audio generation and low‑latency control.  Incorporating similar features, encouraging community engagement and potentially simplifying the architecture would enhance LivePilot’s position as the most intelligent and versatile AI assistant for Ableton Live.

package/README.md

@@ -11,7 +11,7 @@
 [![CI](https://github.com/dreamrec/LivePilot/actions/workflows/ci.yml/badge.svg)](https://github.com/dreamrec/LivePilot/actions/workflows/ci.yml)
 [![GitHub stars](https://img.shields.io/github/stars/dreamrec/LivePilot)](https://github.com/dreamrec/LivePilot/stargazers)
 
-**AI copilot for Ableton Live 12** — 91 MCP tools for music production, sound design, and mixing.
+**AI copilot for Ableton Live 12** — 96 MCP tools for music production, sound design, and mixing.
 
 Control your entire Ableton session through natural language. Create tracks, program MIDI, load instruments, tweak parameters, arrange songs, and mix — all without leaving the keyboard.
 
@@ -156,16 +156,16 @@ npx -y github:dreamrec/LivePilot --status
 
 ---
 
-## 91 Tools Across 9 Domains
+## 96 Tools Across 9 Domains
 
 | Domain | Tools | What you can do |
 |--------|:-----:|-----------------|
 | **Transport** | 12 | Play/stop, tempo, time signature, loop, undo/redo, metronome, diagnostics |
-| **Tracks** | 12 | Create MIDI/audio/return tracks, name, color, mute, solo, arm |
-| **Clips** | 10 | Create, delete, duplicate, fire, stop, loop settings, launch mode |
+| **Tracks** | 14 | Create MIDI/audio/return tracks, name, color, mute, solo, arm, group fold, input monitoring |
+| **Clips** | 11 | Create, delete, duplicate, fire, stop, loop settings, launch mode, warp mode |
 | **Notes** | 8 | Add/get/remove/modify MIDI notes, transpose, quantize, duplicate |
 | **Devices** | 12 | Load instruments & effects, tweak parameters, rack chains, presets |
-| **Scenes** | 6 | Create, delete, duplicate, fire, rename |
+| **Scenes** | 8 | Create, delete, duplicate, fire, rename, color, per-scene tempo |
 | **Mixing** | 8 | Volume, pan, sends, routing, return tracks, master |
 | **Browser** | 4 | Search Ableton's library, browse categories, load presets |
 | **Arrangement** | 19 | Create clips, full MIDI note CRUD, cue points, recording, automation |
@@ -176,11 +176,11 @@ npx -y github:dreamrec/LivePilot --status
 ### 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`
 
-### Tracks (12)
-`get_track_info` · `create_midi_track` · `create_audio_track` · `create_return_track` · `delete_track` · `duplicate_track` · `set_track_name` · `set_track_color` · `set_track_mute` · `set_track_solo` · `set_track_arm` · `stop_track_clips`
+### Tracks (14)
+`get_track_info` · `create_midi_track` · `create_audio_track` · `create_return_track` · `delete_track` · `duplicate_track` · `set_track_name` · `set_track_color` · `set_track_mute` · `set_track_solo` · `set_track_arm` · `stop_track_clips` · `set_group_fold` · `set_track_input_monitoring`
 
-### Clips (10)
-`get_clip_info` · `create_clip` · `delete_clip` · `duplicate_clip` · `fire_clip` · `stop_clip` · `set_clip_name` · `set_clip_color` · `set_clip_loop` · `set_clip_launch`
+### Clips (11)
+`get_clip_info` · `create_clip` · `delete_clip` · `duplicate_clip` · `fire_clip` · `stop_clip` · `set_clip_name` · `set_clip_color` · `set_clip_loop` · `set_clip_launch` · `set_clip_warp_mode`
 
 ### Notes (8)
 `add_notes` · `get_notes` · `remove_notes` · `remove_notes_by_id` · `modify_notes` · `duplicate_notes` · `transpose_notes` · `quantize_clip`
@@ -188,8 +188,8 @@ npx -y github:dreamrec/LivePilot --status
 ### Devices (12)
 `get_device_info` · `get_device_parameters` · `set_device_parameter` · `batch_set_parameters` · `toggle_device` · `delete_device` · `load_device_by_uri` · `find_and_load_device` · `get_rack_chains` · `set_simpler_playback_mode` · `set_chain_volume` · `get_device_presets`
 
-### Scenes (6)
-`get_scenes_info` · `create_scene` · `delete_scene` · `duplicate_scene` · `fire_scene` · `set_scene_name`
+### 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`

package/mcp_server/tools/clips.py

@@ -1,6 +1,6 @@
-"""Clip MCP tools — info, create, delete, duplicate, fire, stop, properties.
+"""Clip MCP tools — info, create, delete, duplicate, fire, stop, properties, warp.
 
-10 tools matching the Remote Script clips domain.
+11 tools matching the Remote Script clips domain.
 """
 
 from fastmcp import Context
@@ -185,3 +185,29 @@ def set_clip_launch(
     if quantization is not None:
         params["quantization"] = quantization
     return _get_ableton(ctx).send_command("set_clip_launch", params)
+
+
+_VALID_WARP_MODES = {0, 1, 2, 3, 4, 6}
+
+
+@mcp.tool()
+def set_clip_warp_mode(
+    ctx: Context,
+    track_index: int,
+    clip_index: int,
+    mode: int,
+    warping: bool | None = None,
+) -> dict:
+    """Set warp mode for an audio clip (0=Beats, 1=Tones, 2=Texture, 3=Re-Pitch, 4=Complex, 6=Complex Pro)."""
+    _validate_track_index(track_index)
+    _validate_clip_index(clip_index)
+    if mode not in _VALID_WARP_MODES:
+        raise ValueError("Warp mode must be one of: 0=Beats, 1=Tones, 2=Texture, 3=Re-Pitch, 4=Complex, 6=Complex Pro")
+    params = {
+        "track_index": track_index,
+        "clip_index": clip_index,
+        "mode": mode,
+    }
+    if warping is not None:
+        params["warping"] = warping
+    return _get_ableton(ctx).send_command("set_clip_warp_mode", params)

package/mcp_server/tools/scenes.py

@@ -1,6 +1,6 @@
-"""Scene MCP tools — list, create, delete, duplicate, fire, rename.
+"""Scene MCP tools — list, create, delete, duplicate, fire, rename, color, tempo.
 
-6 tools matching the Remote Script scenes domain.
+8 tools matching the Remote Script scenes domain.
 """
 
 from fastmcp import Context
@@ -53,11 +53,37 @@ def fire_scene(ctx: Context, scene_index: int) -> dict:
 
 @mcp.tool()
 def set_scene_name(ctx: Context, scene_index: int, name: str) -> dict:
-    """Rename a scene."""
+    """Rename a scene. Pass empty string to clear the name."""
     _validate_scene_index(scene_index)
-    if not name.strip():
-        raise ValueError("Scene name cannot be empty")
     return _get_ableton(ctx).send_command("set_scene_name", {
         "scene_index": scene_index,
         "name": name,
     })
+
+
+def _validate_color_index(color_index: int):
+    if not 0 <= color_index <= 69:
+        raise ValueError("color_index must be between 0 and 69")
+
+
+@mcp.tool()
+def set_scene_color(ctx: Context, scene_index: int, color_index: int) -> dict:
+    """Set scene color (0-69, Ableton's color palette)."""
+    _validate_scene_index(scene_index)
+    _validate_color_index(color_index)
+    return _get_ableton(ctx).send_command("set_scene_color", {
+        "scene_index": scene_index,
+        "color_index": color_index,
+    })
+
+
+@mcp.tool()
+def set_scene_tempo(ctx: Context, scene_index: int, tempo: float) -> dict:
+    """Set scene tempo in BPM (20-999). Fires when the scene launches."""
+    _validate_scene_index(scene_index)
+    if tempo < 20 or tempo > 999:
+        raise ValueError("Tempo must be between 20.0 and 999.0 BPM")
+    return _get_ableton(ctx).send_command("set_scene_tempo", {
+        "scene_index": scene_index,
+        "tempo": tempo,
+    })

package/mcp_server/tools/tracks.py

@@ -1,6 +1,6 @@
-"""Track MCP tools — create, delete, rename, mute, solo, arm.
+"""Track MCP tools — create, delete, rename, mute, solo, arm, group fold, monitor.
 
-12 tools matching the Remote Script tracks domain.
+14 tools matching the Remote Script tracks domain.
 """
 
 from fastmcp import Context
@@ -146,3 +146,25 @@ def stop_track_clips(ctx: Context, track_index: int) -> dict:
     """Stop all playing clips on a track."""
     _validate_track_index(track_index)
     return _get_ableton(ctx).send_command("stop_track_clips", {"track_index": track_index})
+
+
+@mcp.tool()
+def set_group_fold(ctx: Context, track_index: int, folded: bool) -> dict:
+    """Fold or unfold a group track to show/hide its children."""
+    _validate_track_index(track_index)
+    return _get_ableton(ctx).send_command("set_group_fold", {
+        "track_index": track_index,
+        "folded": folded,
+    })
+
+
+@mcp.tool()
+def set_track_input_monitoring(ctx: Context, track_index: int, state: int) -> dict:
+    """Set input monitoring (0=In, 1=Auto, 2=Off). Only for regular tracks, not return tracks."""
+    _validate_track_index(track_index)
+    if state not in (0, 1, 2):
+        raise ValueError("Monitoring state must be 0=In, 1=Auto, or 2=Off")
+    return _get_ableton(ctx).send_command("set_track_input_monitoring", {
+        "track_index": track_index,
+        "state": state,
+    })

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.1.2",
+  "version": "1.2.1",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "AI copilot for Ableton Live 12 — 91 MCP tools for music production, sound design, and mixing",
+  "description": "AI copilot for Ableton Live 12 — 96 MCP tools for music production, sound design, and mixing",
   "author": "Pilot Studio",
   "license": "MIT",
   "type": "commonjs",

package/plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "livepilot",
-  "version": "1.1.2",
-  "description": "AI copilot for Ableton Live 12 — 91 MCP tools for music production, sound design, and mixing",
+  "version": "1.2.1",
+  "description": "AI copilot for Ableton Live 12 — 96 MCP tools for music production, sound design, and mixing",
   "author": "Pilot Studio",
   "skills": [
     "skills/livepilot-core"

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

@@ -1,11 +1,11 @@
 ---
 name: livepilot-core
-description: Core discipline for controlling Ableton Live 12 through LivePilot's 91 MCP tools. Use whenever working with Ableton Live through MCP tools.
+description: Core discipline for controlling Ableton Live 12 through LivePilot's 96 MCP tools. Use whenever working with Ableton Live through MCP tools.
 ---
 
 # LivePilot Core — Ableton Live 12 AI Copilot
 
-LivePilot gives you 91 MCP tools to control Ableton Live 12 in real-time: transport, tracks, clips, MIDI notes, devices, scenes, mixing, browser, and arrangement.
+LivePilot gives you 96 MCP tools to control Ableton Live 12 in real-time: transport, tracks, clips, MIDI notes, devices, scenes, mixing, browser, and arrangement.
 
 ## Golden Rules
 
@@ -16,7 +16,7 @@ LivePilot gives you 91 MCP tools to control Ableton Live 12 in real-time: transp
 5. **Track indices are 0-based** — track 0 is the first track, scene 0 is the first scene
 6. **Color indices 0-69** — Ableton's fixed palette. Don't guess — use the index
 7. **Volume is 0.0-1.0, pan is -1.0 to 1.0** — these are normalized, not dB
-8. **Tempo range 20-999 BPM** — validated before sending to Ableton
+8. **Tempo range 20-969 BPM** — validated before sending to Ableton
 9. **Always name your tracks and clips** — organization is part of the creative process
 
 ## Track Health Checks — MANDATORY
@@ -57,16 +57,16 @@ LivePilot gives you 91 MCP tools to control Ableton Live 12 in real-time: transp
 - MIDI track with no instrument loaded
 - Notes programmed but clip not fired
 
-## Tool Domains (91 total)
+## Tool Domains (96 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`
 
-### Tracks (12)
-`get_track_info` · `create_midi_track` · `create_audio_track` · `create_return_track` · `delete_track` · `duplicate_track` · `set_track_name` · `set_track_color` · `set_track_mute` · `set_track_solo` · `set_track_arm` · `stop_track_clips`
+### Tracks (14)
+`get_track_info` · `create_midi_track` · `create_audio_track` · `create_return_track` · `delete_track` · `duplicate_track` · `set_track_name` · `set_track_color` · `set_track_mute` · `set_track_solo` · `set_track_arm` · `stop_track_clips` · `set_group_fold` · `set_track_input_monitoring`
 
-### Clips (10)
-`get_clip_info` · `create_clip` · `delete_clip` · `duplicate_clip` · `fire_clip` · `stop_clip` · `set_clip_name` · `set_clip_color` · `set_clip_loop` · `set_clip_launch`
+### Clips (11)
+`get_clip_info` · `create_clip` · `delete_clip` · `duplicate_clip` · `fire_clip` · `stop_clip` · `set_clip_name` · `set_clip_color` · `set_clip_loop` · `set_clip_launch` · `set_clip_warp_mode`
 
 ### Notes (8)
 `add_notes` · `get_notes` · `remove_notes` · `remove_notes_by_id` · `modify_notes` · `duplicate_notes` · `transpose_notes` · `quantize_clip`
@@ -74,8 +74,8 @@ LivePilot gives you 91 MCP tools to control Ableton Live 12 in real-time: transp
 ### Devices (12)
 `get_device_info` · `get_device_parameters` · `set_device_parameter` · `batch_set_parameters` · `toggle_device` · `delete_device` · `load_device_by_uri` · `find_and_load_device` · `set_simpler_playback_mode` · `get_rack_chains` · `set_chain_volume` · `get_device_presets`
 
-### Scenes (6)
-`get_scenes_info` · `create_scene` · `delete_scene` · `duplicate_scene` · `fire_scene` · `set_scene_name`
+### 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`
@@ -152,7 +152,7 @@ Deep production knowledge lives in `references/`. Consult these when making crea
 
 | File | What's inside | When to consult |
 |------|--------------|-----------------|
-| `references/overview.md` | All 91 tools mapped with params, units, ranges | Quick lookup for any tool |
+| `references/overview.md` | All 96 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,6 +1,6 @@
 # LivePilot Architecture & Tool Reference
 
-LivePilot is an MCP server that controls Ableton Live 12 in real-time through 91 tools across 9 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 MCP server that controls Ableton Live 12 in real-time through 96 tools across 9 domains. This document maps every tool to what it actually does in Ableton, so you know exactly which tool to reach for.
 
 ## Architecture
 
@@ -14,7 +14,7 @@ Claude Code  ──MCP──►  FastMCP Server  ──TCP/9878──►  Remote
 - **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 91 Tools — What Each One Does
+## The 96 Tools — What Each One Does
 
 ### Transport (12) — Playback, tempo, global state, diagnostics
 
@@ -33,11 +33,11 @@ Claude Code  ──MCP──►  FastMCP Server  ──TCP/9878──►  Remote
 | `get_recent_actions` | Returns log of recent commands sent to Ableton (newest first) | `limit` (1-50, default 20) |
 | `get_session_diagnostics` | Analyzes session for issues: armed tracks, solo leftovers, unnamed tracks, empty clips | — |
 
-### Tracks (12) — Create, delete, configure tracks
+### Tracks (14) — Create, delete, configure, group tracks
 
 | Tool | What it does | Key params |
 |------|-------------|------------|
-| `get_track_info` | Returns clips, devices, mixer state, routing for one track | `track_index` (0-based) |
+| `get_track_info` | Returns clips, devices, mixer state, group/fold info for one track | `track_index` (0-based) |
 | `create_midi_track` | Creates a new MIDI track | `index` (-1=end), `name`, `color` (0-69) |
 | `create_audio_track` | Creates a new audio track | `index` (-1=end), `name`, `color` (0-69) |
 | `create_return_track` | Creates a new return track | — |
@@ -49,12 +49,14 @@ Claude Code  ──MCP──►  FastMCP Server  ──TCP/9878──►  Remote
 | `set_track_solo` | Solos/unsolos | `track_index`, `soloed` (bool) |
 | `set_track_arm` | Arms/disarms for recording | `track_index`, `armed` (bool) |
 | `stop_track_clips` | Stops all playing clips on track | `track_index` |
+| `set_group_fold` | Folds/unfolds a group track | `track_index`, `folded` (bool) |
+| `set_track_input_monitoring` | Sets input monitoring state | `track_index`, `state` (0=In, 1=Auto, 2=Off) |
 
-### Clips (10) — Clip lifecycle and properties
+### Clips (11) — Clip lifecycle, properties, warp
 
 | Tool | What it does | Key params |
 |------|-------------|------------|
-| `get_clip_info` | Returns clip name, length, loop settings, playing state, notes count | `track_index`, `clip_index` |
+| `get_clip_info` | Returns clip name, length, loop settings, playing state, is_midi/is_audio, warp info | `track_index`, `clip_index` |
 | `create_clip` | Creates empty MIDI clip | `track_index`, `clip_index`, `length` (beats) |
 | `delete_clip` | Removes a clip from its slot | `track_index`, `clip_index` |
 | `duplicate_clip` | Copies clip to next slot | `track_index`, `clip_index` |
@@ -64,6 +66,7 @@ Claude Code  ──MCP──►  FastMCP Server  ──TCP/9878──►  Remote
 | `set_clip_color` | Sets clip color | `track_index`, `clip_index`, `color_index` (0-69) |
 | `set_clip_loop` | Configures loop region | `track_index`, `clip_index`, `loop_start`, `loop_end`, `looping` |
 | `set_clip_launch` | Sets launch mode and quantization | `track_index`, `clip_index`, `launch_mode`, `quantization` |
+| `set_clip_warp_mode` | Sets warp mode for audio clips | `track_index`, `clip_index`, `mode` (0=Beats,1=Tones,2=Texture,3=Re-Pitch,4=Complex,6=Complex Pro) |
 
 ### Notes (8) — MIDI note manipulation (Live 12 API)
 
@@ -106,16 +109,18 @@ Claude Code  ──MCP──►  FastMCP Server  ──TCP/9878──►  Remote
 | `set_chain_volume` | Sets volume of a rack chain | `track_index`, `device_index`, `chain_index`, `volume` |
 | `get_device_presets` | Lists presets for a device (audio effects, instruments, MIDI effects) | `device_name` |
 
-### Scenes (6) — Scene management
+### Scenes (8) — Scene management
 
 | Tool | What it does | Key params |
 |------|-------------|------------|
-| `get_scenes_info` | Lists all scenes with names and clip status | — |
+| `get_scenes_info` | Lists all scenes with names, tempo, and color | — |
 | `create_scene` | Creates a new scene | `index` (-1=end) |
 | `delete_scene` | Deletes a scene | `scene_index` |
 | `duplicate_scene` | Duplicates a scene | `scene_index` |
 | `fire_scene` | Launches all clips in a scene | `scene_index` |
 | `set_scene_name` | Renames a scene | `scene_index`, `name` |
+| `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
 

package/remote_script/LivePilot/clips.py

@@ -1,5 +1,5 @@
 """
-LivePilot - Clip domain handlers (10 commands).
+LivePilot - Clip domain handlers (11 commands).
 """
 
 from .router import register
@@ -13,7 +13,7 @@ def get_clip_info(song, params):
     clip_index = int(params["clip_index"])
     clip = get_clip(song, track_index, clip_index)
 
-    return {
+    result = {
         "track_index": track_index,
         "clip_index": clip_index,
         "name": clip.name,
@@ -21,6 +21,8 @@ def get_clip_info(song, params):
         "length": clip.length,
         "is_playing": clip.is_playing,
         "is_recording": clip.is_recording,
+        "is_midi_clip": clip.is_midi_clip,
+        "is_audio_clip": clip.is_audio_clip,
         "looping": clip.looping,
         "loop_start": clip.loop_start,
         "loop_end": clip.loop_end,
@@ -30,6 +32,13 @@ def get_clip_info(song, params):
         "launch_quantization": clip.launch_quantization,
     }
 
+    # Audio-clip-specific fields
+    if clip.is_audio_clip:
+        result["warping"] = clip.warping
+        result["warp_mode"] = clip.warp_mode
+
+    return result
+
 
 @register("create_clip")
 def create_clip(song, params):
@@ -170,3 +179,33 @@ def set_clip_launch(song, params):
         "launch_mode": clip.launch_mode,
         "launch_quantization": clip.launch_quantization,
     }
+
+
+@register("set_clip_warp_mode")
+def set_clip_warp_mode(song, params):
+    """Set warp mode for an audio clip."""
+    track_index = int(params["track_index"])
+    clip_index = int(params["clip_index"])
+    clip = get_clip(song, track_index, clip_index)
+
+    if clip.is_midi_clip:
+        raise ValueError("Warp modes only apply to audio clips")
+
+    mode = int(params["mode"])
+    if mode not in (0, 1, 2, 3, 4, 6):
+        raise ValueError(
+            "Invalid warp mode %d. Valid: 0=Beats, 1=Tones, 2=Texture, "
+            "3=Re-Pitch, 4=Complex, 6=Complex Pro" % mode
+        )
+
+    if "warping" in params:
+        clip.warping = bool(params["warping"])
+
+    clip.warp_mode = mode
+
+    return {
+        "track_index": track_index,
+        "clip_index": clip_index,
+        "warp_mode": clip.warp_mode,
+        "warping": clip.warping,
+    }

package/remote_script/LivePilot/scenes.py

@@ -1,5 +1,5 @@
 """
-LivePilot - Scene domain handlers (6 commands).
+LivePilot - Scene domain handlers (8 commands).
 """
 
 from .router import register
@@ -73,3 +73,27 @@ def set_scene_name(song, params):
     scene = get_scene(song, scene_index)
     scene.name = str(params["name"])
     return {"index": scene_index, "name": scene.name}
+
+
+@register("set_scene_color")
+def set_scene_color(song, params):
+    """Set a scene's color."""
+    scene_index = int(params["scene_index"])
+    scene = get_scene(song, scene_index)
+    scene.color_index = int(params["color_index"])
+    return {"index": scene_index, "color_index": scene.color_index}
+
+
+@register("set_scene_tempo")
+def set_scene_tempo(song, params):
+    """Set a scene's tempo (BPM, 20-999)."""
+    scene_index = int(params["scene_index"])
+    scene = get_scene(song, scene_index)
+    tempo = float(params["tempo"])
+    if tempo < 20 or tempo > 999:
+        raise ValueError("Tempo must be between 20 and 999 BPM")
+    scene.tempo = tempo
+    return {
+        "index": scene_index,
+        "tempo": scene.tempo,
+    }

package/remote_script/LivePilot/tracks.py

@@ -1,5 +1,5 @@
 """
-LivePilot - Track domain handlers (12 commands).
+LivePilot - Track domain handlers (14 commands).
 """
 
 from .router import register
@@ -80,17 +80,23 @@ def get_track_info(song, params):
         "color_index": track.color_index,
         "mute": track.mute,
         "solo": track.solo,
+        "is_foldable": track.is_foldable,
+        "is_grouped": track.is_grouped,
         "clip_slots": clips,
         "devices": devices,
         "mixer": mixer,
         "sends": sends,
     }
 
+    if track.is_foldable:
+        result["fold_state"] = bool(track.fold_state)
+
     # Regular tracks have arm and input type; return tracks get null values
     if track_index >= 0:
         result["arm"] = track.arm
         result["has_midi_input"] = track.has_midi_input
         result["has_audio_input"] = track.has_audio_input
+        result["current_monitoring_state"] = track.current_monitoring_state
     else:
         result["arm"] = None
         result["has_midi_input"] = None
@@ -227,3 +233,36 @@ def stop_track_clips(song, params):
     track = get_track(song, track_index)
     track.stop_all_clips()
     return {"index": track_index, "stopped": True}
+
+
+@register("set_group_fold")
+def set_group_fold(song, params):
+    """Fold or unfold a group track."""
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+    if not track.is_foldable:
+        raise ValueError("Track %d is not a group track" % track_index)
+    track.fold_state = int(bool(params["folded"]))
+    return {
+        "index": track_index,
+        "folded": bool(track.fold_state),
+    }
+
+
+@register("set_track_input_monitoring")
+def set_track_input_monitoring(song, params):
+    """Set input monitoring state for a track (0=In, 1=Auto, 2=Off)."""
+    track_index = int(params["track_index"])
+    if track_index < 0:
+        raise ValueError("Cannot set input monitoring on a return track")
+    track = get_track(song, track_index)
+    state = int(params["state"])
+    if state not in (0, 1, 2):
+        raise ValueError(
+            "Invalid monitoring state %d. Valid: 0=In, 1=Auto, 2=Off" % state
+        )
+    track.current_monitoring_state = state
+    return {
+        "index": track_index,
+        "monitoring_state": track.current_monitoring_state,
+    }