livepilot 1.10.5 → 1.10.7

package/mcp_server/reference_engine/profile_builder.py

@@ -96,11 +96,22 @@ def build_style_reference_profile(style_tactics: list[dict]) -> ReferenceProfile
     # Estimate density from arrangement pattern count
     density_arc = _estimate_density_from_patterns(style_tactics)
 
+    # BUG-B50 fix: the old code hardcoded loudness_posture=0.0 and
+    # empty spectral_contour / width_depth because StyleTactic entries
+    # don't carry those fields. We now derive them heuristically from
+    # the device_chain (each device's params leak its intended sonic
+    # shape — e.g., Auto Filter at 800Hz low-pass = darker spectrum,
+    # Utility Width > 0.6 = wider stereo). Rough but non-empty values
+    # are better than zeros for downstream reference-gap analysis.
+    loudness_posture = _derive_loudness_posture(style_tactics)
+    spectral_contour = _derive_spectral_contour(style_tactics)
+    width_depth = _derive_width_depth(style_tactics)
+
     return ReferenceProfile(
         source_type="style",
-        loudness_posture=0.0,  # style doesn't specify loudness
-        spectral_contour={},  # style doesn't specify spectrum
-        width_depth={},
+        loudness_posture=loudness_posture,
+        spectral_contour=spectral_contour,
+        width_depth=width_depth,
         density_arc=density_arc,
         section_pacing=section_pacing,
         harmonic_character=harmonic_character,
@@ -147,3 +158,118 @@ def _estimate_density_from_patterns(style_tactics: list[dict]) -> list[float]:
             densities.append(min(0.9, 0.3 + n * 0.15))
 
     return densities
+
+
+# ── BUG-B50 derivations — style → loudness/spectral/width heuristics ──────
+
+
+def _derive_loudness_posture(style_tactics: list[dict]) -> float:
+    """Heuristic: compression / saturation / limiter devices imply a
+    specific loudness posture. Glue / Ratio>3 → loud, saturator drive
+    high → cranked/loud, delay/reverb-heavy → quieter mix."""
+    loud_signals = 0
+    quiet_signals = 0
+    for tactic in style_tactics:
+        for dev in tactic.get("device_chain", []):
+            name = str(dev.get("name", "")).lower()
+            params = dev.get("params", {}) or {}
+            if "glue" in name or "limiter" in name:
+                loud_signals += 2
+            if name == "saturator" or "overdrive" in name:
+                drive = float(params.get("Drive", 0) or 0)
+                if drive >= 6:
+                    loud_signals += 1
+            if name == "compressor":
+                ratio = float(params.get("Ratio", 0) or 0)
+                if ratio >= 4:
+                    loud_signals += 1
+            if name == "reverb":
+                # Heavy reverb tails push the mix quieter
+                wet = float(params.get("Dry/Wet", 0) or 0)
+                if wet >= 0.6:
+                    quiet_signals += 1
+    # Normalize to -1..+1 range (loud=+1, quiet=-1, neutral=0)
+    if loud_signals == 0 and quiet_signals == 0:
+        return 0.0
+    net = (loud_signals - quiet_signals) / max(
+        loud_signals + quiet_signals, 1
+    )
+    return round(net, 2)
+
+
+def _derive_spectral_contour(style_tactics: list[dict]) -> dict:
+    """Heuristic: Auto Filter frequencies + device names leak the
+    target spectrum. Low-pass filters → dark, EQ Eight with no params
+    → neutral, saturators → mid-forward."""
+    brightness = 0.5  # neutral starting point
+    mid_emphasis = 0.5
+    dark_hits = 0
+    bright_hits = 0
+    for tactic in style_tactics:
+        for dev in tactic.get("device_chain", []):
+            name = str(dev.get("name", "")).lower()
+            params = dev.get("params", {}) or {}
+            if "auto filter" in name or name == "autofilter":
+                freq = float(params.get("Frequency", 1500) or 1500)
+                # Ableton Auto Filter Frequency is 20-22000; below 2k hints dark
+                if freq < 2000:
+                    dark_hits += 1
+                elif freq > 5000:
+                    bright_hits += 1
+            if "saturator" in name or "overdrive" in name:
+                mid_emphasis += 0.1
+    if dark_hits > bright_hits:
+        brightness = 0.3
+    elif bright_hits > dark_hits:
+        brightness = 0.75
+    return {
+        "band_balance": {
+            "sub": 0.45,
+            "low": 0.5,
+            "mid": min(1.0, mid_emphasis),
+            "high_mid": round(0.3 + brightness * 0.4, 2),
+            "high": round(0.2 + brightness * 0.5, 2),
+        },
+        "brightness": round(brightness, 2),
+        "centroid_hint": "dark" if brightness < 0.4
+                         else "bright" if brightness > 0.65
+                         else "neutral",
+    }
+
+
+def _derive_width_depth(style_tactics: list[dict]) -> dict:
+    """Heuristic: Utility Width, Chorus-Ensemble, or heavy reverb
+    implies a wider stereo field; dry chains imply narrow."""
+    width_value = 0.5
+    depth_value = 0.5
+    for tactic in style_tactics:
+        for dev in tactic.get("device_chain", []):
+            name = str(dev.get("name", "")).lower()
+            params = dev.get("params", {}) or {}
+            if name == "utility":
+                w = params.get("Width")
+                if w is not None:
+                    try:
+                        width_value = max(width_value, float(w))
+                    except (TypeError, ValueError):
+                        pass
+            if "reverb" in name:
+                wet = float(params.get("Dry/Wet", 0) or 0)
+                if wet > 0.4:
+                    depth_value = max(depth_value, 0.7)
+                    width_value = max(width_value, 0.65)
+            if "chorus" in name or "ensemble" in name:
+                width_value = max(width_value, 0.75)
+            if "delay" in name:
+                wet = float(params.get("Dry/Wet", 0) or 0)
+                if wet > 0.2:
+                    depth_value = max(depth_value, 0.6)
+    return {
+        "stereo_width": round(width_value, 2),
+        "depth": round(depth_value, 2),
+        "depth_hint": (
+            "deep" if depth_value > 0.6 else
+            "intimate" if depth_value < 0.4 else
+            "neutral"
+        ),
+    }

package/mcp_server/reference_engine/tools.py

@@ -13,7 +13,9 @@ from ..tools._research_engine import get_style_tactics
 from .profile_builder import build_audio_reference_profile, build_style_reference_profile
 from .gap_analyzer import analyze_gaps, classify_gap_relevance, detect_identity_warnings
 from .tactic_router import build_reference_plan
+import logging
 
+logger = logging.getLogger(__name__)
 
 # ── Helpers ────────────────────────────────────────────────────────
 
@@ -28,6 +30,20 @@ def _fetch_comparison_data(ctx: Context, mix_path: str, reference_path: str) ->
     return compare_to_reference(mix_path, reference_path, normalize=True)
 
 
+def _fetch_memory_tactics(style: str) -> list[dict]:
+    """BUG-B19: pull user-saved techniques tagged with *style* so they
+    feed into the reference-profile lookup path. Best-effort — returns
+    empty list when the memory store isn't available."""
+    if not style:
+        return []
+    try:
+        from ..tools.research import _memory_store
+        return _memory_store.search(query=style, limit=10)
+    except Exception as exc:
+        logger.debug("_fetch_memory_tactics failed for %r: %s", style, exc)
+        return []
+
+
 def _fetch_project_snapshot(ctx: Context) -> dict:
     """Build a lightweight project snapshot for gap analysis."""
     ableton = ctx.lifespan_context["ableton"]
@@ -50,6 +66,7 @@ def _fetch_project_snapshot(ctx: Context) -> dict:
                 rms = rms_snap["value"] if isinstance(rms_snap["value"], (int, float)) else 0.0
                 if rms > 0:
                     import math
+
                     snapshot["loudness"] = round(20 * math.log10(max(rms, 1e-10)), 2)
 
             spec_data = spectral.get("spectrum")
@@ -58,8 +75,8 @@ def _fetch_project_snapshot(ctx: Context) -> dict:
                 key_data = spectral.get("key")
                 if key_data:
                     snapshot["spectral"]["detected_key"] = key_data["value"]
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_fetch_project_snapshot failed: %s", exc)
 
     # Try to get session info for pacing / density
     try:
@@ -69,12 +86,11 @@ def _fetch_project_snapshot(ctx: Context) -> dict:
         # Rough density estimate
         snapshot["density"] = min(1.0, track_count / 20.0)
         snapshot["pacing"] = [{"label": f"scene_{i}", "bars": 8} for i in range(scene_count)]
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_fetch_project_snapshot failed: %s", exc)
 
     return snapshot
 
-
 # ── MCP Tools ──────────────────────────────────────────────────────
 
 
@@ -108,10 +124,21 @@ def build_reference_profile(
         return profile.to_dict()
 
     if style:
-        tactics = get_style_tactics(style)
+        # BUG-B19 fix: also pass user-memory tactics so custom styles
+        # (e.g. "prefuse73" saved via memory_learn) resolve to real
+        # profiles instead of NOT_FOUND. Silently ignore if memory
+        # isn't available (keeps the built-in path working).
+        memory_tactics = _fetch_memory_tactics(style)
+        tactics = get_style_tactics(style, memory_tactics=memory_tactics)
         if not tactics:
             return {
-                "error": f"No style tactics found for '{style}'",
+                "error": (
+                    f"No style tactics found for '{style}' — neither in the "
+                    f"built-in library (burial / daft punk / techno / ambient / "
+                    f"trap / lo-fi) nor in your saved memories. Use "
+                    f"memory_learn to save a '{style}' technique or try "
+                    f"reference_path=<audio-file> for an audio-based profile."
+                ),
                 "code": "NOT_FOUND",
             }
         tactic_dicts = [t.to_dict() for t in tactics]
@@ -156,9 +183,17 @@ def analyze_reference_gaps(
             return comparison
         profile = build_audio_reference_profile(comparison)
     elif style:
-        tactics = get_style_tactics(style)
+        # BUG-B19: hydrate from saved memories too
+        memory_tactics = _fetch_memory_tactics(style)
+        tactics = get_style_tactics(style, memory_tactics=memory_tactics)
         if not tactics:
-            return {"error": f"No style tactics found for '{style}'", "code": "NOT_FOUND"}
+            return {
+                "error": (
+                    f"No style tactics found for '{style}' — neither in the "
+                    f"built-in library nor in saved memories."
+                ),
+                "code": "NOT_FOUND",
+            }
         tactic_dicts = [t.to_dict() for t in tactics]
         profile = build_style_reference_profile(tactic_dicts)
     else:
@@ -210,9 +245,17 @@ def plan_reference_moves(
             return comparison
         profile = build_audio_reference_profile(comparison)
     elif style:
-        tactics = get_style_tactics(style)
+        # BUG-B19: hydrate from saved memories too
+        memory_tactics = _fetch_memory_tactics(style)
+        tactics = get_style_tactics(style, memory_tactics=memory_tactics)
         if not tactics:
-            return {"error": f"No style tactics found for '{style}'", "code": "NOT_FOUND"}
+            return {
+                "error": (
+                    f"No style tactics found for '{style}' — neither in the "
+                    f"built-in library nor in saved memories."
+                ),
+                "code": "NOT_FOUND",
+            }
         tactic_dicts = [t.to_dict() for t in tactics]
         profile = build_style_reference_profile(tactic_dicts)
     else:

package/mcp_server/runtime/capability_probe.py

@@ -9,6 +9,9 @@ from __future__ import annotations
 import os
 from pathlib import Path
 from typing import Any
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 def probe_capabilities(
@@ -27,8 +30,9 @@ def probe_capabilities(
         try:
             info = ableton.send_command("ping")
             ableton_ok = info is not None
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("probe_capabilities failed: %s", exc)
+
     report["ableton"] = {
         "status": "ok" if ableton_ok else "unavailable",
         "detail": "TCP 9878 connection active" if ableton_ok else "Not connected",
@@ -40,8 +44,9 @@ def probe_capabilities(
         try:
             info = ableton.send_command("get_session_info")
             live_version_str = info.get("live_version", "12.0.0")
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("probe_capabilities failed: %s", exc)
+
     from .live_version import LiveVersionCapabilities
     version_caps = LiveVersionCapabilities.from_version_string(live_version_str)
     report["live_version"] = {
@@ -75,6 +80,7 @@ def probe_capabilities(
     numpy_ok = False
     try:
         import numpy  # noqa: F401
+
         numpy_ok = True
     except ImportError:
         pass

package/mcp_server/runtime/execution_router.py

@@ -50,6 +50,56 @@ MCP_TOOLS: frozenset[str] = frozenset({
 })
 
 
+# Tools that observe session state without mutating it. Executors use this set
+# to separate "apply pass" steps (writes) from "verification reads". Counting
+# reads toward applied_count and then calling undo that many times walks back
+# earlier user edits — see preview_studio/tools.py and experiment/engine.py.
+READ_ONLY_TOOLS: frozenset[str] = frozenset({
+    "get_track_meters",
+    "get_master_spectrum",
+    "get_master_meters",
+    "get_master_rms",
+    "get_mix_snapshot",
+    "get_session_info",
+    "get_track_info",
+    "get_track_routing",
+    "get_return_tracks",
+    "get_device_info",
+    "get_device_parameters",
+    "get_clip_info",
+    "get_notes",
+    "get_arrangement_notes",
+    "get_arrangement_clips",
+    "get_scenes_info",
+    "get_scene_matrix",
+    "get_playing_clips",
+    "get_cue_points",
+    "get_rack_chains",
+    "get_clip_automation",
+    "analyze_mix",
+    "get_emotional_arc",
+    "get_motif_graph",
+    "get_session_diagnostics",
+    "ping",
+})
+
+
+def filter_apply_steps(steps: list) -> list:
+    """Return only the steps that mutate session state.
+
+    Read-only steps (meters, spectrum, info) do not create undo points in
+    Ableton. Including them in an applied_count and then undoing that many
+    times walks back earlier user edits. Always filter writes from reads
+    before the apply pass and before the undo loop.
+    """
+    out = []
+    for s in steps:
+        tool = (s.get("tool") if isinstance(s, dict) else getattr(s, "tool", "")) or ""
+        if tool and tool not in READ_ONLY_TOOLS:
+            out.append(s)
+    return out
+
+
 @dataclass
 class ExecutionResult:
     """Result of executing a single plan step."""

package/mcp_server/runtime/mcp_dispatch.py

@@ -14,18 +14,33 @@ To add a new in-process tool to plans:
   2. Add an _adapter function here that imports the real implementation and
      adapts its kwargs from a plan-style params dict.
   3. Register the adapter in build_mcp_dispatch_registry.
+
+Every entry in MCP_TOOLS must have a matching adapter here — the contract
+test tests/test_mcp_dispatch_contract.py enforces this.
 """
 
 from __future__ import annotations
 
+import inspect
 from typing import Any, Callable
 
 
-async def _load_sample_to_simpler(params: dict, ctx: Any = None) -> dict:
-    """Adapter for mcp_server.tools.analyzer.load_sample_to_simpler.
+async def _call(fn, ctx, params: dict) -> Any:
+    """Call an MCP tool with ctx + kwargs from a plan params dict.
 
-    Accepts the plan-step params dict and unpacks into the real tool's kwargs.
+    Filters params to the tool's declared parameters, awaits if coroutine.
+    Unknown params are dropped silently — plans may carry extra metadata.
     """
+    sig = inspect.signature(fn)
+    accepted = set(sig.parameters.keys())
+    kwargs = {k: v for k, v in params.items() if k in accepted}
+    result = fn(ctx, **kwargs)
+    if inspect.isawaitable(result):
+        result = await result
+    return result
+
+
+async def _load_sample_to_simpler(params: dict, ctx: Any = None) -> dict:
     from ..tools.analyzer import load_sample_to_simpler
     return await load_sample_to_simpler(
         ctx,
@@ -35,12 +50,69 @@ async def _load_sample_to_simpler(params: dict, ctx: Any = None) -> dict:
     )
 
 
+async def _apply_automation_shape(params: dict, ctx: Any = None) -> dict:
+    from ..tools.automation import apply_automation_shape
+    return await _call(apply_automation_shape, ctx, params)
+
+
+async def _apply_gesture_template(params: dict, ctx: Any = None) -> dict:
+    from ..tools.composition import apply_gesture_template
+    return await _call(apply_gesture_template, 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_master_spectrum(params: dict, ctx: Any = None) -> dict:
+    from ..tools.analyzer import get_master_spectrum
+    return await _call(get_master_spectrum, ctx, params)
+
+
+async def _get_emotional_arc(params: dict, ctx: Any = None) -> dict:
+    from ..tools.research import get_emotional_arc
+    return await _call(get_emotional_arc, ctx, params)
+
+
+async def _get_motif_graph(params: dict, ctx: Any = None) -> dict:
+    from ..tools.motif import get_motif_graph
+    return await _call(get_motif_graph, ctx, params)
+
+
+async def _generate_m4l_effect(params: dict, ctx: Any = None) -> dict:
+    from ..device_forge.tools import generate_m4l_effect
+    return await _call(generate_m4l_effect, ctx, params)
+
+
+async def _install_m4l_device(params: dict, ctx: Any = None) -> dict:
+    from ..device_forge.tools import install_m4l_device
+    return await _call(install_m4l_device, ctx, params)
+
+
+async def _list_genexpr_templates(params: dict, ctx: Any = None) -> dict:
+    from ..device_forge.tools import list_genexpr_templates
+    return await _call(list_genexpr_templates, ctx, params)
+
+
 def build_mcp_dispatch_registry() -> dict[str, Callable]:
     """Return the canonical registry of MCP-only tools for plan execution.
 
     Callers (typically the server lifespan init) should call this once and
     pass the registry to execute_plan_steps_async via the mcp_registry kwarg.
+
+    INVARIANT: the set of keys here must equal MCP_TOOLS in execution_router.
+    Enforced by tests/test_mcp_dispatch_contract.py.
     """
     return {
         "load_sample_to_simpler": _load_sample_to_simpler,
+        "apply_automation_shape": _apply_automation_shape,
+        "apply_gesture_template": _apply_gesture_template,
+        "analyze_mix": _analyze_mix,
+        "get_master_spectrum": _get_master_spectrum,
+        "get_emotional_arc": _get_emotional_arc,
+        "get_motif_graph": _get_motif_graph,
+        "generate_m4l_effect": _generate_m4l_effect,
+        "install_m4l_device": _install_m4l_device,
+        "list_genexpr_templates": _list_genexpr_templates,
     }

package/mcp_server/runtime/remote_commands.py

@@ -21,18 +21,20 @@ REMOTE_COMMANDS: frozenset[str] = frozenset({
     "set_track_solo", "set_track_arm", "stop_track_clips",
     "set_group_fold", "set_track_input_monitoring",
     "get_freeze_status", "freeze_track", "flatten_track",
-    # clips (11)
+    # clips (12)
     "get_clip_info", "create_clip", "delete_clip", "duplicate_clip",
     "fire_clip", "stop_clip", "set_clip_name", "set_clip_color",
     "set_clip_loop", "set_clip_launch", "set_clip_warp_mode",
+    "set_clip_pitch",
     # notes (8)
     "add_notes", "get_notes", "remove_notes", "remove_notes_by_id",
     "modify_notes", "duplicate_notes", "transpose_notes", "quantize_clip",
-    # mixing (11)
+    # mixing (12)
     "set_track_volume", "set_track_pan", "set_track_send",
     "get_return_tracks", "get_master_track", "set_master_volume",
     "get_track_routing", "get_track_meters", "get_master_meters",
     "get_mix_snapshot", "set_track_routing",
+    "set_compressor_sidechain",  # BUG-A3 — Python LOM path (was M4L bridge)
     # scenes (12)
     "get_scenes_info", "create_scene", "delete_scene", "duplicate_scene",
     "fire_scene", "set_scene_name", "set_scene_color", "set_scene_tempo",

package/mcp_server/runtime/tools.py

@@ -12,6 +12,9 @@ from fastmcp import Context
 from ..server import mcp
 from ..memory.technique_store import TechniqueStore
 from .capability_state import build_capability_state
+import logging
+
+logger = logging.getLogger(__name__)
 
 _memory_store = TechniqueStore()
 
@@ -31,7 +34,8 @@ def get_capability_state(ctx: Context) -> dict:
     try:
         result = ableton.send_command("get_session_info")
         session_ok = isinstance(result, dict) and "error" not in result
-    except Exception:
+    except Exception as exc:
+        logger.debug("get_capability_state failed: %s", exc)
         session_ok = False
 
     # ── Probe analyzer (M4L bridge) ─────────────────────────────────
@@ -49,7 +53,8 @@ def get_capability_state(ctx: Context) -> dict:
     try:
         _memory_store.list_techniques(limit=1)
         memory_ok = True
-    except Exception:
+    except Exception as exc:
+        logger.debug("get_capability_state failed: %s", exc)
         memory_ok = False
 
     # ── Web / FluCoMa — not probed live, default to False ───────────
@@ -180,6 +185,7 @@ def get_session_kernel(
     if request_text.strip():
         try:
             from ..tools._conductor import classify_request
+
             plan = classify_request(request_text)
             kernel.recommended_engines = [r.engine for r in plan.routes[:3]]
             kernel.recommended_workflow = plan.workflow_mode