livepilot 1.26.0 → 1.26.1

package/m4l_device/livepilot_bridge.js

@@ -34,7 +34,7 @@ outlets = 2; // 0: to udpsend (responses), 1: to buffer~/status
 // Single source of truth for the bridge version — bumped alongside the
 // rest of the release manifest. Surfaced in the UI via messnamed("livepilot_version", ...)
 // so the frozen .amxd visibly reports which build it was last exported from.
-var VERSION = "1.26.0";
+var VERSION = "1.26.1";
 
 // ── State ──────────────────────────────────────────────────────────────────
 

package/m4l_device/livepilot_elektron_bridge.js

@@ -0,0 +1,82 @@
+// m4l_device/livepilot_elektron_bridge.js
+// LivePilot Elektron Bridge — runs inside LivePilot_Elektron.amxd.
+//
+// Wire model:
+//
+//   M4L → Python : UDP 9882
+//                  Inbound SysEx from physical MIDI [sysexin → sxformat
+//                  → prepend sysex] arrives at JS as a "sysex <bytes...>"
+//                  message; forwards out outlet 1 (→ [udpsend 9882]).
+//
+//   Python → M4L : UDP 9883
+//                  [udpreceive 9883] outputs bytes as a "list" message
+//                  → JS function list() pushes onto sendQueue.
+//                  [metro 50 @active 1] drives bang() which drains one
+//                  chunk per tick onto outlet 0 (→ [midiout]).
+//
+// Outlets:
+//   0 → [midiout]                  paced chunks to physical MIDI port
+//   1 → [udpsend 127.0.0.1 9882]   sysex-from-device upstream to Python
+//   2 → "set <text>" → live.text   status display
+//   3 → +1 counter → live.numbox   RX message counter
+//
+// Phase 1 design note: heartbeat is intentionally OUT for v1 of the M4L
+// device. The Python bridge uses per-operation timeouts (per design
+// spec §7.3) so it does not need M4L liveness polling. Heartbeat / pong
+// can be added in a Phase 2 patch to the .maxpat if "is M4L loaded?"
+// detection becomes useful — the ping()/pong() functions below are
+// kept as reserved stubs for that future wiring.
+
+inlets = 1;
+outlets = 4;
+
+var sendQueue = [];
+var rxCount = 0;
+
+// Called by [metro 50 @active 1] — drain one queued chunk per tick.
+function bang() {
+    if (sendQueue.length > 0) {
+        var chunk = sendQueue.shift();
+        // Spread chunk into outlet args so Max sees it as a list message
+        outlet.apply(this, [0].concat(chunk));
+    }
+}
+
+// Called by [udpreceive 9883] — outputs raw UDP bytes as a list.
+// This is the Python → M4L outbound MIDI path. Each datagram is a
+// pre-chunked SysEx fragment; we queue and let bang() pace them.
+function list() {
+    var bytes = [];
+    for (var i = 0; i < arguments.length; i++) {
+        bytes.push(arguments[i]);
+    }
+    sendQueue.push(bytes);
+}
+
+// Called when [sysexin → sxformat → prepend sysex] delivers a complete
+// SysEx as a "sysex <bytes...>" message. We forward to Python and
+// bump the RX counter + status.
+function sysex() {
+    var bytes = [];
+    for (var i = 0; i < arguments.length; i++) {
+        bytes.push(arguments[i]);
+    }
+    // Forward to Python via outlet 1 → [udpsend 9882]
+    outlet.apply(this, [1].concat(bytes));
+    // Bump RX counter via outlet 3
+    rxCount += 1;
+    outlet(3, rxCount);
+    // Update status via outlet 2
+    outlet(2, "set", "Online — receiving SysEx");
+}
+
+// Phase 2 reserved: heartbeat ping. Wire [metro 1000] → [t ping] → js
+// to enable. Not wired in Phase 1 .maxpat.
+function ping() {
+    outlet(1, 0xF0, 0x7F, 0x7F, 0x00, 0xF7);
+}
+
+// Phase 2 reserved: receive pong from Python. Currently unused.
+function pong() {
+    outlet(2, "set", "Online — pong received");
+}

package/mcp_server/__init__.py

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

package/mcp_server/composer/develop/apply.py

@@ -64,7 +64,7 @@ async def _bridge_ping_stub(ctx: Any) -> dict:
         bridge = ctx.lifespan_context.get("m4l_bridge")
     if bridge is None:
         raise RuntimeError("bridge not available")
-    return await bridge.send_command("ping", {"timeout": 0.5})
+    return await bridge.send_command("ping", timeout=0.5)
 
 
 async def _back_to_arranger(ctx: Any) -> dict:

package/mcp_server/composer/full/apply.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import logging
 import re as _re
+import inspect
 import time
 
 from fastmcp import Context
@@ -92,6 +93,28 @@ _TONAL_ROLES_ALWAYS_WARP: frozenset[str] = frozenset({
 })
 
 
+async def _call_mcp_analysis_tool(ctx: Context, tool: str, params: dict) -> dict:
+    """Dispatch analyzer/intelligence tools through the MCP registry.
+
+    These tools are Python MCP tools, not Remote Script TCP handlers. Keeping
+    full-mode analysis on the registry path prevents creative plans from
+    passing tests against mocks and then failing in Live as unknown commands.
+    """
+    lifespan = getattr(ctx, "lifespan_context", {}) or {}
+    registry = lifespan.get("mcp_dispatch")
+    if registry is None:
+        from ...runtime.mcp_dispatch import build_mcp_dispatch_registry
+        registry = build_mcp_dispatch_registry()
+
+    fn = registry.get(tool) if registry else None
+    if fn is None:
+        return {"error": f"MCP analysis tool '{tool}' is not registered"}
+
+    call = fn(params, ctx=ctx)
+    result = await call if inspect.isawaitable(call) else call
+    return result if isinstance(result, dict) else {"result": result}
+
+
 def _decide_warp_loops(
     role: str,
     file_path: str,
@@ -825,8 +848,9 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
         # Goal: give the agent acoustic characteristics of the loaded sound so
         # it can reason about fit. ONLY static analysis here (no playback);
         # active solo-trigger analysis is Scope B / v1.25.
-        # Analysis is routed through ableton.send_command so it is intercepted
-        # by the same mock contract as all other commands (testable, consistent).
+        # Analysis is MCP-side intelligence, not a Remote Script TCP command.
+        # Route through the MCP dispatch registry so live execution matches
+        # the same boundary the async plan router uses.
         role = track_spec.get("role", "")
         instrument_uri = (track_spec.get("instrument") or {}).get("uri", "")
         layer_analysis: dict = {"status": "skipped", "reason": "no analyzer applicable"}
@@ -834,7 +858,8 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
             if instrument_uri.startswith(("query:Synths#", "query:Sounds#")):
                 # Synth / preset — analyze the patch
                 try:
-                    patch_result = ableton.send_command(
+                    patch_result = await _call_mcp_analysis_tool(
+                        ctx,
                         "analyze_synth_patch",
                         {"track_index": track_index, "device_index": 0},
                     )
@@ -854,7 +879,8 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
                  any(instrument_uri.lower().endswith(ext) for ext in (".aif", ".wav", ".mp3", ".flac")):
                 # Sample-based — analyze via track reference (no file_path needed)
                 try:
-                    sample_result = ableton.send_command(
+                    sample_result = await _call_mcp_analysis_tool(
+                        ctx,
                         "analyze_sample",
                         {"track_index": track_index, "clip_index": 0},
                     )
@@ -1034,10 +1060,10 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
     # session state.
     mix_analysis: dict = {"status": "skipped", "reason": "not run"}
     try:
-        mix_result = ableton.send_command("analyze_mix", {})
+        mix_result = await _call_mcp_analysis_tool(ctx, "analyze_mix", {})
         if isinstance(mix_result, dict) and not mix_result.get("error"):
             try:
-                masking_result = ableton.send_command("get_masking_report", {})
+                masking_result = await _call_mcp_analysis_tool(ctx, "get_masking_report", {})
             except Exception as mask_exc:
                 masking_result = {"error": str(mask_exc)}
             mix_analysis = {

package/mcp_server/m4l_bridge.py

@@ -1014,6 +1014,11 @@ class M4LBridge:
                 while len(s_bytes) % 4 != 0:
                     s_bytes += b'\x00'
                 arg_data += s_bytes
+            else:
+                raise TypeError(
+                    "OSC argument for %s must be int, float, or str, got %s"
+                    % (address, type(arg).__name__)
+                )
 
         tag_bytes = type_tags.encode('ascii') + b'\x00'
         while len(tag_bytes) % 4 != 0:

package/mcp_server/runtime/execution_router.py

@@ -36,7 +36,10 @@ from .remote_commands import BRIDGE_COMMANDS, REMOTE_COMMANDS
 MCP_TOOLS: frozenset[str] = frozenset({
     "apply_automation_shape",
     "apply_gesture_template",
+    "analyze_sample",
+    "analyze_synth_patch",
     "analyze_mix",
+    "get_masking_report",
     "get_master_spectrum",
     "get_emotional_arc",
     "get_motif_graph",
@@ -92,7 +95,10 @@ READ_ONLY_TOOLS: frozenset[str] = frozenset({
     "get_cue_points",
     "get_rack_chains",
     "get_clip_automation",
+    "analyze_sample",
+    "analyze_synth_patch",
     "analyze_mix",
+    "get_masking_report",
     "get_emotional_arc",
     "get_motif_graph",
     "get_session_diagnostics",

package/mcp_server/runtime/mcp_dispatch.py

@@ -60,11 +60,26 @@ async def _apply_gesture_template(params: dict, ctx: Any = None) -> dict:
     return await _call(apply_gesture_template, ctx, params)
 
 
+async def _analyze_sample(params: dict, ctx: Any = None) -> dict:
+    from ..sample_engine.tools import analyze_sample
+    return await _call(analyze_sample, ctx, params)
+
+
+async def _analyze_synth_patch(params: dict, ctx: Any = None) -> dict:
+    from ..synthesis_brain.tools import analyze_synth_patch
+    return await _call(analyze_synth_patch, ctx, params)
+
+
 async def _analyze_mix(params: dict, ctx: Any = None) -> dict:
     from ..mix_engine.tools import analyze_mix
     return await _call(analyze_mix, ctx, params)
 
 
+async def _get_masking_report(params: dict, ctx: Any = None) -> dict:
+    from ..mix_engine.tools import get_masking_report
+    return await _call(get_masking_report, ctx, params)
+
+
 async def _get_master_spectrum(params: dict, ctx: Any = None) -> dict:
     from ..tools.analyzer import get_master_spectrum
     return await _call(get_master_spectrum, ctx, params)
@@ -151,7 +166,10 @@ def build_mcp_dispatch_registry() -> dict[str, Callable]:
         "load_sample_to_simpler": _load_sample_to_simpler,
         "apply_automation_shape": _apply_automation_shape,
         "apply_gesture_template": _apply_gesture_template,
+        "analyze_sample": _analyze_sample,
+        "analyze_synth_patch": _analyze_synth_patch,
         "analyze_mix": _analyze_mix,
+        "get_masking_report": _get_masking_report,
         "get_master_spectrum": _get_master_spectrum,
         "get_emotional_arc": _get_emotional_arc,
         "get_motif_graph": _get_motif_graph,

package/mcp_server/runtime/remote_commands.py

@@ -83,6 +83,8 @@ REMOTE_COMMANDS: frozenset[str] = frozenset({
     "capture_midi", "start_recording", "stop_recording",
     "get_cue_points", "jump_to_cue", "toggle_cue_point",
     "back_to_arranger", "force_arrangement",
+    "arrangement_automation_via_session_record_start",
+    "arrangement_automation_via_session_record_complete",
     # scales — Song + per-clip scale awareness (Live 12.0+)
     "get_song_scale", "set_song_scale", "set_song_scale_mode",
     "list_available_scales",

package/mcp_server/server.py

@@ -355,14 +355,14 @@ def _coerce_schema_property(prop: dict) -> None:
 def _get_all_tools():
     """Get all registered tools — defends against FastMCP internal drift.
 
-    FastMCP's public API doesn't expose the registry as of 3.2.x (see
+    FastMCP's public API doesn't expose the registry as of 3.3.x (see
     docs/FASTMCP_UPSTREAM_FR.md). Until it does, we probe known internal
     attribute paths. Each probe fires in try/except so a structural
-    rearrangement (e.g. ``_components`` renamed under 3.3+) falls through
+    rearrangement (e.g. ``_components`` renamed under 3.4+) falls through
     to the next path rather than exploding.
 
     WARNING: Accesses FastMCP private internals. Pinned to
-    fastmcp>=3.0.0,<3.3.0 in requirements.txt. The startup self-test
+    fastmcp>=3.3.1,<3.4.0 in requirements.txt. The startup self-test
     (_assert_tool_registry_accessible) will fail loudly if every probe
     returns empty — better than silently returning [] and disabling
     schema coercion.
@@ -370,14 +370,18 @@ def _get_all_tools():
     probes = [
         # FastMCP 0.x: mcp._tool_manager._tools (dict of name -> Tool)
         ("_tool_manager._tools", lambda: list(mcp._tool_manager._tools.values())),
-        # FastMCP 3.0–3.2: mcp._local_provider._components
+        # FastMCP 3.0–3.3: mcp._local_provider._components
+        # (verified 2026-05-21 against fastmcp 3.3.1 — still the active path)
         (
             "_local_provider._components",
             lambda: list(mcp._local_provider._components.values()),
         ),
-        # FastMCP 3.3+ speculative: mcp._local_provider._tools (anticipated
-        # rename based on naming conventions in other providers). Kept here
-        # so a future bump surfaces a partial match rather than a full miss.
+        # FastMCP 3.4+ speculative: mcp._local_provider._tools (anticipated
+        # rename based on naming conventions in other providers). Verified
+        # 2026-05-21 against fastmcp 3.3.1 — the rename did NOT happen in
+        # 3.3.x; ``_local_provider._components`` remains the live registry.
+        # Kept here so a future bump that DOES rename surfaces a partial
+        # match rather than a full miss.
         (
             "_local_provider._tools",
             lambda: list(mcp._local_provider._tools.values()),

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "livepilot",
-  "version": "1.26.0",
+  "version": "1.26.1",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 \u2014 465 tools, 56 domains, 44 semantic moves. Device atlas (5264 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, technique memory, 12 creative intelligence engines",
+  "description": "Agentic production system for Ableton Live 12 — 465 tools, 56 domains, 44 semantic moves. Device atlas (5264 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, technique memory, 12 creative intelligence engines",
   "author": "Pilot Studio",
   "license": "BSL-1.1",
   "type": "commonjs",
   "bin": {
-    "livepilot": "./bin/livepilot.js"
+    "livepilot": "bin/livepilot.js"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/dreamrec/LivePilot"
+    "url": "git+https://github.com/dreamrec/LivePilot.git"
   },
   "homepage": "https://github.com/dreamrec/LivePilot",
   "bugs": {
@@ -47,6 +47,7 @@
   "files": [
     "bin/**/*.js",
     "installer/**/*.js",
+    "livepilot/**",
     "mcp_server/**/*.py",
     "mcp_server/**/*.json",
     "mcp_server/**/*.yaml",
@@ -56,6 +57,9 @@
     "m4l_device/LivePilot_Analyzer.amxd",
     "m4l_device/LivePilot_Analyzer.adv",
     "m4l_device/livepilot_bridge.js",
+    "m4l_device/LivePilot_Elektron.amxd",
+    "m4l_device/LivePilot_Elektron.maxpat",
+    "m4l_device/livepilot_elektron_bridge.js",
     "m4l_device/BUILD_GUIDE.md",
     "requirements.txt",
     "README.md",
@@ -64,6 +68,17 @@
     "server.json",
     "!**/__pycache__/**",
     "!**/*.pyc",
-    "!**/.DS_Store"
+    "!**/.DS_Store",
+    "!livepilot/skills/livepilot-core/references/device-atlas/synths-m4l.md",
+    "!livepilot/skills/livepilot-core/references/device-atlas/plugins-synths.md",
+    "!livepilot/skills/livepilot-core/references/device-atlas/utility-and-workflow.md",
+    "!livepilot/skills/livepilot-core/references/device-atlas/samples-and-irs.md",
+    "!livepilot/skills/livepilot-core/references/device-atlas/presets-by-vibe.md",
+    "!livepilot/skills/livepilot-devices/references/m4l-vendor/**",
+    "!livepilot/skills/livepilot-devices/references/m4l-depth-pass-findings.md",
+    "!livepilot/skills/livepilot-devices/references/m4l-depth-pass-resume.md",
+    "!livepilot/skills/livepilot-devices/references/m4l-library-deep.md",
+    "!livepilot/skills/livepilot-devices/references/m4l-master-reference.md",
+    "!livepilot/skills/livepilot-devices/references/m4l-technique-map.md"
   ]
 }

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.26.0"
+__version__ = "1.26.1"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router

package/remote_script/LivePilot/server.py

@@ -60,6 +60,67 @@ WRITE_COMMANDS = frozenset([
     "clear_clip_automation",
 ])
 
+# Future-safe write detection. WRITE_COMMANDS remains the explicit allow-list
+# for older handlers and readability; the prefix classifier catches newer
+# mutating handlers so they still receive the write timeout and settle delay.
+READ_COMMAND_PREFIXES = ("get_", "list_", "scan_")
+READ_ONLY_COMMANDS = frozenset([
+    "ping",
+    "reload_handlers",
+])
+WRITE_COMMAND_PREFIXES = (
+    "add_",
+    "apply_",
+    "arrangement_automation_",
+    "assign_",
+    "back_to_",
+    "capture_",
+    "cleanup_",
+    "clear_",
+    "continue_",
+    "copy_",
+    "create_",
+    "delete_",
+    "duplicate_",
+    "find_and_load_",
+    "fire_",
+    "flatten_",
+    "force_",
+    "freeze_",
+    "import_",
+    "insert_",
+    "jump_",
+    "load_",
+    "modify_",
+    "move_",
+    "nudge_",
+    "quantize_",
+    "randomize_",
+    "recall_",
+    "remove_",
+    "replace_",
+    "reset_",
+    "set_",
+    "start_",
+    "stop_",
+    "store_",
+    "tap_",
+    "toggle_",
+    "transpose_",
+)
+
+
+def is_write_command(command_type):
+    """Return True if a command is expected to mutate Live state."""
+    if command_type in WRITE_COMMANDS:
+        return True
+    if command_type in READ_ONLY_COMMANDS:
+        return False
+    if command_type.startswith(READ_COMMAND_PREFIXES):
+        return False
+    return command_type.startswith(WRITE_COMMAND_PREFIXES)
+
+
 # Commands that need longer timeouts (e.g., freeze renders audio)
 SLOW_WRITE_COMMANDS = frozenset([
     "freeze_track",
@@ -277,7 +338,7 @@ class LivePilotServer(object):
         cmd_type = command.get("type", "")
 
         # Determine timeout based on read vs write vs slow write
-        is_write = cmd_type in WRITE_COMMANDS
+        is_write = is_write_command(cmd_type)
         if cmd_type in SLOW_WRITE_COMMANDS:
             timeout = 35
         elif is_write:
@@ -343,7 +404,7 @@ class LivePilotServer(object):
             return
 
         cmd_type = command.get("type", "")
-        is_write = cmd_type in WRITE_COMMANDS
+        is_write = is_write_command(cmd_type)
 
         try:
             song = self._cs.song()

package/requirements.txt

@@ -1,6 +1,6 @@
 # LivePilot MCP Server dependencies
-numpy>=2.4.4
-fastmcp>=3.2.4,<3.3.0  # pinned upper bound — _get_all_tools() accesses private internals
+numpy>=2.4.6
+fastmcp>=3.3.1,<3.4.0  # pinned upper bound — _get_all_tools() accesses private internals
 midiutil>=1.2.1
 pretty_midi>=0.2.11
 # v1.8 Perception Layer (offline analysis)
@@ -13,7 +13,7 @@ mutagen>=1.47.0
 # falls back to the SQLite sounds.db which only returns locally downloaded
 # samples (see docs/2026-04-14-bugs-discovered.md — P0-2).
 grpcio>=1.80.0
-protobuf>=7.34.1
+protobuf>=7.35.0
 
 # Known benign warning during install:
 #   ERROR: pip's dependency resolver does not currently take into account

package/server.json

@@ -1,17 +1,17 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.dreamrec/livepilot",
-  "description": "465-tool agentic MCP production system for Ableton Live 12 \u2014 55 domains, 44 semantic moves, device atlas (5264 devices), Splice intelligence (gRPC + GraphQL), 9-band spectral perception auto-loaded, Creative Director skill, technique memory, 12 creative engines",
+  "description": "465-tool agentic MCP production system for Ableton Live 12 \u2014 56 domains, 44 semantic moves, device atlas (5264 devices), Splice intelligence (gRPC + GraphQL), 9-band spectral perception auto-loaded, Creative Director skill, technique memory, 12 creative engines",
   "repository": {
     "url": "https://github.com/dreamrec/LivePilot",
     "source": "github"
   },
-  "version": "1.26.0",
+  "version": "1.26.1",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "livepilot",
-      "version": "1.26.0",
+      "version": "1.26.1",
       "transport": {
         "type": "stdio"
       }