livepilot 1.23.6 → 1.25.0

package/mcp_server/audit/tools.py

@@ -0,0 +1,232 @@
+"""audit_layer — single-tool replacement for the §5 layer-precision checklist.
+
+Fetches once, runs 8 server-side checks, returns a structured report with
+ranked fixes. Replaces the manual sequence:
+
+    solo + get_master_spectrum
+    get_notes (per clip) + sequence critique
+    get_track_info (pan/width)
+    get_masking_report (filter for this track)
+    get_device_parameters (modulation routings)
+    get_device_parameters (default-detection)
+    get_simpler_slices + classify_simpler_slices
+    track_info.devices (effects coverage)
+
+…which was 8+ tool calls of LLM-driven ceremony. Now: one call.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Optional
+
+from fastmcp import Context
+
+from ..server import mcp
+from . import checks
+
+logger = logging.getLogger(__name__)
+
+
+def _get_ableton(ctx: Context):
+    return ctx.lifespan_context["ableton"]
+
+
+def _safe_call(ableton, command: str, params: dict | None = None) -> dict | None:
+    try:
+        return ableton.send_command(command, params or {})
+    except Exception as exc:
+        logger.debug("audit_layer: %s failed: %s", command, exc)
+        return None
+
+
+def _fetch_notes_for_clips(ableton, track_index: int, clip_slots: list[dict]) -> list[list[dict]]:
+    """Pull notes for every populated clip slot. Skips empty/audio clips."""
+    out: list[list[dict]] = []
+    for slot in clip_slots or []:
+        if not slot.get("has_clip"):
+            continue
+        clip_index = slot.get("index")
+        if clip_index is None:
+            continue
+        result = _safe_call(ableton, "get_notes", {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "from_pitch": 0,
+            "pitch_span": 128,
+            "from_time": 0.0,
+        })
+        if result and "notes" in result:
+            out.append(result["notes"])
+    return out
+
+
+def _count_wavetable_routings(ableton, track_index: int, devices: list[dict]) -> int:
+    """Sum non-zero mod-matrix routings across any Wavetable on the track."""
+    total = 0
+    for i, dev in enumerate(devices or []):
+        if dev.get("class_name") != "Wavetable":
+            continue
+        mod = _safe_call(ableton, "get_wavetable_mod_matrix", {
+            "track_index": track_index,
+            "device_index": i,
+        })
+        if not mod:
+            continue
+        # Response shape: {"matrix": [{"source": ..., "target": ..., "amount": ...}, ...]}
+        entries = mod.get("matrix") or mod.get("entries") or []
+        for e in entries:
+            if abs(float(e.get("amount", 0.0))) > 0.001:
+                total += 1
+    return total
+
+
+def _has_clip_automation(ableton, track_index: int, clip_slots: list[dict]) -> bool:
+    """Check if any clip on this track has automation envelopes."""
+    for slot in clip_slots or []:
+        if not slot.get("has_clip"):
+            continue
+        clip_index = slot.get("index")
+        if clip_index is None:
+            continue
+        result = _safe_call(ableton, "get_clip_automation", {
+            "track_index": track_index,
+            "clip_index": clip_index,
+        })
+        if not result:
+            continue
+        envelopes = result.get("envelopes") or result.get("automation") or []
+        if envelopes:
+            return True
+    return False
+
+
+def _maybe_get_timbre_fingerprint(ctx: Context, track_index: int) -> dict | None:
+    """Pull a per-track timbre fingerprint via the synthesis_brain timbre helper.
+
+    Returns None when the M4L bridge is offline or no fingerprint is available.
+    Does NOT solo the track — uses cached spectral data only.
+    """
+    try:
+        from ..synthesis_brain.timbre import extract_timbre_fingerprint  # type: ignore
+    except Exception:
+        return None
+    try:
+        result = extract_timbre_fingerprint(ctx, track_index)  # type: ignore[arg-type]
+        if isinstance(result, dict) and result.get("bands"):
+            return result
+    except Exception as exc:
+        logger.debug("audit_layer timbre fetch failed: %s", exc)
+    return None
+
+
+@mcp.tool()
+def audit_layer(
+    ctx: Context,
+    track_index: int,
+    role: Optional[str] = None,
+    include_masking: bool = True,
+    include_timbre: bool = False,
+) -> dict:
+    """Run the §5 layer-precision audit on a single track in one call.
+
+    Replaces 8 manual checks (timbre, sequence, stereo, masking, modulation,
+    params, samples, effects) with one server-side aggregation. Returns
+    structured report with PASS/WARN/FAIL per check + ranked fixes.
+
+    Args:
+        track_index: Track to audit.
+        role: Optional role override ("kick"/"snare"/"hat"/"perc"/"bass"/
+            "pad"/"lead"/"atmos"/"vox"/"fx"). If omitted, inferred from
+            track name + first instrument class.
+        include_masking: If True (default), pulls cross-track masking report
+            and filters for this track. Adds ~200-600ms.
+        include_timbre: If True, pulls per-track timbre fingerprint via the
+            M4L bridge. Costs an extra spectral read; default False so the
+            tool stays fast on bridge-less sessions.
+
+    Returns one structured report — no follow-up calls needed.
+    """
+    started = time.time()
+    ableton = _get_ableton(ctx)
+
+    track_info = _safe_call(ableton, "get_track_info", {"track_index": track_index})
+    if not track_info:
+        return {
+            "track_index": track_index,
+            "error": "get_track_info failed",
+            "checks": {},
+            "recommended_fixes": [],
+        }
+
+    track_name = track_info.get("name", f"track_{track_index}")
+    devices = track_info.get("devices", []) or []
+    clip_slots = track_info.get("clip_slots", []) or []
+
+    # Role: caller-given or inferred
+    inferred_role = role or checks.infer_role(track_name, devices)
+
+    # Pull per-clip notes only when MIDI clips exist (audio tracks return [])
+    notes_per_clip = _fetch_notes_for_clips(ableton, track_index, clip_slots)
+
+    # Modulation signals: clip automation + wavetable mod matrix routings
+    automation_present = _has_clip_automation(ableton, track_index, clip_slots)
+    wt_routings = _count_wavetable_routings(ableton, track_index, devices)
+
+    # Optional masking — note that get_masking_report is an MCP-server-side
+    # tool (mix_engine.tools), NOT a Remote Script command. We import and
+    # call its python function directly. Going through ableton.send_command
+    # would dispatch to the LOM bridge which has no such handler and silently
+    # fails (BUG-D, caught by 4-way parallel live test 2026-05-01).
+    masking_report = None
+    if include_masking:
+        try:
+            from ..mix_engine.tools import get_masking_report as _get_masking_report_impl
+            masking_report = _get_masking_report_impl(ctx)  # type: ignore[arg-type]
+        except Exception as exc:
+            logger.debug("audit_layer: masking fetch failed: %s", exc)
+    fingerprint = _maybe_get_timbre_fingerprint(ctx, track_index) if include_timbre else None
+
+    # Slice classifications only if Simpler with slices is present
+    slice_classes = None
+    if any(d.get("class_name") == "Simpler" for d in devices):
+        result = _safe_call(ableton, "classify_simpler_slices", {"track_index": track_index})
+        if result:
+            slice_classes = result.get("slices") or result.get("classifications")
+
+    # Run the 8 checks
+    check_results = {
+        "timbre": checks.check_timbre(inferred_role, fingerprint),
+        "sequence": checks.check_sequence(inferred_role, notes_per_clip),
+        "stereo": checks.check_stereo(inferred_role, track_info),
+        "masking": checks.check_masking(track_index, masking_report),
+        "modulation": checks.check_modulation(
+            inferred_role, devices, automation_present, wt_routings
+        ),
+        "params": checks.check_params(inferred_role, devices),
+        "samples": checks.check_samples(inferred_role, devices, slice_classes),
+        "effects": checks.check_effects(inferred_role, devices),
+    }
+
+    overall = checks.rollup_severity(check_results)
+    fixes = checks.rank_fixes(check_results)
+
+    duration_ms = int((time.time() - started) * 1000)
+
+    return {
+        "track_index": track_index,
+        "track_name": track_name,
+        "role": inferred_role,
+        "role_inferred": role is None,
+        "overall_severity": overall,
+        "checks": check_results,
+        "recommended_fixes": fixes,
+        "metadata": {
+            "duration_ms": duration_ms,
+            "clip_count": len([s for s in clip_slots if s.get("has_clip")]),
+            "device_count": len(devices),
+            "timbre_source": "fresh" if fingerprint else "skipped" if not include_timbre else "unavailable",
+            "masking_source": "fresh" if masking_report else "skipped" if not include_masking else "unavailable",
+        },
+    }

package/mcp_server/composer/branch_producer.py

@@ -28,8 +28,8 @@ from typing import Optional
 
 from ..branches import BranchSeed, freeform_seed
 from .prompt_parser import parse_prompt, CompositionIntent
-from .layer_planner import plan_layers, plan_sections
-from .engine import ComposerEngine, CompositionResult
+from .full.layer_planner import plan_layers, plan_sections
+from .full.engine import ComposerEngine, CompositionResult
 
 
 # Strategy registry — each function takes an intent and returns (modified
@@ -302,6 +302,9 @@ def _build_section_hypothesis_plan(intent: CompositionIntent, strategy_name: str
 
     Returns a dict with {"steps", "step_count", "summary"}.
     """
+    # v1.24: SECTION_TEMPLATES removed per vocabulary-not-form principle (Task 12).
+    # plan_layers and plan_sections will raise until Task 14 rewires this.
+    # DEPRECATED in v1.24.
     layers = plan_layers(intent)
     sections = plan_sections(intent)
 

package/mcp_server/composer/develop/__init__.py

@@ -0,0 +1,19 @@
+"""Develop compose mode — extends an existing seed loop into a full track.
+
+Two-phase LLM-creative flow (mirrors fast/full): Phase 1 returns a brief
+with seed identity + vocabulary, Phase 2 (agent) designs variants, Phase 3
+applies them to the live session.
+"""
+from .seed_introspector import classify_track, infer_role_from_name, introspect_seed
+from .brief_builder import build_develop_brief, extract_artist_refs, detect_research_hooks
+from .apply import apply_develop_plan
+
+__all__ = [
+    "classify_track",
+    "infer_role_from_name",
+    "introspect_seed",
+    "build_develop_brief",
+    "extract_artist_refs",
+    "detect_research_hooks",
+    "apply_develop_plan",
+]

package/mcp_server/composer/develop/apply.py

@@ -0,0 +1,217 @@
+"""Develop compose Phase-3 executor — applies agent-designed variant plan to session.
+
+Receives a plan dict from the agent (free-form variant set: agent decides
+count, names, scenes, MIDI), then materializes each variant as a session
+clip. Uses the shared Applier for pre-flight (analyzer/bridge) and
+post-flight (back_to_arranger) so develop benefits from the same fixes
+as fast and full modes.
+
+Develop mode does NOT create new tracks — it only writes session clips
+to existing tracks. So postflight passes an empty applied_track_indices
+list (skips per-track monitoring set, but still calls back_to_arranger).
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any
+
+from fastmcp import Context
+
+from ..framework.applier import Applier
+
+logger = logging.getLogger(__name__)
+
+
+# ── Applier wiring helpers ─────────────────────────────────────────
+
+async def _ensure_analyzer_stub(ctx: Any) -> dict:
+    """Develop mode is read-mostly; analyzer is nice-to-have, not required.
+
+    We still call ensure_analyzer_on_master if available, but failures are
+    non-fatal (unlike full mode where the analyzer is integral).
+    """
+    try:
+        from ...tools.analyzer import ensure_analyzer_on_master  # type: ignore
+        result = ensure_analyzer_on_master(ctx)
+        if isinstance(result, dict):
+            return result
+        return {"status": "unknown"}
+    except Exception as exc:
+        logger.debug("apply_develop: ensure_analyzer non-fatal failure: %s", exc)
+        return {"status": "skipped"}
+
+
+async def _reconnect_bridge_stub(ctx: Any) -> dict:
+    """Reconnect bridge if available; non-fatal failure for develop."""
+    try:
+        from ...tools.analyzer import reconnect_bridge  # type: ignore
+        result = reconnect_bridge(ctx)
+        if isinstance(result, dict):
+            connected = bool(result.get("connected") or result.get("ok"))
+            return {"connected": connected}
+        return {"connected": False}
+    except Exception as exc:
+        logger.debug("apply_develop: reconnect_bridge non-fatal failure: %s", exc)
+        return {"connected": False}
+
+
+async def _bridge_ping_stub(ctx: Any) -> dict:
+    """Lightweight bridge ping — develop doesn't need bridge for clip writes."""
+    bridge = None
+    if hasattr(ctx, "lifespan_context"):
+        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})
+
+
+async def _back_to_arranger(ctx: Any) -> dict:
+    """Call the back_to_arranger MCP primitive."""
+    ableton = ctx.lifespan_context.get("ableton") if hasattr(ctx, "lifespan_context") else None
+    if ableton is None:
+        return {"ok": False}
+    try:
+        return ableton.send_command("back_to_arranger", {})
+    except Exception as exc:
+        logger.warning("apply_develop: back_to_arranger failed: %s", exc)
+        return {"ok": False}
+
+
+def _build_applier() -> Applier:
+    return Applier(
+        ensure_analyzer_fn=_ensure_analyzer_stub,
+        reconnect_bridge_fn=_reconnect_bridge_stub,
+        bridge_ping_fn=_bridge_ping_stub,
+        set_track_input_monitoring_fn=None,  # develop creates no new tracks
+        back_to_arranger_fn=_back_to_arranger,
+        handshake_max_attempts=2,  # develop is bridge-non-critical; short retry
+        handshake_gap_seconds=0.1,
+    )
+
+
+# ── plan validation ────────────────────────────────────────────────
+
+def _validate_plan(plan: dict) -> str | None:
+    """Return error message if plan is invalid, else None."""
+    if not isinstance(plan, dict):
+        return "plan must be a dict"
+    if plan.get("scope") not in (None, "develop"):
+        return f"plan scope must be 'develop' (got {plan.get('scope')!r})"
+    variants = plan.get("variants")
+    if not isinstance(variants, list) or len(variants) == 0:
+        return "plan.variants must be a non-empty list"
+    for i, v in enumerate(variants):
+        if not isinstance(v, dict):
+            return f"variants[{i}] must be a dict"
+        for required in ("track_index", "scene_index"):
+            if required not in v:
+                return f"variants[{i}] missing required field '{required}'"
+        if "notes" in v and not isinstance(v["notes"], list):
+            return f"variants[{i}].notes must be a list (or omitted)"
+    return None
+
+
+# ── main entry point ───────────────────────────────────────────────
+
+async def apply_develop_plan(ctx: Context, plan: dict) -> dict:
+    """Apply an agent-designed develop plan to the live session.
+
+    See module docstring for plan shape. Returns:
+    {
+      "status": "ok" | "partial" | "error",
+      "clips_created": int,
+      "scenes_populated": list[int],
+      "sample_swaps": int,
+      "preflight": dict,         # Applier.preflight() result
+      "postflight": dict,        # Applier.postflight() result
+      "errors": list[dict],      # per-variant failures (variant index + reason)
+      "duration_ms": int,
+    }
+    """
+    started = time.time()
+
+    err = _validate_plan(plan)
+    if err:
+        return {"status": "error", "error": err, "phase": "validate"}
+
+    ableton = ctx.lifespan_context.get("ableton") if hasattr(ctx, "lifespan_context") else None
+    if ableton is None:
+        return {"status": "error", "error": "ableton client not available", "phase": "setup"}
+
+    applier = _build_applier()
+    preflight_result = await applier.preflight(ctx)
+    # Develop is bridge-non-critical; do NOT abort on bridge failure
+
+    # Tempo override (only if plan specifies a different tempo)
+    plan_tempo = plan.get("tempo")
+    if plan_tempo is not None:
+        try:
+            session = ableton.send_command("get_session_info", {})
+            current_tempo = float(session.get("tempo", 0.0))
+            if abs(current_tempo - float(plan_tempo)) > 0.01:
+                ableton.send_command("set_tempo", {"tempo": float(plan_tempo)})
+        except Exception as exc:
+            logger.warning("apply_develop: tempo set failed: %s", exc)
+
+    clip_length = float(plan.get("clip_length_beats", 4.0))
+    clips_created = 0
+    sample_swaps = 0
+    scenes_populated: set[int] = set()
+    errors: list[dict] = []
+
+    for i, v in enumerate(plan["variants"]):
+        track_index = int(v["track_index"])
+        scene_index = int(v["scene_index"])
+        name = v.get("name") or f"v{i}"
+        notes = v.get("notes", [])
+        sample_uri = v.get("sample_uri")
+
+        try:
+            # Optional sample swap (sample-trigger layers only)
+            if sample_uri:
+                ableton.send_command(
+                    "load_browser_item",
+                    {"track_index": track_index, "uri": sample_uri},
+                )
+                sample_swaps += 1
+
+            # Create clip
+            ableton.send_command(
+                "create_clip",
+                {"track_index": track_index, "clip_index": scene_index, "length": clip_length},
+            )
+
+            # Add notes (skip if empty — empty clip is a valid drum-dropout pattern)
+            if notes:
+                ableton.send_command(
+                    "add_notes",
+                    {"track_index": track_index, "clip_index": scene_index, "notes": notes},
+                )
+
+            # Name the clip
+            ableton.send_command(
+                "set_clip_name",
+                {"track_index": track_index, "clip_index": scene_index, "name": name},
+            )
+
+            clips_created += 1
+            scenes_populated.add(scene_index)
+        except Exception as exc:
+            logger.warning("apply_develop: variant[%d] failed: %s", i, exc)
+            errors.append({"variant_index": i, "reason": str(exc)})
+
+    # Postflight — develop creates no tracks, but still call back_to_arranger
+    postflight_result = await applier.postflight(ctx, applied_track_indices=[])
+
+    return {
+        "status": "ok" if not errors else "partial",
+        "clips_created": clips_created,
+        "scenes_populated": sorted(scenes_populated),
+        "sample_swaps": sample_swaps,
+        "preflight": preflight_result,
+        "postflight": postflight_result,
+        "errors": errors,
+        "duration_ms": int((time.time() - started) * 1000),
+    }