livepilot 1.1.1 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 1.2.0 — 2026-03-17
+
+### New Tools (+8, total 99)
+- **`create_group_track`** — group a range of tracks into a foldable group track
+- **`set_group_fold`** — fold/unfold a group track to show/hide children
+- **`freeze_track`** — freeze a track to reduce CPU load
+- **`flatten_track`** — flatten a frozen track to audio permanently
+- **`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
+
+### 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`
+
+## 1.1.2 — 2026-03-17
+
+### Fixes
+- Added missing `clip_index` validation to 4 arrangement MCP tools
+- Standardized `json` import (removed `_json` alias)
+- Added index range to arrangement clip error messages for consistency
+- Made installer version-agnostic (`/^Live \d+/` regex instead of hardcoded "Live 12")
+- Standardized project description across all config files
+
 ## 1.1.1 — 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 real-time music production, sound design, and mixing.
+**AI copilot for Ableton Live 12** — 99 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.
 

package/installer/paths.js

@@ -26,7 +26,7 @@ function findAbletonPaths() {
       try {
         const entries = fs.readdirSync(prefsDir);
         for (const entry of entries) {
-          if (entry.startsWith("Live 12")) {
+          if (/^Live \d+/.test(entry)) {
             candidates.push({
               path: path.join(prefsDir, entry, "User Remote Scripts"),
               description: `Ableton Preferences (${entry})`,
@@ -53,7 +53,7 @@ function findAbletonPaths() {
       try {
         const entries = fs.readdirSync(abletonAppData);
         for (const entry of entries) {
-          if (entry.startsWith("Live 12")) {
+          if (/^Live \d+/.test(entry)) {
             candidates.push({
               path: path.join(abletonAppData, entry, "Preferences", "User Remote Scripts"),
               description: `Ableton AppData (${entry})`,

package/mcp_server/tools/arrangement.py

@@ -3,7 +3,7 @@
 19 tools matching the Remote Script arrangement domain.
 """
 
-import json as _json
+import json
 
 from fastmcp import Context
 
@@ -147,8 +147,9 @@ def add_arrangement_notes(
     start_time in notes is relative to the clip start, not the song timeline.
     """
     _validate_track_index(track_index)
+    _validate_clip_index(clip_index)
     if isinstance(notes, str):
-        notes = _json.loads(notes)
+        notes = json.loads(notes)
     return _get_ableton(ctx).send_command("add_arrangement_notes", {
         "track_index": track_index,
         "clip_index": clip_index,
@@ -181,6 +182,7 @@ def set_arrangement_automation(
     For parameter_type="send": send_index required (0=A, 1=B, ...).
     """
     _validate_track_index(track_index)
+    _validate_clip_index(clip_index)
     if parameter_type not in ("device", "volume", "panning", "send"):
         raise ValueError("parameter_type must be 'device', 'volume', 'panning', or 'send'")
     if parameter_type == "device":
@@ -189,7 +191,7 @@ def set_arrangement_automation(
     if parameter_type == "send" and send_index is None:
         raise ValueError("send_index required for parameter_type='send'")
     if isinstance(points, str):
-        points = _json.loads(points)
+        points = json.loads(points)
     if not points:
         raise ValueError("points list cannot be empty")
     params: dict = {
@@ -224,6 +226,7 @@ def transpose_arrangement_notes(
     time_span:   length of note range in beats (defaults to full clip)
     """
     _validate_track_index(track_index)
+    _validate_clip_index(clip_index)
     if not -127 <= semitones <= 127:
         raise ValueError("semitones must be between -127 and 127")
     params: dict = {
@@ -248,6 +251,7 @@ def set_arrangement_clip_name(
 ) -> dict:
     """Rename an arrangement clip by its index in the track's arrangement_clips list."""
     _validate_track_index(track_index)
+    _validate_clip_index(clip_index)
     if not name.strip():
         raise ValueError("name cannot be empty")
     return _get_ableton(ctx).send_command("set_arrangement_clip_name", {
@@ -333,7 +337,7 @@ def remove_arrangement_notes_by_id(
     _validate_track_index(track_index)
     _validate_clip_index(clip_index)
     if isinstance(note_ids, str):
-        note_ids = _json.loads(note_ids)
+        note_ids = json.loads(note_ids)
     if not note_ids:
         raise ValueError("note_ids list cannot be empty")
     return _get_ableton(ctx).send_command("remove_arrangement_notes_by_id", {
@@ -355,7 +359,7 @@ def modify_arrangement_notes(
     _validate_track_index(track_index)
     _validate_clip_index(clip_index)
     if isinstance(modifications, str):
-        modifications = _json.loads(modifications)
+        modifications = json.loads(modifications)
     if not modifications:
         raise ValueError("modifications list cannot be empty")
     for mod in modifications:
@@ -388,7 +392,7 @@ def duplicate_arrangement_notes(
     _validate_track_index(track_index)
     _validate_clip_index(clip_index)
     if isinstance(note_ids, str):
-        note_ids = _json.loads(note_ids)
+        note_ids = json.loads(note_ids)
     if not note_ids:
         raise ValueError("note_ids list cannot be empty")
     return _get_ableton(ctx).send_command("duplicate_arrangement_notes", {

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
@@ -61,3 +61,31 @@ def set_scene_name(ctx: Context, scene_index: int, name: str) -> dict:
         "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. Fires when the scene launches. Set to 0 to clear."""
+    _validate_scene_index(scene_index)
+    if tempo != 0 and (tempo < 20 or tempo > 999):
+        raise ValueError("Tempo must be 0 (clear) or 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, freeze, monitor.
 
-12 tools matching the Remote Script tracks domain.
+17 tools matching the Remote Script tracks domain.
 """
 
 from fastmcp import Context
@@ -146,3 +146,63 @@ 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 create_group_track(
+    ctx: Context,
+    start_index: int,
+    end_index: int,
+    name: str | None = None,
+    color: int | None = None,
+) -> dict:
+    """Create a group track containing tracks from start_index to end_index (inclusive)."""
+    _validate_track_index(start_index)
+    _validate_track_index(end_index)
+    if end_index < start_index:
+        raise ValueError("end_index must be >= start_index")
+    params = {"start_index": start_index, "end_index": end_index}
+    if name is not None:
+        if not name.strip():
+            raise ValueError("Track name cannot be empty")
+        params["name"] = name
+    if color is not None:
+        _validate_color_index(color)
+        params["color_index"] = color
+    return _get_ableton(ctx).send_command("create_group_track", params)
+
+
+@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 freeze_track(ctx: Context, track_index: int) -> dict:
+    """Freeze a track to reduce CPU load. Frozen tracks render to audio cache."""
+    _validate_track_index(track_index)
+    return _get_ableton(ctx).send_command("freeze_track", {"track_index": track_index})
+
+
+@mcp.tool()
+def flatten_track(ctx: Context, track_index: int) -> dict:
+    """Flatten a frozen track to audio permanently. Use undo to revert."""
+    _validate_track_index(track_index)
+    return _get_ableton(ctx).send_command("flatten_track", {"track_index": track_index})
+
+
+@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.1",
+  "version": "1.2.0",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "AI copilot for Ableton Live 12 — 91 MCP tools for production, sound design, and mixing",
+  "description": "AI copilot for Ableton Live 12 — 99 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.0",
-  "description": "AI copilot for Ableton Live 12 — 91 tools for production, sound design, and mixing",
+  "version": "1.2.0",
+  "description": "AI copilot for Ableton Live 12 — 99 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 99 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 99 MCP tools to control Ableton Live 12 in real-time: transport, tracks, clips, MIDI notes, devices, scenes, mixing, browser, and arrangement.
 
 ## Golden Rules
 

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 99 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
 
@@ -33,14 +33,15 @@ 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 (17) — Create, delete, configure, group, freeze 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 | — |
+| `create_group_track` | Groups a range of tracks into a group track | `start_index`, `end_index`, `name`, `color` |
 | `delete_track` | Deletes a track | `track_index` |
 | `duplicate_track` | Duplicates track with all contents | `track_index` |
 | `set_track_name` | Renames a track | `track_index`, `name` |
@@ -49,12 +50,16 @@ 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) |
+| `freeze_track` | Freezes a track to reduce CPU | `track_index` |
+| `flatten_track` | Flattens a frozen track to audio (use undo to revert) | `track_index` |
+| `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 +69,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 +112,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 (0 to clear) | `scene_index`, `tempo` (20-999 or 0) |
 
 ### Mixing (8) — Levels, panning, routing
 

package/remote_script/LivePilot/arrangement.py

@@ -583,7 +583,10 @@ def set_arrangement_clip_name(song, params):
     track = get_track(song, track_index)
     arr_clips = list(track.arrangement_clips)
     if clip_index < 0 or clip_index >= len(arr_clips):
-        raise IndexError("Arrangement clip index out of range")
+        raise IndexError(
+            "Arrangement clip index %d out of range (0..%d)"
+            % (clip_index, len(arr_clips) - 1)
+        )
     arr_clips[clip_index].name = name
     return {"track_index": track_index, "clip_index": clip_index, "name": name}
 

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). Set to 0 to clear the scene tempo."""
+    scene_index = int(params["scene_index"])
+    scene = get_scene(song, scene_index)
+    tempo = float(params["tempo"])
+    if tempo != 0 and (tempo < 20 or tempo > 999):
+        raise ValueError("Tempo must be 0 (clear) or between 20 and 999 BPM")
+    scene.tempo = tempo
+    return {
+        "index": scene_index,
+        "tempo": scene.tempo if scene.tempo > 0 else None,
+    }

package/remote_script/LivePilot/tracks.py

@@ -1,5 +1,5 @@
 """
-LivePilot - Track domain handlers (12 commands).
+LivePilot - Track domain handlers (17 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,91 @@ def stop_track_clips(song, params):
     track = get_track(song, track_index)
     track.stop_all_clips()
     return {"index": track_index, "stopped": True}
+
+
+@register("create_group_track")
+def create_group_track(song, params):
+    """Create a group track containing the specified track range."""
+    start = int(params["start_index"])
+    end = int(params["end_index"])
+    tracks = list(song.tracks)
+    if start < 0 or start >= len(tracks):
+        raise IndexError(
+            "start_index %d out of range (0..%d)" % (start, len(tracks) - 1)
+        )
+    if end < start or end >= len(tracks):
+        raise IndexError(
+            "end_index %d out of range (%d..%d)" % (end, start, len(tracks) - 1)
+        )
+    # Select the range of tracks, then use the API
+    song.view.selected_track = tracks[start]
+    for i in range(start, end + 1):
+        tracks[i].is_part_of_selection = True
+    song.create_group_track()
+    # The new group track is inserted at start_index
+    new_tracks = list(song.tracks)
+    group_track = new_tracks[start]
+    if "name" in params:
+        group_track.name = str(params["name"])
+    if "color_index" in params:
+        group_track.color_index = int(params["color_index"])
+    return {
+        "index": start,
+        "name": group_track.name,
+        "is_foldable": group_track.is_foldable,
+    }
+
+
+@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("freeze_track")
+def freeze_track(song, params):
+    """Freeze a track to reduce CPU load."""
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+    if track_index < 0:
+        raise ValueError("Cannot freeze a return track")
+    track.freeze()
+    return {"index": track_index, "frozen": True}
+
+
+@register("flatten_track")
+def flatten_track(song, params):
+    """Flatten a frozen track to audio (irreversible — use undo to revert)."""
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+    if track_index < 0:
+        raise ValueError("Cannot flatten a return track")
+    track.flatten()
+    return {"index": track_index, "flattened": True}
+
+
+@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,
+    }