livepilot 1.10.4 → 1.10.6

package/mcp_server/experiment/engine.py

@@ -22,7 +22,9 @@ import time
 from typing import Optional
 
 from .models import ExperimentSet, ExperimentBranch, BranchSnapshot
+import logging
 
+logger = logging.getLogger(__name__)
 
 # ── In-memory experiment store ───────────────────────────────────────────────
 
@@ -34,9 +36,9 @@ def _gen_id(prefix: str, seed: str) -> str:
     h = hashlib.sha256(f"{prefix}:{seed}:{time.time()}".encode()).hexdigest()[:8]
     return f"{prefix}_{h}"
 
-
 # ── Create experiments ───────────────────────────────────────────────────────
 
+
 def create_experiment(
     request_text: str,
     move_ids: list[str],
@@ -83,9 +85,9 @@ def list_experiments() -> list[dict]:
     """List all experiment sets."""
     return [exp.to_dict() for exp in _EXPERIMENTS.values()]
 
-
 # ── Run experiments (requires Ableton connection) ────────────────────────────
 
+
 def run_branch(
     branch: ExperimentBranch,
     ableton,  # AbletonConnection
@@ -143,7 +145,8 @@ def _run_branch_sync(branch, ableton, compiled_plan, capture_fn):
     for _ in range(steps_executed):
         try:
             ableton.send_command("undo", {})
-        except Exception:
+        except Exception as exc:
+            logger.debug("_run_branch_sync failed: %s", exc)
             break
 
     branch.status = "evaluated" if steps_executed > 0 else "failed"
@@ -215,7 +218,8 @@ async def run_branch_async(
     for _ in range(steps_executed):
         try:
             ableton.send_command("undo", {})
-        except Exception:
+        except Exception as exc:
+            logger.debug("run_branch_async failed: %s", exc)
             break
 
     # A branch is "evaluated" only if it actually applied at least one step.
@@ -244,9 +248,9 @@ def evaluate_branch(
     branch.score = result.get("score", 0.0)
     return branch
 
-
 # ── Commit / discard ─────────────────────────────────────────────────────────
 
+
 async def commit_branch_async(
     experiment: ExperimentSet,
     branch_id: str,

package/mcp_server/experiment/tools.py

@@ -18,6 +18,9 @@ from fastmcp import Context
 from ..server import mcp
 from . import engine
 from .models import BranchSnapshot
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 def _get_ableton(ctx: Context):
@@ -35,25 +38,22 @@ def _capture_snapshot(ctx: Context) -> BranchSnapshot:
     try:
         meters = ableton.send_command("get_track_meters", {"include_stereo": True})
         snapshot.track_meters = meters.get("tracks", [])
-    except Exception:
-        pass
-
+    except Exception as exc:
+        logger.debug("_capture_snapshot failed: %s", exc)
     # Spectral data (requires M4L analyzer)
     if spectral and spectral.is_connected:
         try:
             spec = spectral.get("spectrum")
             if spec:
                 snapshot.spectrum = spec.get("value", {})
-        except Exception:
-            pass
-
+        except Exception as exc:
+            logger.debug("_capture_snapshot failed: %s", exc)
         try:
             rms_data = spectral.get("rms")
             if rms_data:
                 snapshot.rms = rms_data.get("value")
-        except Exception:
-            pass
-
+        except Exception as exc:
+            logger.debug("_capture_snapshot failed: %s", exc)
     return snapshot
 
 

package/mcp_server/hook_hunter/tools.py

@@ -17,6 +17,9 @@ from fastmcp import Context
 
 from ..server import mcp
 from . import analyzer
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 def _get_ableton(ctx: Context):
@@ -39,8 +42,8 @@ def _fetch_tracks_and_scenes(ctx: Context) -> tuple[list[dict], list[dict], dict
     try:
         session = ableton.send_command("get_session_info", {})
         tracks = session.get("tracks", [])
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_fetch_tracks_and_scenes failed: %s", exc)
 
     try:
         matrix = ableton.send_command("get_scene_matrix")
@@ -50,15 +53,16 @@ def _fetch_tracks_and_scenes(ctx: Context) -> tuple[list[dict], list[dict], dict
                 zip(matrix.get("scenes", []), matrix.get("matrix", []))
             )
         ]
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_fetch_tracks_and_scenes failed: %s", exc)
 
     # Fetch motif data — via shared motif service
     try:
         from ..services.motif_service import get_motif_data, fetch_notes_from_ableton
         notes_by_track = fetch_notes_from_ableton(ableton, tracks)
         motif_data = get_motif_data(notes_by_track)
-    except Exception:
+    except Exception as exc:
+        logger.debug("_fetch_tracks_and_scenes failed: %s", exc)
         pass  # Motif graph requires notes in clips; empty dict is valid fallback
 
     return tracks, scenes, motif_data
@@ -325,7 +329,6 @@ def suggest_payoff_repair(ctx: Context) -> dict:
         "repair_count": len(repairs),
     }
 
-
 # ── Helpers ───────────────────────────────────────────────────────
 
 
@@ -376,8 +379,8 @@ def _get_section_data(ableton) -> list[dict]:
                 "density": round(density, 3),
                 "has_drums": has_drums,
             })
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_get_section_data failed: %s", exc)
 
     return sections
 
@@ -391,6 +394,7 @@ def _get_song_brain_dict() -> dict:
     except Exception as _e:
         if __debug__:
             import sys
+
             print(f"LivePilot: SongBrain unavailable in hook_hunter: {_e}", file=sys.stderr)
     return {}
 
@@ -421,7 +425,8 @@ def detect_hook_neglect(ctx: Context) -> dict:
 
     try:
         matrix = ableton.send_command("get_scene_matrix")
-    except Exception:
+    except Exception as exc:
+        logger.debug("detect_hook_neglect failed: %s", exc)
         return {
             "neglected": False,
             "hook": hook.to_dict(),

package/mcp_server/m4l_bridge.py

@@ -7,6 +7,17 @@ the M4L device on the master track. Sends commands back for deep LOM access.
 Architecture:
     M4L → UDP:9880 → SpectralReceiver → SpectralCache → MCP tools
     MCP tools → M4LBridge → UDP:9881 → M4L device
+
+OSC address convention:
+    - OUTGOING (this side → M4L): address string is sent WITHOUT a leading
+      slash because Max's `udpreceive` treats a literal '/' as part of the
+      selector. The JS side (livepilot_bridge.js) routes on bare selectors
+      like "cmd" / "ping".
+    - INCOMING (M4L → this side): the M4L side uses Max's `udpsend`, whose
+      outlet messages include the leading slash (e.g. "/response"). The
+      `_parse_osc` helper normalizes with `rest = "/" + rest.lstrip("/\\")`
+      so both forms are tolerated — keep that normalization; both sides
+      bend toward leniency but the outgoing convention here is slash-less.
 """
 
 from __future__ import annotations

package/mcp_server/memory/taste_graph.py

@@ -17,6 +17,9 @@ from __future__ import annotations
 import time
 from dataclasses import dataclass, field
 from typing import Optional
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 @dataclass
@@ -127,7 +130,8 @@ class TasteGraph:
         if self._persistent_store is not None:
             try:
                 self._persistent_store.record_move_outcome(move_id, family, kept, score)
-            except Exception:
+            except Exception as exc:
+                logger.debug("record_move_outcome failed: %s", exc)
                 pass  # persistence is best-effort
 
     def record_device_use(self, device_name: str, positive: bool = True) -> None:
@@ -249,9 +253,9 @@ class TasteGraph:
             "explanations": explanations,
         }
 
-
 # ── Builder ──────────────────────────────────────────────────────────────────
 
+
 def build_taste_graph(
     taste_store=None,   # TasteMemoryStore
     anti_store=None,    # AntiMemoryStore
@@ -299,6 +303,7 @@ def build_taste_graph(
         # Device affinities
         for dev_name, dev_data in persisted.get("device_affinities", {}).items():
             from .taste_graph import DeviceAffinity
+
             graph.device_affinities[dev_name] = DeviceAffinity(
                 device_name=dev_name,
                 affinity=dev_data.get("affinity", 0.0),

package/mcp_server/mix_engine/tools.py

@@ -15,6 +15,10 @@ from ..evaluation.fabric import evaluate_sonic_move
 from .state_builder import build_mix_state
 from .critics import run_all_mix_critics
 from .planner import plan_mix_moves
+import logging
+
+logger = logging.getLogger(__name__)
+
 
 
 # ── Helpers ─────────────────────────────────────────────────────────
@@ -32,7 +36,8 @@ def _fetch_mix_data(ctx: Context) -> dict:
         try:
             info = ableton.send_command("get_track_info", {"track_index": i})
             track_infos.append(info)
-        except Exception:
+        except Exception as exc:
+            logger.debug("_fetch_mix_data failed: %s", exc)
             continue
 
     # Get spectrum and RMS data directly from SpectralCache (not TCP)
@@ -51,8 +56,8 @@ def _fetch_mix_data(ctx: Context) -> dict:
             rms_snap = spectral.get("rms")
             if rms_snap:
                 rms_data = rms_snap["value"] if isinstance(rms_snap["value"], dict) else rms_snap["value"]
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_fetch_mix_data failed: %s", exc)
 
     return {
         "session_info": session_info,

package/mcp_server/musical_intelligence/tools.py

@@ -13,6 +13,9 @@ from fastmcp import Context
 
 from ..server import mcp
 from . import detectors
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 def _get_ableton(ctx: Context):
@@ -34,7 +37,8 @@ def detect_repetition_fatigue(ctx: Context) -> dict:
     # Get scene matrix for clip reuse analysis
     try:
         matrix = ableton.send_command("get_scene_matrix")
-    except Exception:
+    except Exception as exc:
+        logger.debug("detect_repetition_fatigue failed: %s", exc)
         matrix = {}
 
     scenes = []
@@ -53,8 +57,8 @@ def detect_repetition_fatigue(ctx: Context) -> dict:
         track_list = session_info.get("tracks", [])
         notes_by_track = fetch_notes_from_ableton(ableton, track_list)
         motif_graph = get_motif_data(notes_by_track)
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("detect_repetition_fatigue failed: %s", exc)
 
     report = detectors.detect_repetition_fatigue(scenes, motif_graph)
     return report.to_dict()
@@ -97,7 +101,8 @@ def infer_section_purposes(ctx: Context) -> dict:
     # Get scene matrix for density analysis
     try:
         matrix = ableton.send_command("get_scene_matrix")
-    except Exception:
+    except Exception as exc:
+        logger.debug("infer_section_purposes failed: %s", exc)
         matrix = {}
 
     scenes = []
@@ -132,7 +137,8 @@ def score_emotional_arc(ctx: Context) -> dict:
 
     try:
         matrix = ableton.send_command("get_scene_matrix")
-    except Exception:
+    except Exception as exc:
+        logger.debug("score_emotional_arc failed: %s", exc)
         matrix = {}
 
     scenes = []
@@ -147,7 +153,6 @@ def score_emotional_arc(ctx: Context) -> dict:
     arc = detectors.score_emotional_arc(purposes)
     return arc.to_dict()
 
-
 # ── Phrase Evaluation ────────────────────────────────────────────────
 
 
@@ -179,14 +184,14 @@ def analyze_phrase_arc(
     try:
         from ..tools._perception_engine import compute_loudness
         loudness_data = compute_loudness(file_path, detail="full")
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("analyze_phrase_arc failed: %s", exc)
 
     try:
         from ..tools._perception_engine import compute_spectral
         spectrum_data = compute_spectral(file_path)
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("analyze_phrase_arc failed: %s", exc)
 
     critique = phrase_critic.analyze_phrase(loudness_data, spectrum_data, target)
     critique.render_id = file_path.split("/")[-1] if "/" in file_path else file_path

package/mcp_server/performance_engine/tools.py

@@ -12,6 +12,10 @@ from ..server import mcp
 from .models import EnergyWindow, SceneRole
 from .planner import build_performance_state, plan_scene_transition, suggest_energy_moves
 from .safety import classify_move_safety, get_blocked_moves, get_safe_moves
+import logging
+
+logger = logging.getLogger(__name__)
+
 
 
 # ── Helpers ─────────────────────────────────────────────────────────
@@ -87,8 +91,8 @@ def _fetch_scene_data(ctx: Context) -> tuple[list[SceneRole], int]:
             if s.get("is_triggered", False):
                 current_scene = i
                 break
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_fetch_scene_data failed: %s", exc)
 
     return scene_roles, current_scene
 

package/mcp_server/preview_studio/tools.py

@@ -15,6 +15,9 @@ from fastmcp import Context
 
 from ..server import mcp
 from . import engine
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 def _get_ableton(ctx: Context):
@@ -39,10 +42,9 @@ def _find_wonder_session_by_preview(set_id: str):
     try:
         from ..wonder_mode.session import find_session_by_preview_set
         return find_session_by_preview_set(set_id)
-    except Exception:
+    except Exception as exc:
+        logger.debug("_find_wonder_session_by_preview failed: %s", exc)
         return None
-
-
 @mcp.tool()
 def create_preview_set(
     ctx: Context,
@@ -148,8 +150,8 @@ def create_preview_set(
         # Fallback: if no keyword match, take top 3 from full registry
         if not available_moves:
             available_moves = registry.list_moves()[:3]
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("create_preview_set failed: %s", exc)
 
     # Get song brain if available
     song_brain: dict = {}
@@ -177,8 +179,8 @@ def create_preview_set(
             persistent_store=persistent,
         )
         taste_graph = graph.to_dict()
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("create_preview_set failed: %s", exc)
 
     ps = engine.create_preview_set(
         request_text=request_text,
@@ -345,8 +347,8 @@ async def commit_preview_variant(
             )
             if ws.creative_thread_id:
                 resolve_thread(ws.creative_thread_id)
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("commit_preview_variant failed: %s", exc)
 
         # Update taste graph (with persistent backing)
         try:
@@ -373,8 +375,8 @@ async def commit_preview_variant(
                     family=family,
                     kept=True,
                 )
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("commit_preview_variant failed: %s", exc)
 
         result["wonder_session_id"] = ws.session_id
 
@@ -488,6 +490,7 @@ async def render_preview_variant(
                     playback_started = True
 
                     import time as _time
+
                     _time.sleep(play_seconds)
 
                     spectral_after = cache.get_all()
@@ -496,7 +499,8 @@ async def render_preview_variant(
                     playback_started = False
 
                     preview_mode = "audible_preview"
-            except Exception:
+            except Exception as exc:
+                logger.debug("render_preview_variant failed: %s", exc)
                 # Spectral capture is best-effort; keep preview_mode as metadata_only
                 pass
 
@@ -507,12 +511,14 @@ async def render_preview_variant(
             if playback_started:
                 try:
                     ableton.send_command("stop_playback", {})
-                except Exception:
-                    pass
+                except Exception as exc:
+                    logger.debug("render_preview_variant failed: %s", exc)
+
             for _ in range(applied_count):
                 try:
                     ableton.send_command("undo")
-                except Exception:
+                except Exception as exc:
+                    logger.debug("render_preview_variant failed: %s", exc)
                     break
 
         variant.status = "rendered"

package/mcp_server/project_brain/tools.py

@@ -11,6 +11,10 @@ from fastmcp import Context
 
 from ..server import mcp
 from .builder import build_project_state_from_data
+import logging
+
+logger = logging.getLogger(__name__)
+
 
 
 def _get_ableton(ctx: Context):
@@ -39,7 +43,8 @@ def build_project_brain(ctx: Context) -> dict:
     try:
         scenes_resp = ableton.send_command("get_scenes_info")
         scenes = scenes_resp.get("scenes", [])
-    except Exception:
+    except Exception as exc:
+        logger.debug("build_project_brain failed: %s", exc)
         scenes = session_info.get("scenes", [])
 
     # 3. Get clip matrix (scene_matrix)
@@ -47,8 +52,8 @@ def build_project_brain(ctx: Context) -> dict:
     try:
         matrix_resp = ableton.send_command("get_scene_matrix")
         clip_matrix = matrix_resp.get("matrix", [])
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("build_project_brain failed: %s", exc)
 
     # 4. Gather per-track info with devices
     track_infos = []
@@ -58,7 +63,8 @@ def build_project_brain(ctx: Context) -> dict:
                 "track_index": track["index"],
             })
             track_infos.append(info)
-        except Exception:
+        except Exception as exc:
+            logger.debug("build_project_brain failed: %s", exc)
             track_infos.append({
                 "index": track.get("index", 0),
                 "name": track.get("name", ""),
@@ -75,8 +81,8 @@ def build_project_brain(ctx: Context) -> dict:
             clips = arr.get("clips", [])
             if clips:
                 arrangement_clips[track["index"]] = clips
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("build_project_brain failed: %s", exc)
 
     # 5b. Build notes_map for role inference.
     # Shape: {section_id: {track_index: [notes]}}. Without this, role_graph
@@ -102,12 +108,14 @@ def build_project_brain(ctx: Context) -> dict:
                         notes = notes_resp.get("notes", [])
                         if notes:
                             per_track[t_idx] = notes
-                except Exception:
+                except Exception as exc:
+                    logger.debug("build_project_brain failed: %s", exc)
                     # Individual note fetch failing is fine — continue with others
                     continue
             if per_track:
                 notes_map[section_id] = per_track
-    except Exception:
+    except Exception as exc:
+        logger.debug("build_project_brain failed: %s", exc)
         # Overall failure: empty map, degrade to "all tracks active" fallback
         notes_map = {}
 
@@ -127,8 +135,8 @@ def build_project_brain(ctx: Context) -> dict:
                 if spectral.get(key) is not None:
                     flucoma_ok = True
                     break
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("build_project_brain failed: %s", exc)
 
     # 7. Build state
     state = build_project_state_from_data(

package/mcp_server/reference_engine/tools.py

@@ -13,7 +13,9 @@ from ..tools._research_engine import get_style_tactics
 from .profile_builder import build_audio_reference_profile, build_style_reference_profile
 from .gap_analyzer import analyze_gaps, classify_gap_relevance, detect_identity_warnings
 from .tactic_router import build_reference_plan
+import logging
 
+logger = logging.getLogger(__name__)
 
 # ── Helpers ────────────────────────────────────────────────────────
 
@@ -50,6 +52,7 @@ def _fetch_project_snapshot(ctx: Context) -> dict:
                 rms = rms_snap["value"] if isinstance(rms_snap["value"], (int, float)) else 0.0
                 if rms > 0:
                     import math
+
                     snapshot["loudness"] = round(20 * math.log10(max(rms, 1e-10)), 2)
 
             spec_data = spectral.get("spectrum")
@@ -58,8 +61,8 @@ def _fetch_project_snapshot(ctx: Context) -> dict:
                 key_data = spectral.get("key")
                 if key_data:
                     snapshot["spectral"]["detected_key"] = key_data["value"]
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_fetch_project_snapshot failed: %s", exc)
 
     # Try to get session info for pacing / density
     try:
@@ -69,12 +72,11 @@ def _fetch_project_snapshot(ctx: Context) -> dict:
         # Rough density estimate
         snapshot["density"] = min(1.0, track_count / 20.0)
         snapshot["pacing"] = [{"label": f"scene_{i}", "bars": 8} for i in range(scene_count)]
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_fetch_project_snapshot failed: %s", exc)
 
     return snapshot
 
-
 # ── MCP Tools ──────────────────────────────────────────────────────
 
 

package/mcp_server/runtime/capability_probe.py

@@ -9,6 +9,9 @@ from __future__ import annotations
 import os
 from pathlib import Path
 from typing import Any
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 def probe_capabilities(
@@ -27,8 +30,9 @@ def probe_capabilities(
         try:
             info = ableton.send_command("ping")
             ableton_ok = info is not None
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("probe_capabilities failed: %s", exc)
+
     report["ableton"] = {
         "status": "ok" if ableton_ok else "unavailable",
         "detail": "TCP 9878 connection active" if ableton_ok else "Not connected",
@@ -40,8 +44,9 @@ def probe_capabilities(
         try:
             info = ableton.send_command("get_session_info")
             live_version_str = info.get("live_version", "12.0.0")
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("probe_capabilities failed: %s", exc)
+
     from .live_version import LiveVersionCapabilities
     version_caps = LiveVersionCapabilities.from_version_string(live_version_str)
     report["live_version"] = {
@@ -75,6 +80,7 @@ def probe_capabilities(
     numpy_ok = False
     try:
         import numpy  # noqa: F401
+
         numpy_ok = True
     except ImportError:
         pass

package/mcp_server/runtime/tools.py

@@ -12,6 +12,9 @@ from fastmcp import Context
 from ..server import mcp
 from ..memory.technique_store import TechniqueStore
 from .capability_state import build_capability_state
+import logging
+
+logger = logging.getLogger(__name__)
 
 _memory_store = TechniqueStore()
 
@@ -31,7 +34,8 @@ def get_capability_state(ctx: Context) -> dict:
     try:
         result = ableton.send_command("get_session_info")
         session_ok = isinstance(result, dict) and "error" not in result
-    except Exception:
+    except Exception as exc:
+        logger.debug("get_capability_state failed: %s", exc)
         session_ok = False
 
     # ── Probe analyzer (M4L bridge) ─────────────────────────────────
@@ -49,7 +53,8 @@ def get_capability_state(ctx: Context) -> dict:
     try:
         _memory_store.list_techniques(limit=1)
         memory_ok = True
-    except Exception:
+    except Exception as exc:
+        logger.debug("get_capability_state failed: %s", exc)
         memory_ok = False
 
     # ── Web / FluCoMa — not probed live, default to False ───────────
@@ -180,6 +185,7 @@ def get_session_kernel(
     if request_text.strip():
         try:
             from ..tools._conductor import classify_request
+
             plan = classify_request(request_text)
             kernel.recommended_engines = [r.engine for r in plan.routes[:3]]
             kernel.recommended_workflow = plan.workflow_mode