livepilot 1.26.0 → 1.26.2

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.2";
 
 // ── 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.2"

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/composer/full/brief_builder.py

@@ -47,6 +47,15 @@ _DESIGN_TARGETS = (
     "moves to schedule at chosen phrase boundaries. For niche style references "
     "in research_hooks, run WebSearch to ground your form choices in the "
     "actual conventions of that subgenre.\n\n"
+    "CHARACTER-FIRST NORMAL MODE:\n"
+    "Do not spend full mode on long level-balancing loops. Producers can adjust "
+    "simple volume by ear; your high-value job is to choose instruments, sources, "
+    "device chains, macro states, envelopes, filters, saturation, modulation, "
+    "and structural reveals that fit the requested character. Use analyzer/mix "
+    "feedback as evidence and safety, but prefer timbral/source decisions over "
+    "`set_track_volume`, `set_track_pan`, or broad send tweaking unless the "
+    "brief explicitly asks for mix balance, loudness, headroom, stereo translation, "
+    "or masking repair.\n\n"
     "INSTRUMENT SELECTION (v1.25 hybrid knowledge surface — MANDATED FOUR-SOURCE SEARCH):\n"
     "The brief's `atlas_anchors` is ONE source. Before committing any role pick "
     "you MUST also query the other three sources below. Factory-atlas-only picks "

package/mcp_server/evaluation/feature_extractors.py

@@ -9,7 +9,7 @@ All returned values are clamped to 0.0-1.0 for consistent scoring.
 from __future__ import annotations
 
 import math
-from typing import Optional
+from typing import Any, Optional
 
 from ..tools._evaluation_contracts import MEASURABLE_DIMENSIONS
 
@@ -19,6 +19,42 @@ def _clamp(value: float, lo: float = 0.0, hi: float = 1.0) -> float:
     return max(lo, min(hi, value))
 
 
+def _number(value: Any) -> Optional[float]:
+    """Best-effort numeric coercion for analyzer payloads."""
+    if isinstance(value, bool):
+        return float(value)
+    if isinstance(value, (int, float)):
+        return float(value)
+    return None
+
+
+def _nested_number(payload: Any, *keys: str) -> Optional[float]:
+    """Read a numeric value from a dict payload using candidate keys."""
+    if isinstance(payload, dict):
+        for key in keys:
+            value = _number(payload.get(key))
+            if value is not None:
+                return value
+    return _number(payload)
+
+
+def _centroid_to_unit(centroid: float) -> float:
+    """Map centroid-like values to 0..1.
+
+    FluCoMa deployments may report centroid in Hz or normalized units.
+    Values <= 1 are treated as normalized. Larger values are mapped across
+    a practical musical range where 150 Hz is very dark and 8 kHz is bright.
+    """
+    if centroid <= 1.0:
+        return _clamp(centroid)
+    return _clamp((centroid - 150.0) / (8000.0 - 150.0))
+
+
+def _lufs_to_unit(lufs: float) -> float:
+    """Map momentary LUFS to a rough 0..1 energy proxy."""
+    return _clamp((lufs + 60.0) / 60.0)
+
+
 def extract_dimension_value(
     snapshot: dict,
     dimension: str,
@@ -37,31 +73,49 @@ def extract_dimension_value(
     if not snapshot or not isinstance(snapshot, dict):
         return None
 
-    bands = snapshot.get("spectrum")
-    if not bands:
-        return None
+    bands = snapshot.get("spectrum") or {}
+    spectral_shape = snapshot.get("spectral_shape") or {}
+    onset = snapshot.get("onset") or {}
+    novelty = snapshot.get("novelty") or {}
+    loudness = snapshot.get("loudness") or {}
 
     rms = snapshot.get("rms")
     peak = snapshot.get("peak")
 
     if dimension == "brightness":
+        centroid = _nested_number(spectral_shape, "centroid", "centroid_hz")
+        if centroid is not None:
+            return _centroid_to_unit(centroid)
+        if not bands:
+            return None
         high = bands.get("high", 0)
         presence = bands.get("presence", 0)
         return _clamp((high + presence) / 2.0)
 
     elif dimension == "warmth":
+        if not bands:
+            return None
         return _clamp(bands.get("low_mid", 0))
 
     elif dimension == "weight":
-        sub = bands.get("sub", 0)
+        if not bands:
+            return None
+        sub = bands.get("sub_low", bands.get("sub", 0))
         low = bands.get("low", 0)
         return _clamp((sub + low) / 2.0)
 
     elif dimension == "clarity":
+        if not bands:
+            return None
         low_mid = bands.get("low_mid", 0)
         return _clamp(1.0 - low_mid)
 
     elif dimension == "density":
+        flatness = _nested_number(spectral_shape, "flatness", "spectral_flatness")
+        if flatness is not None:
+            return _clamp(flatness)
+        if not bands:
+            return None
         vals = [max(v, 1e-10) for v in bands.values()
                 if isinstance(v, (int, float))]
         if not vals:
@@ -71,14 +125,104 @@ def extract_dimension_value(
         return _clamp(geo_mean / max(arith_mean, 1e-10))
 
     elif dimension == "energy":
-        return _clamp(rms) if rms is not None else None
+        rms_value = _number(rms)
+        if rms_value is not None:
+            return _clamp(rms_value)
+        lufs = _nested_number(loudness, "momentary_lufs", "lufs", "integrated_lufs")
+        if lufs is not None:
+            return _lufs_to_unit(lufs)
+        return None
 
     elif dimension == "punch":
-        if rms and peak and rms > 0:
-            crest_db = 20.0 * math.log10(max(peak / rms, 1.0))
+        rms_value = _number(rms)
+        peak_value = _number(peak)
+        if rms_value and peak_value and rms_value > 0:
+            crest_db = 20.0 * math.log10(max(peak_value / rms_value, 1.0))
             return _clamp(crest_db / 20.0)
+        onset_strength = _nested_number(onset, "strength", "onset")
+        if onset_strength is not None:
+            return _clamp(onset_strength)
+        spectral_crest = _nested_number(spectral_shape, "crest")
+        if spectral_crest is not None:
+            return _clamp(spectral_crest)
+        return None
+
+    elif dimension == "novelty":
+        novelty_score = _nested_number(novelty, "score", "novelty", "value")
+        return _clamp(novelty_score) if novelty_score is not None else None
+
+    elif dimension == "motion":
+        novelty_score = _nested_number(novelty, "score", "novelty", "value")
+        onset_strength = _nested_number(onset, "strength", "onset")
+        vals = [v for v in (novelty_score, onset_strength) if v is not None]
+        if vals:
+            return _clamp(sum(vals) / len(vals))
         return None
 
     else:
         # Unmeasurable dimension
         return None
+
+
+def _label_low_mid_high(value: float, low: str, mid: str, high: str) -> str:
+    if value < 0.33:
+        return low
+    if value > 0.67:
+        return high
+    return mid
+
+
+def extract_character_profile(snapshot: dict) -> dict:
+    """Summarize analyzer data as a production-oriented character profile.
+
+    This is intentionally descriptive, not prescriptive. Engines can attach
+    the profile to their analysis response so the agent chooses sound-source,
+    device, and parameter moves before reaching for generic level changes.
+    """
+    if not snapshot or not isinstance(snapshot, dict):
+        return {"available": False, "values": {}, "labels": {}, "biases": []}
+
+    dimensions = (
+        "brightness", "warmth", "weight", "clarity", "density",
+        "energy", "punch", "motion", "novelty",
+    )
+    values = {
+        dim: round(val, 4)
+        for dim in dimensions
+        if (val := extract_dimension_value(snapshot, dim)) is not None
+    }
+
+    labels: dict[str, str] = {}
+    if "brightness" in values:
+        labels["brightness"] = _label_low_mid_high(values["brightness"], "dark", "balanced", "bright")
+    if "warmth" in values:
+        labels["warmth"] = _label_low_mid_high(values["warmth"], "lean", "warm", "thick")
+    if "weight" in values:
+        labels["weight"] = _label_low_mid_high(values["weight"], "light", "grounded", "heavy")
+    if "density" in values:
+        labels["density"] = _label_low_mid_high(values["density"], "peaked", "shaped", "flat/noisy")
+    if "punch" in values:
+        labels["punch"] = _label_low_mid_high(values["punch"], "soft", "defined", "spiky")
+    if "motion" in values:
+        labels["motion"] = _label_low_mid_high(values["motion"], "static", "moving", "busy")
+
+    biases: list[str] = []
+    if values.get("brightness", 0.5) > 0.72:
+        biases.append("prefer filter tone, source choice, or de-harshing over lowering track volume")
+    if values.get("brightness", 0.5) < 0.28:
+        biases.append("prefer oscillator/filter opening, excitation, or air-band source choice over level boosts")
+    if values.get("motion", 0.5) < 0.25:
+        biases.append("prefer modulation, envelope drift, or evolving devices before static mix moves")
+    if values.get("punch", 0.5) < 0.25:
+        biases.append("prefer envelope/transient shaping or source layering before pushing volume")
+    if values.get("density", 0.0) > 0.75:
+        biases.append("prefer subtractive filtering or simpler source selection when the spectrum is flat/noisy")
+    if values.get("weight", 0.5) < 0.25:
+        biases.append("prefer instrument/register/source changes for low-end weight before master gain")
+
+    return {
+        "available": bool(values),
+        "values": values,
+        "labels": labels,
+        "biases": biases,
+    }

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/mix_engine/state_builder.py

@@ -68,6 +68,19 @@ def _name_signals_non_anchor(track_name: str) -> bool:
 # Frequency bands where masking is most problematic.
 _MASKING_BANDS = ("sub", "low", "low_mid", "mid", "high_mid", "presence", "high")
 
+_MASKING_ROLE_ALIASES = {
+    "sub_bass": "bass",
+    "hihat": "percussion",
+    "hat": "percussion",
+    "clap": "percussion",
+    "snare": "percussion",
+}
+
+
+def _masking_role(role: str) -> str:
+    """Normalize detailed track roles into the collision-rule vocabulary."""
+    return _MASKING_ROLE_ALIASES.get(role, role)
+
 
 # ── Balance ─────────────────────────────────────────────────────────
 
@@ -164,7 +177,7 @@ def build_masking_map(
     # Build role->indices mapping
     role_to_indices: dict[str, list[int]] = {}
     for idx, role in track_roles.items():
-        role_to_indices.setdefault(role, []).append(idx)
+        role_to_indices.setdefault(_masking_role(role), []).append(idx)
 
     # Known problematic role pairs and their collision bands
     collision_rules: list[tuple[str, str, str, float]] = [
@@ -267,7 +280,11 @@ def build_mix_state(
     role_hints = role_hints or {}
 
     balance = build_balance_state(track_infos, role_hints)
-    masking = build_masking_map(spectrum, role_hints)
+    inferred_roles = {
+        track.track_index: role_hints.get(track.track_index, track.role)
+        for track in balance.track_states
+    }
+    masking = build_masking_map(spectrum, inferred_roles)
 
     # Extract peak from spectrum if available
     peak = None

package/mcp_server/mix_engine/tools.py

@@ -11,6 +11,7 @@ from fastmcp import Context
 from ..server import mcp
 from ..tools._evaluation_contracts import EvaluationRequest
 from ..tools._snapshot_normalizer import normalize_sonic_snapshot
+from ..evaluation.feature_extractors import extract_character_profile
 from ..evaluation.fabric import evaluate_sonic_move
 from .state_builder import build_mix_state
 from .critics import run_all_mix_critics
@@ -56,6 +57,18 @@ def _fetch_mix_data(ctx: Context) -> dict:
             rms_snap = spectral.get("rms")
             if rms_snap:
                 rms_data = rms_snap["value"] if isinstance(rms_snap["value"], dict) else rms_snap["value"]
+                if spectrum is not None:
+                    spectrum["rms"] = rms_data.get("rms") if isinstance(rms_data, dict) else rms_data
+            peak_snap = spectral.get("peak")
+            if peak_snap and spectrum is not None:
+                spectrum["peak"] = peak_snap["value"]
+
+            for key in ("spectral_shape", "mel_bands", "chroma", "onset", "novelty", "loudness"):
+                snap = spectral.get(key)
+                if snap:
+                    if spectrum is None:
+                        spectrum = {}
+                    spectrum[key] = snap["value"]
     except Exception as exc:
         logger.debug("_fetch_mix_data failed: %s", exc)
 
@@ -86,9 +99,12 @@ def analyze_mix(ctx: Context) -> dict:
     )
     issues = run_all_mix_critics(mix_state)
     moves = plan_mix_moves(issues, mix_state)
+    sonic_snapshot = normalize_sonic_snapshot(data["spectrum"], source="mix_engine")
+    sonic_character = extract_character_profile(sonic_snapshot or {})
 
     return {
         "mix_state": mix_state.to_dict(),
+        "sonic_character": sonic_character,
         "issues": [i.to_dict() for i in issues],
         "suggested_moves": [m.to_dict() for m in moves],
         "issue_count": len(issues),
@@ -110,8 +126,10 @@ def get_mix_issues(ctx: Context) -> dict:
         rms_data=data["rms_data"],
     )
     issues = run_all_mix_critics(mix_state)
+    sonic_snapshot = normalize_sonic_snapshot(data["spectrum"], source="mix_engine")
 
     return {
+        "sonic_character": extract_character_profile(sonic_snapshot or {}),
         "issues": [i.to_dict() for i in issues],
         "issue_count": len(issues),
     }
@@ -133,8 +151,10 @@ def plan_mix_move(ctx: Context) -> dict:
     )
     issues = run_all_mix_critics(mix_state)
     moves = plan_mix_moves(issues, mix_state)
+    sonic_snapshot = normalize_sonic_snapshot(data["spectrum"], source="mix_engine")
 
     return {
+        "sonic_character": extract_character_profile(sonic_snapshot or {}),
         "moves": [m.to_dict() for m in moves],
         "move_count": len(moves),
         "issue_count": len(issues),
@@ -212,10 +232,12 @@ def get_mix_summary(ctx: Context) -> dict:
         rms_data=data["rms_data"],
     )
     issues = run_all_mix_critics(mix_state)
+    sonic_snapshot = normalize_sonic_snapshot(data["spectrum"], source="mix_engine")
 
     return {
         "track_count": len(mix_state.balance.track_states),
         "issue_count": len(issues),
+        "sonic_character": extract_character_profile(sonic_snapshot or {}),
         "dynamics": mix_state.dynamics.to_dict(),
         "stereo": mix_state.stereo.to_dict(),
         "depth": mix_state.depth.to_dict(),

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()),