livepilot 1.9.24 → 1.10.1

package/mcp_server/tools/_conductor.py

@@ -110,6 +110,12 @@ _ROUTING_PATTERNS: list[tuple[str, str, str, str, list[str]]] = [
     # Research requests
     (r"research|how.?to|technique|tutorial|learn", "research", "research", "research_technique", []),
     (r"style.?tactic|production.?style|genre.?approach", "research", "research", "get_style_tactics", []),
+
+    # Sample requests
+    (r"sample|splice|loop|chop|flip|break(?:beat)?|one.?shot", "sample_engine", "sample", "search_samples", ["analyze_sample", "plan_sample_workflow"]),
+    (r"slice|transient.?hit|slice.?mode", "sample_engine", "sample", "plan_slice_workflow", ["search_samples"]),
+    (r"vocal.?sample|foley|field.?record|found.?sound", "sample_engine", "sample", "search_samples", ["analyze_sample"]),
+    (r"texture.?sample|ambient.?sample|atmo.?sample", "sample_engine", "sample", "search_samples", ["suggest_sample_technique"]),
 ]
 
 
@@ -164,6 +170,16 @@ def _infer_workflow_mode(request_lower: str) -> str:
     if re.search(r"fix|quick|just|only|undo|revert|simple", request_lower):
         return "quick_fix"
 
+    # Slice workflow
+    if re.search(r"slice|chop|transient.?hit", request_lower):
+        return "slice_workflow"
+
+    # Sample workflows
+    if re.search(r"sample|splice|foley|found.?sound|one.?shot|break(?:beat)?|flip|loop", request_lower):
+        if re.search(r"arrange|section|verse|chorus|drop|bridge|hook", request_lower):
+            return "sample_plus_arrangement"
+        return "sample_discovery"
+
     # Agentic loop keywords (full autonomous)
     if re.search(r"autonomous|auto|full|everything|deep|polish|finish", request_lower):
         return "agentic_loop"

package/mcp_server/tools/_planner_engine.py

@@ -164,6 +164,8 @@ class SectionPlan:
     tracks_entering: list[int]  # new elements introduced in this section
     tracks_exiting: list[int]  # elements removed in this section
 
+    sample_hints: list[str] = field(default_factory=list)
+
     def length_bars(self) -> int:
         return self.end_bar - self.start_bar
 
@@ -196,6 +198,28 @@ class ArrangementPlan:
         }
 
 
+# ── Section Sample Hints ─────────────────────────────────────────────
+
+_SECTION_SAMPLE_DEFAULTS: dict[str, list[str]] = {
+    "intro": ["texture_bed", "fill_one_shot"],
+    "verse": ["texture_bed", "fill_one_shot"],
+    "pre_chorus": ["transition_fx", "texture_bed"],
+    "chorus": ["hook_sample", "break_layer", "fill_one_shot"],
+    "drop": ["hook_sample", "break_layer", "fill_one_shot"],
+    "build": ["transition_fx", "texture_bed"],
+    "bridge": ["texture_bed", "transition_fx"],
+    "breakdown": ["texture_bed"],
+    "outro": ["texture_bed", "fill_one_shot"],
+}
+
+
+def add_sample_hints(plan: "ArrangementPlan") -> None:
+    """Populate sample_hints on each section based on section type."""
+    for section in plan.sections:
+        section_key = section.section_type.value.lower()
+        section.sample_hints = _SECTION_SAMPLE_DEFAULTS.get(section_key, ["texture_bed"])
+
+
 # ── Core Planner ─────────────────────────────────────────────────────
 
 def plan_arrangement_from_loop(

package/mcp_server/tools/analyzer.py

@@ -381,6 +381,8 @@ async def load_sample_to_simpler(
         return {"error": "Sample replacement failed after bootstrap"}
 
     result["method"] = "bootstrap_and_replace"
+    result["device_index"] = actual_device_index  # additive — for step-result binding
+    result["track_index"] = track_index
     return result
 
 

package/mcp_server/tools/arrangement.py

@@ -143,6 +143,48 @@ def create_arrangement_clip(
     return _get_ableton(ctx).send_command("create_arrangement_clip", params)
 
 
+@mcp.tool()
+def create_native_arrangement_clip(
+    ctx: Context,
+    track_index: int,
+    start_time: float,
+    length: float,
+    name: str = "",
+    color_index: Optional[int] = None,
+) -> dict:
+    """Create an empty MIDI clip directly in Arrangement View (Live 12.1.10+).
+
+    Unlike create_arrangement_clip (which duplicates a session clip), this creates
+    a native arrangement clip with full automation envelope support — volume rides,
+    filter sweeps, send automation all work natively.
+
+    Requires Live 12.1.10+. Falls back with a clear error on older versions.
+
+    track_index: 0+ for regular MIDI tracks
+    start_time:  beat position (0.0 = song start, 4.0 = bar 2 in 4/4)
+    length:      clip length in beats
+    name:        optional clip display name
+    color_index: optional 0-69 Ableton color
+    """
+    _validate_track_index(track_index)
+    if start_time < 0:
+        raise ValueError("start_time must be >= 0")
+    if length <= 0:
+        raise ValueError("length must be > 0")
+
+    params = {
+        "track_index": track_index,
+        "start_time": start_time,
+        "length": length,
+    }
+    if name:
+        params["name"] = name
+    if color_index is not None:
+        params["color_index"] = color_index
+
+    return _get_ableton(ctx).send_command("create_native_arrangement_clip", params)
+
+
 @mcp.tool()
 def add_arrangement_notes(
     ctx: Context,
@@ -288,6 +330,33 @@ def back_to_arranger(ctx: Context) -> dict:
     return _get_ableton(ctx).send_command("back_to_arranger")
 
 
+@mcp.tool()
+def force_arrangement(
+    ctx: Context,
+    beat_time: float = 0,
+    loop_start: float = 0,
+    loop_length: float = 0,
+    play: bool = True,
+) -> dict:
+    """Force ALL tracks to follow the arrangement and start playback.
+
+    Atomically: stops all session clips, releases every track from
+    session override, sets back-to-arranger, jumps to position, and
+    starts playing. This is the "play my arrangement from the top"
+    command.
+
+    beat_time: position to start from (default 0 = beginning)
+    loop_start: loop region start in beats (default 0)
+    loop_length: loop region length in beats (0 = no loop change)
+    play: whether to start playback (default True)
+    """
+    params: dict = {"beat_time": beat_time, "play": play}
+    if loop_length > 0:
+        params["loop_start"] = loop_start
+        params["loop_length"] = loop_length
+    return _get_ableton(ctx).send_command("force_arrangement", params)
+
+
 @mcp.tool()
 def get_arrangement_notes(
     ctx: Context,

package/mcp_server/tools/automation.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 from typing import Any, Optional
 
 from fastmcp import Context
+from pydantic import BaseModel, Field
 
 from ..curves import generate_curve, generate_from_recipe, list_recipes
 from ..server import mcp
@@ -27,10 +28,22 @@ def _ensure_list(v: Any) -> list:
         except json.JSONDecodeError as exc:
             raise ValueError(f"Invalid JSON in parameter: {exc}") from exc
     if isinstance(v, list):
-        return v
+        normalized = []
+        for item in v:
+            if isinstance(item, BaseModel):
+                normalized.append(item.model_dump(exclude_none=True))
+            else:
+                normalized.append(item)
+        return normalized
     return [v]
 
 
+class AutomationPoint(BaseModel):
+    time: float
+    value: float
+    duration: Optional[float] = Field(default=None, ge=0.0)
+
+
 @mcp.tool()
 def get_clip_automation(
     ctx: Context,
@@ -62,7 +75,7 @@ def set_clip_automation(
     track_index: int,
     clip_index: int,
     parameter_type: str,
-    points: Any,
+    points: list[AutomationPoint] | str,
     device_index: Optional[int] = None,
     parameter_index: Optional[int] = None,
     send_index: Optional[int] = None,

package/mcp_server/tools/devices.py

@@ -1,6 +1,6 @@
 """Device MCP tools — parameters, racks, browser loading, plugin deep control.
 
-15 tools matching the Remote Script devices domain + M4L bridge.
+16 tools matching the Remote Script devices domain + M4L bridge.
 """
 
 from __future__ import annotations
@@ -359,14 +359,15 @@ def find_and_load_device(ctx: Context, track_index: int, device_name: str) -> di
     if not device_name.strip():
         raise ValueError("device_name cannot be empty")
 
-    # Guardrail: bare Drum Rack produces silence (no samples loaded)
+    # Guardrail: bare Drum Rack produces silence unless building programmatically (12.3+)
     if device_name.strip().lower() == "drum rack":
         raise ValueError(
             "Loading a bare 'Drum Rack' creates an empty rack that produces silence. "
-            "Instead, use search_browser(path='drums') to find a kit preset "
-            "(e.g., '808 Core Kit'), then load it with load_browser_item(). "
-            "Or use DS drum synths (DS Kick, DS Snare, DS HH, DS Tom, DS Clap, "
-            "DS Cymbal) which are self-contained."
+            "Options: (1) search_browser(path='drums') to find a kit preset "
+            "(e.g., '808 Core Kit'), then load with load_browser_item(). "
+            "(2) On Live 12.3+: use insert_device('Drum Rack') + insert_rack_chain "
+            "+ set_drum_chain_note to build a kit programmatically. "
+            "(3) DS drum synths (DS Kick, DS Snare, DS HH) are self-contained."
         )
 
     result = _get_ableton(ctx).send_command("find_and_load_device", {
@@ -376,6 +377,116 @@ def find_and_load_device(ctx: Context, track_index: int, device_name: str) -> di
     return _postflight_loaded_device(ctx, result)
 
 
+@mcp.tool()
+def insert_device(
+    ctx: Context,
+    track_index: int,
+    device_name: str,
+    position: int = -1,
+    device_index: Optional[int] = None,
+    chain_index: Optional[int] = None,
+) -> dict:
+    """Insert a native Live device by name — 10x faster than browser search (Live 12.3+).
+
+    Only works for native devices (Reverb, Compressor, EQ Eight, Drift, etc.).
+    For plugins, M4L devices, or presets, use find_and_load_device or load_browser_item.
+
+    track_index:  0+ for regular tracks, -1/-2 for returns, -1000 for master
+    device_name:  exact device name (e.g. 'Reverb', 'Auto Filter', 'Wavetable')
+    position:     device chain position (0 = first, -1 = end of chain)
+    device_index: required when inserting into a rack chain (identifies the rack)
+    chain_index:  insert into this chain of a rack device (for building drum kits)
+
+    Drum Rack construction workflow (12.3+):
+    1. insert_device(track_index, 'Drum Rack')       — create empty rack
+    2. insert_rack_chain(track_index, device_index)   — add chains
+    3. set_drum_chain_note(chain_index, note=36)      — assign C1 (kick)
+    4. insert_device(track_index, 'Simpler',          — add instrument
+       device_index=rack_idx, chain_index=0)            into chain
+
+    On Live < 12.3: returns an error suggesting find_and_load_device instead.
+    """
+    _validate_track_index(track_index)
+    if not device_name.strip():
+        raise ValueError("device_name cannot be empty")
+
+    params = {
+        "track_index": track_index,
+        "device_name": device_name,
+        "position": position,
+    }
+    if device_index is not None:
+        params["device_index"] = device_index
+    if chain_index is not None:
+        if device_index is None:
+            raise ValueError("device_index is required when chain_index is provided")
+        _validate_device_index(device_index)
+        _validate_chain_index(chain_index)
+        params["chain_index"] = chain_index
+
+    result = _get_ableton(ctx).send_command("insert_device", params)
+    return _postflight_loaded_device(ctx, result)
+
+
+@mcp.tool()
+def insert_rack_chain(
+    ctx: Context,
+    track_index: int,
+    device_index: int,
+    position: int = -1,
+) -> dict:
+    """Insert a new chain into a Rack device — Instrument Rack, Audio Effect Rack, or Drum Rack (Live 12.3+).
+
+    Use with insert_device + set_drum_chain_note to build Drum Racks from scratch:
+    1. insert_device(track, 'Drum Rack') to create the rack
+    2. insert_rack_chain(track, rack_device_index) to add chains
+    3. set_drum_chain_note(chain_index=0, note=36) to assign C1 (kick)
+    4. insert_device(track, 'Simpler', device_index=rack, chain_index=0) into chain
+
+    track_index:  track containing the rack
+    device_index: rack device index on the track
+    position:     chain position (-1 = append to end)
+    """
+    _validate_track_index(track_index)
+    _validate_device_index(device_index)
+
+    return _get_ableton(ctx).send_command("insert_rack_chain", {
+        "track_index": track_index,
+        "device_index": device_index,
+        "position": position,
+    })
+
+
+@mcp.tool()
+def set_drum_chain_note(
+    ctx: Context,
+    track_index: int,
+    device_index: int,
+    chain_index: int,
+    note: int,
+) -> dict:
+    """Set which MIDI note triggers a Drum Rack chain (Live 12.3+).
+
+    Standard drum mapping:
+    C1 (36) = Kick, D1 (38) = Snare, F#1 (42) = Closed HH,
+    A#1 (46) = Open HH, C#2 (49) = Crash, D#2 (51) = Ride
+
+    note: MIDI note 0-127, or -1 for 'All Notes'
+    """
+    _validate_track_index(track_index)
+    _validate_device_index(device_index)
+    _validate_chain_index(chain_index)
+    if note < -1 or note > 127:
+        raise ValueError("note must be -1 (All Notes) or 0-127")
+
+    return _get_ableton(ctx).send_command("set_drum_chain_note", {
+        "track_index": track_index,
+        "device_index": device_index,
+        "chain_index": chain_index,
+        "note": note,
+    })
+
+
 @mcp.tool()
 def set_simpler_playback_mode(
     ctx: Context,

package/mcp_server/tools/notes.py

@@ -9,6 +9,7 @@ import json
 from typing import Any, Optional
 
 from fastmcp import Context
+from pydantic import BaseModel, Field
 
 from ..server import mcp
 
@@ -25,9 +26,36 @@ def _ensure_list(value: Any) -> list:
             return json.loads(value)
         except json.JSONDecodeError as exc:
             raise ValueError(f"Invalid JSON in parameter: {exc}") from exc
+    if isinstance(value, list):
+        normalized = []
+        for item in value:
+            if isinstance(item, BaseModel):
+                normalized.append(item.model_dump(exclude_none=True))
+            else:
+                normalized.append(item)
+        return normalized
     return value
 
 
+class NoteSpec(BaseModel):
+    pitch: int = Field(ge=0, le=127)
+    start_time: float
+    duration: float = Field(gt=0)
+    velocity: Optional[float] = Field(default=None, ge=0.0, le=127.0)
+    probability: Optional[float] = Field(default=None, ge=0.0, le=1.0)
+    velocity_deviation: Optional[float] = Field(default=None, ge=-127.0, le=127.0)
+    release_velocity: Optional[float] = Field(default=None, ge=0.0, le=127.0)
+
+
+class NoteModification(BaseModel):
+    note_id: int
+    pitch: Optional[int] = Field(default=None, ge=0, le=127)
+    start_time: Optional[float] = None
+    duration: Optional[float] = Field(default=None, gt=0)
+    velocity: Optional[float] = Field(default=None, ge=0.0, le=127.0)
+    probability: Optional[float] = Field(default=None, ge=0.0, le=1.0)
+
+
 def _validate_track_index(track_index: int):
     """Validate track index. Must be >= 0 for regular tracks."""
     if track_index < 0:
@@ -78,7 +106,7 @@ def _validate_note(note: dict):
 
 
 @mcp.tool()
-def add_notes(ctx: Context, track_index: int, clip_index: int, notes: Any) -> dict:
+def add_notes(ctx: Context, track_index: int, clip_index: int, notes: list[NoteSpec] | str) -> dict:
     """Add MIDI notes to a clip. notes is a JSON array: [{pitch, start_time, duration, velocity?, probability?, velocity_deviation?, release_velocity?}]."""
     _validate_track_index(track_index)
     _validate_clip_index(clip_index)
@@ -157,7 +185,7 @@ def remove_notes(
 
 
 @mcp.tool()
-def remove_notes_by_id(ctx: Context, track_index: int, clip_index: int, note_ids: Any) -> dict:
+def remove_notes_by_id(ctx: Context, track_index: int, clip_index: int, note_ids: list[int] | str) -> dict:
     """Remove specific MIDI notes by their IDs (JSON array of ints). Use undo to revert."""
     _validate_track_index(track_index)
     _validate_clip_index(clip_index)
@@ -172,7 +200,12 @@ def remove_notes_by_id(ctx: Context, track_index: int, clip_index: int, note_ids
 
 
 @mcp.tool()
-def modify_notes(ctx: Context, track_index: int, clip_index: int, modifications: Any) -> dict:
+def modify_notes(
+    ctx: Context,
+    track_index: int,
+    clip_index: int,
+    modifications: list[NoteModification] | str,
+) -> dict:
     """Modify existing MIDI notes by ID. modifications is a JSON array: [{note_id, pitch?, start_time?, duration?, velocity?, probability?}]."""
     _validate_track_index(track_index)
     _validate_clip_index(clip_index)
@@ -202,7 +235,7 @@ def duplicate_notes(
     ctx: Context,
     track_index: int,
     clip_index: int,
-    note_ids: Any,
+    note_ids: list[int] | str,
     time_offset: float = 0.0,
 ) -> dict:
     """Duplicate specific notes by ID (JSON array of ints), with optional time offset (in beats)."""

package/mcp_server/tools/planner.py

@@ -88,6 +88,9 @@ def plan_arrangement(
         style=style,
     )
 
+    # Add section-level sample role hints
+    planner_engine.add_sample_hints(plan)
+
     result = plan.to_dict()
     result["loop_identity"] = loop_identity.to_dict()
     result["available_styles"] = sorted(planner_engine.VALID_STYLES)

package/mcp_server/wonder_mode/diagnosis.py

@@ -23,6 +23,11 @@ _DOMAIN_MAP: dict[str, list[str]] = {
     "too_safe_to_progress": ["sound_design", "transition"],
     "section_missing": ["arrangement", "transition"],
     "transition_not_earned": ["transition", "arrangement"],
+    # Sample-domain patterns (session-state analysis, not action-history)
+    "no_organic_texture": ["sample", "sound_design"],
+    "stale_drums": ["sample", "arrangement"],
+    "vocal_processing_monotony": ["sample", "sound_design"],
+    "dense_but_static": ["sample", "mix"],
 }
 
 _STUCKNESS_THRESHOLD = 0.2  # Below this, treat as user_request