livepilot 1.26.2 → 1.27.1

package/mcp_server/runtime/tools.py

@@ -7,10 +7,11 @@ Tools:
 
 from __future__ import annotations
 
-import importlib.util
 import logging
+import os
+from pathlib import Path
 import urllib.request
-from typing import Optional
+from typing import Any, Optional
 
 from fastmcp import Context
 
@@ -21,6 +22,14 @@ from .capability_state import build_capability_state
 logger = logging.getLogger(__name__)
 
 _memory_store = TechniqueStore()
+_FLUCOMA_STREAM_KEYS = (
+    "spectral_shape",
+    "mel_bands",
+    "chroma",
+    "onset",
+    "novelty",
+    "loudness",
+)
 
 
 # ── Capability probes ──────────────────────────────────────────────────
@@ -51,21 +60,296 @@ def _probe_web(timeout: float = 0.5) -> bool:
         return False
 
 
-def _probe_flucoma() -> bool:
-    """Check whether the ``flucoma`` Python package is importable.
+def _flucoma_package_dirs() -> list[Path]:
+    """Return likely Max package locations for FluCoMa."""
+    home = Path.home()
+    if os.name == "nt":
+        docs = Path(os.environ.get("USERPROFILE", str(home))) / "Documents"
+    else:
+        docs = home / "Documents"
+    return [
+        docs / "Max 9" / "Packages" / "FluidCorpusManipulation",
+        docs / "Max 8" / "Packages" / "FluidCorpusManipulation",
+    ]
 
-    Uses ``importlib.util.find_spec`` so no import side-effects fire
-    (matching the pattern already used for optional capability probes
-    elsewhere in the codebase). Returns False if the package is missing
-    or if the spec lookup itself raises.
+
+def _probe_flucoma_package() -> bool:
+    """Check whether the FluCoMa Max package exists on disk.
+
+    LivePilot's real-time FluCoMa support is Max-for-Live based. There is
+    no required Python package named ``flucoma``; probing importability
+    caused false ``flucoma_not_installed`` reports on healthy systems.
     """
     try:
-        return importlib.util.find_spec("flucoma") is not None
+        for package_dir in _flucoma_package_dirs():
+            if not package_dir.exists():
+                continue
+            if (package_dir / "package-info.json").exists():
+                return True
+            externals = package_dir / "externals"
+            if externals.exists() and any(externals.glob("fluid.*")):
+                return True
+            return True
+        return False
     except Exception as exc:  # noqa: BLE001
-        logger.debug("_probe_flucoma failed: %s", exc)
+        logger.debug("_probe_flucoma_package failed: %s", exc)
         return False
 
 
+def _probe_flucoma(spectral=None) -> dict:
+    """Probe the Max/bridge-backed FluCoMa runtime.
+
+    ``available`` means at least one FluCoMa stream has reached the
+    spectral cache. ``device_loaded`` means the external package appears
+    installed (or streams prove it is working from a frozen analyzer).
+    """
+    package_installed = _probe_flucoma_package()
+    bridge_connected = bool(
+        spectral is not None and getattr(spectral, "is_connected", False)
+    )
+
+    streams: dict[str, bool] = {}
+    if bridge_connected:
+        for key in _FLUCOMA_STREAM_KEYS:
+            try:
+                streams[key] = spectral.get(key) is not None
+            except Exception as exc:  # noqa: BLE001
+                logger.debug("_probe_flucoma stream %s failed: %s", key, exc)
+                streams[key] = False
+
+    active_streams = sum(1 for present in streams.values() if present)
+    available = active_streams > 0
+    device_loaded = package_installed or available
+
+    reasons: list[str] = []
+    if not device_loaded:
+        reasons.append("flucoma_not_installed")
+    if not bridge_connected:
+        reasons.append("flucoma_bridge_unavailable")
+    elif not available:
+        reasons.append("flucoma_no_streams")
+
+    return {
+        "available": available,
+        "device_loaded": device_loaded,
+        "bridge_connected": bridge_connected,
+        "active_streams": active_streams,
+        "streams": streams,
+        "reasons": reasons,
+    }
+
+
+def _normalize_flucoma_probe(raw) -> dict:
+    """Back-compat shim for tests/extensions that monkeypatch a bool probe."""
+    if isinstance(raw, bool):
+        return {
+            "available": raw,
+            "device_loaded": raw,
+            "reasons": [] if raw else ["flucoma_not_installed"],
+        }
+    if isinstance(raw, dict):
+        available = bool(raw.get("available", False))
+        return {
+            **raw,
+            "available": available,
+            "device_loaded": bool(raw.get("device_loaded", available)),
+            "reasons": list(raw.get("reasons", [])),
+        }
+    return {
+        "available": False,
+        "device_loaded": False,
+        "reasons": ["flucoma_probe_failed"],
+    }
+
+
+def _run_flucoma_probe(spectral=None) -> dict:
+    try:
+        return _normalize_flucoma_probe(_probe_flucoma(spectral))
+    except TypeError:
+        # Older tests monkeypatch _probe_flucoma as a no-arg callable.
+        return _normalize_flucoma_probe(_probe_flucoma())
+
+
+def _session_info(ableton) -> dict:
+    try:
+        info = ableton.send_command("get_session_info")
+        return info if isinstance(info, dict) else {}
+    except Exception as exc:  # noqa: BLE001
+        logger.debug("_session_info probe failed: %s", exc)
+        return {}
+
+
+def _live_version_from_session(session_info: dict) -> str:
+    version = session_info.get("live_version")
+    return str(version) if version else "12.0.0"
+
+
+def _normalize_probe_surface(
+    raw: Any,
+    *,
+    default_reason: str,
+    default_mode: str = "manual_only",
+) -> dict:
+    if isinstance(raw, dict):
+        mode = str(raw.get("mode") or default_mode)
+        available = bool(raw.get("available", mode in {"readable", "routable", "callable"}))
+        reasons = list(raw.get("reasons") or [])
+        if not available and not reasons:
+            reasons.append(default_reason)
+        return {
+            "mode": mode,
+            "available": available,
+            "reasons": reasons,
+            "observed": dict(raw.get("observed") or {}),
+        }
+    return {
+        "mode": default_mode,
+        "available": False,
+        "reasons": [default_reason],
+        "observed": {},
+    }
+
+
+def _probe_link_audio_surface(ableton, session_info: Optional[dict] = None) -> dict:
+    """Read-only Link Audio surface probe.
+
+    Current Live 12.4 builds expose Link Audio as product UX, but no stable
+    Remote Script/M4L routing contract has been proven. This helper looks for
+    explicit evidence if future Remote Scripts surface it; otherwise it reports
+    manual_only with a reason instead of claiming support from version alone.
+    """
+    info = session_info or _session_info(ableton)
+    observed = {
+        "peers_visible": bool(info.get("link_audio_peers") or info.get("link_peers")),
+        "inputs_visible": bool(info.get("link_audio_inputs") or info.get("audio_inputs")),
+        "routing_visible": bool(info.get("link_audio_routing")),
+    }
+    if observed["peers_visible"] and observed["inputs_visible"] and observed["routing_visible"]:
+        return {
+            "mode": "routable",
+            "available": True,
+            "reasons": [],
+            "observed": observed,
+        }
+    if observed["peers_visible"] or observed["inputs_visible"]:
+        return {
+            "mode": "readable",
+            "available": True,
+            "reasons": [],
+            "observed": observed,
+        }
+    return {
+        "mode": "manual_only",
+        "available": False,
+        "reasons": ["link_audio_not_exposed"],
+        "observed": observed,
+    }
+
+
+def _probe_stem_workflow_surface(ableton, session_info: Optional[dict] = None) -> dict:
+    """Read-only selected-time stem workflow probe.
+
+    This intentionally does not invoke stem separation. It only reports
+    callable evidence if a future Remote Script/M4L surface advertises a
+    stable command path.
+    """
+    info = session_info or _session_info(ableton)
+    callable_paths = list(info.get("stem_callable_paths") or [])
+    if callable_paths:
+        return {
+            "mode": "callable",
+            "available": True,
+            "reasons": [],
+            "observed": {"callable_paths": callable_paths},
+        }
+    return {
+        "mode": "manual_only",
+        "available": False,
+        "reasons": ["stem_command_not_observable"],
+        "observed": {"callable_paths": []},
+    }
+
+
+def _probe_live_12_4_domain(
+    *,
+    ableton,
+    session_info: dict,
+    feature_available: bool,
+    surface_probe,
+    default_reason: str,
+) -> dict:
+    live_version = _live_version_from_session(session_info)
+    if not feature_available:
+        return {
+            "ok": True,
+            "live_version": live_version,
+            "mode": "unavailable",
+            "available": False,
+            "reasons": ["live_version_below_12_4"],
+            "observed": {},
+        }
+    try:
+        surface = _normalize_probe_surface(
+            surface_probe(ableton, session_info=session_info),
+            default_reason=default_reason,
+        )
+    except Exception as exc:  # noqa: BLE001
+        logger.debug("Live 12.4 surface probe failed: %s", exc)
+        surface = {
+            "mode": "manual_only",
+            "available": False,
+            "reasons": [f"probe_failed: {type(exc).__name__}"],
+            "observed": {},
+        }
+    return {
+        "ok": True,
+        "live_version": live_version,
+        **surface,
+    }
+
+
+def _probe_link_audio_domain(ableton, session_info: dict) -> dict:
+    from .live_version import LiveVersionCapabilities
+
+    caps = LiveVersionCapabilities.from_session_info(session_info)
+    return _probe_live_12_4_domain(
+        ableton=ableton,
+        session_info=session_info,
+        feature_available=caps.has_link_audio,
+        surface_probe=_probe_link_audio_surface,
+        default_reason="link_audio_not_exposed",
+    )
+
+
+def _probe_stem_workflow_domain(ableton, session_info: dict) -> dict:
+    from .live_version import LiveVersionCapabilities
+
+    caps = LiveVersionCapabilities.from_session_info(session_info)
+    return _probe_live_12_4_domain(
+        ableton=ableton,
+        session_info=session_info,
+        feature_available=caps.has_stem_time_selection,
+        surface_probe=_probe_stem_workflow_surface,
+        default_reason="stem_command_not_observable",
+    )
+
+
+@mcp.tool()
+def probe_link_audio(ctx: Context) -> dict:
+    """Read-only probe for Live 12.4 Link Audio MCP controllability."""
+    ableton = ctx.lifespan_context["ableton"]
+    session_info = _session_info(ableton)
+    return _probe_link_audio_domain(ableton, session_info)
+
+
+@mcp.tool()
+def probe_stem_workflow(ctx: Context) -> dict:
+    """Read-only probe for Live 12.4 selected-time stem workflow support."""
+    ableton = ctx.lifespan_context["ableton"]
+    session_info = _session_info(ableton)
+    return _probe_stem_workflow_domain(ableton, session_info)
+
+
 @mcp.tool()
 def get_capability_state(ctx: Context) -> dict:
     """Probe the runtime and return a capability state snapshot.
@@ -77,13 +361,8 @@ def get_capability_state(ctx: Context) -> dict:
     spectral = ctx.lifespan_context.get("spectral")
 
     # ── Probe session ───────────────────────────────────────────────
-    session_ok = False
-    try:
-        result = ableton.send_command("get_session_info")
-        session_ok = isinstance(result, dict) and "error" not in result
-    except Exception as exc:
-        logger.debug("get_capability_state failed: %s", exc)
-        session_ok = False
+    session_info = _session_info(ableton)
+    session_ok = bool(session_info) and "error" not in session_info
 
     # ── Probe analyzer (M4L bridge) ─────────────────────────────────
     analyzer_ok = False
@@ -109,8 +388,12 @@ def get_capability_state(ctx: Context) -> dict:
     # a curated research corpus is installed (see ``research`` domain).
     web_ok = _probe_web()
 
-    # ── FluCoMa — optional import via find_spec (no side effects) ───
-    flucoma_ok = _probe_flucoma()
+    # ── FluCoMa — Max package + live bridge streams ─────────────────
+    flucoma_probe = _run_flucoma_probe(spectral)
+
+    # ── Live 12.4 probe-first surfaces ──────────────────────────────
+    link_probe = _probe_link_audio_domain(ableton, session_info)
+    stem_probe = _probe_stem_workflow_domain(ableton, session_info)
 
     state = build_capability_state(
         session_ok=session_ok,
@@ -118,7 +401,13 @@ def get_capability_state(ctx: Context) -> dict:
         analyzer_fresh=analyzer_fresh,
         memory_ok=memory_ok,
         web_ok=web_ok,
-        flucoma_ok=flucoma_ok,
+        flucoma_ok=flucoma_probe["available"],
+        flucoma_device_loaded=flucoma_probe["device_loaded"],
+        flucoma_reasons=flucoma_probe["reasons"],
+        link_audio_mode=link_probe["mode"],
+        link_audio_reasons=link_probe["reasons"],
+        stem_workflow_mode=stem_probe["mode"],
+        stem_workflow_reasons=stem_probe["reasons"],
     )
 
     return state.to_dict()
@@ -134,6 +423,7 @@ def get_session_kernel(
     creativity_profile: str = "",
     sacred_elements: Optional[list] = None,
     synth_hints: Optional[dict] = None,
+    operation_profile: str = "studio_deep",
 ) -> dict:
     """Build the unified turn snapshot for V2 orchestration.
 
@@ -159,6 +449,9 @@ def get_session_kernel(
       synth_hints: focus hints for synthesis_brain; shape is open in PR2
         and firms up in PR9. Typical keys: track_indices, device_paths,
         target_timbre, preferred_devices.
+      operation_profile: safety/intent posture for this turn. Known values:
+        safe_live, studio_deep, arrangement_build, sound_design_deep,
+        release_audit.
 
     Returns: SessionKernel dict with kernel_id, session topology, capabilities,
     memory context, routing hints, and (if provided) creative controls.
@@ -183,7 +476,9 @@ def get_session_kernel(
     # does, and propagate through. Without this the kernel's capability view
     # lies to orchestration planners.
     web_ok = _probe_web()
-    flucoma_ok = _probe_flucoma()
+    flucoma_probe = _run_flucoma_probe(spectral)
+    link_probe = _probe_link_audio_domain(ableton, session_info if isinstance(session_info, dict) else {})
+    stem_probe = _probe_stem_workflow_domain(ableton, session_info if isinstance(session_info, dict) else {})
 
     # v1.17.4: probe memory the same way too. Previously memory_ok=True was
     # hardcoded — if the store raised, the kernel still reported memory
@@ -201,7 +496,13 @@ def get_session_kernel(
         analyzer_fresh=analyzer_fresh,
         memory_ok=memory_ok,
         web_ok=web_ok,
-        flucoma_ok=flucoma_ok,
+        flucoma_ok=flucoma_probe["available"],
+        flucoma_device_loaded=flucoma_probe["device_loaded"],
+        flucoma_reasons=flucoma_probe["reasons"],
+        link_audio_mode=link_probe["mode"],
+        link_audio_reasons=link_probe["reasons"],
+        stem_workflow_mode=stem_probe["mode"],
+        stem_workflow_reasons=stem_probe["reasons"],
     )
 
     # Optional subcomponents — degrade gracefully, but reach into the SAME
@@ -286,6 +587,7 @@ def get_session_kernel(
         anti_preferences=anti_prefs,
         freshness=freshness,
         creativity_profile=creativity_profile,
+        operation_profile=operation_profile,
         sacred_elements=sacred_elements,
         synth_hints=synth_hints,
     )

package/mcp_server/sample_engine/critics.py

@@ -301,9 +301,13 @@ def run_vibe_fit_critic(
             recommendation="No taste evidence yet — neutral score",
         )
 
-    # Compute energy proxy from sample characteristics (0.0 - 1.0)
-    # brightness and transient_density are both 0.0-1.0 range
-    energy = (profile.brightness + profile.transient_density) / 2.0
+    # Compute energy proxy from sample characteristics (0.0 - 1.0).
+    # brightness is already a 0.0-1.0 fraction, but transient_density is peaks
+    # PER SECOND (unbounded). Normalize it through a saturating curve before
+    # averaging so a busy break does not pin the proxy to 1.0 for every sample.
+    # ~12 peaks/s (busy 16ths) maps to ~1.0.
+    transient_norm = max(0.0, min(1.0, profile.transient_density / 12.0))
+    energy = (profile.brightness + transient_norm) / 2.0
     energy = max(0.0, min(1.0, energy))
 
     # Compare against novelty_band as taste proxy

package/mcp_server/sample_engine/slice_workflow.py

@@ -12,8 +12,9 @@ from __future__ import annotations
 
 import hashlib
 
-# Simpler maps slices to MIDI notes starting at C3 (60)
-SLICE_BASE_NOTE = 60
+# Simpler maps slices to MIDI notes starting at C1 (36): slice N -> pitch 36+N.
+# Notes at 60+ (C3) trigger no slice and produce silence.
+SLICE_BASE_NOTE = 36
 
 
 def plan_slice_steps(

package/mcp_server/sample_engine/tools.py

@@ -6,6 +6,7 @@ direct Splice online catalog hunt/download via the gRPC client.
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import os
 from typing import Optional
@@ -57,7 +58,11 @@ async def analyze_sample(
         return {"error": "Could not determine file path — provide file_path directly"}
 
     source = "session_clip" if track_index is not None else "filesystem"
-    profile = build_profile_from_filename(file_path, source=source)
+    # Offload audio decode + numpy FFT off the event loop (heavy CPU/IO).
+    loop = asyncio.get_running_loop()
+    profile = await loop.run_in_executor(
+        None, build_profile_from_filename, file_path, source
+    )
     return profile.to_dict()
 
 
@@ -86,6 +91,11 @@ def evaluate_sample_fit(
     song_key = None
     session_tempo = 120.0
     existing_roles: list[str] = []
+    # Map track index -> name so the key-detection loop below can look a
+    # track's name up by its real index. existing_roles is a *packed*
+    # list (unnamed/errored tracks are skipped), so indexing it by track
+    # index misaligns names with the clip that produced the notes.
+    track_names_by_index: dict[int, str] = {}
 
     try:
         ableton = ctx.lifespan_context["ableton"]
@@ -100,6 +110,7 @@ def evaluate_sample_fit(
                 name = track_info.get("name", "").lower()
                 if name:
                     existing_roles.append(name)
+                    track_names_by_index[i] = name
             except Exception as exc:
                 logger.debug("get_track_info(%d) skipped: %s", i, exc)
                 continue
@@ -147,9 +158,7 @@ def evaluate_sample_fit(
                 ) else []
                 if not notes:
                     continue
-                track_name = (
-                    existing_roles[i] if i < len(existing_roles) else ""
-                )
+                track_name = track_names_by_index.get(i, "")
                 if harmonic_score(notes, track_name) >= 0.3:
                     harmonic_pool.extend(notes)
 
@@ -189,7 +198,11 @@ def evaluate_sample_fit(
         recommended_intent=intent,
         surgeon_plan=surgeon_plan,
         alchemist_plan=alchemist_plan,
-        warnings=[c.recommendation for c in critics.values() if c.score < 0.5],
+        warnings=[
+            c.recommendation
+            for c in critics.values()
+            if getattr(c, "available", True) and c.score < 0.5
+        ],
     )
     return report.to_dict()
 
@@ -316,12 +329,16 @@ async def search_samples(
         if not used_grpc:
             splice = SpliceSource()
             if splice.enabled:
-                splice_results = splice.search(
-                    query=query,
-                    max_results=max_results,
-                    key=key,
-                    bpm_min=bpm_min,
-                    bpm_max=bpm_max,
+                # Offload blocking SQLite query off the event loop.
+                splice_results = await asyncio.get_running_loop().run_in_executor(
+                    None,
+                    lambda: splice.search(
+                        query=query,
+                        max_results=max_results,
+                        key=key,
+                        bpm_min=bpm_min,
+                        bpm_max=bpm_max,
+                    ),
                 )
                 for candidate in splice_results:
                     d = candidate.to_dict()
@@ -335,12 +352,16 @@ async def search_samples(
             browser = BrowserSource()
             for category in browser.DEFAULT_CATEGORIES:
                 try:
-                    search_result = ableton.send_command("search_browser", {
-                        "path": category,
-                        "name_filter": query,
-                        "loadable_only": True,
-                        "max_results": max_results,
-                    })
+                    # Offload blocking TCP round-trip off the event loop.
+                    search_result = await asyncio.get_running_loop().run_in_executor(
+                        None,
+                        lambda: ableton.send_command("search_browser", {
+                            "path": category,
+                            "name_filter": query,
+                            "loadable_only": True,
+                            "max_results": max_results,
+                        }),
+                    )
                     raw = search_result.get("results", [])
                     parsed = browser.parse_results(raw, category)
                     for candidate in parsed:
@@ -359,7 +380,10 @@ async def search_samples(
             "~/Music", "~/Documents/Samples",
             "~/Documents/LivePilot/downloads",
         ])
-        fs_results = fs.search(query, max_results=max_results)
+        # Offload blocking recursive filesystem scan off the event loop.
+        fs_results = await asyncio.get_running_loop().run_in_executor(
+            None, lambda: fs.search(query, max_results=max_results)
+        )
         for candidate in fs_results:
             d = candidate.to_dict()
             d["source_priority"] = 3
@@ -1049,10 +1073,18 @@ async def splice_download_sample(
     if copy_to_user_library:
         dest_dir = os.path.expanduser(_SPLICE_USER_LIB_DEST)
         try:
-            os.makedirs(dest_dir, exist_ok=True)
             dest_path = os.path.join(dest_dir, os.path.basename(local_path))
-            if not os.path.exists(dest_path):
-                shutil.copy2(local_path, dest_path)
+
+            def _copy_into_user_library():
+                os.makedirs(dest_dir, exist_ok=True)
+                if not os.path.exists(dest_path):
+                    shutil.copy2(local_path, dest_path)
+
+            # Offload the blocking filesystem copy off the event loop,
+            # mirroring the run_in_executor used in splice_preview_sample.
+            await asyncio.get_running_loop().run_in_executor(
+                None, _copy_into_user_library
+            )
             response["user_library_path"] = dest_path
             # URI format Ableton uses for user_library samples
             response["browser_uri"] = (

package/mcp_server/song_brain/builder.py

@@ -566,7 +566,23 @@ def detect_identity_drift(
         drift.drift_score += 0.2 * len(lost)
 
     # Energy arc shift
-    if before.energy_arc and after.energy_arc:
+    # Align on section_id rather than list position: inserting/removing/
+    # renaming-to-empty a scene shifts energy_arc indices (the BUG-B12 skip
+    # drops empty sections), so a positional diff fabricates drift on every
+    # section after the change. Diffing the shared section_ids compares like
+    # with like and is stable under reordering/insertion.
+    before_energy = {s.section_id: s.energy_level for s in before.section_purposes}
+    after_energy = {s.section_id: s.energy_level for s in after.section_purposes}
+    shared_ids = before_energy.keys() & after_energy.keys()
+    if shared_ids:
+        diff = sum(
+            abs(before_energy[sid] - after_energy[sid]) for sid in shared_ids
+        ) / len(shared_ids)
+        drift.energy_arc_shift = round(diff, 3)
+        drift.drift_score += diff * 0.2
+    elif before.energy_arc and after.energy_arc:
+        # Fallback for snapshots that carry energy_arc but no section_purposes
+        # (e.g. older brains): keep the legacy positional comparison.
         min_len = min(len(before.energy_arc), len(after.energy_arc))
         if min_len > 0:
             diff = sum(

package/mcp_server/sound_design/tools.py

@@ -408,7 +408,7 @@ def _cross_engine_hint_for_track(
         return None
     track_issues = [
         i for i in mix_issues
-        if getattr(i, "track_index", None) == track_index
+        if track_index in (getattr(i, "affected_tracks", []) or [])
     ]
     if not track_issues:
         return None