livepilot 1.10.5 → 1.10.7

package/mcp_server/wonder_mode/tools.py

@@ -7,19 +7,23 @@
 
 from __future__ import annotations
 
+import logging
+
 from fastmcp import Context
 
 from ..server import mcp
 from . import engine
 
+logger = logging.getLogger(__name__)
+
 
 def _get_song_brain_dict() -> dict:
     try:
         from ..song_brain.tools import _current_brain
         if _current_brain is not None:
             return _current_brain.to_dict()
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("song_brain lookup failed: %s", exc)
     return {}
 
 
@@ -37,8 +41,8 @@ def _get_taste_graph(ctx: Context):
             taste_store=taste_store, anti_store=anti_store,
             persistent_store=persistent,
         )
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("taste_graph build failed: %s", exc)
     return None
 
 
@@ -47,7 +51,8 @@ def _get_active_constraints():
     try:
         from ..creative_constraints.tools import _active_constraints
         return _active_constraints
-    except Exception:
+    except Exception as exc:
+        logger.debug("creative_constraints not importable: %s", exc)
         return None
 
 
@@ -60,7 +65,8 @@ def _get_ledger_entries(ctx: Context) -> list[dict]:
         )
         entries = ledger.get_recent_moves(limit=20)
         return [e.to_dict() for e in entries]
-    except Exception:
+    except Exception as exc:
+        logger.warning("action_ledger recent_moves failed: %s", exc)
         return []
 
 
@@ -77,15 +83,16 @@ def _get_stuckness_report(ctx: Context, song_brain: dict) -> dict | None:
             ableton = ctx.lifespan_context.get("ableton")
             if ableton:
                 session_info = ableton.send_command("get_session_info", {})
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.warning("session_info fetch for stuckness failed: %s", exc)
         report = detect_stuckness(
             action_history=action_ledger,
             session_info=session_info,
             song_brain=song_brain,
         )
         return report.to_dict()
-    except Exception:
+    except Exception as exc:
+        logger.warning("stuckness detection failed: %s", exc)
         return None
 
 
@@ -144,8 +151,9 @@ def enter_wonder_mode(
                     sample_context["sample_file_path"] = best.get("file_path", "")
                     sample_context["sample_name"] = best.get("name", "")
                     sample_context["material_type"] = best.get("material_type", "")
-        except Exception:
-            pass  # Graceful degradation — analytical variants still work
+        except Exception as exc:
+            # Graceful degradation — analytical variants still work
+            logger.warning("sample opportunity search failed: %s", exc)
 
     # 1c. Get session info for kernel
     session_info = {}
@@ -153,8 +161,8 @@ def enter_wonder_mode(
         ableton = ctx.lifespan_context.get("ableton")
         if ableton:
             session_info = ableton.send_command("get_session_info", {})
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("session_info fetch for kernel failed: %s", exc)
 
     # 2. Generate variants
     result = engine.generate_wonder_variants(
@@ -194,8 +202,8 @@ def enter_wonder_mode(
             domain=thread_domain,
         )
         ws.creative_thread_id = thread.thread_id
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("open creative thread failed: %s", exc)
 
     # 5. Store session
     store_wonder_session(ws)
@@ -290,8 +298,8 @@ def discard_wonder_session(
             identity_effect="",
             user_sentiment="disliked",
         )
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("record_turn_resolution(rejected) failed: %s", exc)
 
     # Update taste graph — rejection is a negative signal for all executable variants
     try:
@@ -304,16 +312,16 @@ def discard_wonder_session(
                         family=v["family"],
                         kept=False,
                     )
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("taste_graph negative-signal update failed: %s", exc)
 
     # Discard linked preview set
     if ws.preview_set_id:
         try:
             from ..preview_studio.engine import discard_set
             discard_set(ws.preview_set_id)
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.warning("discard_set(%s) failed: %s", ws.preview_set_id, exc)
 
     return {
         "discarded": True,

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.10.5",
+  "version": "1.10.7",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 320 tools, 43 domains. Device atlas (1305 devices), sample engine (Splice + browser + filesystem), auto-composition, spectral perception, technique memory, creative intelligence (12 engines)",
+  "description": "Agentic production system for Ableton Live 12 — 323 tools, 45 domains. Device atlas (1305 devices), sample engine (Splice + browser + filesystem), auto-composition, spectral perception, technique memory, creative intelligence (12 engines)",
   "author": "Pilot Studio",
   "license": "BSL-1.1",
   "type": "commonjs",

package/remote_script/LivePilot/__init__.py

@@ -5,9 +5,10 @@ Entry point for the ControlSurface. Ableton calls create_instance(c_instance)
 when this script is selected in Preferences > Link, Tempo & MIDI.
 """
 
-__version__ = "1.10.5"
+__version__ = "1.10.7"
 
 from _Framework.ControlSurface import ControlSurface
+from . import router
 from .server import LivePilotServer
 from . import transport    # noqa: F401  — registers transport handlers
 from . import tracks       # noqa: F401  — registers track handlers
@@ -23,8 +24,62 @@ from . import clip_automation   # noqa: F401  — registers clip automation hand
 from . import version_detect    # noqa: F401  — version detection
 
 
+# ── Reload plumbing (BUG-B-reload, Batch 20) ──────────────────────────────
+# Ableton keeps `sys.modules["LivePilot.*"]` cached across Control Surface
+# toggles. Without intervention, edits to handler files don't take effect
+# until a full Ableton restart — the toggle just re-instantiates the
+# ControlSurface class without re-importing submodules.
+#
+# Fix: track whether this is the first create_instance call per
+# interpreter lifetime. On subsequent calls, force-reload the router
+# (which clears _handlers) and every handler module (which re-fires
+# @register decorators with the updated code). Result: a Control Surface
+# toggle now behaves like a fresh module reload, so live-editing mixing.py
+# / devices.py / etc. and re-toggling is enough — no Ableton restart.
+
+_FIRST_CREATE_INSTANCE = True
+
+_HANDLER_MODULES = (
+    transport, tracks, clips, notes, devices, scenes,
+    mixing, browser, arrangement, diagnostics,
+    clip_automation, version_detect,
+)
+
+
+def _force_reload_handlers():
+    """Force Python to re-read the handler modules from disk.
+
+    Called on every create_instance() except the first, so edits to
+    handler files take effect via Control Surface toggle without
+    restarting Ableton. Order matters: router first (clears _handlers),
+    then each handler module (re-registers its @register decorators).
+    """
+    import importlib
+    try:
+        importlib.reload(router)
+    except Exception:
+        pass
+    for mod in _HANDLER_MODULES:
+        try:
+            importlib.reload(mod)
+        except Exception:
+            # Don't block Ableton startup on a single bad reload —
+            # the stale version will still work for that handler
+            pass
+
+
 def create_instance(c_instance):
-    """Factory function called by Ableton Live."""
+    """Factory function called by Ableton Live.
+
+    Called once on initial Control Surface enable, AND every time the
+    user toggles the Control Surface off and on. The reload path below
+    makes the toggle behave like a fresh import — crucial for dev
+    ergonomics when iterating on mixing.py / devices.py / etc.
+    """
+    global _FIRST_CREATE_INSTANCE
+    if not _FIRST_CREATE_INSTANCE:
+        _force_reload_handlers()
+    _FIRST_CREATE_INSTANCE = False
     return LivePilot(c_instance)
 
 

package/remote_script/LivePilot/clips.py

@@ -36,6 +36,16 @@ def get_clip_info(song, params):
     if clip.is_audio_clip:
         result["warping"] = clip.warping
         result["warp_mode"] = clip.warp_mode
+        # BUG-A4: expose pitch/gain so callers can reason about sample
+        # transposition vs session key. Pitch is in semitones (int, -48..+48),
+        # pitch_fine in cents (-50..+50), gain linear (normalized 0..1 in Live).
+        # Some Live builds expose these as None on freshly-recorded clips
+        # before a warp pass; wrap in try/except for safety.
+        for attr in ("pitch_coarse", "pitch_fine", "gain"):
+            try:
+                result[attr] = getattr(clip, attr)
+            except AttributeError:
+                pass
 
     return result
 
@@ -202,6 +212,65 @@ def set_clip_launch(song, params):
     }
 
 
+@register("set_clip_pitch")
+def set_clip_pitch(song, params):
+    """Set pitch/gain on an audio clip (BUG-A5).
+
+    Audio clips only — MIDI clips raise ValueError.
+
+    Parameters
+    ----------
+    track_index, clip_index : int
+    coarse : int, optional        -- semitones, -48..+48
+    fine   : float, optional      -- cents, -50.0..+50.0
+    gain   : float, optional      -- linear normalized (0..1 in Live)
+
+    At least one of (coarse, fine, gain) must be provided.
+    """
+    track_index = int(params["track_index"])
+    clip_index = int(params["clip_index"])
+    clip = get_clip(song, track_index, clip_index)
+
+    if clip.is_midi_clip:
+        raise ValueError("set_clip_pitch only works on audio clips")
+
+    coarse = params.get("coarse")
+    fine = params.get("fine")
+    gain = params.get("gain")
+
+    if coarse is None and fine is None and gain is None:
+        raise ValueError(
+            "Provide at least one of: coarse (semitones), fine (cents), gain (0-1)"
+        )
+
+    if coarse is not None:
+        c = int(coarse)
+        if c < -48 or c > 48:
+            raise ValueError("coarse must be in -48..+48 semitones")
+        clip.pitch_coarse = c
+    if fine is not None:
+        f = float(fine)
+        if f < -50.0 or f > 50.0:
+            raise ValueError("fine must be in -50..+50 cents")
+        clip.pitch_fine = f
+    if gain is not None:
+        g = float(gain)
+        if g < 0.0 or g > 1.0:
+            raise ValueError("gain must be in 0..1")
+        clip.gain = g
+
+    result = {
+        "track_index": track_index,
+        "clip_index": clip_index,
+    }
+    for attr in ("pitch_coarse", "pitch_fine", "gain"):
+        try:
+            result[attr] = getattr(clip, attr)
+        except AttributeError:
+            pass
+    return result
+
+
 @register("set_clip_warp_mode")
 def set_clip_warp_mode(song, params):
     """Set warp mode for an audio clip."""

package/remote_script/LivePilot/mixing.py

@@ -293,3 +293,120 @@ def set_track_routing(song, params):
         result["output_routing_channel"] = track.output_routing_channel.display_name
 
     return result
+
+
+@register("set_compressor_sidechain")
+def set_compressor_sidechain(song, params):
+    """Configure a Compressor's sidechain input routing (BUG-A3).
+
+    Same LOM pattern as set_track_routing — the sidechain properties
+    (available_sidechain_input_routing_types / _channels) are on the
+    device object and Python's Remote Script accesses them cleanly.
+    This used to be routed through the M4L bridge (v1.10.6) but Max JS
+    LiveAPI couldn't read the available_* lists in Live 12.3.6, so it's
+    back on the Python side where it belongs.
+
+    Params:
+        track_index: 0+ regular, -1/-2 returns, -1000 master
+        device_index: Compressor's position in the chain
+        source_type (optional): RoutingType display name
+                                (e.g. "1-DRUMS", "Ext. In", "No Input")
+        source_channel (optional): RoutingChannel display name
+                                   (e.g. "Post FX", "Pre FX", "Post Mixer")
+
+    Omit a param to leave that property unchanged.
+    """
+    track_index = int(params["track_index"])
+    device_index = int(params["device_index"])
+    source_type = params.get("source_type")
+    source_channel = params.get("source_channel")
+
+    track = get_track(song, track_index)
+    devices = list(track.devices)
+    if device_index < 0 or device_index >= len(devices):
+        raise ValueError(
+            "Device index %d out of range (track has %d devices)"
+            % (device_index, len(devices))
+        )
+    device = devices[device_index]
+
+    class_name = device.class_name
+    if class_name not in ("Compressor2", "Compressor"):
+        raise ValueError(
+            "Not a Compressor device (class is %s)" % class_name
+        )
+
+    # Older Compressor builds may not expose `sidechain_enabled` as a
+    # property; the automatable "S/C On" parameter is the fallback.
+    # Try both paths so the sidechain gets enabled whichever surface is
+    # available on this Live version.
+    try:
+        device.sidechain_enabled = True
+    except AttributeError:
+        # Fallback: find the "S/C On" parameter and toggle it
+        for param in device.parameters:
+            if param.name == "S/C On":
+                param.value = 1
+                break
+
+    result = {
+        "ok": True,
+        "track_index": track_index,
+        "device_index": device_index,
+    }
+
+    if source_type is not None and source_type != "":
+        if not hasattr(device, "available_sidechain_input_routing_types"):
+            raise ValueError(
+                "This Live build doesn't expose "
+                "device.available_sidechain_input_routing_types"
+            )
+        available = list(device.available_sidechain_input_routing_types)
+        matched = None
+        for rt in available:
+            if rt.display_name == source_type:
+                matched = rt
+                break
+        if matched is None:
+            options = [rt.display_name for rt in available]
+            raise ValueError(
+                "Sidechain input type '%s' not found. Available: %s"
+                % (source_type, ", ".join(options))
+            )
+        device.sidechain_input_routing_type = matched
+
+    if source_channel is not None and source_channel != "":
+        if not hasattr(device, "available_sidechain_input_routing_channels"):
+            raise ValueError(
+                "This Live build doesn't expose "
+                "device.available_sidechain_input_routing_channels"
+            )
+        available = list(device.available_sidechain_input_routing_channels)
+        matched = None
+        for ch in available:
+            if ch.display_name == source_channel:
+                matched = ch
+                break
+        if matched is None:
+            options = [ch.display_name for ch in available]
+            raise ValueError(
+                "Sidechain input channel '%s' not found. Available: %s"
+                % (source_channel, ", ".join(options))
+            )
+        device.sidechain_input_routing_channel = matched
+
+    # Read back canonical display names
+    try:
+        result["sidechain"] = {
+            "type": device.sidechain_input_routing_type.display_name,
+            "channel": device.sidechain_input_routing_channel.display_name,
+            "enabled": bool(getattr(device, "sidechain_enabled", True)),
+        }
+    except AttributeError:
+        # Very old Compressor — fall back to whatever we set above
+        result["sidechain"] = {
+            "type": source_type or "",
+            "channel": source_channel or "",
+            "enabled": True,
+        }
+    return result

package/remote_script/LivePilot/router.py

@@ -62,8 +62,20 @@ def dispatch(song, command):
         )
 
     # Built-in ping — no handler registration needed.
+    # BUG-A1: embed remote_script version + supported command set so the
+    # MCP server can detect stale installs. An old Remote Script (pre-12.3
+    # handler adds) would return an older version here; the MCP server
+    # compares and warns the user to reinstall.
     if cmd_type == "ping":
-        return success_response(request_id, {"pong": True})
+        try:
+            from . import __version__ as rs_version
+        except ImportError:
+            rs_version = "unknown"
+        return success_response(request_id, {
+            "pong": True,
+            "remote_script_version": rs_version,
+            "commands": sorted(_handlers.keys()),
+        })
 
     handler = _handlers.get(cmd_type)
     if handler is None:

package/scripts/generate_tool_catalog.py

@@ -51,45 +51,20 @@ def get_tools() -> list[dict]:
 
 
 def infer_domain(module: str) -> str:
-    """Infer domain from module path."""
-    if "semantic_moves" in module:
-        return "Semantic Moves"
-    if "experiment" in module:
-        return "Experiments"
-    if "musical_intelligence" in module:
-        return "Musical Intelligence"
-    if "memory.tools" in module:
-        return "Memory Fabric"
-    if "mix_engine" in module:
-        return "Mix Engine"
-    if "sound_design" in module:
-        return "Sound Design"
-    if "transition_engine" in module:
-        return "Transition Engine"
-    if "reference_engine" in module:
-        return "Reference Engine"
-    if "translation_engine" in module:
-        return "Translation Engine"
-    if "performance_engine" in module:
-        return "Performance Engine"
-    if "project_brain" in module:
-        return "Project Brain"
-    if "evaluation" in module:
-        return "Evaluation"
-    if "runtime" in module:
-        return "Runtime"
-
-    # Core tools — extract from module name
+    """Infer domain from module path using the same module-layout rule as
+    ``scripts/sync_metadata.py``:
+      - ``mcp_server.<X>.<...>``              → ``<X>``
+      - ``mcp_server.tools.<Y>``              → ``<Y>``
+    The display name is Title-Cased; underscores become spaces.
+    """
     parts = module.split(".")
-    for p in reversed(parts):
-        if p in ("transport", "tracks", "clips", "notes", "devices", "scenes",
-                  "mixing", "browser", "arrangement", "memory", "analyzer",
-                  "automation", "theory", "generative", "harmony", "midi_io",
-                  "perception", "agent_os", "composition", "motif", "research",
-                  "planner"):
-            return p.replace("_", " ").title()
-
-    return "Other"
+    if len(parts) < 2 or parts[0] != "mcp_server":
+        return "Other"
+    if parts[1] == "tools":
+        domain_key = parts[2] if len(parts) > 2 else "other"
+    else:
+        domain_key = parts[1]
+    return domain_key.replace("_", " ").title()
 
 
 def main():