livepilot 1.10.5 → 1.10.7

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
@@ -131,7 +135,18 @@ def develop_hook(
     # Look up the actual hook to adapt strategies by type
     hook_type = "melodic"  # default
     hook_description = "the hook"
-    if hook_id:
+    # BUG-B31: when no hook_id is provided, default to the session's primary
+    # hook. Previously the tool emitted generic advice even though
+    # find_primary_hook was already available — users had to manually chain
+    # find_primary_hook → develop_hook to get type-specific tactics.
+    if not hook_id:
+        tracks, scenes, motif_data = _fetch_tracks_and_scenes(ctx)
+        primary = analyzer.find_primary_hook(tracks, motif_data, scenes)
+        if primary is not None:
+            hook_id = primary.hook_id
+            hook_type = primary.hook_type
+            hook_description = primary.description
+    elif hook_id:
         tracks, scenes, motif_data = _fetch_tracks_and_scenes(ctx)
         candidates = analyzer.find_hook_candidates(tracks, motif_data, scenes)
         match = [c for c in candidates if c.hook_id == hook_id]
@@ -325,12 +340,18 @@ def suggest_payoff_repair(ctx: Context) -> dict:
         "repair_count": len(repairs),
     }
 
-
 # ── Helpers ───────────────────────────────────────────────────────
 
 
 def _get_section_data(ableton) -> list[dict]:
-    """Build section data from Ableton scenes with real energy/density/has_drums."""
+    """Build section data from Ableton scenes with real energy/density/has_drums.
+
+    BUG-B51 fix: also fetches per-section note signals (unique pitch
+    count, note count, velocity-variance) so compare_phrase_impact can
+    differentiate two sections that share energy/density but have
+    different clip contents. Without these, the old comparator emitted
+    identical scores for every pair of same-density sections.
+    """
     sections: list[dict] = []
     try:
         matrix = ableton.send_command("get_scene_matrix")
@@ -339,11 +360,6 @@ def _get_section_data(ableton) -> list[dict]:
 
         # Detect drum track indices by name
         drum_keywords = {"drum", "beat", "kick", "hat", "perc", "snare"}
-        track_names = []
-        # tracks may be in matrix metadata or session_info
-        for ti, row_entry in enumerate(matrix_rows[0] if matrix_rows else []):
-            track_names.append("")  # placeholder — we'll use scenes_list tracks if available
-        # Use scene matrix track info if available
         track_info = matrix.get("tracks", [])
         drum_indices = set()
         for ti, track in enumerate(track_info):
@@ -358,16 +374,49 @@ def _get_section_data(ableton) -> list[dict]:
             clip_count = sum(1 for c in row if c)
             total_tracks = max(len(row), 1)
 
-            # has_drums: check if any drum track has a clip in this scene
             has_drums = any(
                 di < len(row) and row[di]
                 for di in drum_indices
             ) if drum_indices else False
 
             density = min(1.0, clip_count / total_tracks)
-            # energy: density + drum bonus
             energy = min(1.0, density + (0.1 if has_drums else 0.0))
 
+            # BUG-B51: cheap per-section note signals. Sample up to 3
+            # non-drum tracks in this scene for a flavor of the
+            # section's harmonic/rhythmic content. Keeps the call
+            # count bounded so compare_phrase_impact doesn't explode.
+            unique_pitches: set = set()
+            note_count = 0
+            velocity_variance = 0.0
+            sampled = 0
+            for t_idx, cell in enumerate(row):
+                if sampled >= 3 or not cell:
+                    continue
+                if t_idx in drum_indices:
+                    continue
+                try:
+                    notes_resp = ableton.send_command("get_notes", {
+                        "track_index": t_idx, "clip_index": i,
+                    })
+                except Exception:
+                    continue
+                notes = notes_resp.get("notes", []) if isinstance(
+                    notes_resp, dict
+                ) else []
+                if not notes:
+                    continue
+                sampled += 1
+                note_count += len(notes)
+                for n in notes:
+                    unique_pitches.add(int(n.get("pitch", 0)) % 12)
+                vels = [int(n.get("velocity", 0)) for n in notes]
+                if len(vels) >= 2:
+                    mean_v = sum(vels) / len(vels)
+                    velocity_variance += sum(
+                        (v - mean_v) ** 2 for v in vels
+                    ) / len(vels)
+
             sections.append({
                 "id": f"scene_{i}",
                 "name": scene.get("name", f"Scene {i}"),
@@ -375,9 +424,14 @@ def _get_section_data(ableton) -> list[dict]:
                 "energy": round(energy, 3),
                 "density": round(density, 3),
                 "has_drums": has_drums,
+                # BUG-B51: these three differentiate otherwise-identical
+                # sections. Downstream phrase scorer reads them.
+                "unique_pitch_classes": len(unique_pitches),
+                "note_count": note_count,
+                "velocity_variance": round(velocity_variance, 3),
             })
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_get_section_data failed: %s", exc)
 
     return sections
 
@@ -391,6 +445,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 +476,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
@@ -267,14 +278,26 @@ class SpectralReceiver(asyncio.DatagramProtocol):
             self._handle_chunk(int(args[0]), int(args[1]), str(args[2]))
 
     def _handle_response(self, encoded: str) -> None:
-        """Decode a single-packet base64 response."""
+        """Decode a single-packet base64 response.
+
+        Resolves _response_callback exactly once, then clears it. Without the
+        clear, a second late packet could overwrite a future belonging to a
+        different in-flight command. The protocol has no request id yet
+        (livepilot_bridge.js:666 emits bare /response), so correlation relies
+        on the single-command-in-flight invariant enforced by M4LBridge._cmd_lock
+        plus this one-shot clear.
+        """
         try:
             # URL-safe base64 decode (- and _ instead of + and /)
             padded = encoded + "=" * (-len(encoded) % 4)
             decoded = base64.urlsafe_b64decode(padded).decode('utf-8')
             result = _normalize_bridge_payload(json.loads(decoded))
-            if self._response_callback and not self._response_callback.done():
-                self._response_callback.set_result(result)
+            cb = self._response_callback
+            if cb and not cb.done():
+                cb.set_result(result)
+            # Clear regardless — either we consumed it, or it was already
+            # done/abandoned. Future packets with no owner get dropped.
+            self._response_callback = None
         except Exception as exc:
             import sys
             print(f"LivePilot: failed to decode bridge response: {exc}", file=sys.stderr)
@@ -365,11 +388,14 @@ class M4LBridge:
                 result = await asyncio.wait_for(future, timeout=timeout)
                 return result
             except asyncio.TimeoutError:
-                # Clear the stale future so a delayed response doesn't resolve
-                # a future that no caller is waiting on
+                return {"error": "M4L bridge timeout — device may be busy or removed"}
+            finally:
+                # Always clear the future — on success the receiver has already
+                # cleared it inside _handle_response, but calling again is a
+                # no-op. On timeout this is what prevents a delayed packet from
+                # resolving a future belonging to the next command.
                 if self.receiver:
                     self.receiver.set_response_future(None)
-                return {"error": "M4L bridge timeout — device may be busy or removed"}
 
     async def send_capture(self, command: str, *args: Any, timeout: float = 35.0) -> dict:
         """Send a capture command to the M4L device and wait for /capture_complete."""

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/detectors.py

@@ -208,11 +208,43 @@ def detect_role_conflicts(
                   "Layer drum parts into one Drum Rack or pan them apart"),
     }
 
+    # BUG-B1 fix: intentional drum + percussion layering is the core
+    # aesthetic in hip-hop / Dilla / lo-fi / beat-scene music, not a
+    # conflict. Heuristic to demote drum-role conflicts when the track
+    # names make that layering obvious (one "DRUMS" + one "PERC/CONGA/
+    # SHAKER" is distinct instruments, not a fight for the same role).
+    _PERC_NAMES = {
+        "perc", "percussion", "conga", "congas", "shaker",
+        "tambourine", "cowbell", "triangle", "bongo",
+        "djembe", "claves", "hi-hat", "hihat", "hat",
+    }
+
+    def _looks_like_layering(group: list[dict]) -> bool:
+        """True if at least one of the tracks has a percussion-specific
+        name (distinct from the main drum kit)."""
+        if len(group) < 2:
+            return False
+        perc_track_count = 0
+        for track in group:
+            name = str(track.get("name", "")).lower()
+            if any(tok in name for tok in _PERC_NAMES):
+                perc_track_count += 1
+        # Needs at least one main "drums" track AND one perc track
+        return 1 <= perc_track_count < len(group)
+
     conflicts = []
     for role, (desc, rec) in UNIQUE_ROLES.items():
         group = role_groups.get(role, [])
         if len(group) > 1:
             severity = min(0.9, 0.3 + (len(group) - 1) * 0.2)
+            if role == "drums" and _looks_like_layering(group):
+                # Demote severity — this looks intentional, not a conflict
+                severity = max(0.1, severity - 0.4)
+                rec = (
+                    "Drum + percussion layering detected — if this is "
+                    "intentional (hip-hop / Dilla / lo-fi), ignore. "
+                    "Otherwise: " + rec
+                )
             conflicts.append(RoleConflict(
                 role=role,
                 tracks=group,

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,39 +12,68 @@ 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 ─────────────────────────────────────────────────────────
 
 
-def _infer_role(name: str, index: int, scene_count: int) -> str:
-    """Infer a scene's role from its name or position."""
-    lower = name.lower()
-    for role in ("intro", "verse", "chorus", "build", "drop", "breakdown", "outro", "transition"):
-        if role in lower:
-            return role
-    # Positional fallback
+# BUG-E4 / E5 fix: performance_engine used to have its own _infer_role() keyword
+# list and _infer_energy() static {role → number} table. Those diverged from
+# _composition_engine's richer section classifier, which caused
+# get_performance_state and analyze_composition to label the same scenes
+# differently (Deep Flow: drop vs verse, Sun Peak: drop vs chorus) and to
+# report dissimilar energies (composition derived from active-track density,
+# performance looked up a hard-coded 0.2/0.4/0.7 table). Now performance
+# consumes composition's section graph as the source of truth and only keeps
+# a positional fallback for scenes without enough data.
+_POSITIONAL_FALLBACK_ROLES = {
+    "first": "intro",
+    "last": "outro",
+    "early": "intro",
+    "middle_low": "verse",
+    "middle_high": "chorus",
+    "late": "outro",
+    "default": "verse",
+}
+
+
+def _positional_fallback_role(index: int, scene_count: int) -> str:
+    """Map a scene index to a role when no composition data is available.
+
+    Kept only as a last-resort so we still produce a sensible answer for
+    unnamed scenes or when build_section_graph_from_scenes returns empty.
+    Callers should prefer the composition-engine result when it exists.
+    """
+    if scene_count <= 0:
+        return _POSITIONAL_FALLBACK_ROLES["default"]
     if index == 0:
-        return "intro"
+        return _POSITIONAL_FALLBACK_ROLES["first"]
     if index == scene_count - 1:
-        return "outro"
+        return _POSITIONAL_FALLBACK_ROLES["last"]
     if scene_count > 4:
-        quarter = scene_count / 4
+        quarter = scene_count / 4.0
         if index < quarter:
-            return "intro"
-        elif index < quarter * 2:
-            return "verse"
-        elif index < quarter * 3:
-            return "chorus"
-        else:
-            return "outro"
-    return "verse"
+            return _POSITIONAL_FALLBACK_ROLES["early"]
+        if index < quarter * 2:
+            return _POSITIONAL_FALLBACK_ROLES["middle_low"]
+        if index < quarter * 3:
+            return _POSITIONAL_FALLBACK_ROLES["middle_high"]
+        return _POSITIONAL_FALLBACK_ROLES["late"]
+    return _POSITIONAL_FALLBACK_ROLES["default"]
+
 
+def _positional_fallback_energy(role: str) -> float:
+    """Static energy map used only when density is unavailable.
 
-def _infer_energy(role: str) -> float:
-    """Infer energy level from scene role."""
-    energy_map = {
-        "intro": 0.2,
+    Kept tiny and explicit so the fallback path is obvious — the primary
+    source of energy is _composition_engine's density-based value.
+    """
+    return {
+        "intro": 0.3,
         "verse": 0.4,
         "build": 0.6,
         "chorus": 0.7,
@@ -52,23 +81,82 @@ def _infer_energy(role: str) -> float:
         "breakdown": 0.3,
         "transition": 0.5,
         "outro": 0.2,
-    }
-    return energy_map.get(role, 0.5)
+    }.get(role, 0.5)
 
 
 def _fetch_scene_data(ctx: Context) -> tuple[list[SceneRole], int]:
-    """Fetch scene info from Ableton and build SceneRole list."""
+    """Fetch scene info + composition graph from Ableton and build SceneRole list.
+
+    BUG-E4 / E5 fix: roles + energies now flow from composition_engine's
+    build_section_graph_from_scenes, which uses keyword matching + active-
+    track density for energy. Unnamed scenes fall back to the positional
+    heuristic. This keeps get_performance_state in sync with
+    get_section_graph / analyze_composition.
+    """
+    from ..tools._composition_engine import (
+        build_section_graph_from_scenes,
+        SectionNode as CESectionNode,
+    )
+
     ableton = ctx.lifespan_context["ableton"]
 
     scenes_info = ableton.send_command("get_scenes_info", {})
     scenes_list = scenes_info.get("scenes", [])
     scene_count = len(scenes_list)
 
+    # Pull session topology + clip matrix so composition engine can compute
+    # active-track density. If any of these fails we fall back to the
+    # positional heuristic — preserving the old behavior as a safety net.
+    track_count = 0
+    clip_matrix: list[list[dict]] = []
+    try:
+        session_info = ableton.send_command("get_session_info", {})
+        track_count = int(session_info.get("track_count", 0))
+    except Exception as exc:
+        logger.debug("_fetch_scene_data session_info failed: %s", exc)
+    try:
+        mtx = ableton.send_command("get_scene_matrix", {})
+        if isinstance(mtx, dict):
+            clip_matrix = mtx.get("matrix", []) or []
+    except Exception as exc:
+        logger.debug("_fetch_scene_data scene_matrix failed: %s", exc)
+
+    # Build the composition section graph. Each SectionNode has
+    # section_id = f"sec_{raw_enumerate_index:02d}" per BUG-E1 fix, so we
+    # can index by scene position directly.
+    ce_sections: list[CESectionNode] = []
+    try:
+        if scenes_list and clip_matrix and track_count > 0:
+            ce_sections = build_section_graph_from_scenes(
+                scenes_list, clip_matrix, track_count,
+            )
+    except Exception as exc:
+        logger.debug("_fetch_scene_data section graph failed: %s", exc)
+
+    ce_by_scene_idx: dict[int, CESectionNode] = {}
+    for sec in ce_sections:
+        # section_id format "sec_02" → scene index 2 (raw enumerate index)
+        sid = str(sec.section_id)
+        if sid.startswith("sec_"):
+            try:
+                ce_by_scene_idx[int(sid[4:])] = sec
+            except ValueError:
+                pass
+
     scene_roles: list[SceneRole] = []
     for i, scene_data in enumerate(scenes_list):
         name = scene_data.get("name", f"Scene {i}")
-        role = _infer_role(name, i, scene_count)
-        energy = _infer_energy(role)
+        ce_sec = ce_by_scene_idx.get(i)
+        if ce_sec is not None:
+            # SectionType is an enum; .value gives the string vocabulary
+            stype = ce_sec.section_type
+            role = stype.value if hasattr(stype, "value") else str(stype)
+            energy = float(ce_sec.energy)
+        else:
+            # Unnamed scene or build failed — positional fallback
+            role = _positional_fallback_role(i, scene_count)
+            energy = _positional_fallback_energy(role)
+
         scene_roles.append(SceneRole(
             scene_index=i,
             name=name,
@@ -81,14 +169,13 @@ def _fetch_scene_data(ctx: Context) -> tuple[list[SceneRole], int]:
     current_scene = 0
     try:
         session_info = ableton.send_command("get_session_info", {})
-        # Check if any scene is marked as triggered/playing
         session_scenes = session_info.get("scenes", [])
         for i, s in enumerate(session_scenes):
             if s.get("is_triggered", False):
                 current_scene = i
                 break
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_fetch_scene_data current_scene failed: %s", exc)
 
     return scene_roles, current_scene