livepilot 1.10.0 → 1.10.2

package/mcp_server/sample_engine/slice_workflow.py

@@ -0,0 +1,190 @@
+"""Slice workflow planner — generates MIDI patterns for sliced samples.
+
+Given a slice count and musical intent, produces a complete workflow plan:
+- Create a clip
+- Program MIDI notes mapped to Simpler slices
+- Suggest follow-up techniques
+
+This is pure computation — does not execute against Ableton.
+"""
+
+from __future__ import annotations
+
+import hashlib
+
+# Simpler maps slices to MIDI notes starting at C3 (60)
+SLICE_BASE_NOTE = 60
+
+
+def plan_slice_steps(
+    slice_count: int,
+    intent: str = "rhythm",
+    bars: int = 4,
+    tempo: float = 120.0,
+    track_index: int = 0,
+    clip_index: int = 0,
+) -> dict:
+    """Generate a slice workflow plan with real MIDI notes.
+
+    Returns a dict with steps (tool calls), note_map, and suggestions.
+    """
+    note_map = _build_note_map(slice_count)
+    beats = bars * 4  # 4/4 time
+    notes = _generate_notes(note_map, intent, beats, slice_count)
+
+    steps = []
+
+    steps.append({
+        "tool": "create_clip",
+        "params": {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "length": float(beats),
+        },
+        "description": f"Create {bars}-bar clip for {intent} slice pattern",
+    })
+
+    steps.append({
+        "tool": "add_notes",
+        "params": {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "notes": notes,
+        },
+        "description": f"Program {len(notes)} notes across {slice_count} slices",
+    })
+
+    return {
+        "steps": steps,
+        "note_map": note_map,
+        "slice_count": slice_count,
+        "intent": intent,
+        "bars": bars,
+        "note_count": len(notes),
+        "suggested_techniques": _suggest_techniques(intent),
+    }
+
+
+def _build_note_map(slice_count: int) -> list[dict]:
+    """Map slice indices to MIDI notes."""
+    return [
+        {"slice_index": i, "midi_note": SLICE_BASE_NOTE + i, "label": f"Slice {i + 1}"}
+        for i in range(slice_count)
+    ]
+
+
+def _generate_notes(
+    note_map: list[dict], intent: str, beats: int, slice_count: int,
+) -> list[dict]:
+    """Generate MIDI notes based on intent. Uses deterministic patterns."""
+    generators = {
+        "rhythm": _gen_rhythm,
+        "hook": _gen_hook,
+        "texture": _gen_texture,
+        "percussion": _gen_percussion,
+        "melodic": _gen_melodic,
+    }
+    gen = generators.get(intent, _gen_rhythm)
+    return gen(note_map, beats, slice_count)
+
+
+def _gen_rhythm(note_map: list, beats: int, sc: int) -> list[dict]:
+    """Sparse groove — hits on downbeats and off-beats."""
+    notes = []
+    step = 0.5  # 8th notes
+    for t in range(int(beats / step)):
+        time = t * step
+        if t % 4 == 0:
+            idx = 0
+        elif t % 4 == 2:
+            idx = min(1, sc - 1)
+        elif t % 8 in (3, 7) and sc > 2:
+            idx = min(2 + (t % 3), sc - 1)
+        else:
+            continue
+        vel = 100 - (t % 4) * 5  # Downbeats louder
+        notes.append({
+            "pitch": note_map[idx]["midi_note"],
+            "start_time": time,
+            "duration": step * 0.8,
+            "velocity": max(60, min(127, vel)),
+        })
+    return notes
+
+
+def _gen_hook(note_map: list, beats: int, sc: int) -> list[dict]:
+    """Repeated motif contour — short phrase looped."""
+    phrase_len = min(4.0, beats)
+    motif_slices = list(range(min(4, sc)))
+    notes = []
+    reps = max(1, int(beats / phrase_len))
+    for rep in range(reps):
+        offset = rep * phrase_len
+        for i, idx in enumerate(motif_slices):
+            notes.append({
+                "pitch": note_map[idx]["midi_note"],
+                "start_time": offset + i * (phrase_len / len(motif_slices)),
+                "duration": phrase_len / len(motif_slices) * 0.9,
+                "velocity": 100 - i * 5,
+            })
+    return notes
+
+
+def _gen_texture(note_map: list, beats: int, sc: int) -> list[dict]:
+    """Sparse, long notes — sustained atmosphere."""
+    notes = []
+    used = min(3, sc)
+    spacing = beats / max(used, 1)
+    for i in range(used):
+        notes.append({
+            "pitch": note_map[i]["midi_note"],
+            "start_time": i * spacing,
+            "duration": spacing * 0.95,
+            "velocity": 65,
+        })
+    return notes
+
+
+def _gen_percussion(note_map: list, beats: int, sc: int) -> list[dict]:
+    """Kick/snare/hat-like distribution."""
+    notes = []
+    step = 0.25  # 16th notes
+    for t in range(int(beats / step)):
+        time = t * step
+        if t % 8 == 0 and sc > 0:
+            notes.append({"pitch": note_map[0]["midi_note"], "start_time": time,
+                         "duration": 0.2, "velocity": 110})
+        if t % 8 == 4 and sc > 1:
+            notes.append({"pitch": note_map[min(1, sc - 1)]["midi_note"], "start_time": time,
+                         "duration": 0.2, "velocity": 100})
+        if t % 2 == 0 and sc > 2:
+            notes.append({"pitch": note_map[min(2, sc - 1)]["midi_note"], "start_time": time,
+                         "duration": 0.15, "velocity": 70})
+    return notes
+
+
+def _gen_melodic(note_map: list, beats: int, sc: int) -> list[dict]:
+    """Pitch contour phrase — ascending/descending motion."""
+    notes = []
+    phrase_notes = min(8, sc)
+    step = beats / max(phrase_notes, 1)
+    for i in range(phrase_notes):
+        notes.append({
+            "pitch": note_map[i % sc]["midi_note"],
+            "start_time": i * step,
+            "duration": step * 0.85,
+            "velocity": 85,
+        })
+    return notes
+
+
+def _suggest_techniques(intent: str) -> list[str]:
+    """Suggest follow-up techniques based on intent."""
+    suggestions = {
+        "rhythm": ["quantize_clip", "add reverb send for depth", "layer with acoustic hits"],
+        "hook": ["duplicate for variation", "add filter automation", "pitch shift for call-response"],
+        "texture": ["heavy reverb send", "low-pass filter automation", "pan automation"],
+        "percussion": ["parallel compression", "transient shaping", "short room reverb send"],
+        "melodic": ["add delay send", "pitch correction if needed", "double with octave layer"],
+    }
+    return suggestions.get(intent, ["quantize_clip", "add effects"])

package/mcp_server/sample_engine/tools.py

@@ -1,4 +1,4 @@
-"""Sample Engine MCP tools — 6 intelligence-layer tools.
+"""Sample Engine MCP tools — 7 intelligence-layer tools.
 
 No new Ableton communication — these orchestrate existing tools
 through the analyzer, critics, planner, and technique library.
@@ -319,6 +319,8 @@ def plan_sample_workflow(
     intent: str = "rhythm",
     philosophy: str = "auto",
     target_track: Optional[int] = None,
+    section_type: Optional[str] = None,
+    desired_role: Optional[str] = None,
 ) -> dict:
     """Full end-to-end sample workflow: analyze, critique, select technique, compile plan.
 
@@ -328,6 +330,8 @@ def plan_sample_workflow(
     intent: rhythm, texture, layer, melody, vocal, atmosphere, transform
     philosophy: surgeon, alchemist, auto
     target_track: existing track index, or None for new track
+    section_type: optional section context (intro, verse, chorus, drop, etc.)
+    desired_role: optional sample role (hook_sample, texture_bed, break_layer, etc.)
     """
     if file_path is None and search_query is None:
         return {"error": "Provide either file_path or search_query"}
@@ -440,3 +444,102 @@ def get_sample_opportunities(ctx: Context) -> dict:
         "opportunities": opportunities,
         "track_count": track_count,
     }
+
+
+@mcp.tool()
+def plan_slice_workflow(
+    ctx: Context,
+    file_path: Optional[str] = None,
+    track_index: Optional[int] = None,
+    device_index: int = 0,
+    intent: str = "rhythm",
+    target_section: Optional[str] = None,
+    target_track: Optional[int] = None,
+    bars: int = 4,
+    style_hint: str = "",
+) -> dict:
+    """Plan an end-to-end slice workflow for a sample.
+
+    Generates a Simpler slice strategy, MIDI note mapping, and starter
+    pattern based on musical intent. Returns a compiled workflow plan —
+    does NOT execute. The agent steps through each tool call in sequence.
+
+    Provide either file_path (new sample to load) or track_index +
+    device_index (existing Simpler with loaded sample).
+
+    intent: rhythm | hook | texture | percussion | melodic
+    bars: number of bars for the pattern (default 4)
+    target_section: optional section name for arrangement hints
+    style_hint: optional genre/style context (e.g. "dilla", "burial")
+    """
+    from .slice_workflow import plan_slice_steps
+
+    # Determine slice count — default 8 for file-based, or would come from
+    # get_simpler_slices in a real execution
+    # Read tempo from session if connected, otherwise default
+    tempo = 120.0
+    try:
+        ableton = ctx.lifespan_context.get("ableton")
+        if ableton:
+            info = ableton.send_command("get_session_info", {})
+            tempo = float(info.get("tempo", 120.0))
+    except Exception:
+        pass
+
+    # Read slice count from existing Simpler if track provided
+    slice_count = 8  # Default transient slice count
+    if track_index is not None:
+        try:
+            ableton = ctx.lifespan_context.get("ableton")
+            if ableton:
+                slices = ableton.send_command("get_simpler_slices", {
+                    "track_index": track_index, "device_index": device_index,
+                })
+                if isinstance(slices, dict) and slices.get("slice_count"):
+                    slice_count = slices["slice_count"]
+        except Exception:
+            pass  # Fall back to default
+
+    # Build the plan
+    plan = plan_slice_steps(
+        slice_count=slice_count,
+        intent=intent,
+        bars=bars,
+        tempo=tempo,
+        track_index=target_track if target_track is not None else 0,
+    )
+
+    # Prepend sample loading steps if file_path provided
+    if file_path:
+        load_steps = [
+            {
+                "tool": "create_midi_track",
+                "params": {"name": f"Slice {intent.title()}"},
+                "description": "Create track for sliced sample",
+            },
+            {
+                "tool": "load_sample_to_simpler",
+                "params": {"track_index": target_track or 0, "file_path": file_path},
+                "description": f"Load sample into Simpler: {file_path}",
+            },
+            {
+                "tool": "set_simpler_playback_mode",
+                "params": {"track_index": target_track or 0, "device_index": 0, "playback_mode": 2},
+                "description": "Set Simpler to Slice mode",
+            },
+        ]
+        plan["steps"] = load_steps + plan["steps"]
+
+    # Add arrangement hints if section provided
+    if target_section:
+        plan["arrangement_hints"] = {
+            "target_section": target_section,
+            "suggested_placement": f"Place slice pattern in {target_section}",
+        }
+
+    plan["file_path"] = file_path
+    plan["track_index"] = track_index
+    plan["device_index"] = device_index
+    plan["style_hint"] = style_hint
+
+    return plan

package/mcp_server/semantic_moves/device_creation_moves.py

@@ -15,7 +15,7 @@ CREATE_CHAOS_MODULATOR = SemanticMove(
     targets={"novelty": 0.8, "motion": 0.6, "surprise": 0.7},
     protect={"clarity": 0.5},
     risk_level="medium",
-    compile_plan=[
+    plan_template=[
         {
             "tool": "generate_m4l_effect",
             "params": {
@@ -46,7 +46,7 @@ CREATE_FEEDBACK_RESONATOR = SemanticMove(
     targets={"depth": 0.6, "texture": 0.5, "novelty": 0.4},
     protect={"clarity": 0.6, "punch": 0.5},
     risk_level="low",
-    compile_plan=[
+    plan_template=[
         {
             "tool": "generate_m4l_effect",
             "params": {
@@ -77,7 +77,7 @@ CREATE_WAVEFOLDER_EFFECT = SemanticMove(
     targets={"edge": 0.6, "novelty": 0.5, "energy": 0.4},
     protect={"warmth": 0.5},
     risk_level="medium",
-    compile_plan=[
+    plan_template=[
         {
             "tool": "generate_m4l_effect",
             "params": {
@@ -108,7 +108,7 @@ CREATE_BITCRUSHER_EFFECT = SemanticMove(
     targets={"edge": 0.5, "novelty": 0.4, "texture": 0.4},
     protect={"clarity": 0.4},
     risk_level="low",
-    compile_plan=[
+    plan_template=[
         {
             "tool": "generate_m4l_effect",
             "params": {
@@ -139,7 +139,7 @@ CREATE_KARPLUS_STRING = SemanticMove(
     targets={"novelty": 0.5, "texture": 0.6, "depth": 0.4},
     protect={"clarity": 0.6},
     risk_level="low",
-    compile_plan=[
+    plan_template=[
         {
             "tool": "generate_m4l_effect",
             "params": {
@@ -170,7 +170,7 @@ CREATE_STOCHASTIC_TEXTURE = SemanticMove(
     targets={"texture": 0.7, "novelty": 0.6, "motion": 0.5},
     protect={"clarity": 0.4},
     risk_level="medium",
-    compile_plan=[
+    plan_template=[
         {
             "tool": "generate_m4l_effect",
             "params": {
@@ -201,7 +201,7 @@ CREATE_FDN_REVERB = SemanticMove(
     targets={"depth": 0.7, "width": 0.5, "novelty": 0.4},
     protect={"punch": 0.5, "clarity": 0.5},
     risk_level="low",
-    compile_plan=[
+    plan_template=[
         {
             "tool": "generate_m4l_effect",
             "params": {

package/mcp_server/semantic_moves/mix_moves.py

@@ -10,7 +10,7 @@ TIGHTEN_LOW_END = SemanticMove(
     targets={"weight": 0.4, "punch": 0.3, "clarity": 0.3},
     protect={"warmth": 0.6},
     risk_level="low",
-    compile_plan=[
+    plan_template=[
         {"tool": "get_master_spectrum", "params": {}, "description": "Check current sub/low balance", "backend": "mcp_tool"},
         {"tool": "set_device_parameter", "params": {"description": "High-pass sub bass around 30-40 Hz"}, "description": "HP filter sub rumble", "backend": "remote_command"},
         {"tool": "set_track_volume", "params": {"description": "Reduce sub bass volume 5-10% if sub > 50%"}, "description": "Reduce sub volume", "backend": "remote_command"},
@@ -29,7 +29,7 @@ WIDEN_STEREO = SemanticMove(
     targets={"width": 0.5, "clarity": 0.3, "depth": 0.2},
     protect={"cohesion": 0.7},
     risk_level="low",
-    compile_plan=[
+    plan_template=[
         {"tool": "analyze_mix", "params": {}, "description": "Check current stereo state", "backend": "mcp_tool"},
         {"tool": "set_track_pan", "params": {"description": "Pan harmonic elements wider: +/-25-40%"}, "description": "Pan harmonics wider", "backend": "remote_command"},
         {"tool": "set_track_pan", "params": {"description": "Pan percussion subtly: +/-10-20%"}, "description": "Pan perc subtly", "backend": "remote_command"},
@@ -48,7 +48,7 @@ MAKE_PUNCHIER = SemanticMove(
     targets={"punch": 0.5, "energy": 0.3, "contrast": 0.2},
     protect={"clarity": 0.7, "warmth": 0.5},
     risk_level="low",
-    compile_plan=[
+    plan_template=[
         {"tool": "get_track_meters", "params": {"include_stereo": True}, "description": "Read current levels", "backend": "remote_command"},
         {"tool": "set_track_volume", "params": {"description": "Push drum track +5-8%"}, "description": "Push drum level", "backend": "remote_command"},
         {"tool": "set_track_volume", "params": {"description": "Pull pad/texture -5-10%"}, "description": "Pull back pads", "backend": "remote_command"},
@@ -67,7 +67,7 @@ DARKEN_MIX = SemanticMove(
     targets={"warmth": 0.5, "depth": 0.3, "width": 0.2},
     protect={"width": 0.7, "clarity": 0.5},
     risk_level="low",
-    compile_plan=[
+    plan_template=[
         {"tool": "get_master_spectrum", "params": {}, "description": "Check current tonal balance", "backend": "mcp_tool"},
         {"tool": "set_device_parameter", "params": {"description": "Lower EQ/Auto Filter high shelf -2-4dB on bright tracks"}, "description": "Roll off highs", "backend": "remote_command"},
         {"tool": "set_track_send", "params": {"description": "Increase reverb send on darkened elements for depth compensation"}, "description": "Compensate depth", "backend": "remote_command"},
@@ -85,7 +85,7 @@ REDUCE_REPETITION = SemanticMove(
     targets={"motion": 0.4, "novelty": 0.3, "contrast": 0.3},
     protect={"cohesion": 0.6},
     risk_level="medium",
-    compile_plan=[
+    plan_template=[
         {"tool": "apply_automation_shape", "params": {"curve_type": "perlin", "description": "Perlin noise on filter cutoff"}, "description": "Add organic filter drift", "backend": "mcp_tool"},
         {"tool": "apply_automation_shape", "params": {"curve_type": "perlin", "description": "Perlin noise on send levels"}, "description": "Add depth movement", "backend": "mcp_tool"},
         {"tool": "set_device_parameter", "params": {"description": "Increase Beat Repeat variation or chance"}, "description": "Add rhythmic variation", "backend": "remote_command"},
@@ -103,7 +103,7 @@ MAKE_KICK_BASS_LOCK = SemanticMove(
     targets={"weight": 0.4, "punch": 0.3, "groove": 0.3},
     protect={"warmth": 0.6, "cohesion": 0.7},
     risk_level="low",
-    compile_plan=[
+    plan_template=[
         {"tool": "get_device_parameters", "params": {"description": "Read bass EQ/filter state"}, "description": "Inspect bass chain", "backend": "remote_command"},
         {"tool": "set_device_parameter", "params": {"description": "High-pass bass at 40-60 Hz to clear space for kick sub"}, "description": "HP bass for kick clearance", "backend": "remote_command"},
         {"tool": "set_device_parameter", "params": {"description": "Sidechain compressor or volume duck on bass from kick"}, "description": "Duck bass on kick hits", "backend": "remote_command"},
@@ -121,7 +121,7 @@ CREATE_BUILDUP_TENSION = SemanticMove(
     targets={"tension": 0.5, "energy": 0.3, "contrast": 0.2},
     protect={"clarity": 0.6},
     risk_level="medium",
-    compile_plan=[
+    plan_template=[
         {"tool": "apply_gesture_template", "params": {"template_name": "tension_ratchet"}, "description": "Apply staged tension ratchet", "backend": "mcp_tool"},
         {"tool": "apply_automation_shape", "params": {"curve_type": "exponential", "description": "Rising HP filter over 4-8 bars"}, "description": "HP filter rise", "backend": "mcp_tool"},
         {"tool": "set_track_send", "params": {"description": "Increase reverb send for wash effect"}, "description": "Add reverb wash", "backend": "remote_command"},
@@ -139,7 +139,7 @@ SMOOTH_SCENE_HANDOFF = SemanticMove(
     targets={"cohesion": 0.5, "motion": 0.3, "contrast": 0.2},
     protect={"clarity": 0.7},
     risk_level="low",
-    compile_plan=[
+    plan_template=[
         {"tool": "apply_gesture_template", "params": {"template_name": "pre_arrival_vacuum"}, "description": "Pull energy back before transition", "backend": "mcp_tool"},
         {"tool": "apply_gesture_template", "params": {"template_name": "re_entry_spotlight"}, "description": "Spotlight returning elements", "backend": "mcp_tool"},
     ],

package/mcp_server/semantic_moves/models.py

@@ -1,8 +1,8 @@
 """SemanticMove — high-level musical intent that compiles to tool sequences.
 
 A semantic move expresses WHAT to achieve musically, not HOW to achieve it
-parametrically. Each move has a compile_plan that decomposes into existing
-deterministic MCP tools, and a verification_plan that checks the result.
+parametrically. Each move has a plan_template (static metadata for discovery)
+and is compiled at runtime through compiler.compile() for executable plans.
 """
 
 from __future__ import annotations
@@ -15,13 +15,13 @@ class SemanticMove:
     """A musical action expressed as intent, not parameters."""
 
     move_id: str
-    family: str  # mix, arrangement, transition, sound_design, performance
+    family: str  # mix, arrangement, transition, sound_design, performance, sample
     intent: str  # human-readable description of the musical goal
     targets: dict = field(default_factory=dict)  # dimension -> weight
     protect: dict = field(default_factory=dict)  # dimension -> threshold
     risk_level: str = "low"  # low, medium, high
     required_capabilities: list = field(default_factory=list)
-    compile_plan: list = field(default_factory=list)  # [{tool, params, description}]
+    plan_template: list = field(default_factory=list)  # [{tool, params, description}] — static metadata, NOT runtime truth
     verification_plan: list = field(default_factory=list)  # [{tool, check}]
     confidence: float = 0.7
 
@@ -34,13 +34,13 @@ class SemanticMove:
             "protect": self.protect,
             "risk_level": self.risk_level,
             "required_capabilities": self.required_capabilities,
-            "compile_plan_steps": len(self.compile_plan),
+            "plan_template_steps": len(self.plan_template),
             "confidence": self.confidence,
         }
 
     def to_full_dict(self) -> dict:
-        """Full representation including compile and verification plans."""
+        """Full representation including plan template and verification plans."""
         d = self.to_dict()
-        d["compile_plan"] = self.compile_plan
+        d["plan_template"] = self.plan_template
         d["verification_plan"] = self.verification_plan
         return d

package/mcp_server/semantic_moves/performance_moves.py

@@ -15,7 +15,7 @@ RECOVER_ENERGY = SemanticMove(
     protect={"clarity": 0.7},
     risk_level="low",
     required_capabilities=["session"],
-    compile_plan=[
+    plan_template=[
         {"tool": "set_track_volume", "params": {"description": "Gradually restore drum volume"}, "description": "Bring drums back", "backend": "remote_command"},
         {"tool": "set_track_volume", "params": {"description": "Restore bass volume"}, "description": "Bring bass back", "backend": "remote_command"},
         {"tool": "set_track_send", "params": {"description": "Reduce reverb send to tighten mix"}, "description": "Tighten reverb", "backend": "remote_command"},
@@ -33,7 +33,7 @@ DECOMPRESS_TENSION = SemanticMove(
     protect={"cohesion": 0.6},
     risk_level="low",
     required_capabilities=["session"],
-    compile_plan=[
+    plan_template=[
         {"tool": "set_track_volume", "params": {"description": "Pull back high-energy elements 15-20%"}, "description": "Pull energy down", "backend": "remote_command"},
         {"tool": "set_track_send", "params": {"description": "Increase reverb for spaciousness"}, "description": "Open space", "backend": "remote_command"},
     ],
@@ -50,7 +50,7 @@ SAFE_SPOTLIGHT = SemanticMove(
     protect={"cohesion": 0.7, "energy": 0.5},
     risk_level="low",
     required_capabilities=["session"],
-    compile_plan=[
+    plan_template=[
         {"tool": "set_track_volume", "params": {"description": "Pull non-spotlight tracks to 30-40%"}, "description": "Pull background", "backend": "remote_command"},
         {"tool": "set_track_volume", "params": {"description": "Push spotlight track to 80-85%"}, "description": "Push spotlight", "backend": "remote_command"},
     ],
@@ -67,7 +67,7 @@ EMERGENCY_SIMPLIFY = SemanticMove(
     protect={"energy": 0.3},
     risk_level="low",
     required_capabilities=["session"],
-    compile_plan=[
+    plan_template=[
         {"tool": "set_track_volume", "params": {"description": "Pull all non-rhythm tracks to 10-15%"}, "description": "Strip to essentials", "backend": "remote_command"},
         {"tool": "set_track_volume", "params": {"description": "Keep drums at current level"}, "description": "Maintain rhythm", "backend": "remote_command"},
     ],

package/mcp_server/semantic_moves/sample_compilers.py

@@ -11,6 +11,11 @@ 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 = []
@@ -34,13 +39,13 @@ def _compile_sample_chop_rhythm(move: SemanticMove, kernel: dict) -> CompiledPla
 
     steps.append(CompiledStep(
         tool="load_sample_to_simpler",
-        params={"track_index": new_idx},
+        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, "mode": "slice"},
+        params={"track_index": new_idx, "device_index": 0, "playback_mode": 2},
         description="Switch to slice mode for rhythmic chopping",
     ))
     descriptions.append("Slice sample")
@@ -88,7 +93,7 @@ def _compile_sample_texture_layer(move: SemanticMove, kernel: dict) -> CompiledP
 
     steps.append(CompiledStep(
         tool="load_sample_to_simpler",
-        params={"track_index": new_idx},
+        params={"track_index": new_idx, "file_path": _resolve_sample_path(kernel)},
         description="Load textural sample into Simpler",
     ))
     descriptions.append("Load texture sample")
@@ -141,7 +146,7 @@ def _compile_sample_vocal_ghost(move: SemanticMove, kernel: dict) -> CompiledPla
 
     steps.append(CompiledStep(
         tool="load_sample_to_simpler",
-        params={"track_index": new_idx},
+        params={"track_index": new_idx, "file_path": _resolve_sample_path(kernel)},
         description="Load vocal sample into Simpler",
     ))
 
@@ -205,13 +210,13 @@ def _compile_sample_break_layer(move: SemanticMove, kernel: dict) -> CompiledPla
 
     steps.append(CompiledStep(
         tool="load_sample_to_simpler",
-        params={"track_index": new_idx},
+        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, "mode": "slice"},
+        params={"track_index": new_idx, "device_index": 0, "playback_mode": 2},
         description="Slice break by transients for individual hits",
     ))
     descriptions.append("Slice break")
@@ -262,7 +267,7 @@ def _compile_sample_resample_destroy(move: SemanticMove, kernel: dict) -> Compil
 
     steps.append(CompiledStep(
         tool="load_sample_to_simpler",
-        params={"track_index": new_idx},
+        params={"track_index": new_idx, "file_path": _resolve_sample_path(kernel)},
         description="Load sample for destruction",
     ))
     descriptions.append("Load source")
@@ -321,13 +326,13 @@ def _compile_sample_one_shot_accent(move: SemanticMove, kernel: dict) -> Compile
 
     steps.append(CompiledStep(
         tool="load_sample_to_simpler",
-        params={"track_index": new_idx},
+        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, "mode": "one_shot"},
+        params={"track_index": new_idx, "device_index": 0, "playback_mode": 1},
         description="One-shot mode for trigger playback",
     ))
     descriptions.append("One-shot mode")

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"},