livepilot 1.8.4 → 1.9.1

package/.claude-plugin/marketplace.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
   "name": "dreamrec-LivePilot",
-  "description": "Agentic MCP production system for Ableton Live 12 — 168 tools, 17 domains",
+  "description": "Agentic MCP production system for Ableton Live 12 — 178 tools, 17 domains",
   "owner": {
     "name": "dreamrec",
     "email": "dreamrec@users.noreply.github.com"
@@ -9,8 +9,8 @@
   "plugins": [
     {
       "name": "livepilot",
-      "description": "Agentic production system for Ableton Live 12 — 168 tools, 17 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
-      "version": "1.8.4",
+      "description": "Agentic production system for Ableton Live 12 — 178 tools, 17 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
+      "version": "1.9.1",
       "author": {
         "name": "Pilot Studio"
       },

package/AGENTS.md

@@ -1,4 +1,4 @@
-# LivePilot v1.8.4 — Ableton Live 12
+# LivePilot v1.9.1 — Ableton Live 12
 
 ## Project
 - **Repo:** This directory (LivePilot)
@@ -22,7 +22,7 @@
 ## Key Rules
 - ALL Live Object Model (LOM) calls must execute on Ableton's main thread via schedule_message queue
 - Live 12 minimum — use modern note API (add_new_notes, get_notes_extended, apply_note_modifications)
-- 168 tools across 17 domains: transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, analyzer, automation, theory, generative, harmony, midi_io, perception
+- 178 tools across 17 domains: transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, analyzer, automation, theory, generative, harmony, midi_io, perception
 - JSON over TCP, newline-delimited, port 9878
 - Structured errors with codes: INDEX_ERROR, NOT_FOUND, INVALID_PARAM, STATE_ERROR, TIMEOUT, INTERNAL
 
@@ -43,4 +43,4 @@ When modifying .amxd attributes that Max editor won't persist (e.g., `openinpres
 4. Structure: 24-byte `ampf` header + `ptch` chunk + `mx@c` header + JSON patcher + frozen deps
 
 ## Tool Count
-Currently 168 tools. If adding/removing tools, update: README.md, package.json description, livepilot/.Codex-plugin/plugin.json, server.json, livepilot/skills/livepilot-core/SKILL.md, livepilot/skills/livepilot-core/references/overview.md, AGENTS.md, CHANGELOG.md, tests/test_tools_contract.py, docs/manual/index.md, docs/manual/tool-reference.md
+Currently 178 tools. If adding/removing tools, update: README.md, package.json description, livepilot/.Codex-plugin/plugin.json, server.json, livepilot/skills/livepilot-core/SKILL.md, livepilot/skills/livepilot-core/references/overview.md, AGENTS.md, CHANGELOG.md, tests/test_tools_contract.py, docs/manual/index.md, docs/manual/tool-reference.md

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 1.9.1 — Rebuild .amxd with v1.9 Bridge (March 2026)
+
+- Rebuild LivePilot_Analyzer.amxd in Max editor to freeze 3 new plugin parameter bridge commands
+- Binary-patch `openinpresentation` for presentation mode
+
+## 1.9.0 — Scene Matrix, Freeze/Flatten, Plugin Deep Control (March 2026)
+
+**10 new tools (168 → 178), 3 features shipped.**
+
+### Scene Matrix Operations (+4 tools)
+- `get_scene_matrix` — full N×M clip grid with states (empty/stopped/playing/triggered/recording)
+- `fire_scene_clips` — fire a scene with optional track filter for selective launching
+- `stop_all_clips` — stop all playing clips in the session (panic button)
+- `get_playing_clips` — return all currently playing or triggered clips
+
+### Track Freeze/Flatten (+3 tools)
+- `freeze_track` — freeze a track (render devices to audio for CPU savings)
+- `flatten_track` — flatten a frozen track (commit rendered audio permanently)
+- `get_freeze_status` — check if a track is frozen
+
+### Plugin Parameter Mapping (+3 tools, M4L)
+- `get_plugin_parameters` — get ALL VST/AU plugin parameters including unconfigured ones
+- `map_plugin_parameter` — add a plugin parameter to Ableton's Configure list for automation
+- `get_plugin_presets` — list a plugin's internal presets and banks
+
+### Infrastructure
+- `SLOW_WRITE_COMMANDS` set for freeze_track (35s timeout vs 15s for normal writes)
+- Removed "Coming" section from README — all roadmap features shipped or dropped
+
 ## 1.8.4 — Bug Fix Audit (March 2026)
 
 **5 bugs fixed (2 P1, 3 P2), verified live in Ableton.**

package/README.md

@@ -9,7 +9,7 @@
 
 An agentic production system for Ableton Live 12.
 
-168 tools. Device atlas. Spectral perception. Technique memory.
+178 tools. Device atlas. Spectral perception. Technique memory.
 Neo-Riemannian harmony. Euclidean rhythm. Species counterpoint.
 
 
@@ -37,7 +37,7 @@ Neo-Riemannian harmony. Euclidean rhythm. Species counterpoint.
 │         └───────────────────┼───────────────────┘           │
 │                             ▼                               │
 │                    ┌─────────────────┐                      │
-│                    │   168 MCP Tools  │                      │
+│                    │   178 MCP Tools  │                      │
 │                    │   17 domains     │                      │
 │                    └────────┬────────┘                      │
 │                             │                               │
@@ -59,7 +59,7 @@ via a Max for Live device.
 The memory gives it history — a searchable library of production decisions
 that persists across sessions.
 
-All three feed into 168 deterministic tools that execute on Ableton's main thread
+All three feed into 178 deterministic tools that execute on Ableton's main thread
 through the official Live Object Model API. Everything is reversible with undo.
 
 <br>
@@ -476,7 +476,7 @@ Check memory before creative decisions. Verify every mutation.
 
 ## Full Tool List
 
-168 tools across 17 domains.
+178 tools across 17 domains.
 
 <br>
 
@@ -769,17 +769,6 @@ Check memory before creative decisions. Verify every mutation.
 
 ---
 
-## Coming
-
-```
-□  Plugin parameter mapping — VST/AU deep control
-□  Audio track freeze/flatten automation
-□  Clip launch scene matrix operations
-□  Multi-track arrangement templates
-```
-
-<br>
-
 ---
 
 ## CLI

package/livepilot/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "livepilot",
-  "version": "1.8.4",
-  "description": "Agentic production system for Ableton Live 12 — 168 tools, 17 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
+  "version": "1.9.1",
+  "description": "Agentic production system for Ableton Live 12 — 178 tools, 17 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
   "author": {
     "name": "Pilot Studio"
   }

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

@@ -1,17 +1,17 @@
 ---
 name: livepilot-core
-description: Core discipline for LivePilot — agentic production system for Ableton Live 12. 168 tools across 17 domains. Device atlas (280+ devices), M4L analyzer (spectrum/RMS/key detection), technique memory, automation intelligence (16 curve types, 15 recipes), music theory (Krumhansl-Schmuckler, species counterpoint), generative algorithms (Euclidean rhythm, tintinnabuli, phase shift), neo-Riemannian harmony (PRL transforms, Tonnetz), MIDI file I/O. Use whenever working with Ableton Live through MCP tools.
+description: Core discipline for LivePilot — agentic production system for Ableton Live 12. 178 tools across 17 domains. Device atlas (280+ devices), M4L analyzer (spectrum/RMS/key detection), technique memory, automation intelligence (16 curve types, 15 recipes), music theory (Krumhansl-Schmuckler, species counterpoint), generative algorithms (Euclidean rhythm, tintinnabuli, phase shift), neo-Riemannian harmony (PRL transforms, Tonnetz), MIDI file I/O. Use whenever working with Ableton Live through MCP tools.
 ---
 
 # LivePilot Core — Ableton Live 12
 
-Agentic production system for Ableton Live 12. 168 tools across 17 domains, three layers:
+Agentic production system for Ableton Live 12. 178 tools across 17 domains, three layers:
 
 - **Device Atlas** — A structured knowledge corpus of 280+ instruments, 139 drum kits, and 350+ impulse responses. Consult the atlas before loading any device. It contains real browser URIs, preset names, and sonic descriptions. Never guess a device name — look it up.
 - **M4L Analyzer** — Real-time audio analysis on the master bus (8-band spectrum, RMS/peak, key detection). Use it to verify mixing decisions, detect frequency problems, and find the key before writing harmonic content.
 - **Technique Memory** — Persistent storage for production decisions. Consult `memory_recall` before creative tasks to understand the user's taste. Save techniques when the user likes something. The memory shapes future decisions without constraining them.
 
-These layers sit on top of 168 deterministic tools across 17 domains: transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, analyzer, automation, theory, generative, harmony, MIDI I/O, and perception.
+These layers sit on top of 178 deterministic tools across 17 domains: transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, analyzer, automation, theory, generative, harmony, MIDI I/O, and perception.
 
 ## Golden Rules
 
@@ -32,7 +32,7 @@ These layers sit on top of 168 deterministic tools across 17 domains: transport,
 Not all tools respond instantly. Know the tiers and act accordingly.
 
 ### Instant (<1s) — Use freely, no warning needed
-All 168 core tools (transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, automation, theory, generative, harmony, midi_io, perception) plus Layer A perception tools (spectral shape, timbral profile, mel spectrum, chroma, onsets, harmonic/percussive, novelty, momentary loudness). These are the reflex tools — call them anytime without hesitation.
+All 178 core tools (transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, automation, theory, generative, harmony, midi_io, perception) plus Layer A perception tools (spectral shape, timbral profile, mel spectrum, chroma, onsets, harmonic/percussive, novelty, momentary loudness). These are the reflex tools — call them anytime without hesitation.
 
 ### Fast (1-5s) — Use freely, barely noticeable
 `analyze_loudness` · `analyze_dynamic_range` · `compare_loudness`
@@ -117,7 +117,7 @@ Never skip levels. The user's question determines the entry point, but always st
 - MIDI track with no instrument loaded
 - Notes programmed but clip not fired
 
-## Tool Domains (168 total)
+## Tool Domains (178 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`
@@ -374,7 +374,7 @@ Deep production knowledge lives in `references/`. Consult these when making crea
 
 | File | What's inside | When to consult |
 |------|--------------|-----------------|
-| `references/overview.md` | All 168 tools mapped with params, units, ranges | Quick lookup for any tool |
+| `references/overview.md` | All 178 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/livepilot/skills/livepilot-core/references/overview.md

@@ -1,6 +1,6 @@
-# LivePilot v1.8.4 — Architecture & Tool Reference
+# LivePilot v1.9.1 — Architecture & Tool Reference
 
-Agentic production system for Ableton Live 12. 168 tools across 17 domains. Device atlas (280+ devices), spectral perception (M4L analyzer), technique memory, automation intelligence (16 curve types, 15 recipes), music theory (Krumhansl-Schmuckler, species counterpoint), generative algorithms (Euclidean rhythm, tintinnabuli, phase shift, additive process), neo-Riemannian harmony (PRL transforms, Tonnetz), MIDI file I/O.
+Agentic production system for Ableton Live 12. 178 tools across 17 domains. Device atlas (280+ devices), spectral perception (M4L analyzer), technique memory, automation intelligence (16 curve types, 15 recipes), music theory (Krumhansl-Schmuckler, species counterpoint), generative algorithms (Euclidean rhythm, tintinnabuli, phase shift, additive process), neo-Riemannian harmony (PRL transforms, Tonnetz), MIDI file I/O.
 
 ## Architecture
 

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

@@ -27,20 +27,20 @@ Run this checklist EVERY time the user says "update everything", "push", "releas
 
 ## 2. Tool Count (must ALL match)
 
-Current: **168 tools across 17 domains**.
+Current: **178 tools across 17 domains**.
 Core (no M4L): **139**. Analyzer (M4L): **29**. Perception (offline): **4**.
 
 Verify: `grep -rc "@mcp.tool" mcp_server/tools/ | grep -v ":0" | awk -F: '{sum+=$2} END{print sum}'`
 
 Files that reference tool count:
 - [ ] `README.md` — header, PERCEPTION section ("139 core...29 analyzer"), Analyzer table header "(29)", Perception table header "(4)"
-- [ ] `package.json` → `"description"` (168 tools, 17 domains)
+- [ ] `package.json` → `"description"` (178 tools, 17 domains)
 - [ ] `server.json` → `"description"`
 - [ ] `livepilot/.claude-plugin/plugin.json` → `"description"`
 - [ ] `.claude-plugin/marketplace.json` → `"description"`
-- [ ] `CLAUDE.md` → "168 tools across 17 domains"
-- [ ] `livepilot/skills/livepilot-core/SKILL.md` — "168 tools across 17 domains", Analyzer (29), Perception (4)
-- [ ] `livepilot/skills/livepilot-core/references/overview.md` — "168 tools across 17 domains"
+- [ ] `CLAUDE.md` → "178 tools across 17 domains"
+- [ ] `livepilot/skills/livepilot-core/SKILL.md` — "178 tools across 17 domains", Analyzer (29), Perception (4)
+- [ ] `livepilot/skills/livepilot-core/references/overview.md` — "178 tools across 17 domains"
 - [ ] `docs/manual/index.md` — domain table: Analyzer (29), Perception (4)
 - [ ] `docs/manual/getting-started.md` — "139 core tools...29 analyzer"
 - [ ] `docs/manual/tool-reference.md` — all domains present with correct counts
@@ -86,7 +86,7 @@ Current: **17 domains**: transport, tracks, clips, notes, devices, scenes, mixin
 
 - [ ] `README.md` — features match current capabilities, "Coming" section is accurate
 - [ ] `docs/manual/getting-started.md` — install instructions current
-- [ ] `docs/manual/tool-reference.md` — all 17 domains listed, all 168 tools present
+- [ ] `docs/manual/tool-reference.md` — all 17 domains listed, all 178 tools present
 - [ ] `docs/TOOL_REFERENCE.md` — all 17 domains present
 - [ ] `docs/M4L_BRIDGE.md` — architecture accurate, core tool count correct
 

package/m4l_device/livepilot_bridge.js

@@ -83,7 +83,7 @@ function anything() {
 function dispatch(cmd, args) {
     switch(cmd) {
         case "ping":
-            send_response({"ok": true, "version": "1.8.4"});
+            send_response({"ok": true, "version": "1.9.1"});
             break;
         case "get_params":
             cmd_get_params(args);
@@ -161,6 +161,16 @@ function dispatch(cmd, args) {
         case "get_display_values":
             cmd_get_display_values(args);
             break;
+        // ── Plugin Parameters ──
+        case "get_plugin_params":
+            cmd_get_plugin_params(args);
+            break;
+        case "map_plugin_param":
+            cmd_map_plugin_param(args);
+            break;
+        case "get_plugin_presets":
+            cmd_get_plugin_presets(args);
+            break;
         default:
             send_response({"error": "Unknown command: " + cmd});
     }
@@ -1035,6 +1045,165 @@ function pad2(n) {
     return n < 10 ? "0" + n : "" + n;
 }
 
+// ── Plugin Parameters ──────────────────────────────────────────────────────
+
+function cmd_get_plugin_params(args) {
+    // Returns all parameters for a VST/AU plugin device
+    var track_idx = parseInt(args[0]);
+    var device_idx = parseInt(args[1]);
+    var path = build_device_path(track_idx, device_idx);
+
+    cursor_a.goto(path);
+    var class_name = cursor_a.get("class_name").toString();
+
+    // Check if this is a plugin device
+    var is_plugin = (class_name === "PluginDevice" || class_name === "AuPluginDevice");
+    if (!is_plugin) {
+        send_response({
+            "error": "Device is " + class_name + ", not a plugin (PluginDevice/AuPluginDevice)"
+        });
+        return;
+    }
+
+    var device_name = cursor_a.get("name").toString();
+    var param_count = cursor_a.getcount("parameters");
+    var params = [];
+    var current = 0;
+    var batch_size = 4;
+
+    function read_batch() {
+        var end = Math.min(current + batch_size, param_count);
+        for (var i = current; i < end; i++) {
+            cursor_b.goto(path + " parameters " + i);
+            params.push({
+                index: i,
+                name: cursor_b.get("name").toString(),
+                value: parseFloat(cursor_b.get("value")),
+                min: parseFloat(cursor_b.get("min")),
+                max: parseFloat(cursor_b.get("max")),
+                default_value: parseFloat(cursor_b.get("default_value")),
+                is_quantized: parseInt(cursor_b.get("is_quantized")) === 1,
+                value_string: String(cursor_b.call("str_for_value", parseFloat(cursor_b.get("value"))))
+            });
+        }
+        current = end;
+
+        if (current < param_count) {
+            var next_task = new Task(read_batch);
+            next_task.schedule(50);
+        } else {
+            send_response({
+                "track": track_idx,
+                "device": device_idx,
+                "name": device_name,
+                "class_name": class_name,
+                "is_plugin": true,
+                "parameter_count": param_count,
+                "parameters": params
+            });
+        }
+    }
+
+    if (param_count > 0) {
+        read_batch();
+    } else {
+        send_response({
+            "track": track_idx,
+            "device": device_idx,
+            "name": device_name,
+            "class_name": class_name,
+            "is_plugin": true,
+            "parameter_count": 0,
+            "parameters": []
+        });
+    }
+}
+
+function cmd_map_plugin_param(args) {
+    // Add a plugin parameter to Ableton's Configure list
+    var track_idx = parseInt(args[0]);
+    var device_idx = parseInt(args[1]);
+    var param_idx = parseInt(args[2]);
+    var path = build_device_path(track_idx, device_idx);
+
+    cursor_a.goto(path);
+    var param_count = cursor_a.getcount("parameters");
+    if (param_idx < 0 || param_idx >= param_count) {
+        send_response({"error": "Parameter index " + param_idx + " out of range (0.." + (param_count - 1) + ")"});
+        return;
+    }
+
+    // Navigate to the parameter and read its name
+    cursor_b.goto(path + " parameters " + param_idx);
+    var param_name = cursor_b.get("name").toString();
+
+    // Select the parameter — this is how Ableton's Configure mode works
+    // via LiveAPI. The parameter becomes visible in the device's macro panel.
+    try {
+        cursor_a.set("selected_parameter", param_idx);
+        cursor_a.call("store_chosen_bank");
+        send_response({
+            "mapped": true,
+            "parameter_index": param_idx,
+            "parameter_name": param_name
+        });
+    } catch(e) {
+        send_response({
+            "error": "Failed to map parameter: " + e.message,
+            "parameter_index": param_idx,
+            "parameter_name": param_name
+        });
+    }
+}
+
+function cmd_get_plugin_presets(args) {
+    // List plugin's internal presets
+    var track_idx = parseInt(args[0]);
+    var device_idx = parseInt(args[1]);
+    var path = build_device_path(track_idx, device_idx);
+
+    cursor_a.goto(path);
+    var class_name = cursor_a.get("class_name").toString();
+    var device_name = cursor_a.get("name").toString();
+
+    var is_plugin = (class_name === "PluginDevice" || class_name === "AuPluginDevice");
+    if (!is_plugin) {
+        send_response({
+            "error": "Device is " + class_name + ", not a plugin"
+        });
+        return;
+    }
+
+    // Read presets — the presets property returns an array of preset names
+    var presets = [];
+    try {
+        var preset_count = cursor_a.getcount("presets");
+        for (var i = 0; i < preset_count; i++) {
+            cursor_b.goto(path + " presets " + i);
+            presets.push({
+                index: i,
+                name: cursor_b.get("name").toString()
+            });
+        }
+    } catch(e) {
+        // Some plugins don't expose presets via LOM
+    }
+
+    // Try to get selected preset index
+    var selected = -1;
+    try {
+        selected = parseInt(cursor_a.get("selected_preset_index"));
+    } catch(e) {}
+
+    send_response({
+        "track": track_idx,
+        "device": device_idx,
+        "name": device_name,
+        "presets": presets,
+        "selected_preset": selected
+    });
+}
+
 // ── Helpers ────────────────────────────────────────────────────────────────
 
 function build_track_path(track_idx) {

package/mcp_server/__init__.py

@@ -1,2 +1,2 @@
 """LivePilot MCP Server — bridges MCP protocol to Ableton Live."""
-__version__ = "1.8.4"
+__version__ = "1.9.1"

package/mcp_server/tools/devices.py

@@ -1,6 +1,6 @@
-"""Device MCP tools — parameters, racks, browser loading.
+"""Device MCP tools — parameters, racks, browser loading, plugin deep control.
 
-12 tools matching the Remote Script devices domain.
+15 tools matching the Remote Script devices domain + M4L bridge.
 """
 
 from __future__ import annotations
@@ -254,3 +254,96 @@ def get_device_presets(ctx: Context, device_name: str) -> dict:
     return _get_ableton(ctx).send_command("get_device_presets", {
         "device_name": device_name,
     })
+
+
+# ── Plugin Deep Control (M4L Bridge) ────────────────────────────────────
+
+
+def _get_m4l(ctx: Context):
+    """Get M4LBridge from lifespan context."""
+    bridge = ctx.lifespan_context.get("m4l")
+    if not bridge:
+        raise RuntimeError("M4L bridge not initialized")
+    return bridge
+
+
+def _get_spectral(ctx: Context):
+    """Get SpectralCache from lifespan context."""
+    cache = ctx.lifespan_context.get("spectral")
+    if not cache:
+        raise RuntimeError("Spectral cache not initialized")
+    return cache
+
+
+def _require_analyzer(cache) -> None:
+    if not cache.is_connected:
+        raise ValueError(
+            "LivePilot Analyzer not detected. "
+            "Drag 'LivePilot Analyzer' onto the master track."
+        )
+
+
+@mcp.tool()
+async def get_plugin_parameters(
+    ctx: Context,
+    track_index: int,
+    device_index: int,
+) -> dict:
+    """Get ALL parameters from a VST/AU plugin including unconfigured ones.
+
+    Returns every parameter the plugin exposes — not just the 128
+    that Ableton's Configure panel shows. Includes name, value, min,
+    max, default, and display string for each.
+    Only works on PluginDevice/AuPluginDevice types.
+    Requires LivePilot Analyzer on master track.
+    """
+    _validate_track_index(track_index)
+    _validate_device_index(device_index)
+    cache = _get_spectral(ctx)
+    _require_analyzer(cache)
+    bridge = _get_m4l(ctx)
+    return await bridge.send_command("get_plugin_params", track_index, device_index)
+
+
+@mcp.tool()
+async def map_plugin_parameter(
+    ctx: Context,
+    track_index: int,
+    device_index: int,
+    parameter_index: int,
+) -> dict:
+    """Add a plugin parameter to Ableton's Configure list for automation.
+
+    After mapping, the parameter becomes visible in the device's macro
+    panel and can be automated with set_device_parameter or
+    set_clip_automation like any native parameter.
+    Requires LivePilot Analyzer on master track.
+    """
+    _validate_track_index(track_index)
+    _validate_device_index(device_index)
+    if parameter_index < 0:
+        raise ValueError("parameter_index must be >= 0")
+    cache = _get_spectral(ctx)
+    _require_analyzer(cache)
+    bridge = _get_m4l(ctx)
+    return await bridge.send_command("map_plugin_param", track_index, device_index, parameter_index)
+
+
+@mcp.tool()
+async def get_plugin_presets(
+    ctx: Context,
+    track_index: int,
+    device_index: int,
+) -> dict:
+    """List a VST/AU plugin's internal presets and banks.
+
+    Returns preset names and the currently selected preset index.
+    Only works on PluginDevice/AuPluginDevice types.
+    Requires LivePilot Analyzer on master track.
+    """
+    _validate_track_index(track_index)
+    _validate_device_index(device_index)
+    cache = _get_spectral(ctx)
+    _require_analyzer(cache)
+    bridge = _get_m4l(ctx)
+    return await bridge.send_command("get_plugin_presets", track_index, device_index)

package/mcp_server/tools/midi_io.py

@@ -14,6 +14,7 @@ from typing import Any, Optional
 
 from fastmcp import Context
 
+from ..connection import AbletonConnectionError
 from ..server import mcp
 from . import _theory_engine as theory
 
@@ -177,18 +178,25 @@ def import_midi_to_clip(
 
     if create_clip:
         # Check if clip already exists — only create if the slot is empty
+        slot_has_clip = False
         try:
             ableton.send_command("get_clip_info", {
                 "track_index": track_index,
                 "clip_index": clip_index,
             })
+            slot_has_clip = True
+        except AbletonConnectionError:
+            # Slot is empty — no clip to clear
+            pass
+
+        if slot_has_clip:
             # Clip exists — clear its notes before importing
             ableton.send_command("remove_notes", {
                 "track_index": track_index,
                 "clip_index": clip_index,
             })
-        except Exception:
-            # No clip in slot — create one
+        else:
+            # Empty slot — create a new clip
             ableton.send_command("create_clip", {
                 "track_index": track_index,
                 "clip_index": clip_index,

package/mcp_server/tools/scenes.py

@@ -1,8 +1,11 @@
-"""Scene MCP tools — list, create, delete, duplicate, fire, rename, color, tempo.
+"""Scene MCP tools — list, create, delete, duplicate, fire, rename, color, tempo, matrix.
 
-8 tools matching the Remote Script scenes domain.
+12 tools matching the Remote Script scenes domain.
 """
 
+import json
+from typing import Any, Optional
+
 from fastmcp import Context
 
 from ..server import mcp
@@ -87,3 +90,63 @@ def set_scene_tempo(ctx: Context, scene_index: int, tempo: float) -> dict:
         "scene_index": scene_index,
         "tempo": tempo,
     })
+
+
+# ── Scene Matrix Operations ─────────────────────────────────────────────
+
+
+def _ensure_list(value: Any) -> list:
+    if isinstance(value, str):
+        return json.loads(value)
+    return value
+
+
+@mcp.tool()
+def get_scene_matrix(ctx: Context) -> dict:
+    """Get the full session clip grid: every track x every scene.
+
+    Returns clip states (empty/stopped/playing/triggered/recording),
+    clip names, and colors. Use this for a bird's-eye view of the
+    entire session before making clip launch decisions.
+    """
+    return _get_ableton(ctx).send_command("get_scene_matrix")
+
+
+@mcp.tool()
+def fire_scene_clips(
+    ctx: Context,
+    scene_index: int,
+    track_indices: Optional[Any] = None,
+) -> dict:
+    """Fire a scene, optionally filtering to specific tracks.
+
+    If track_indices is omitted, fires the entire scene (all tracks).
+    If provided (JSON array of ints), fires only those tracks' clip slots
+    from the scene — useful for launching drums + bass without triggering
+    the lead, or building up layers gradually.
+    """
+    _validate_scene_index(scene_index)
+    params: dict = {"scene_index": scene_index}
+    if track_indices is not None:
+        track_indices = _ensure_list(track_indices)
+        for ti in track_indices:
+            if int(ti) < 0:
+                raise ValueError("track_indices must all be >= 0")
+        params["track_indices"] = track_indices
+    return _get_ableton(ctx).send_command("fire_scene_clips", params)
+
+
+@mcp.tool()
+def stop_all_clips(ctx: Context) -> dict:
+    """Stop all playing clips in the session. Panic button."""
+    return _get_ableton(ctx).send_command("stop_all_clips")
+
+
+@mcp.tool()
+def get_playing_clips(ctx: Context) -> dict:
+    """Get all currently playing or triggered clips.
+
+    Returns track index/name, clip index/name, and whether each clip
+    is actively playing or just triggered (waiting for quantization).
+    """
+    return _get_ableton(ctx).send_command("get_playing_clips")

package/mcp_server/tools/tracks.py

@@ -1,6 +1,6 @@
-"""Track MCP tools — create, delete, rename, mute, solo, arm, group fold, monitor.
+"""Track MCP tools — create, delete, rename, mute, solo, arm, group fold, monitor, freeze, flatten.
 
-14 tools matching the Remote Script tracks domain.
+17 tools matching the Remote Script tracks domain.
 """
 
 from __future__ import annotations
@@ -173,3 +173,46 @@ def set_track_input_monitoring(ctx: Context, track_index: int, state: int) -> di
         "track_index": track_index,
         "state": state,
     })
+
+
+# ── Freeze / Flatten ────────────────────────────────────────────────────
+
+
+@mcp.tool()
+def freeze_track(ctx: Context, track_index: int) -> dict:
+    """Freeze a track — render all devices to audio for CPU savings.
+
+    Freeze is async in Ableton: this initiates the render and returns
+    immediately. Poll get_freeze_status to check when it's done.
+    Freezing a track that's already frozen is a no-op.
+    """
+    _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 — commit rendered audio permanently.
+
+    Destructive: replaces all devices with the rendered audio file.
+    The track must already be frozen. Use undo to revert.
+    """
+    _validate_track_index(track_index)
+    return _get_ableton(ctx).send_command("flatten_track", {
+        "track_index": track_index,
+    })
+
+
+@mcp.tool()
+def get_freeze_status(ctx: Context, track_index: int) -> dict:
+    """Check if a track is frozen.
+
+    Use after freeze_track to poll for completion, or before
+    flatten_track to verify the track is ready to flatten.
+    """
+    _validate_track_index(track_index)
+    return _get_ableton(ctx).send_command("get_freeze_status", {
+        "track_index": track_index,
+    })

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.8.4",
+  "version": "1.9.1",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 168 tools, 17 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
+  "description": "Agentic production system for Ableton Live 12 — 178 tools, 17 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
   "author": "Pilot Studio",
   "license": "MIT",
   "type": "commonjs",

package/remote_script/LivePilot/__init__.py

@@ -5,7 +5,7 @@ Entry point for the ControlSurface. Ableton calls create_instance(c_instance)
 when this script is selected in Preferences > Link, Tempo & MIDI.
 """
 
-__version__ = "1.8.4"
+__version__ = "1.9.1"
 
 from _Framework.ControlSurface import ControlSurface
 from .server import LivePilotServer

package/remote_script/LivePilot/arrangement.py

@@ -107,6 +107,31 @@ def create_arrangement_clip(song, params):
 
             clip_count += 1
             pos += loop_length
+
+        # Trim the last clip's overshoot: if the last duplicate extends
+        # past end_pos, remove notes beyond the requested region and
+        # set loop_end so only the needed portion plays.
+        if clip_count > 0:
+            arr_clips = list(track.arrangement_clips)
+            for c in arr_clips:
+                clip_end = c.start_time + c.length
+                if c.start_time >= start_time and clip_end > end_pos + 0.01:
+                    # This clip overshoots — trim its content
+                    overshoot_start = end_pos - c.start_time
+                    if overshoot_start > 0:
+                        try:
+                            c.looping = True
+                            c.loop_start = 0.0
+                            c.loop_end = overshoot_start
+                        except (AttributeError, RuntimeError):
+                            pass
+                        # Remove notes beyond the trim point
+                        try:
+                            c.remove_notes_extended(
+                                0, 128, overshoot_start, c.length
+                            )
+                        except Exception:
+                            pass
     finally:
         song.end_undo_step()
 

package/remote_script/LivePilot/scenes.py

@@ -1,5 +1,5 @@
 """
-LivePilot - Scene domain handlers (8 commands).
+LivePilot - Scene domain handlers (12 commands).
 """
 
 from .router import register
@@ -97,3 +97,112 @@ def set_scene_tempo(song, params):
         "index": scene_index,
         "tempo": scene.tempo,
     }
+
+
+# ── Scene Matrix Operations ─────────────────────────────────────────────
+
+
+@register("get_scene_matrix")
+def get_scene_matrix(song, params):
+    """Return the full clip grid: tracks x scenes with clip states."""
+    tracks = list(song.tracks)
+    scenes = list(song.scenes)
+
+    track_headers = []
+    for i, t in enumerate(tracks):
+        track_headers.append({"index": i, "name": t.name})
+
+    scene_headers = []
+    for i, s in enumerate(scenes):
+        scene_headers.append({
+            "index": i,
+            "name": s.name,
+            "tempo": s.tempo if s.tempo > 0 else None,
+        })
+
+    matrix = []
+    for si, scene in enumerate(scenes):
+        row = []
+        for ti, track in enumerate(tracks):
+            slots = list(track.clip_slots)
+            if si >= len(slots):
+                row.append({"state": "missing"})
+                continue
+            slot = slots[si]
+            cell = {"state": "empty"}
+            if slot.has_clip and slot.clip:
+                clip = slot.clip
+                if clip.is_recording:
+                    cell["state"] = "recording"
+                elif clip.is_playing:
+                    cell["state"] = "playing"
+                elif clip.is_triggered:
+                    cell["state"] = "triggered"
+                else:
+                    cell["state"] = "stopped"
+                cell["name"] = clip.name
+                cell["color_index"] = clip.color_index
+            row.append(cell)
+        matrix.append(row)
+
+    return {
+        "tracks": track_headers,
+        "scenes": scene_headers,
+        "matrix": matrix,
+    }
+
+
+@register("fire_scene_clips")
+def fire_scene_clips(song, params):
+    """Fire a scene with optional track filter."""
+    scene_index = int(params["scene_index"])
+    track_indices = params.get("track_indices")
+
+    scene = get_scene(song, scene_index)
+
+    if track_indices is None:
+        # Fire entire scene
+        scene.fire()
+        return {"scene_index": scene_index, "fired": "all"}
+
+    # Fire specific tracks only
+    tracks = list(song.tracks)
+    fired = []
+    for ti in track_indices:
+        ti = int(ti)
+        if ti < 0 or ti >= len(tracks):
+            raise IndexError("Track index %d out of range (0..%d)" % (ti, len(tracks) - 1))
+        slots = list(tracks[ti].clip_slots)
+        if scene_index < len(slots):
+            slots[scene_index].fire()
+            fired.append(ti)
+
+    return {"scene_index": scene_index, "fired_tracks": fired}
+
+
+@register("stop_all_clips")
+def stop_all_clips(song, params):
+    """Stop all playing clips in the session."""
+    song.stop_all_clips()
+    return {"stopped": True}
+
+
+@register("get_playing_clips")
+def get_playing_clips(song, params):
+    """Return all currently playing or triggered clips."""
+    tracks = list(song.tracks)
+    clips = []
+    for ti, track in enumerate(tracks):
+        for si, slot in enumerate(track.clip_slots):
+            if slot.has_clip and slot.clip:
+                clip = slot.clip
+                if clip.is_playing or clip.is_triggered:
+                    clips.append({
+                        "track_index": ti,
+                        "track_name": track.name,
+                        "clip_index": si,
+                        "clip_name": clip.name,
+                        "is_playing": clip.is_playing,
+                        "is_triggered": clip.is_triggered,
+                    })
+    return {"clips": clips}

package/remote_script/LivePilot/server.py

@@ -39,6 +39,9 @@ WRITE_COMMANDS = frozenset([
     # scenes
     "create_scene", "delete_scene", "duplicate_scene", "fire_scene",
     "set_scene_name", "set_scene_color", "set_scene_tempo",
+    "fire_scene_clips", "stop_all_clips",
+    # tracks (freeze/flatten)
+    "freeze_track", "flatten_track",
     # mixing
     "set_track_volume", "set_track_pan", "set_track_send",
     "set_master_volume", "set_track_routing",
@@ -57,6 +60,11 @@ WRITE_COMMANDS = frozenset([
     "clear_clip_automation",
 ])
 
+# Commands that need longer timeouts (e.g., freeze renders audio)
+SLOW_WRITE_COMMANDS = frozenset([
+    "freeze_track",
+])
+
 
 class LivePilotServer(object):
     """TCP server that bridges JSON commands to Ableton's main thread.
@@ -212,9 +220,14 @@ class LivePilotServer(object):
         request_id = command.get("id", "unknown")
         cmd_type = command.get("type", "")
 
-        # Determine timeout based on read vs write
+        # Determine timeout based on read vs write vs slow write
         is_write = cmd_type in WRITE_COMMANDS
-        timeout = 15 if is_write else 10
+        if cmd_type in SLOW_WRITE_COMMANDS:
+            timeout = 35
+        elif is_write:
+            timeout = 15
+        else:
+            timeout = 10
 
         # Per-command response queue
         response_queue = queue.Queue()

package/remote_script/LivePilot/tracks.py

@@ -1,5 +1,5 @@
 """
-LivePilot - Track domain handlers (14 commands).
+LivePilot - Track domain handlers (17 commands).
 """
 
 from .router import register
@@ -267,3 +267,73 @@ def set_track_input_monitoring(song, params):
         "index": track_index,
         "monitoring_state": track.current_monitoring_state,
     }
+
+
+# ── Freeze / Flatten ────────────────────────────────────────────────────
+
+
+@register("get_freeze_status")
+def get_freeze_status(song, params):
+    """Return freeze state for a track."""
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+    return {
+        "track_index": track_index,
+        "is_frozen": track.is_frozen,
+    }
+
+
+@register("freeze_track")
+def freeze_track(song, params):
+    """Freeze a track — render all devices to audio for CPU savings.
+
+    Freeze is async in Ableton — this call initiates it and returns
+    immediately. Use get_freeze_status to poll for completion.
+    """
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+    if track.is_frozen:
+        return {
+            "track_index": track_index,
+            "is_frozen": True,
+            "note": "Track is already frozen",
+        }
+    # In Live 12, freeze is a track method accessible from ControlSurface
+    try:
+        track.freeze()
+    except AttributeError:
+        raise ValueError(
+            "freeze() not available on this track type. "
+            "Only MIDI and audio tracks with devices can be frozen."
+        )
+    return {
+        "track_index": track_index,
+        "freezing": True,
+        "note": "Freeze initiated. Poll get_freeze_status to check completion.",
+    }
+
+
+@register("flatten_track")
+def flatten_track(song, params):
+    """Flatten a frozen track — commits rendered audio permanently.
+
+    Destructive operation. The track must already be frozen.
+    Wrapped in undo step so it can be reverted.
+    """
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+    if not track.is_frozen:
+        raise ValueError(
+            "Track %d is not frozen. Freeze it first with freeze_track."
+            % track_index
+        )
+    song.begin_undo_step()
+    try:
+        # flatten() is a method on the track, not the song
+        track.flatten()
+    finally:
+        song.end_undo_step()
+    return {
+        "track_index": track_index,
+        "flattened": True,
+    }