livepilot 1.10.5 → 1.10.7

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

@@ -10,6 +10,7 @@ These tools power the Agent OS cyclical loop:
 from __future__ import annotations
 
 import json
+import logging
 from typing import Optional
 
 from fastmcp import Context
@@ -18,6 +19,8 @@ from ..server import mcp
 from ..memory.technique_store import TechniqueStore
 from . import _agent_os_engine as engine
 
+logger = logging.getLogger(__name__)
+
 _memory_store = TechniqueStore()
 
 
@@ -125,8 +128,9 @@ def build_world_model(ctx: Context) -> dict:
                 "track_index": track["index"]
             })
             track_infos.append(ti)
-        except Exception:
-            pass  # Skip tracks that fail — don't block world model build
+        except Exception as exc:
+            # Skip tracks that fail — don't block world model build
+            logger.debug("world-model track %s skipped: %s", track.get("index"), exc)
 
     # Fetch spectral data (may be unavailable)
     spectrum = None
@@ -147,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(
@@ -184,13 +205,14 @@ def build_world_model(ctx: Context) -> dict:
         try:
             matrix_data = ableton.send_command("get_scene_matrix")
             clip_matrix = matrix_data.get("matrix", [])
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("scene_matrix fetch for structural critic skipped: %s", exc)
 
         sections = comp_engine.build_section_graph_from_scenes(scenes, clip_matrix, track_count)
         structural_issues = comp_engine.run_form_critic(sections)
-    except Exception:
-        pass  # Composition engine unavailable — degrade gracefully
+    except Exception as exc:
+        # Composition engine unavailable — degrade gracefully
+        logger.warning("structural critic unavailable: %s", exc)
 
     result = wm.to_dict()
     result["issues"] = {
@@ -276,7 +298,8 @@ def analyze_outcomes(
         techniques = _memory_store.list_techniques(
             type_filter="outcome", sort_by="updated_at", limit=limit,
         )
-    except Exception:
+    except Exception as exc:
+        logger.warning("analyze_outcomes list_techniques failed: %s", exc)
         techniques = []
 
     # Extract payloads from full technique records
@@ -288,8 +311,8 @@ def analyze_outcomes(
             payload = full.get("payload", {})
             if isinstance(payload, dict):
                 outcomes.append(payload)
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("outcome payload %s skipped: %s", t.get("id"), exc)
 
     return engine.analyze_outcome_history(outcomes)
 
@@ -316,7 +339,8 @@ def get_technique_card(
         techniques = _memory_store.search(
             query=query, type_filter="technique_card", limit=limit,
         )
-    except Exception:
+    except Exception as exc:
+        logger.warning("technique_card search(%r) failed: %s", query, exc)
         techniques = []
 
     cards = []
@@ -333,8 +357,8 @@ def get_technique_card(
                     "rating": t.get("rating", 0),
                     "replay_count": t.get("replay_count", 0),
                 })
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("technique_card %s payload skipped: %s", t.get("id"), exc)
 
     return {
         "query": query,
@@ -367,7 +391,8 @@ def get_taste_profile(
         techniques = _memory_store.list_techniques(
             type_filter="outcome", sort_by="updated_at", limit=limit,
         )
-    except Exception:
+    except Exception as exc:
+        logger.warning("taste_profile list_techniques failed: %s", exc)
         techniques = []
 
     outcomes = []
@@ -377,8 +402,8 @@ def get_taste_profile(
             payload = full.get("payload", {})
             if isinstance(payload, dict):
                 outcomes.append(payload)
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("taste_profile outcome %s skipped: %s", t.get("id"), exc)
 
     return engine.get_taste_profile(outcomes)
 

package/mcp_server/tools/analyzer.py

@@ -7,6 +7,7 @@ These tools are optional — all core tools work without the device.
 from __future__ import annotations
 
 import os
+from typing import Optional
 
 from fastmcp import Context
 
@@ -43,7 +44,8 @@ def _require_analyzer(cache) -> None:
                 ctx.lifespan_context["ableton"].send_command("get_master_track")
                 if ctx else {}
             )
-        except Exception:
+        except Exception as exc:
+            logger.debug("_require_analyzer failed: %s", exc)
             track = {}
 
         devices = track.get("devices", []) if isinstance(track, dict) else []
@@ -254,7 +256,6 @@ async def walk_device_tree(
     bridge = _get_m4l(ctx)
     return await bridge.send_command("walk_rack", track_index, device_index)
 
-
 # ── Phase 2: Sample Operations ─────────────────────────────────────────
 
 
@@ -276,10 +277,11 @@ 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) ────────────────────────
 #
@@ -386,7 +388,8 @@ async def _simpler_post_load_hygiene(
             "device_index": device_index,
             "parameters": hygiene_params,
         })
-    except Exception:
+    except Exception as exc:
+        logger.debug("_simpler_post_load_hygiene failed: %s", exc)
         # non-fatal — verification already succeeded
         pass
 
@@ -617,7 +620,6 @@ async def warp_simpler(
     bridge = _get_m4l(ctx)
     return await bridge.send_command("warp_simpler", track_index, device_index, beats)
 
-
 # ── Phase 2: Warp Markers ──────────────────────────────────────────────
 
 
@@ -702,7 +704,6 @@ async def remove_warp_marker(
         "remove_warp_marker", track_index, clip_index, beat_time
     )
 
-
 # ── Phase 2: Clip & Display ────────────────────────────────────────────
 
 
@@ -760,7 +761,6 @@ async def get_display_values(
     bridge = _get_m4l(ctx)
     return await bridge.send_command("get_display_values", track_index, device_index, timeout=15.0)
 
-
 # ── Phase 3: Audio Capture ─────────────────────────────────────────────
 
 
@@ -819,6 +819,7 @@ async def capture_audio(
                 dst_path = os.path.join(CAPTURE_DIR, dst_name)
                 try:
                     import shutil
+
                     shutil.move(src_path, dst_path)
                     result["file_path"] = dst_path
                 except OSError:
@@ -844,7 +845,6 @@ async def capture_stop(ctx: Context) -> dict:
     await bridge.cancel_capture_future()
     return await bridge.send_command("capture_stop")
 
-
 # ── Phase 4: FluCoMa Real-Time ───────────────────────────────────────────
 
 PITCH_NAMES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
@@ -969,3 +969,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)

package/mcp_server/tools/automation.py

@@ -14,6 +14,9 @@ from pydantic import BaseModel, Field
 
 from ..curves import generate_curve, generate_from_recipe, list_recipes
 from ..server import mcp
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 def _get_ableton(ctx: Context):
@@ -23,6 +26,7 @@ def _get_ableton(ctx: Context):
 def _ensure_list(v: Any) -> list:
     if isinstance(v, str):
         import json
+
         try:
             return json.loads(v)
         except json.JSONDecodeError as exc:
@@ -372,7 +376,8 @@ def apply_automation_recipe(
                 if abs(p_max - p_min) > 1.5 or p_min < -0.5:
                     for pt in points:
                         pt["value"] = p_min + pt["value"] * (p_max - p_min)
-        except Exception:
+        except Exception as exc:
+            logger.debug("apply_automation_recipe failed: %s", exc)
             pass  # Fail open — write values as-is if we can't read the range
 
     # Safety clamp: auto_pan amplitude should be limited to avoid full L/R swing