livepilot 1.9.24 → 1.10.1

package/mcp_server/semantic_moves/sample_compilers.py

@@ -0,0 +1,377 @@
+"""Compilers for sample-domain semantic moves.
+
+These compile sample manipulation intents into concrete tool call sequences
+using the session kernel to find appropriate tracks and devices.
+"""
+
+from __future__ import annotations
+
+from .compiler import CompiledPlan, CompiledStep, register_compiler
+from .models import SemanticMove
+from . import resolvers
+
+
+def _resolve_sample_path(kernel: dict) -> str:
+    """Get the sample file path from kernel, or return placeholder."""
+    return kernel.get("sample_file_path", "{sample_file_path}")
+
+
+def _compile_sample_chop_rhythm(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'sample_chop_rhythm': load, slice, and chop a sample for rhythm."""
+    steps = []
+    descriptions = []
+    warnings = []
+
+    # Find drum/percussion tracks to layer alongside
+    drums = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
+
+    # Create a new track for the chopped sample
+    steps.append(CompiledStep(
+        tool="create_midi_track",
+        params={"name": "Chop"},
+        description="Create track for chopped sample",
+    ))
+    descriptions.append("Create chop track")
+
+    # Load into Simpler — track index will be last + 1
+    tracks = kernel.get("session_info", {}).get("tracks", [])
+    new_idx = len(tracks)
+
+    steps.append(CompiledStep(
+        tool="load_sample_to_simpler",
+        params={"track_index": new_idx, "file_path": _resolve_sample_path(kernel)},
+        description="Load sample into Simpler for slicing",
+    ))
+
+    steps.append(CompiledStep(
+        tool="set_simpler_playback_mode",
+        params={"track_index": new_idx, "device_index": 0, "playback_mode": 2},
+        description="Switch to slice mode for rhythmic chopping",
+    ))
+    descriptions.append("Slice sample")
+
+    # Balance against existing drums
+    if drums:
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": new_idx, "volume": 0.55},
+            description="Set chop volume below main drums",
+        ))
+    else:
+        warnings.append("No drum tracks found — chop will be the primary rhythm")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify chopped sample producing audio",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="medium",
+        summary="; ".join(descriptions) if descriptions else "Chop sample for rhythm",
+        requires_approval=True,
+        warnings=warnings,
+    )
+
+
+def _compile_sample_texture_layer(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'sample_texture_layer': load and filter a sample as background texture."""
+    steps = []
+    descriptions = []
+
+    tracks = kernel.get("session_info", {}).get("tracks", [])
+    new_idx = len(tracks)
+
+    steps.append(CompiledStep(
+        tool="create_midi_track",
+        params={"name": "Texture"},
+        description="Create track for texture layer",
+    ))
+
+    steps.append(CompiledStep(
+        tool="load_sample_to_simpler",
+        params={"track_index": new_idx, "file_path": _resolve_sample_path(kernel)},
+        description="Load textural sample into Simpler",
+    ))
+    descriptions.append("Load texture sample")
+
+    # Low volume for background placement
+    steps.append(CompiledStep(
+        tool="set_track_volume",
+        params={"track_index": new_idx, "volume": 0.35},
+        description="Set texture low in mix for background presence",
+    ))
+    descriptions.append("Set background level")
+
+    # Add reverb send for spatial depth
+    steps.append(CompiledStep(
+        tool="set_track_send",
+        params={"track_index": new_idx, "send_index": 0, "value": 0.40},
+        description="Heavy reverb for spatial depth on texture",
+    ))
+    descriptions.append("Add reverb depth")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify texture layer producing audio at low level",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="low",
+        summary="; ".join(descriptions),
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+    )
+
+
+def _compile_sample_vocal_ghost(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'sample_vocal_ghost': reverse, pitch, and wash a vocal sample."""
+    steps = []
+    descriptions = []
+
+    tracks = kernel.get("session_info", {}).get("tracks", [])
+    new_idx = len(tracks)
+
+    steps.append(CompiledStep(
+        tool="create_midi_track",
+        params={"name": "Ghost Vox"},
+        description="Create track for ghost vocal",
+    ))
+
+    steps.append(CompiledStep(
+        tool="load_sample_to_simpler",
+        params={"track_index": new_idx, "file_path": _resolve_sample_path(kernel)},
+        description="Load vocal sample into Simpler",
+    ))
+
+    steps.append(CompiledStep(
+        tool="reverse_simpler",
+        params={"track_index": new_idx},
+        description="Reverse vocal for ghostly character",
+    ))
+    descriptions.append("Reverse vocal")
+
+    # Heavy reverb wash
+    steps.append(CompiledStep(
+        tool="set_track_send",
+        params={"track_index": new_idx, "send_index": 0, "value": 0.55},
+        description="Heavy reverb wash for ghostly depth",
+    ))
+    descriptions.append("Reverb wash")
+
+    # Low volume — ghosts live in the background
+    steps.append(CompiledStep(
+        tool="set_track_volume",
+        params={"track_index": new_idx, "volume": 0.30},
+        description="Set ghost vocal low in mix",
+    ))
+    descriptions.append("Background level")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify ghost vocal producing audio with reverb tail",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="medium",
+        summary="; ".join(descriptions),
+        requires_approval=True,
+    )
+
+
+def _compile_sample_break_layer(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'sample_break_layer': slice a break and layer over existing drums."""
+    steps = []
+    descriptions = []
+    warnings = []
+
+    drums = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
+    if not drums:
+        warnings.append("No existing drum tracks — break will be the primary rhythm")
+
+    tracks = kernel.get("session_info", {}).get("tracks", [])
+    new_idx = len(tracks)
+
+    steps.append(CompiledStep(
+        tool="create_midi_track",
+        params={"name": "Break"},
+        description="Create track for breakbeat layer",
+    ))
+
+    steps.append(CompiledStep(
+        tool="load_sample_to_simpler",
+        params={"track_index": new_idx, "file_path": _resolve_sample_path(kernel)},
+        description="Load breakbeat into Simpler",
+    ))
+
+    steps.append(CompiledStep(
+        tool="set_simpler_playback_mode",
+        params={"track_index": new_idx, "device_index": 0, "playback_mode": 2},
+        description="Slice break by transients for individual hits",
+    ))
+    descriptions.append("Slice break")
+
+    # Sit below main drums
+    steps.append(CompiledStep(
+        tool="set_track_volume",
+        params={"track_index": new_idx, "volume": 0.45},
+        description="Set break layer below main drums",
+    ))
+    descriptions.append("Balance break level")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify break layer producing audio alongside drums",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="medium",
+        summary="; ".join(descriptions) if descriptions else "Layer breakbeat",
+        requires_approval=True,
+        warnings=warnings,
+    )
+
+
+def _compile_sample_resample_destroy(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'sample_resample_destroy': warp and mangle a sample destructively.
+
+    SAFETY: This is a high-risk move — always requires approval.
+    Only adjusts device params when a known device is confirmed present.
+    """
+    steps = []
+    descriptions = []
+    warnings = ["High-risk: destructive processing — consider duplicating track first"]
+
+    tracks = kernel.get("session_info", {}).get("tracks", [])
+    new_idx = len(tracks)
+
+    steps.append(CompiledStep(
+        tool="create_midi_track",
+        params={"name": "Destroy"},
+        description="Create track for destructive resampling",
+    ))
+
+    steps.append(CompiledStep(
+        tool="load_sample_to_simpler",
+        params={"track_index": new_idx, "file_path": _resolve_sample_path(kernel)},
+        description="Load sample for destruction",
+    ))
+    descriptions.append("Load source")
+
+    steps.append(CompiledStep(
+        tool="warp_simpler",
+        params={"track_index": new_idx},
+        description="Apply extreme warp for time-stretch artifacts",
+    ))
+    descriptions.append("Warp for artifacts")
+
+    # Use volume + send instead of blindly setting device params
+    steps.append(CompiledStep(
+        tool="set_track_send",
+        params={"track_index": new_idx, "send_index": 0, "value": 0.30},
+        description="Add reverb send for destroyed texture depth",
+    ))
+
+    steps.append(CompiledStep(
+        tool="set_track_volume",
+        params={"track_index": new_idx, "volume": 0.50},
+        description="Set destroyed sample at moderate level",
+    ))
+    descriptions.append("Set level")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify destroyed sample producing audio",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="high",
+        summary="; ".join(descriptions),
+        requires_approval=True,
+        warnings=warnings,
+    )
+
+
+def _compile_sample_one_shot_accent(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'sample_one_shot_accent': load a one-shot for rhythmic punctuation."""
+    steps = []
+    descriptions = []
+
+    tracks = kernel.get("session_info", {}).get("tracks", [])
+    new_idx = len(tracks)
+
+    steps.append(CompiledStep(
+        tool="create_midi_track",
+        params={"name": "Accent"},
+        description="Create track for one-shot accent",
+    ))
+
+    steps.append(CompiledStep(
+        tool="load_sample_to_simpler",
+        params={"track_index": new_idx, "file_path": _resolve_sample_path(kernel)},
+        description="Load one-shot into Simpler",
+    ))
+
+    steps.append(CompiledStep(
+        tool="set_simpler_playback_mode",
+        params={"track_index": new_idx, "device_index": 0, "playback_mode": 1},
+        description="One-shot mode for trigger playback",
+    ))
+    descriptions.append("One-shot mode")
+
+    steps.append(CompiledStep(
+        tool="crop_simpler",
+        params={"track_index": new_idx},
+        description="Tight crop around the transient",
+    ))
+    descriptions.append("Crop to transient")
+
+    # Accent should be punchy but not dominating
+    steps.append(CompiledStep(
+        tool="set_track_volume",
+        params={"track_index": new_idx, "volume": 0.60},
+        description="Set accent at punchy but balanced level",
+    ))
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify one-shot accent triggers cleanly",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="low",
+        summary="; ".join(descriptions) if descriptions else "One-shot accent",
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+    )
+
+
+# ── Register ────────────────────────────────────────────────────────────────
+
+register_compiler("sample_chop_rhythm", _compile_sample_chop_rhythm)
+register_compiler("sample_texture_layer", _compile_sample_texture_layer)
+register_compiler("sample_vocal_ghost", _compile_sample_vocal_ghost)
+register_compiler("sample_break_layer", _compile_sample_break_layer)
+register_compiler("sample_resample_destroy", _compile_sample_resample_destroy)
+register_compiler("sample_one_shot_accent", _compile_sample_one_shot_accent)

package/mcp_server/semantic_moves/sound_design_moves.py

@@ -13,7 +13,7 @@ ADD_WARMTH = SemanticMove(
     targets={"warmth": 0.5, "depth": 0.3, "cohesion": 0.2},
     protect={"clarity": 0.6, "punch": 0.5},
     risk_level="low",
-    compile_plan=[
+    plan_template=[
         {"tool": "set_device_parameter", "params": {"description": "Add Saturator drive +2-4dB for harmonic warmth"}, "description": "Add saturation", "backend": "remote_command"},
         {"tool": "set_device_parameter", "params": {"description": "Boost EQ low-mid shelf +1-2dB"}, "description": "Low-mid warmth", "backend": "remote_command"},
     ],
@@ -30,7 +30,7 @@ ADD_TEXTURE = SemanticMove(
     targets={"motion": 0.4, "novelty": 0.3, "depth": 0.3},
     protect={"clarity": 0.6},
     risk_level="medium",
-    compile_plan=[
+    plan_template=[
         {"tool": "apply_automation_shape", "params": {"curve_type": "perlin", "description": "Perlin noise on filter cutoff for organic texture"}, "description": "Organic filter motion", "backend": "mcp_tool"},
         {"tool": "set_track_send", "params": {"description": "Increase delay send for spatial texture"}, "description": "Spatial texture via delay", "backend": "remote_command"},
     ],
@@ -46,7 +46,7 @@ SHAPE_TRANSIENTS = SemanticMove(
     targets={"punch": 0.5, "clarity": 0.3, "groove": 0.2},
     protect={"warmth": 0.5},
     risk_level="low",
-    compile_plan=[
+    plan_template=[
         {"tool": "set_device_parameter", "params": {"description": "Adjust Compressor attack time (faster = sharper transients, slower = rounder)"}, "description": "Shape attack", "backend": "remote_command"},
         {"tool": "set_device_parameter", "params": {"description": "Adjust Compressor release for rhythmic pumping"}, "description": "Shape release", "backend": "remote_command"},
     ],
@@ -62,7 +62,7 @@ ADD_SPACE = SemanticMove(
     targets={"depth": 0.5, "width": 0.3, "clarity": 0.2},
     protect={"punch": 0.6, "clarity": 0.5},
     risk_level="low",
-    compile_plan=[
+    plan_template=[
         {"tool": "set_track_send", "params": {"description": "Increase reverb send to 25-35%"}, "description": "Add reverb depth", "backend": "remote_command"},
         {"tool": "set_track_send", "params": {"description": "Add subtle delay send 10-15%"}, "description": "Add delay texture", "backend": "remote_command"},
         {"tool": "set_track_pan", "params": {"description": "Widen pan slightly for spatial presence"}, "description": "Widen spatial field", "backend": "remote_command"},

package/mcp_server/semantic_moves/tools.py

@@ -27,13 +27,15 @@ def list_semantic_moves(
     Semantic moves express WHAT to achieve musically, not HOW parametrically.
     Each move compiles into a sequence of existing deterministic tools.
 
-    domain: filter by family (mix, arrangement, transition, sound_design, performance)
+    domain: filter by family (e.g. mix, arrangement, transition, sound_design, sample, performance)
     style: filter by genre/style (reserved for future use)
 
     Returns: list of moves with move_id, family, intent, targets, risk_level.
     """
     moves = registry.list_moves(domain=domain, style=style)
-    return {"moves": moves, "count": len(moves), "available_domains": ["mix", "arrangement"]}
+    all_moves = registry.list_moves()
+    domains = sorted({m.get("family", "") for m in all_moves if m.get("family")})
+    return {"moves": moves, "count": len(moves), "available_domains": domains}
 
 
 @mcp.tool()
@@ -43,9 +45,13 @@ def preview_semantic_move(
 ) -> dict:
     """Preview what a semantic move will do before applying it.
 
-    Returns the full compile plan (tool sequence), verification plan,
-    targets, protection constraints, and risk level. Use this to understand
-    the impact before committing.
+    Returns the static plan_template + verification_plans, PLUS an additive
+    compiled_plan field built by compiling the move against a lightweight
+    kernel of the current session. Use compiled_plan to inspect the concrete
+    tool calls the move would emit right now; use plan_template to understand
+    the move's shape independent of session state.
+
+    Existing callers reading plan_template are unaffected by the addition.
     """
     move = registry.get_move(move_id)
     if not move:
@@ -55,7 +61,46 @@ def preview_semantic_move(
             "available_moves": available,
         }
 
-    return move.to_full_dict()
+    result = move.to_full_dict()
+
+    # Additive: compile against a lightweight kernel so callers get an
+    # executable representation alongside the static plan_template.
+    try:
+        from ..runtime.session_kernel import build_session_kernel
+        from ..runtime.capability_state import build_capability_state
+        from . import compiler as move_compiler
+
+        ableton = None
+        if hasattr(ctx, "lifespan_context"):
+            ableton = ctx.lifespan_context.get("ableton")
+
+        session_info: dict = {}
+        if ableton is not None:
+            try:
+                info = ableton.send_command("get_session_info")
+                if isinstance(info, dict):
+                    session_info = info
+            except Exception:
+                session_info = {}
+
+        state = build_capability_state(
+            session_ok=bool(session_info),
+            analyzer_ok=False,
+            memory_ok=True,
+        )
+        kernel = build_session_kernel(
+            session_info=session_info,
+            capability_state=state.to_dict(),
+        )
+        plan = move_compiler.compile(move, kernel.to_dict())
+        result["compiled_plan"] = plan.to_dict()
+        result["compiled_plan_executable"] = bool(plan.executable)
+    except Exception as e:
+        result["compiled_plan"] = None
+        result["compiled_plan_executable"] = False
+        result["compiled_plan_error"] = str(e)
+
+    return result
 
 
 @mcp.tool()
@@ -124,7 +169,7 @@ def propose_next_best_move(
 
 
 @mcp.tool()
-def apply_semantic_move(
+async def apply_semantic_move(
     ctx: Context,
     move_id: str,
     mode: str = "improve",
@@ -177,14 +222,22 @@ def apply_semantic_move(
         result["note"] = "Awaiting approval — present the plan to the user, then execute steps individually"
         return result
 
-    # explore mode — execute through unified router
-    from ..runtime.execution_router import execute_plan_steps
+    # explore mode — execute through the async router
+    from ..runtime.execution_router import execute_plan_steps_async
 
     step_dicts = [
         {"tool": step.tool, "params": step.params, "description": step.description}
         for step in plan.steps
     ]
-    exec_results = execute_plan_steps(step_dicts, ableton=ableton, ctx=ctx)
+    bridge = ctx.lifespan_context.get("m4l")
+    mcp_registry = ctx.lifespan_context.get("mcp_dispatch", {})
+    exec_results = await execute_plan_steps_async(
+        step_dicts,
+        ableton=ableton,
+        bridge=bridge,
+        mcp_registry=mcp_registry,
+        ctx=ctx,
+    )
 
     executed_steps = []
     for i, er in enumerate(exec_results):

package/mcp_server/semantic_moves/transition_moves.py

@@ -10,7 +10,7 @@ INCREASE_FORWARD_MOTION = SemanticMove(
     targets={"motion": 0.5, "energy": 0.3, "tension": 0.2},
     protect={"clarity": 0.6},
     risk_level="low",
-    compile_plan=[
+    plan_template=[
         {"tool": "apply_automation_shape", "params": {"curve_type": "exponential", "description": "Rising filter cutoff over 4 bars"}, "description": "Rising filter sweep", "backend": "mcp_tool"},
         {"tool": "set_track_volume", "params": {"description": "Push rhythm elements +5-8%"}, "description": "Push rhythm forward", "backend": "remote_command"},
         {"tool": "apply_automation_shape", "params": {"curve_type": "linear", "description": "Rising reverb send for anticipation"}, "description": "Build reverb wash", "backend": "mcp_tool"},
@@ -27,7 +27,7 @@ OPEN_CHORUS = SemanticMove(
     targets={"energy": 0.4, "width": 0.3, "contrast": 0.3},
     protect={"clarity": 0.6, "cohesion": 0.5},
     risk_level="medium",
-    compile_plan=[
+    plan_template=[
         {"tool": "set_track_volume", "params": {"description": "Push all melodic tracks +10-15%"}, "description": "Push chorus energy", "backend": "remote_command"},
         {"tool": "set_track_pan", "params": {"description": "Widen stereo field on chords/pads"}, "description": "Widen stereo", "backend": "remote_command"},
         {"tool": "set_track_send", "params": {"description": "Increase reverb/delay sends for spaciousness"}, "description": "Add space", "backend": "remote_command"},
@@ -45,7 +45,7 @@ CREATE_BREAKDOWN = SemanticMove(
     targets={"contrast": 0.5, "depth": 0.3, "clarity": 0.2},
     protect={"cohesion": 0.5},
     risk_level="medium",
-    compile_plan=[
+    plan_template=[
         {"tool": "set_track_volume", "params": {"description": "Pull drums to 20-30%"}, "description": "Strip drums", "backend": "remote_command"},
         {"tool": "set_track_volume", "params": {"description": "Pull bass to 30-40%"}, "description": "Reduce bass", "backend": "remote_command"},
         {"tool": "set_track_send", "params": {"description": "Increase reverb send on remaining elements"}, "description": "Add reverb depth", "backend": "remote_command"},
@@ -62,7 +62,7 @@ BRIDGE_SECTIONS = SemanticMove(
     targets={"motion": 0.4, "contrast": 0.3, "cohesion": 0.3},
     protect={"clarity": 0.6},
     risk_level="low",
-    compile_plan=[
+    plan_template=[
         {"tool": "apply_automation_shape", "params": {"curve_type": "cosine", "description": "Gentle filter sweep across bridge"}, "description": "Bridge filter motion", "backend": "mcp_tool"},
         {"tool": "set_track_volume", "params": {"description": "Gentle volume crossfade between section elements"}, "description": "Crossfade elements", "backend": "remote_command"},
     ],