livepilot 1.23.6 → 1.25.0

package/mcp_server/server.py

@@ -308,6 +308,7 @@ from .atlas import tools as atlas_tools                        # noqa: F401, E40
 from .composer import tools as composer_tools                  # noqa: F401, E402
 from .synthesis_brain import tools as synthesis_brain_tools    # noqa: F401, E402
 from .user_corpus import tools as user_corpus_tools            # noqa: F401, E402
+from .audit import tools as audit_tools                        # noqa: F401, E402
 from .tools import diagnostics   # noqa: F401, E402
 from .tools import miditool       # noqa: F401, E402
 

package/mcp_server/splice_client/client.py

@@ -218,6 +218,7 @@ class SpliceGRPCClient:
         tags: Optional[list[str]] = None,
         genre: str = "",
         sample_type: str = "",
+        instrument: str = "",
         sort: str = "",
         per_page: int = 20,
         page: int = 1,
@@ -230,6 +231,11 @@ class SpliceGRPCClient:
         `collection_uuid` scopes search to a single user collection
         (e.g. "Likes", "bass") — pure taste signal when present.
         `file_hash` is a direct lookup for a single sample.
+        `instrument` filters by Splice's instrument category — examples
+        the gRPC schema accepts include "bass", "drum", "synth",
+        "piano", "vocal", "fx", "guitar", "pad". Crucial for full-mode
+        composition where role-correctness matters more than text-match
+        on free-form query strings (BUG-FULL-MODE-9, 2026-05-01).
         """
         if not self.connected:
             return SpliceSearchResult()
@@ -248,6 +254,7 @@ class SpliceGRPCClient:
                 BPMMax=bpm_max,
                 Tags=tags or [],
                 Genre=genre,
+                Instrument=instrument,
                 SampleType=sample_type,
                 SortFn=sort,
                 PerPage=per_page,

package/mcp_server/tools/_analyzer_engine/sample.py

@@ -66,10 +66,63 @@ _DRUM_ROOT_MAP = {
 }
 
 
+_LOOP_PATH_HINTS = (
+    "/loops/",
+    "/drum_loops/",
+    "/melodic_loops/",
+    "/pad_loops/",
+    "/bass_loops/",
+    "/synth_loops/",
+    "/perc_loops/",
+    "/vocal_loops/",
+    "/fx_loops/",
+)
+_ONESHOT_HINTS = (
+    "oneshot",
+    "one_shot",
+    "one-shot",
+    "_os_",
+    "/oneshots/",
+    "/one_shots/",
+    "/one-shots/",
+)
+_LOOP_FILENAME_RE = re.compile(
+    r"(?:_|\b)\d{2,3}(?:_|bpm|\b)|(?:_|\b)loop(?:_|\b)",
+    re.IGNORECASE,
+)
+
+
 def _is_warped_loop(file_path: str) -> bool:
-    """Return True if the filename contains a BPM marker (likely a tempo-locked loop)."""
+    """Return True if the file is likely a tempo-locked loop sample.
+
+    2026-05-01 broadening (BUG-FULL-MODE-3): the original regex only matched
+    "125bpm" / "125 bpm" literal patterns, which fails for the most common
+    Splice naming where BPM is embedded as bare digits (e.g.
+    `lfh_drums_125_hubble_hatclp.wav`). The broadened detection also looks
+    at the path components (`/drum_loops/`, `/melodic_loops/`, etc.) and
+    excludes explicit one-shots.
+
+    Why it matters: the hygiene step that ran on a "false" verdict left
+    Simplers without `S Loop On=1`, so the loop never actually loops — it
+    plays once and stops. Combined with `Ve Mode=None` (also fixed below),
+    every Splice loop loaded into Simpler was silent.
+    """
+    full_lower = file_path.lower()
+    # One-shots are explicitly NOT warped loops, even when path also has loop hints
+    if any(hint in full_lower for hint in _ONESHOT_HINTS):
+        return False
+
     stem = os.path.splitext(os.path.basename(file_path))[0]
-    return bool(_BPM_IN_FILENAME_RE.search(stem))
+    if _BPM_IN_FILENAME_RE.search(stem):
+        return True
+    if _LOOP_FILENAME_RE.search(stem):
+        return True
+    # Append trailing slash so `/loops/` and `/drum_loops/` match the
+    # last directory component cleanly (os.path.dirname strips trailing /).
+    parent = os.path.dirname(file_path).lower() + "/"
+    if any(seg in parent for seg in _LOOP_PATH_HINTS):
+        return True
+    return False
 
 
 def _filename_stem(file_path: str) -> str:
@@ -104,9 +157,18 @@ async def _simpler_post_load_hygiene(
     track_index: int,
     device_index: int,
     file_path: str,
+    warp_loops: bool = True,
 ) -> dict:
     """Apply post-load hygiene to a newly loaded Simpler and verify success.
 
+    `warp_loops` (BUG-FULL-MODE-12, 2026-05-01): when True (default),
+    tempo-locked loops get `simpler_set_warp(warping=1, mode=Beats|...)`
+    so they play in sync with project tempo. Set False for creative
+    chop mode where un-warped loops produce intentional rhythmic
+    mismatches (J Dilla territory). compose_full_apply translates its
+    `warp_strategy` parameter ("always" / "smart" / "chop") into the
+    right per-step boolean before calling this.
+
     Steps:
       1. Read track info to verify the device's actual name matches the
          expected sample stem. If it doesn't, return an error.
@@ -150,13 +212,43 @@ async def _simpler_post_load_hygiene(
             "expected_stem": expected_stem,
         }
 
-    # Step 2: turn Snap OFF — required for reliable playback after replace
+    # Step 2: post-load defaults
+    #
+    # Hygiene applied unconditionally (BUG-FULL-MODE-3, 2026-05-01):
+    #
+    #   `Snap=0`     — required so non-quantized sample playback works.
+    #   `Volume=0`   — load_browser_item / replace_sample come up at
+    #                  -12 dB (the documented Simpler default) which makes
+    #                  the sample audible-on-track-meter but inaudible on
+    #                  the master meter. 0 dB is the right gain-staged
+    #                  default for any newly loaded sample.
+    #                  Ref: feedback_simpler_default_volume.md.
+    #
+    # NOTE on Ve Mode (2026-05-01 reconsidered): an earlier draft of this
+    # hygiene set `Ve Mode = 4` ("Trigger" / AD-R envelope) so the sample
+    # would play "in full" regardless of note duration. That choice was
+    # wrong: AD-R retriggers the AD envelope continuously while held,
+    # producing audible tremolo on long sustained notes (every 600ms at
+    # default Ve Decay). Live's default `Ve Mode = 0` (None — standard
+    # ADSR with sustain held until note-off) is the correct idiomatic
+    # default, AS LONG AS the trigger note duration matches the clip
+    # length. The companion fix is in `engine.py` where the planner now
+    # emits `duration = SOURCE_BEATS` for sample-trigger notes.
+    #
+    # Empirical Ve Mode mapping (live-probed against Live 12.4):
+    #     0 = None    (default; standard ADSR with sustain) ← keep this
+    #     1 = Loop    (AD loops while held)
+    #     2 = Beat    (envelope synced to beat divisions)
+    #     3 = Sync    (envelope synced to host tempo)
+    #     4 = Trigger (AD-R; cycles AD until note-off — caused tremolo bug)
+    is_loop = _is_warped_loop(file_path)
     hygiene_params: list[dict] = [
         {"name_or_index": "Snap", "value": 0},
+        {"name_or_index": "Volume", "value": 0.0},
     ]
 
     # Step 3: smart defaults for warped loops
-    if _is_warped_loop(file_path):
+    if is_loop:
         hygiene_params.extend([
             {"name_or_index": "S Start", "value": 0.0},
             {"name_or_index": "S Length", "value": 1.0},
@@ -166,12 +258,21 @@ async def _simpler_post_load_hygiene(
     # Step 4: auto-detect drum root note from filename (BUG-2026-04-22#18).
     # Only applied for one-shots — warped loops keep Live's default root
     # because their root note is irrelevant at loop playback speeds.
+    #
+    # 2026-05-02 — fixed param name: was "Sample Pitch Coarse" (doesn't exist
+    # on OriginalSimpler — silently failed). Correct param is "Transpose"
+    # (semitone offset from C3=60). Convert detected drum root → Transpose:
+    # Transpose = 60 - drum_root. Example: drum_root=36 (C1) → Transpose=+24,
+    # so triggering MIDI 36 plays the sample at original recorded pitch.
     drum_root = None
-    if not _is_warped_loop(file_path):
+    if not is_loop:
         drum_root = _detect_drum_root_note(file_path)
         if drum_root is not None:
+            transpose_value = 60 - int(drum_root)
+            # Clamp to Simpler's Transpose range (-48..+48 semitones)
+            transpose_value = max(-48, min(48, transpose_value))
             hygiene_params.append(
-                {"name_or_index": "Sample Pitch Coarse", "value": drum_root}
+                {"name_or_index": "Transpose", "value": transpose_value}
             )
 
     try:
@@ -185,11 +286,75 @@ async def _simpler_post_load_hygiene(
         # non-fatal — verification already succeeded
         pass
 
+    # Step 5: force Classic playback mode (BUG-FULL-MODE-3).
+    # Live auto-slices drum loops into Slice mode on load, which means a
+    # single C3 trigger note doesn't map to any slice → silence. Classic
+    # mode is the correct default for sample playback; user can switch
+    # to Slice/One-Shot explicitly if they want.
+    playback_mode_set = False
+    try:
+        ableton.send_command("set_simpler_playback_mode", {
+            "track_index": track_index,
+            "device_index": device_index,
+            "playback_mode": 0,  # 0 = Classic, 1 = One-Shot, 2 = Slice
+        })
+        playback_mode_set = True
+    except Exception as exc:
+        logger.debug("_simpler_post_load_hygiene: set_simpler_playback_mode failed: %s", exc)
+
+    # Step 6: enable Simpler warp on tempo-locked loops (BUG-FULL-MODE-11,
+    # 2026-05-01). Splice loops embed the source BPM in the filename
+    # (e.g. `SO_SD_90_drum_loop_slippy.wav` = 90 BPM) but Simpler loads
+    # them at NATIVE rate by default — a 90-BPM drum loop in a 122-BPM
+    # project plays 35% slow.
+    #
+    # `simpler_set_warp` toggles `SimplerDevice.sample.warping` which
+    # lives on the sample child object — only reachable via the M4L
+    # bridge (Python LiveAPI can't step into the sample child). The
+    # bridge call is positional, NOT a dict.
+    #
+    # warp_mode mapping (from Live's docs):
+    #     0 = Beats        — drums / percussive (transient-preserving)
+    #     1 = Tones        — mono harmonic material
+    #     2 = Texture      — poly / ambient / vocals (smoothest)
+    #     3 = Re-Pitch     — classic pitch-shift (NOT what we want here)
+    #     4 = Complex      — full musical material (mid CPU)
+    #     6 = Complex Pro  — highest quality (highest CPU)
+    #
+    # Choosing by file path hint mirrors the `_LOOP_PATH_HINTS` partition.
+    # One-shots stay un-warped — warping a kick produces phasing.
+    warp_set = False
+    if is_loop and warp_loops:
+        path_lower = file_path.lower()
+        if any(seg in path_lower for seg in ("/drum_loops/", "drum_loop", "drumloop", "/breaks/", "/break_", "/perc_loops/")):
+            warp_mode = 0  # Beats
+        elif any(seg in path_lower for seg in ("/vocal_loops/", "vocal_loop", "/vox/", "vocal")):
+            warp_mode = 2  # Texture — preserves vocal transients
+        elif any(seg in path_lower for seg in ("/pad_loops/", "pad_loop", "/melodic_loops/", "melodic_loop", "/synth_loops/", "synth_loop", "/bass_loops/", "bass_loop")):
+            warp_mode = 4  # Complex — best for harmonic material
+        else:
+            warp_mode = 0  # default to Beats — safest for unknown loops
+        try:
+            await bridge.send_command(
+                "simpler_set_warp",
+                int(track_index),
+                int(device_index),
+                1,                  # warping ON
+                int(warp_mode),
+                timeout=10.0,
+            )
+            warp_set = True
+        except Exception as exc:
+            logger.debug("_simpler_post_load_hygiene: simpler_set_warp failed: %s", exc)
+
     return {
         "verified": True,
         "device_name": actual_name,
         "track_index": track_index,
         "device_index": device_index,
-        "warped_loop_defaults_applied": _is_warped_loop(file_path),
+        "warped_loop_defaults_applied": is_loop,
+        "volume_set": True,
+        "playback_mode_set": playback_mode_set,
+        "warp_set": warp_set,
         "auto_root_note": drum_root,
     }

package/mcp_server/tools/_planner_engine.py

@@ -26,64 +26,10 @@ from ._composition_engine import (
 )
 
 
-# ── Section Templates ────────────────────────────────────────────────
-
-# Prototypical section sequences by style. Each entry:
-# (section_type, energy_target, density_target, typical_bars)
-STYLE_TEMPLATES: dict[str, list[tuple[SectionType, float, float, int]]] = {
-    "electronic": [
-        (SectionType.INTRO, 0.2, 0.2, 16),
-        (SectionType.VERSE, 0.5, 0.5, 16),
-        (SectionType.BUILD, 0.6, 0.6, 8),
-        (SectionType.DROP, 0.9, 0.9, 16),
-        (SectionType.BREAKDOWN, 0.3, 0.3, 8),
-        (SectionType.BUILD, 0.7, 0.7, 8),
-        (SectionType.DROP, 1.0, 1.0, 16),
-        (SectionType.OUTRO, 0.2, 0.2, 16),
-    ],
-    "hiphop": [
-        (SectionType.INTRO, 0.3, 0.3, 8),
-        (SectionType.VERSE, 0.6, 0.6, 16),
-        (SectionType.CHORUS, 0.8, 0.8, 8),
-        (SectionType.VERSE, 0.6, 0.6, 16),
-        (SectionType.CHORUS, 0.8, 0.8, 8),
-        (SectionType.BRIDGE, 0.5, 0.4, 8),
-        (SectionType.CHORUS, 0.9, 0.9, 8),
-        (SectionType.OUTRO, 0.3, 0.3, 8),
-    ],
-    "pop": [
-        (SectionType.INTRO, 0.3, 0.3, 8),
-        (SectionType.VERSE, 0.5, 0.5, 16),
-        (SectionType.PRE_CHORUS, 0.6, 0.6, 8),
-        (SectionType.CHORUS, 0.8, 0.8, 8),
-        (SectionType.VERSE, 0.5, 0.5, 16),
-        (SectionType.PRE_CHORUS, 0.6, 0.6, 8),
-        (SectionType.CHORUS, 0.9, 0.9, 8),
-        (SectionType.BRIDGE, 0.4, 0.4, 8),
-        (SectionType.CHORUS, 1.0, 1.0, 8),
-        (SectionType.OUTRO, 0.3, 0.3, 8),
-    ],
-    "ambient": [
-        (SectionType.INTRO, 0.1, 0.1, 32),
-        (SectionType.VERSE, 0.3, 0.3, 32),
-        (SectionType.VERSE, 0.5, 0.5, 32),
-        (SectionType.BREAKDOWN, 0.2, 0.2, 16),
-        (SectionType.VERSE, 0.4, 0.4, 32),
-        (SectionType.OUTRO, 0.1, 0.1, 32),
-    ],
-    "techno": [
-        (SectionType.INTRO, 0.3, 0.3, 16),
-        (SectionType.VERSE, 0.6, 0.6, 32),
-        (SectionType.BUILD, 0.7, 0.7, 8),
-        (SectionType.DROP, 1.0, 1.0, 32),
-        (SectionType.BREAKDOWN, 0.3, 0.3, 16),
-        (SectionType.BUILD, 0.8, 0.8, 8),
-        (SectionType.DROP, 1.0, 1.0, 32),
-        (SectionType.OUTRO, 0.3, 0.3, 16),
-    ],
-}
-
-VALID_STYLES = frozenset(STYLE_TEMPLATES.keys())
+# v1.24: STYLE_TEMPLATES removed per vocabulary-not-form principle (Task 12).
+# The framework provides VOCABULARY (descriptive). The LLM provides FORM
+# (creative). Genre form templates (section sequences, bar counts, drop
+# placements) belong in the LLM's training data + WebSearch fallback, NOT here.
 
 
 # ── Loop Identity ────────────────────────────────────────────────────
@@ -226,18 +172,34 @@ def plan_arrangement_from_loop(
     loop_identity: LoopIdentity,
     target_duration_bars: int = 128,
     style: str = "electronic",
+    section_template: Optional[list[tuple["SectionType", float, float, int]]] = None,
 ) -> ArrangementPlan:
     """Transform a loop identity into a full arrangement blueprint.
 
-    1. Select section template based on style
+    # DEPRECATED in v1.24 — full mode is now LLM-creative. This function may
+    # remain functional but should not be relied on for v1.24+ flows.
+    # v1.24: STYLE_TEMPLATES removed per vocabulary-not-form principle (Task 12).
+    # Callers must supply section_template explicitly; the built-in registry is gone.
+
+    1. Use caller-supplied section_template (required in v1.24+)
     2. Scale section lengths to target duration
     3. Plan element reveal order (what enters/exits when)
     4. Suggest gesture automation for transitions
-    """
-    if style not in STYLE_TEMPLATES:
-        raise ValueError(f"Unknown style '{style}'. Valid: {sorted(VALID_STYLES)}")
 
-    template = STYLE_TEMPLATES[style]
+    Args:
+        section_template: List of (SectionType, energy_target, density_target,
+            bars) tuples. The LLM or caller is responsible for providing this
+            based on the genre/mood context. MUST start with INTRO and end with
+            OUTRO by convention.
+    """
+    if section_template is None:
+        raise ValueError(
+            "section_template is required in v1.24+. "
+            "STYLE_TEMPLATES was removed — the LLM provides form, not the framework. "
+            "Pass an explicit section_template list."
+        )
+
+    template = section_template
 
     # 1. Scale sections to target duration
     template_bars = sum(s[3] for s in template)

package/mcp_server/tools/analyzer.py

@@ -573,6 +573,7 @@ async def replace_simpler_sample(
     file_path: str,
     chain_index: Optional[int] = None,
     nested_device_index: Optional[int] = None,
+    warp_loops: bool = True,
 ) -> dict:
     """Load an audio file into a Simpler device by absolute file path.
 
@@ -618,7 +619,8 @@ async def replace_simpler_sample(
     )
     if native is not None:
         hygiene = await _simpler_post_load_hygiene(
-            bridge, ableton, track_index, device_index, file_path
+            bridge, ableton, track_index, device_index, file_path,
+            warp_loops=warp_loops,
         )
         if not hygiene.get("verified"):
             return hygiene
@@ -642,7 +644,8 @@ async def replace_simpler_sample(
         }
 
     hygiene = await _simpler_post_load_hygiene(
-        bridge, ableton, track_index, device_index, file_path
+        bridge, ableton, track_index, device_index, file_path,
+        warp_loops=warp_loops,
     )
     if not hygiene.get("verified"):
         return hygiene
@@ -660,6 +663,7 @@ async def load_sample_to_simpler(
     track_index: int,
     file_path: str,
     device_index: int = 0,
+    warp_loops: bool = True,
 ) -> dict:
     """Load an audio file into a NEW Simpler device on a track.
 
@@ -703,7 +707,8 @@ async def load_sample_to_simpler(
             )
             if native is not None:
                 hygiene = await _simpler_post_load_hygiene(
-                    bridge, ableton, track_index, actual_device_index, file_path
+                    bridge, ableton, track_index, actual_device_index, file_path,
+                    warp_loops=warp_loops,
                 )
                 if not hygiene.get("verified"):
                     return hygiene
@@ -759,7 +764,8 @@ async def load_sample_to_simpler(
 
     # Step 4: Verify by reading back the device name (P0-1 guard)
     hygiene = await _simpler_post_load_hygiene(
-        bridge, ableton, track_index, actual_device_index, file_path
+        bridge, ableton, track_index, actual_device_index, file_path,
+        warp_loops=warp_loops,
     )
     if not hygiene.get("verified"):
         return hygiene

package/mcp_server/tools/browser.py

@@ -158,28 +158,57 @@ def search_browser(
     return _get_ableton(ctx).send_command("search_browser", params)
 
 
-# Role-aware Simpler defaults — BUG-2026-04-22 #17 + #18.
+# M4L instrument post-load hygiene — 2026-05-02.
+# Some Max-for-Live instruments load with defaults that immediately produce loud
+# unwanted output (Harmonic Drone Generator from Drone Lab is the canonical
+# example: Latch on + Density 80% + Volume −6 dB + all 8 voices active = a wall
+# of sustained drone the moment any MIDI note touches it). Apply tames here so
+# the device is workable on first load. Each entry maps a device-name match
+# (substring) to a list of (parameter_name, value) pairs.
+#
+# Detection runs UNCONDITIONALLY (not gated on `role` like _SIMPLER_ROLE_DEFAULTS)
+# because these M4L instruments are typically loaded without a role parameter.
+_M4L_INSTRUMENT_HYGIENE: dict[str, list[tuple[str, float]]] = {
+    "Harmonic Drone Generator": [
+        ("Latch", 0),       # Off — prevents indefinite note sustain after one trigger
+        ("Volume", -40),    # ≈ -20 dB display (default is -18 / -6 dB which is too loud)
+        ("Density", 40),    # 40% (default 80% is too dense for a background bed)
+    ],
+}
+
+
+# Role-aware Simpler defaults — BUG-2026-04-22 #17 + #18, plus 2026-05-02 fix.
 # Each role maps to a list of (parameter_name, value) pairs applied after
 # load via set_device_parameter. Trigger Mode polarity per BUG #9:
-# 0 = Trigger (one-shot), 1 = Gate (held). Volume in dB. Root in MIDI pitch.
+# 0 = Trigger (one-shot), 1 = Gate (held). Volume in dB. Transpose in semitones.
+#
+# 2026-05-02 — fixed pitch-shift bug:
+# Earlier versions used "Sample Pitch Coarse" param name, which DOES NOT EXIST
+# on OriginalSimpler — the call silently raised and was swallowed. Result: every
+# drum-role Simpler played 24 semitones below original pitch ("super low" sound)
+# because the Simpler's default sample root is C3 (60), but drum convention sends
+# MIDI 36 (C1). The correct parameter is "Transpose" (range -48..+48 semitones);
+# +24 compensates for the C3-vs-C1 mismatch so drum samples play at original
+# recorded pitch when MIDI 36 is sent. Melodic/texture roles use Transpose=0
+# because their default playback range centers on C3 (60) — no compensation needed.
 _SIMPLER_ROLE_DEFAULTS = {
     "drum": [
         ("Snap", 0),
         ("Volume", 0.0),
         ("Trigger Mode", 0),  # Trigger / one-shot
-        ("Sample Pitch Coarse", 36),  # C1, matches drum-pad convention
+        ("Transpose", 24),    # Compensate C3-default → C1-drum-convention root
     ],
     "melodic": [
         ("Snap", 1),
         ("Volume", 0.0),
         ("Trigger Mode", 1),  # Gate / held
-        ("Sample Pitch Coarse", 60),  # C3
+        ("Transpose", 0),     # C3 default — melodic input range
     ],
     "texture": [
         ("Snap", 0),
         ("Volume", -6.0),
         ("Trigger Mode", 1),  # Gate
-        ("Sample Pitch Coarse", 60),  # C3
+        ("Transpose", 0),     # C3 default — sustained-input range
     ],
 }
 
@@ -238,26 +267,80 @@ def load_browser_item(
         "uri": uri,
     })
 
-    # Post-load: apply role-aware defaults if the loaded device is a Simpler.
-    if role and isinstance(result, dict) and not result.get("error"):
-        device_index = result.get("device_index")
-        device_class = str(result.get("class_name") or result.get("device_name") or "")
-        if device_index is not None and "Simpler" in device_class:
-            applied = []
-            for name, value in _SIMPLER_ROLE_DEFAULTS[role]:
+    # Post-load: probe the loaded device once, then apply two layers of hygiene.
+    #
+    # 2026-05-02 — fixed device-detection bug. The TCP load_browser_item command
+    # returns {loaded, name, device_count} with NO device_index and NO class_name,
+    # so the previous detection (`result.get("device_index")` / `result.get("class_name")`)
+    # always failed and the role-defaults branch was never entered. Resolution:
+    # treat newly-loaded sample-on-empty-track as device_index=0 (Live places the
+    # instrument at chain head) and verify class + name via get_device_info.
+    #
+    # Layer 1 (gated on `role`): Simpler role-aware defaults — Snap/Volume/
+    # Trigger Mode/Transpose for drum/melodic/texture roles.
+    # Layer 2 (unconditional): M4L instrument hygiene — name-matched tames for
+    # known problem devices (Harmonic Drone Generator's Latch + loud defaults).
+    device_index_resolved: Optional[int] = None
+    device_class = ""
+    device_name_loaded = ""
+    if isinstance(result, dict) and result.get("loaded") and not result.get("error"):
+        device_index_resolved = result.get("device_index")
+        try:
+            probe = ableton.send_command("get_device_info", {
+                "track_index": track_index,
+                "device_index": 0,
+            })
+            device_class = str(probe.get("class_name", "") or "")
+            device_name_loaded = str(probe.get("name", "") or result.get("name", "") or "")
+            if device_index_resolved is None:
+                device_index_resolved = 0
+        except Exception:
+            pass
+
+    # Layer 1 — Simpler role-aware defaults
+    if role and device_index_resolved is not None and "Simpler" in device_class:
+        applied = []
+        for name, value in _SIMPLER_ROLE_DEFAULTS[role]:
+            try:
+                ableton.send_command("set_device_parameter", {
+                    "track_index": track_index,
+                    "device_index": int(device_index_resolved),
+                    "parameter_name": name,
+                    "value": value,
+                })
+                applied.append({"parameter": name, "value": value})
+            except Exception as exc:
+                # Don't fail the whole load if one default doesn't apply
+                # (parameter name might not exist on every Simpler variant).
+                applied.append({"parameter": name, "skipped": str(exc)})
+        result["role"] = role
+        result["role_defaults_applied"] = applied
+        result["device_class"] = device_class
+
+    # Layer 2 — M4L instrument hygiene (unconditional, name-matched).
+    # Detects Harmonic Drone Generator and other known problem M4L instruments
+    # by name substring, applies tame defaults to prevent loud-on-load surprises.
+    if device_index_resolved is not None and device_name_loaded:
+        for hygiene_name, params in _M4L_INSTRUMENT_HYGIENE.items():
+            if hygiene_name not in device_name_loaded:
+                continue
+            applied_hygiene = []
+            for name, value in params:
                 try:
                     ableton.send_command("set_device_parameter", {
                         "track_index": track_index,
-                        "device_index": int(device_index),
+                        "device_index": int(device_index_resolved),
                         "parameter_name": name,
                         "value": value,
                     })
-                    applied.append({"parameter": name, "value": value})
+                    applied_hygiene.append({"parameter": name, "value": value})
                 except Exception as exc:
-                    # Don't fail the whole load if one default doesn't apply
-                    # (parameter name might not exist on every Simpler variant).
-                    applied.append({"parameter": name, "skipped": str(exc)})
-            result["role"] = role
-            result["role_defaults_applied"] = applied
+                    applied_hygiene.append({"parameter": name, "skipped": str(exc)})
+            result["m4l_hygiene"] = {
+                "device_name": hygiene_name,
+                "applied": applied_hygiene,
+            }
+            result.setdefault("device_class", device_class)
+            break  # one hygiene match per load
 
     return result

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.23.6",
+  "version": "1.25.0",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 \u2014 453 tools, 54 domains, 44 semantic moves. Device atlas (5264 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, technique memory, 12 creative intelligence engines",
+  "description": "Agentic production system for Ableton Live 12 \u2014 462 tools, 55 domains, 44 semantic moves. Device atlas (5264 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, technique memory, 12 creative intelligence engines",
   "author": "Pilot Studio",
   "license": "BSL-1.1",
   "type": "commonjs",

package/remote_script/LivePilot/__init__.py

@@ -5,7 +5,7 @@ Entry point for the ControlSurface. Ableton calls create_instance(c_instance)
 when this script is selected in Preferences > Link, Tempo & MIDI.
 """
 
-__version__ = "1.23.6"
+__version__ = "1.25.0"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router

package/server.json

@@ -1,17 +1,17 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.dreamrec/livepilot",
-  "description": "453-tool agentic MCP production system for Ableton Live 12 \u2014 53 domains, 44 semantic moves, device atlas (5264 devices), Splice intelligence (gRPC + GraphQL), 9-band spectral perception auto-loaded, Creative Director skill, technique memory, 12 creative engines",
+  "description": "462-tool agentic MCP production system for Ableton Live 12 \u2014 55 domains, 44 semantic moves, device atlas (5264 devices), Splice intelligence (gRPC + GraphQL), 9-band spectral perception auto-loaded, Creative Director skill, technique memory, 12 creative engines",
   "repository": {
     "url": "https://github.com/dreamrec/LivePilot",
     "source": "github"
   },
-  "version": "1.23.6",
+  "version": "1.25.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "livepilot",
-      "version": "1.23.1",
+      "version": "1.25.0",
       "transport": {
         "type": "stdio"
       }