livepilot 1.10.6 → 1.10.8

package/mcp_server/tools/_composition_engine/sections.py

@@ -194,6 +194,15 @@ def detect_phrases(
 
     Uses note density changes and gap detection to find phrase boundaries.
     Falls back to regular grid (4 or 8 bar phrases).
+
+    BUG-B22 fix: most clips are 4-8 bar loops. In an 8-bar section with
+    4-bar clips, notes have start_time 0..16 (one clip cycle). The old
+    algorithm placed them at absolute bars section.start_bar + 0..4 only,
+    leaving bars 4..7 of the section reading as "empty" — which produced
+    note_density=0 for the second half even though Ableton loops those
+    clips to fill the section. We now infer each track's clip length
+    from its max note start_time and wrap note bars modulo that length,
+    so a looping clip's density spreads across the whole section.
     """
     section_length = section.length_bars()
     if section_length <= 0:
@@ -204,12 +213,46 @@ def detect_phrases(
     for bar in range(section.start_bar, section.end_bar):
         bar_densities[bar] = 0
 
+    section_bar_count = section.end_bar - section.start_bar
+
     for track_notes in notes_by_track.values():
+        if not track_notes:
+            continue
+        # Infer this track's clip span (in bars) from the max start_time.
+        # The clip LOOPS to fill the section, so notes at start_time=0
+        # repeat every span bars. Round UP so a 3.5-beat phrase counts
+        # as 1 bar (not 0).
+        max_start_beat = max(
+            float(n.get("start_time", 0) or 0) for n in track_notes
+        )
+        clip_span_bars = max(
+            1,
+            int((max_start_beat / beats_per_bar) + 1),
+        )
+        # If we can't determine a sensible span, fall back to section length
+        if clip_span_bars <= 0:
+            clip_span_bars = section_bar_count
+
         for note in track_notes:
-            start_beat = note.get("start_time", 0)
-            note_bar = section.start_bar + int(start_beat / beats_per_bar)
-            if section.start_bar <= note_bar < section.end_bar:
-                bar_densities[note_bar] = bar_densities.get(note_bar, 0) + 1
+            start_beat = float(note.get("start_time", 0) or 0)
+            clip_bar = int(start_beat / beats_per_bar)
+            # Fill-copy the note across all loop iterations that fit
+            # inside the section. For a 4-bar clip in an 8-bar section
+            # that means each note contributes to bars 0..3 AND 4..7.
+            if clip_span_bars >= section_bar_count:
+                # Clip is already section-long (or longer) — no looping
+                positions = [clip_bar]
+            else:
+                # Wrap by modulo — project across the section
+                positions = list(range(
+                    clip_bar % clip_span_bars,
+                    section_bar_count,
+                    clip_span_bars,
+                ))
+            for offset in positions:
+                note_bar = section.start_bar + offset
+                if section.start_bar <= note_bar < section.end_bar:
+                    bar_densities[note_bar] = bar_densities.get(note_bar, 0) + 1
 
     # Find phrase boundaries using density drops (gaps)
     boundaries = [section.start_bar]

package/mcp_server/tools/_harmony_engine.py

@@ -195,13 +195,45 @@ def find_shortest_path(
 # ---------------------------------------------------------------------------
 
 def classify_transform_sequence(chords: list[tuple[int, str]]) -> list[str]:
-    """Identify the PRL transform between each consecutive pair of chords.
-
-    Tries single transforms (P, L, R) first, then 2-step compound
-    transforms (PL, PR, LP, LR, RP, RL) for richer classification.
+    """Identify the neo-Riemannian transform between each consecutive pair.
+
+    Tries (in order):
+      1. Single transforms: P, L, R
+      2. 2-step compounds: PL, PR, LP, LR, RP, RL, PP, LL, RR
+      3. 3-step compounds: PLR, PRL, LPR, LRP, RLP, RPL, PLP, PRP, LPL, …
+         (BUG-B24: needed for progressions that step through mediants)
+      4. Diatonic-step primitives: S2↑ / S2↓ (whole-step root motion,
+         same quality) and S1↑ / S1↓ (half-step root motion, same
+         quality). These aren't classical neo-Riemannian transforms —
+         but Gm → Am (D minor iv → v) IS a valid progression, so the
+         transform alphabet needs SOME label for it. Marking it with a
+         dedicated symbol is cleaner than returning "?", which cascades
+         into misleading "diatonic cycle fragment" classifications
+         downstream.
     """
-    _COMPOUNDS = ["PL", "PR", "LP", "LR", "RP", "RL",
-                  "PP", "LL", "RR"]
+    _TWO_STEP = ["PL", "PR", "LP", "LR", "RP", "RL",
+                 "PP", "LL", "RR"]
+    _THREE_STEP = [
+        "PLR", "PRL", "LPR", "LRP", "RLP", "RPL",
+        "PLP", "LPL", "PRP", "RPR", "LRL", "RLR",
+    ]
+
+    def _try_primitive_step(a: tuple[int, str], b: tuple[int, str]) -> str:
+        """Detect same-quality step motion → S1/S2 primitive."""
+        if a[1] != b[1]:
+            return "?"
+        interval = (b[0] - a[0]) % 12
+        # Prefer the signed direction symbol for readability
+        if interval == 1:
+            return "S1u"  # semitone up
+        if interval == 11:
+            return "S1d"  # semitone down
+        if interval == 2:
+            return "S2u"  # whole-step up (Gm → Am in Dm)
+        if interval == 10:
+            return "S2d"  # whole-step down
+        return "?"
+
     result = []
     for i in range(len(chords) - 1):
         found = "?"
@@ -210,15 +242,27 @@ def classify_transform_sequence(chords: list[tuple[int, str]]) -> list[str]:
             if fn(*chords[i]) == chords[i + 1]:
                 found = label
                 break
-        # Try 2-step compound transforms
+        # Try 2-step compounds
+        if found == "?":
+            for compound in _TWO_STEP:
+                try:
+                    if apply_transforms(*chords[i], compound) == chords[i + 1]:
+                        found = compound
+                        break
+                except (ValueError, KeyError):
+                    continue
+        # Try 3-step compounds (BUG-B24)
         if found == "?":
-            for compound in _COMPOUNDS:
+            for compound in _THREE_STEP:
                 try:
                     if apply_transforms(*chords[i], compound) == chords[i + 1]:
                         found = compound
                         break
                 except (ValueError, KeyError):
                     continue
+        # Final fallback: same-quality step motion (BUG-B24)
+        if found == "?":
+            found = _try_primitive_step(chords[i], chords[i + 1])
         result.append(found)
     return result
 

package/mcp_server/tools/_research_engine.py

@@ -162,15 +162,52 @@ def targeted_research(
     findings: list[ResearchFinding] = []
     sources_searched = []
 
-    # 1. Device atlas findings
+    # 1. Device atlas findings.
+    # BUG-B43 fix: device_atlas_results is a list of search_browser
+    # RESPONSES (each with {path, items: [...], count, ...}) — NOT a
+    # list of device entries. The old code read response.get("name")
+    # which always returned "" because the response has no top-level
+    # name. Every finding came back as "Device: Unknown". We now
+    # flatten the responses, look up each item's real atlas metadata,
+    # and build one finding per resolved device.
     if device_atlas_results:
         sources_searched.append("device_atlas")
-        for entry in device_atlas_results:
+        flattened_entries: list[dict] = []
+        for response in device_atlas_results:
+            if not isinstance(response, dict):
+                continue
+            # Accept old shape (single device dict) for forward compat
+            if response.get("name") and not response.get("items"):
+                flattened_entries.append(response)
+                continue
+            items = response.get("items") or response.get("results") or []
+            for item in items:
+                if not isinstance(item, dict):
+                    continue
+                flattened_entries.append({
+                    "name": item.get("name", ""),
+                    "uri": item.get("uri", ""),
+                    "category": response.get("path", ""),
+                    "is_loadable": item.get("is_loadable", False),
+                })
+
+        for entry in flattened_entries:
             name = entry.get("name", "")
+            if not name:
+                continue  # skip phantom empties
+            # Try to enrich with atlas lookup — gives real description,
+            # character_tags, genres.
+            try:
+                from ..atlas import _atlas_instance as _atlas
+                if _atlas is not None:
+                    full = _atlas.lookup(name)
+                    if full:
+                        entry = {**full, **entry}
+            except Exception:
+                pass
+
             text = _format_device_finding(entry)
             relevance = _score_finding_relevance(text, query_info["keywords"])
-
-            # Boost relevance if device was in our predicted list
             if name in query_info["likely_devices"]:
                 relevance = min(1.0, relevance + 0.3)
 
@@ -179,7 +216,10 @@ def targeted_research(
                 source_id=name,
                 relevance=round(relevance, 3),
                 content=text,
-                metadata={"device_name": name, "category": entry.get("category", "")},
+                metadata={
+                    "device_name": name,
+                    "category": entry.get("category", ""),
+                },
             ))
 
     # 2. Memory findings (technique cards, outcomes, research notes)
@@ -522,21 +562,60 @@ def get_style_tactics(
             if any(query in p.lower() for p in tactic.arrangement_patterns):
                 results.append(tactic)
 
-    # Search user memory tactics
+    # Search user memory tactics.
+    # BUG-B18 fix: TechniqueStore.search() strips the payload from
+    # summaries, so `mem.get("payload", {})` was always empty and the
+    # old match-by-payload.artist_or_genre code never fired. Users who
+    # saved 3 "Prefuse73" techniques via memory_learn got back 0
+    # tactics from get_style_tactics("prefuse73"). We now match on
+    # name + tags + qualities.summary + payload (if present) and
+    # adapt the memory-entry to a StyleTactic regardless of whether
+    # the caller formatted the payload in the exact style_tactic shape.
     if memory_tactics:
         for mem in memory_tactics:
-            payload = mem.get("payload", {})
-            if isinstance(payload, dict):
-                mem_genre = payload.get("artist_or_genre", "").lower()
-                mem_name = payload.get("tactic_name", "").lower()
-                if query in mem_genre or query in mem_name:
-                    results.append(StyleTactic(
-                        artist_or_genre=payload.get("artist_or_genre", ""),
-                        tactic_name=payload.get("tactic_name", ""),
-                        arrangement_patterns=payload.get("arrangement_patterns", []),
-                        device_chain=payload.get("device_chain", []),
-                        automation_gestures=payload.get("automation_gestures", []),
-                        verification=payload.get("verification", []),
-                    ))
+            if not isinstance(mem, dict):
+                continue
+            # Build the searchable text from whichever shape the memory
+            # entry uses. This is lenient on purpose — saved techniques
+            # don't need to pre-commit to a schema to surface here.
+            name = str(mem.get("name", ""))
+            tags = mem.get("tags", []) or []
+            qualities = mem.get("qualities", {}) or {}
+            summary = str(qualities.get("summary", "") or "")
+            payload = mem.get("payload", {}) or {}
+
+            searchable = " ".join([
+                name.lower(), summary.lower(),
+                " ".join(str(t).lower() for t in tags),
+                str(payload.get("artist_or_genre", "")).lower(),
+                str(payload.get("tactic_name", "")).lower(),
+            ])
+            if query not in searchable:
+                continue
+
+            # Adapt to StyleTactic — prefer payload fields when present,
+            # fall back to the summary for arrangement_patterns, etc.
+            artist_or_genre = str(
+                payload.get("artist_or_genre")
+                or next((t for t in tags if query in str(t).lower()), "")
+                or query
+            )
+            tactic_name = str(payload.get("tactic_name") or name or summary[:40])
+            arrangement_patterns = (
+                payload.get("arrangement_patterns")
+                or [summary] if summary else []
+            )
+            device_chain = payload.get("device_chain", []) or []
+            automation_gestures = payload.get("automation_gestures", []) or []
+            verification = payload.get("verification", []) or []
+
+            results.append(StyleTactic(
+                artist_or_genre=artist_or_genre,
+                tactic_name=tactic_name,
+                arrangement_patterns=arrangement_patterns,
+                device_chain=device_chain,
+                automation_gestures=automation_gestures,
+                verification=verification,
+            ))
 
     return results

package/mcp_server/tools/_theory_engine.py

@@ -218,16 +218,98 @@ def detect_key(notes: list[dict], mode_detection: bool = True) -> dict:
 
 
 def chord_name(midi_pitches: list[int]) -> str:
-    """Identify chord from MIDI pitches -> 'C-major triad'."""
-    pcs = sorted(set(p % 12 for p in midi_pitches))
-    if not pcs:
+    """Identify chord from MIDI pitches -> 'C-major triad'.
+
+    Root-selection rules (BUG-B2 / BUG-B5):
+      1) Prefer the bass note (lowest MIDI pitch) as root — matches
+         musical convention and handles partial voicings correctly.
+      2) Accept exact CHORD_PATTERNS match first.
+      3) If no exact match, allow subset match (partial chord e.g.
+         Dm7(no5)) and superset match (add-tone e.g. Gm7(add11)).
+      4) Only fall back to the pitch-class-0 guess when nothing else
+         works — previous code always returned pcs[0] on miss, which
+         mis-labeled Dm7 as a "C chord" just because C has pc=0.
+    """
+    if not midi_pitches:
         return "unknown"
-    # Try each pitch class as potential root
-    for root in pcs:
-        intervals = tuple(sorted((pc - root) % 12 for pc in pcs))
+    pcs_set = set(p % 12 for p in midi_pitches)
+    pcs_sorted_pc = sorted(pcs_set)  # numerical pc order, used for fallback only
+    bass_pc = min(midi_pitches) % 12
+
+    # Ordered candidate roots: bass first, then remaining pcs (low→high).
+    # This gives musical priority to the bass note without ignoring cases
+    # where a non-bass root yields a cleaner exact match (2nd-pass scoring).
+    ordered_roots: list[int] = [bass_pc] + [pc for pc in pcs_sorted_pc if pc != bass_pc]
+
+    # ── Pass 1: exact CHORD_PATTERNS match ─────────────────────────────
+    exact_matches: list[tuple[int, tuple[int, ...]]] = []
+    for root in ordered_roots:
+        intervals = tuple(sorted((pc - root) % 12 for pc in pcs_set))
         if intervals in CHORD_PATTERNS:
-            return f"{NOTE_NAMES[root]}-{CHORD_PATTERNS[intervals]}"
-    return f"{NOTE_NAMES[pcs[0]]} chord"
+            exact_matches.append((root, intervals))
+
+    if exact_matches:
+        # Prefer the match where root == bass_pc
+        for root, intervals in exact_matches:
+            if root == bass_pc:
+                return f"{NOTE_NAMES[root]}-{CHORD_PATTERNS[intervals]}"
+        # Otherwise the first (bass-first iteration) wins
+        root, intervals = exact_matches[0]
+        return f"{NOTE_NAMES[root]}-{CHORD_PATTERNS[intervals]}"
+
+    # ── Pass 2: subset match (partial chord — missing tones) ───────────
+    # e.g. D-F-C → (0, 3, 10) is a subset of (0, 3, 7, 10) = minor seventh.
+    # Report the canonical name with "(no X)" where X is the missing interval.
+    interval_names = {
+        0: "root", 2: "2", 3: "♭3", 4: "3", 5: "4", 6: "♭5",
+        7: "5", 8: "♭6", 9: "6", 10: "♭7", 11: "7",
+    }
+    # Prefer bass-pc first.
+    for root in ordered_roots:
+        intervals_set = set((pc - root) % 12 for pc in pcs_set)
+        if 0 not in intervals_set:
+            continue
+        for pattern, label in CHORD_PATTERNS.items():
+            pattern_set = set(pattern)
+            if intervals_set.issubset(pattern_set) and intervals_set != pattern_set:
+                missing = sorted(pattern_set - intervals_set)
+                missing_names = ",".join(interval_names.get(m, str(m)) for m in missing)
+                return f"{NOTE_NAMES[root]}-{label} (no {missing_names})"
+
+    # ── Pass 3: superset match (extended chord — added tensions) ───────
+    # e.g. G-Bb-D-F-A → pattern minor-seventh (0,3,7,10) is a subset of
+    # {0,2,3,7,10}; the extra 2 is an added 9 (or 11 depending on voicing).
+    # Report "Gm7(add2)".
+    add_interval_names = {
+        1: "♭9", 2: "9", 4: "♯9", 5: "11", 6: "♯11",
+        8: "♭13", 9: "13", 11: "maj7",
+    }
+    for root in ordered_roots:
+        intervals_set = set((pc - root) % 12 for pc in pcs_set)
+        if 0 not in intervals_set:
+            continue
+        # Try each pattern as the core, extras as tensions. Track the
+        # chosen pattern size so we prefer 7ths over triads (the bug in
+        # the first draft was using len(set(label_string)) — chars, not
+        # intervals — which broke the tie-break for BUG-B2.
+        best_superset: tuple[str, list[int], int] | None = None
+        for pattern, label in CHORD_PATTERNS.items():
+            pattern_set = set(pattern)
+            if pattern_set.issubset(intervals_set) and pattern_set != intervals_set:
+                extras = sorted(intervals_set - pattern_set)
+                # Prefer the longest pattern (seventh chords win over triads)
+                if best_superset is None or len(pattern_set) > best_superset[2]:
+                    best_superset = (label, extras, len(pattern_set))
+        if best_superset is not None:
+            label, extras, _ = best_superset
+            add_names = ",".join(add_interval_names.get(e, str(e)) for e in extras)
+            return f"{NOTE_NAMES[root]}-{label} (add {add_names})"
+
+    # ── Pass 4: fallback — name by bass note, not pcs[0] ───────────────
+    # Previous behavior returned NOTE_NAMES[pcs[0]] (numerically lowest pc,
+    # which put C first for any chord containing C). Bass-note is musically
+    # correct — if we can't identify the quality, at least the root is right.
+    return f"{NOTE_NAMES[bass_pc]} chord"
 
 
 def roman_numeral(chord_pcs: list[int], tonic: int, mode: str) -> dict:
@@ -399,8 +481,18 @@ def roman_figure_to_pitches(figure: str, tonic: int, mode: str) -> dict:
         p = base_midi + ((pc - root_pc) % 12)
         midi.append(p)
 
+    # BUG-B23: the original figure string's case can disagree with the
+    # resolved quality (e.g. "IV" resolving to a minor triad on the 4th
+    # scale degree of D minor). Convention says uppercase numerals encode
+    # major/augmented and lowercase encode minor/diminished. Return a
+    # normalized figure so callers receive internally consistent data;
+    # the raw input figure stays reflected in 'figure_requested' for
+    # debugging / compatibility.
+    normalized_figure = _normalize_figure_case(figure, quality)
+
     return {
-        "figure": figure,
+        "figure": normalized_figure,
+        "figure_requested": figure,
         "root_pc": root_pc,
         "pitches": [pitch_name(m) for m in midi],
         "midi_pitches": midi,
@@ -408,6 +500,43 @@ def roman_figure_to_pitches(figure: str, tonic: int, mode: str) -> dict:
     }
 
 
+def _normalize_figure_case(figure: str, quality: str) -> str:
+    """Return *figure* with its numeral's case matched to *quality*.
+
+    Uppercase numerals (I, II, …, VII) conventionally encode major-family
+    qualities; lowercase (i, ii, …, vii) encode minor-family. We preserve
+    any leading accidentals (b/#) and trailing suffix (7, maj7, °, etc.)
+    and only flip the numeral itself. Safe on edge cases: if the figure
+    doesn't start with a recognized numeral, it's returned unchanged.
+    """
+    if not figure:
+        return figure
+    # Split off leading accidentals
+    prefix = ""
+    remaining = figure
+    while remaining and remaining[0] in ("b", "#"):
+        prefix += remaining[0]
+        remaining = remaining[1:]
+    # Match numeral greedily (longest first so VII wins over VI wins over V)
+    numeral = ""
+    for rn in ["VII", "VI", "IV", "III", "II", "V", "I"]:
+        if remaining.upper().startswith(rn):
+            numeral = rn
+            break
+    if not numeral:
+        return figure
+    suffix = remaining[len(numeral):]
+    # Minor family: lowercase. Major family: uppercase.
+    q = quality.lower() if isinstance(quality, str) else ""
+    is_minor_family = (
+        q.startswith("minor")
+        or q.startswith("half-diminished")
+        or q.startswith("diminished")
+    )
+    new_numeral = numeral.lower() if is_minor_family else numeral
+    return prefix + new_numeral + suffix
+
+
 def check_voice_leading(prev_pitches: list[int], curr_pitches: list[int]) -> list[dict]:
     """Check voice leading issues between two chords."""
     issues = []

package/mcp_server/tools/agent_os.py

@@ -151,11 +151,28 @@ def build_world_model(ctx: Context) -> dict:
         if key_data:
             detected_key = key_data["value"] if isinstance(key_data["value"], dict) else {"key": key_data["value"]}
 
+        # BUG-E6 fix: derive flucoma_available from the same 6-stream probe
+        # that check_flucoma uses. Previously we read a dedicated
+        # "flucoma_status" key that the M4L bridge doesn't emit, so the
+        # fallback `{"flucoma_available": False}` always won even when all
+        # 6 FluCoMa streams were actively delivering data.
+        _flu_streams = ("spectral_shape", "mel_bands", "chroma",
+                        "onset", "novelty", "loudness")
+        active = sum(1 for k in _flu_streams if spectral.get(k) is not None)
+        flucoma_status = {
+            "flucoma_available": active > 0,
+            "active_streams": active,
+        }
+        # Keep any explicit flucoma_status payload the bridge may emit
+        # alongside as extra metadata — without letting it override the
+        # stream-based truth.
         flucoma_data = spectral.get("flucoma_status")
-        if flucoma_data:
-            flucoma_status = flucoma_data["value"] if isinstance(flucoma_data["value"], dict) else {}
+        if flucoma_data and isinstance(flucoma_data.get("value"), dict):
+            extras = {k: v for k, v in flucoma_data["value"].items()
+                      if k not in flucoma_status}
+            flucoma_status.update(extras)
     else:
-        flucoma_status = {"flucoma_available": False}
+        flucoma_status = {"flucoma_available": False, "active_streams": 0}
 
     # Build model
     wm = engine.build_world_model_from_data(

package/mcp_server/tools/analyzer.py

@@ -6,12 +6,20 @@ These tools are optional — all core tools work without the device.
 
 from __future__ import annotations
 
+import logging
 import os
+import re  # used below in filename parsing helpers
+from typing import Optional
 
 from fastmcp import Context
 
 from ..server import mcp, _identify_port_holder
 
+# Logger must be defined before any helper that uses it — _require_analyzer
+# below calls logger.debug on an exception path, so defining the logger later
+# in the file risked NameError under unusual import orderings.
+logger = logging.getLogger(__name__)
+
 CAPTURE_DIR = os.path.expanduser("~/Documents/LivePilot/captures")
 
 
@@ -276,12 +284,6 @@ async def get_clip_file_path(
     bridge = _get_m4l(ctx)
     return await bridge.send_command("get_clip_file_path", track_index, clip_index)
 
-import os  # for filename parsing in smart-defaults helper
-import re
-import logging
-
-logger = logging.getLogger(__name__)
-
 # ── Sample loading helpers (P0-1, P1-1, P2-6 fixes) ────────────────────────
 #
 # Critical bug 2026-04-14 (see docs/2026-04-14-bugs-discovered.md):
@@ -968,3 +970,100 @@ def check_flucoma(ctx: Context) -> dict:
         streams[key] = cache.get(key) is not None
     active = sum(1 for v in streams.values() if v)
     return {"flucoma_available": active > 0, "active_streams": active, "streams": streams}
+
+
+# ── BUG-A2 + A3: deep-LOM properties via M4L bridge ──────────────────
+
+
+@mcp.tool()
+async def simpler_set_warp(
+    ctx: Context,
+    track_index: int,
+    device_index: int,
+    warping: bool,
+    warp_mode: Optional[int] = None,
+) -> dict:
+    """Toggle a Simpler's sample warping + set the warp algorithm (BUG-A2).
+
+    Python's Remote Script ControlSurface API can't reach Simpler's
+    `warping` or `warp_mode` — they live on the sample child object
+    (SimplerDevice.sample.*) that only Max for Live's JavaScript LiveAPI
+    can step into. This tool routes through the M4L bridge to do the
+    write.
+
+    When enabling warping, pass the desired warp_mode too so Live doesn't
+    default to whatever was there last:
+
+        warp_mode 0 = Beats      (good for drums / percussive loops)
+        warp_mode 1 = Tones      (mono harmonic material)
+        warp_mode 2 = Texture    (poly / ambient material)
+        warp_mode 3 = Re-Pitch   (classic pitch-shift feel)
+        warp_mode 4 = Complex    (music / full mixes — higher CPU)
+        warp_mode 6 = Complex Pro (highest quality — highest CPU)
+
+    Args:
+        track_index: 0+ for regular tracks
+        device_index: Simpler device's position in the chain
+        warping: True → enable sample warp; False → disable
+        warp_mode: 0-6 (omit to leave the current mode unchanged)
+
+    Requires LivePilot Analyzer on master track.
+    """
+    if warp_mode is not None and warp_mode not in (0, 1, 2, 3, 4, 6):
+        raise ValueError("warp_mode must be 0,1,2,3,4,6 (no 5 — Live skips it)")
+    cache = _get_spectral(ctx)
+    _require_analyzer(cache)
+    bridge = _get_m4l(ctx)
+    return await bridge.send_command(
+        "simpler_set_warp",
+        int(track_index),
+        int(device_index),
+        1 if warping else 0,
+        -1 if warp_mode is None else int(warp_mode),
+        timeout=10.0,
+    )
+
+
+@mcp.tool()
+async def compressor_set_sidechain(
+    ctx: Context,
+    track_index: int,
+    device_index: int,
+    source_type: str = "",
+    source_channel: str = "",
+) -> dict:
+    """Configure a Compressor's sidechain INPUT ROUTING (BUG-A3).
+
+    Complements set_device_parameter's `S/C On` toggle: that enables the
+    sidechain, this picks WHICH track/channel feeds the detector. The
+    routing properties (`sidechain_input_routing_type`,
+    `sidechain_input_routing_channel`) aren't in Compressor's automatable
+    parameter list, but Python's Remote Script reaches them directly as
+    device properties (same LOM pattern as set_track_routing).
+
+    Args:
+        track_index: 0+ regular, -1/-2 returns, -1000 master
+        device_index: Compressor position in the chain
+        source_type: sidechain source display name
+            (e.g. "1-Kick", "Ext. In", "No Input")
+        source_channel: tap point on the source
+            (e.g. "Post FX", "Pre FX", "Post Mixer")
+
+    Omit a param to leave that property unchanged. If a display name
+    doesn't match, the error message includes the full list of available
+    options from the running Live session.
+
+    Routes through the Remote Script (TCP) — does NOT require the M4L
+    analyzer. This is the Python-side path introduced after the M4L
+    bridge approach hit LiveAPI shape issues in Live 12.3.6.
+    """
+    params: dict = {
+        "track_index": int(track_index),
+        "device_index": int(device_index),
+    }
+    if source_type:
+        params["source_type"] = str(source_type)
+    if source_channel:
+        params["source_channel"] = str(source_channel)
+    ableton = ctx.lifespan_context["ableton"]
+    return ableton.send_command("set_compressor_sidechain", params)