livepilot 1.9.21 → 1.9.23

package/mcp_server/semantic_moves/performance_compilers.py

@@ -0,0 +1,208 @@
+"""Compilers for performance-safe semantic moves.
+
+Critical rule: NEVER compile to blocked actions (delete, create, device load).
+Only volume, pan, send, and automation are allowed.
+"""
+
+from __future__ import annotations
+
+from .compiler import CompiledPlan, CompiledStep, register_compiler
+from .models import SemanticMove
+from . import resolvers
+
+
+def _compile_recover_energy(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'recover_energy': bring drums+bass back gradually."""
+    steps = []
+    descriptions = []
+
+    drum_tracks = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
+    bass_tracks = resolvers.find_tracks_by_role(kernel, ["bass"])
+
+    for dt in drum_tracks[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": dt["index"], "volume": 0.70},
+            description=f"Restore {dt['name']} to 0.70 for energy recovery",
+        ))
+        descriptions.append(f"Restore {dt['name']} to 0.70")
+
+    for bt in bass_tracks[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": bt["index"], "volume": 0.60},
+            description=f"Restore {bt['name']} to 0.60",
+        ))
+        descriptions.append(f"Restore {bt['name']} to 0.60")
+
+    # Pull reverb back to tighten
+    pad_tracks = resolvers.find_tracks_by_role(kernel, ["pad", "chords"])
+    for pt in pad_tracks[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_send",
+            params={"track_index": pt["index"], "send_index": 0, "value": 0.15},
+            description=f"Tighten reverb on {pt['name']} to 0.15",
+        ))
+        descriptions.append(f"Tighten reverb on {pt['name']}")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify energy recovered",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="low",
+        summary="; ".join(descriptions) if descriptions else "No rhythm tracks found",
+        requires_approval=False,  # Performance moves execute immediately
+    )
+
+
+def _compile_decompress_tension(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'decompress_tension': pull back energy, open space."""
+    steps = []
+    descriptions = []
+
+    lead_tracks = resolvers.find_tracks_by_role(kernel, ["lead", "chords"])
+    pad_tracks = resolvers.find_tracks_by_role(kernel, ["pad"])
+
+    for lt in lead_tracks[:2]:
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": lt["index"], "volume": 0.35},
+            description=f"Pull {lt['name']} to 0.35 for decompression",
+        ))
+        descriptions.append(f"Pull {lt['name']} to 0.35")
+
+    for pt in pad_tracks[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_send",
+            params={"track_index": pt["index"], "send_index": 0, "value": 0.40},
+            description=f"Open reverb on {pt['name']} to 0.40 for spaciousness",
+        ))
+        descriptions.append(f"Open reverb on {pt['name']}")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify decompression — energy lower, space wider",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="low",
+        summary="; ".join(descriptions) if descriptions else "No tracks to decompress",
+        requires_approval=False,
+    )
+
+
+def _compile_safe_spotlight(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'safe_spotlight': pull non-spotlight tracks, push one."""
+    steps = []
+    descriptions = []
+    warnings = []
+
+    all_tracks = kernel.get("session_info", {}).get("tracks", [])
+    if not all_tracks:
+        warnings.append("No tracks found")
+        return CompiledPlan(
+            move_id=move.move_id, intent=move.intent, warnings=warnings,
+            summary="No tracks to spotlight",
+        )
+
+    # Spotlight the first lead or melodic track; pull everything else
+    lead_tracks = resolvers.find_tracks_by_role(kernel, ["lead", "chords"])
+    spotlight = lead_tracks[0] if lead_tracks else all_tracks[0]
+    spotlight_idx = spotlight.get("index", 0)
+    spotlight_name = spotlight.get("name", f"Track {spotlight_idx}")
+
+    # Pull non-spotlight audio tracks
+    for track in all_tracks:
+        idx = track.get("index", 0)
+        name = track.get("name", "")
+        if idx == spotlight_idx:
+            continue
+        if track.get("type") in ("return", "master"):
+            continue
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": idx, "volume": 0.30},
+            description=f"Pull {name} to 0.30 (background)",
+        ))
+
+    # Push spotlight
+    steps.append(CompiledStep(
+        tool="set_track_volume",
+        params={"track_index": spotlight_idx, "volume": 0.82},
+        description=f"Push spotlight {spotlight_name} to 0.82",
+    ))
+    descriptions.append(f"Spotlight {spotlight_name}")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify spotlight dominant, others still audible",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="low",
+        summary="; ".join(descriptions),
+        requires_approval=False,
+    )
+
+
+def _compile_emergency_simplify(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'emergency_simplify': strip to drums+bass only."""
+    steps = []
+    descriptions = []
+
+    all_tracks = kernel.get("session_info", {}).get("tracks", [])
+    drum_tracks = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
+    bass_tracks = resolvers.find_tracks_by_role(kernel, ["bass"])
+    keep_indices = {t["index"] for t in drum_tracks + bass_tracks}
+
+    for track in all_tracks:
+        idx = track.get("index", 0)
+        name = track.get("name", "")
+        if track.get("type") in ("return", "master"):
+            continue
+        if idx in keep_indices:
+            continue
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": idx, "volume": 0.10},
+            description=f"Strip {name} to 0.10 (emergency simplify)",
+        ))
+
+    descriptions.append("Strip to drums+bass only")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify drums+bass dominant, others at background level",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="low",
+        summary="; ".join(descriptions),
+        requires_approval=False,
+    )
+
+
+# ── Register ────────────────────────────────────────────────────────────────
+
+register_compiler("recover_energy", _compile_recover_energy)
+register_compiler("decompress_tension", _compile_decompress_tension)
+register_compiler("safe_spotlight", _compile_safe_spotlight)
+register_compiler("emergency_simplify", _compile_emergency_simplify)

package/mcp_server/semantic_moves/performance_moves.py

@@ -0,0 +1,81 @@
+"""Performance-safe semantic moves — safe actions during live performance.
+
+Every move in this family MUST compile only to safe or caution actions.
+Blocked actions (delete, create, device load) are never used.
+"""
+
+from .models import SemanticMove
+from .registry import register
+
+RECOVER_ENERGY = SemanticMove(
+    move_id="recover_energy",
+    family="performance",
+    intent="Recover energy after a breakdown — bring elements back in gradually",
+    targets={"energy": 0.5, "cohesion": 0.3, "motion": 0.2},
+    protect={"clarity": 0.7},
+    risk_level="low",
+    required_capabilities=["session"],
+    compile_plan=[
+        {"tool": "set_track_volume", "params": {"description": "Gradually restore drum volume"}, "description": "Bring drums back"},
+        {"tool": "set_track_volume", "params": {"description": "Restore bass volume"}, "description": "Bring bass back"},
+        {"tool": "set_track_send", "params": {"description": "Reduce reverb send to tighten mix"}, "description": "Tighten reverb"},
+    ],
+    verification_plan=[
+        {"tool": "get_track_meters", "check": "drum and bass tracks producing audio"},
+    ],
+)
+
+DECOMPRESS_TENSION = SemanticMove(
+    move_id="decompress_tension",
+    family="performance",
+    intent="Release built-up tension — open filters, reduce density, create space",
+    targets={"clarity": 0.4, "depth": 0.3, "width": 0.3},
+    protect={"cohesion": 0.6},
+    risk_level="low",
+    required_capabilities=["session"],
+    compile_plan=[
+        {"tool": "set_track_volume", "params": {"description": "Pull back high-energy elements 15-20%"}, "description": "Pull energy down"},
+        {"tool": "set_track_send", "params": {"description": "Increase reverb for spaciousness"}, "description": "Open space"},
+    ],
+    verification_plan=[
+        {"tool": "get_track_meters", "check": "all tracks still alive, overall energy decreased"},
+    ],
+)
+
+SAFE_SPOTLIGHT = SemanticMove(
+    move_id="safe_spotlight",
+    family="performance",
+    intent="Spotlight one element by pulling others back — no muting, just volume balance",
+    targets={"contrast": 0.5, "clarity": 0.3, "motion": 0.2},
+    protect={"cohesion": 0.7, "energy": 0.5},
+    risk_level="low",
+    required_capabilities=["session"],
+    compile_plan=[
+        {"tool": "set_track_volume", "params": {"description": "Pull non-spotlight tracks to 30-40%"}, "description": "Pull background"},
+        {"tool": "set_track_volume", "params": {"description": "Push spotlight track to 80-85%"}, "description": "Push spotlight"},
+    ],
+    verification_plan=[
+        {"tool": "get_track_meters", "check": "spotlight track clearly dominant, others still audible"},
+    ],
+)
+
+EMERGENCY_SIMPLIFY = SemanticMove(
+    move_id="emergency_simplify",
+    family="performance",
+    intent="Emergency simplify — pull everything back to drums+bass only for recovery",
+    targets={"clarity": 0.6, "cohesion": 0.4},
+    protect={"energy": 0.3},
+    risk_level="low",
+    required_capabilities=["session"],
+    compile_plan=[
+        {"tool": "set_track_volume", "params": {"description": "Pull all non-rhythm tracks to 10-15%"}, "description": "Strip to essentials"},
+        {"tool": "set_track_volume", "params": {"description": "Keep drums at current level"}, "description": "Maintain rhythm"},
+    ],
+    verification_plan=[
+        {"tool": "get_track_meters", "check": "drums producing audio, other tracks at low but nonzero level"},
+    ],
+)
+
+# Register all performance moves
+for _move in [RECOVER_ENERGY, DECOMPRESS_TENSION, SAFE_SPOTLIGHT, EMERGENCY_SIMPLIFY]:
+    register(_move)

package/mcp_server/semantic_moves/registry.py

@@ -0,0 +1,32 @@
+"""Semantic move registry — stable IDs, discoverable by domain and style."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .models import SemanticMove
+
+_REGISTRY: dict[str, SemanticMove] = {}
+
+
+def register(move: SemanticMove) -> None:
+    """Register a semantic move. Duplicate IDs overwrite silently."""
+    _REGISTRY[move.move_id] = move
+
+
+def get_move(move_id: str) -> Optional[SemanticMove]:
+    """Get a move by ID. Returns None if not found."""
+    return _REGISTRY.get(move_id)
+
+
+def list_moves(domain: str = "", style: str = "") -> list[dict]:
+    """List all registered moves, optionally filtered by domain/style."""
+    moves = list(_REGISTRY.values())
+    if domain:
+        moves = [m for m in moves if m.family == domain]
+    return [m.to_dict() for m in moves]
+
+
+def count() -> int:
+    """Return total number of registered moves."""
+    return len(_REGISTRY)

package/mcp_server/semantic_moves/resolvers.py

@@ -0,0 +1,126 @@
+"""Resolvers — find tracks, devices, and parameters from a SessionKernel.
+
+These are the "eyes" of the semantic move compiler. They inspect the kernel's
+session topology to find the right targets for a musical intent.
+
+Pure functions — no I/O, no MCP calls. They read from the kernel dict only.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+# ── Role inference from track names ──────────────────────────────────────────
+
+_ROLE_KEYWORDS: dict[str, list[str]] = {
+    "drums": ["drum", "beat", "kit", "perc", "rhythm", "hat", "kick", "snare"],
+    "bass": ["bass", "sub", "808", "low"],
+    "chords": ["chord", "rhodes", "keys", "piano", "organ", "electric", "wurli"],
+    "pad": ["pad", "texture", "ambient", "drone", "atmosphere"],
+    "lead": ["lead", "melody", "synth", "glitch", "hook", "vocal"],
+    "percussion": ["perc", "shaker", "tambourine", "conga", "bongo", "rim"],
+    "fx": ["fx", "effect", "noise", "riser", "impact", "sweep"],
+}
+
+
+def infer_role(track_name: str) -> str:
+    """Infer a musical role from a track name. Returns 'unknown' if no match."""
+    name_lower = track_name.lower()
+    for role, keywords in _ROLE_KEYWORDS.items():
+        for kw in keywords:
+            if kw in name_lower:
+                return role
+    return "unknown"
+
+
+# ── Track finders ────────────────────────────────────────────────────────────
+
+def find_tracks_by_role(kernel: dict, roles: list[str]) -> list[dict]:
+    """Find all tracks whose inferred role is in the given list.
+
+    Returns list of {index, name, role, volume, pan} for matched tracks.
+    """
+    tracks = kernel.get("session_info", {}).get("tracks", [])
+    results = []
+    for track in tracks:
+        role = infer_role(track.get("name", ""))
+        if role in roles:
+            results.append({
+                "index": track.get("index", 0),
+                "name": track.get("name", ""),
+                "role": role,
+                "volume": track.get("volume"),
+                "pan": track.get("pan"),
+                "mute": track.get("mute", False),
+                "solo": track.get("solo", False),
+            })
+    return results
+
+
+def find_loudest_track(kernel: dict) -> Optional[dict]:
+    """Find the track with the highest volume setting."""
+    tracks = kernel.get("session_info", {}).get("tracks", [])
+    if not tracks:
+        return None
+    # Volume might not be in session_info tracks — return the first non-muted
+    non_muted = [t for t in tracks if not t.get("mute", False)]
+    return non_muted[0] if non_muted else tracks[0]
+
+
+def find_track_by_name(kernel: dict, name_substring: str) -> Optional[dict]:
+    """Find a track whose name contains the given substring (case-insensitive)."""
+    tracks = kernel.get("session_info", {}).get("tracks", [])
+    name_lower = name_substring.lower()
+    for track in tracks:
+        if name_lower in track.get("name", "").lower():
+            return track
+    return None
+
+
+# ── Device finders ───────────────────────────────────────────────────────────
+
+def find_device_on_track(
+    kernel: dict, track_index: int, device_class: str
+) -> Optional[dict]:
+    """Find a device by class name on a track. Returns {device_index, name} or None.
+
+    Note: This requires device data in the kernel, which may not always be
+    available. Returns None if device data is missing.
+    """
+    # Device data would be in an extended kernel; for now, return None
+    # and let the compiler use find_and_load_device as a fallback
+    return None
+
+
+# ── Spectral helpers ─────────────────────────────────────────────────────────
+
+def get_spectral_balance(kernel: dict) -> Optional[dict]:
+    """Extract spectral band balance from the kernel's capability data.
+
+    Returns None if no spectral data is available.
+    """
+    # Spectral data isn't stored in the base kernel — it would come from
+    # a pre-capture. Return None for graceful degradation.
+    return None
+
+
+def is_analyzer_available(kernel: dict) -> bool:
+    """Check if the M4L analyzer is connected."""
+    cap = kernel.get("capability_state", {})
+    domains = cap.get("domains", {})
+    analyzer = domains.get("analyzer", {})
+    return analyzer.get("available", False)
+
+
+# ── Volume math ──────────────────────────────────────────────────────────────
+
+def clamp_volume(vol: float) -> float:
+    """Clamp volume to Ableton's 0.0-1.0 range."""
+    return max(0.0, min(1.0, vol))
+
+
+def adjust_volume(current: float, delta_percent: float) -> float:
+    """Adjust a volume by a percentage. delta_percent=5 means +5%."""
+    new = current + (delta_percent / 100.0)
+    return clamp_volume(new)