livepilot 1.10.4 → 1.10.6

package/mcp_server/tools/analyzer.py

@@ -43,7 +43,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 +255,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,6 +276,130 @@ async def get_clip_file_path(
     bridge = _get_m4l(ctx)
     return await bridge.send_command("get_clip_file_path", track_index, clip_index)
 
+import os  # for filename parsing in smart-defaults helper
+import re
+import logging
+
+logger = logging.getLogger(__name__)
+
+# ── Sample loading helpers (P0-1, P1-1, P2-6 fixes) ────────────────────────
+#
+# Critical bug 2026-04-14 (see docs/2026-04-14-bugs-discovered.md):
+#
+# The M4L bridge's `replace_simpler_sample` command can report success even
+# when the sample is still the bootstrap placeholder. The Simpler's display
+# name also does NOT refresh after a replace. After loading, Simpler's Snap
+# parameter is ON by default which causes the Sample Start position to
+# snap to a location outside the new sample's valid audio — resulting in
+# silent playback.
+#
+# The fixes below:
+#   1. After replace, verify by reading the actual device name via
+#      get_track_info and comparing to the expected filename stem. If the
+#      name doesn't match, return a clear error so the caller doesn't
+#      silently ship the wrong audio.
+#   2. Auto-set Snap=0 to disarm the zero-crossing snap that breaks playback.
+#   3. For WARPED LOOPS (detected by "NNbpm" in the filename), set
+#      S Start=0, S Length=1, S Loop On=1 so the full loop plays in its
+#      musical phrasing. For ONE-SHOTS, leave defaults alone.
+
+_BPM_IN_FILENAME_RE = re.compile(r"(\d{2,3})\s*bpm", re.IGNORECASE)
+
+
+def _is_warped_loop(file_path: str) -> bool:
+    """Return True if the filename contains a BPM marker (likely a tempo-locked loop)."""
+    stem = os.path.splitext(os.path.basename(file_path))[0]
+    return bool(_BPM_IN_FILENAME_RE.search(stem))
+
+
+def _filename_stem(file_path: str) -> str:
+    return os.path.splitext(os.path.basename(file_path))[0]
+
+
+async def _simpler_post_load_hygiene(
+    bridge,
+    ableton,
+    track_index: int,
+    device_index: int,
+    file_path: str,
+) -> dict:
+    """Apply post-load hygiene to a newly loaded Simpler and verify success.
+
+    Steps:
+      1. Read track info to verify the device's actual name matches the
+         expected sample stem. If it doesn't, return an error.
+      2. Set Snap=0 (Off) — required so sample playback works.
+      3. If filename indicates a warped loop, set S Start=0, S Length=1,
+         S Loop On=1 so the loop plays fully instead of being cropped.
+      4. Return a verified response dict.
+    """
+    expected_stem = _filename_stem(file_path)
+
+    # Step 1: verify device name matches expected file
+    try:
+        track_info = ableton.send_command(
+            "get_track_info", {"track_index": track_index}
+        )
+    except Exception as exc:
+        return {"error": f"Verification read failed: {exc}"}
+
+    devices = track_info.get("devices", []) or []
+    if device_index < 0 or device_index >= len(devices):
+        return {
+            "error": (
+                f"Device index {device_index} out of range after load "
+                f"(track has {len(devices)} devices)"
+            ),
+            "verified": False,
+        }
+    device = devices[device_index]
+    actual_name = str(device.get("name") or "")
+    verified = expected_stem in actual_name or actual_name in expected_stem
+    if not verified:
+        return {
+            "error": (
+                f"Sample verification FAILED — Simpler name '{actual_name}' "
+                f"does not match requested file '{expected_stem}'. The bridge "
+                f"reported success but the actual sample is different. "
+                f"Try `load_browser_item` with a user_library URI instead."
+            ),
+            "verified": False,
+            "actual_device_name": actual_name,
+            "expected_stem": expected_stem,
+        }
+
+    # Step 2: turn Snap OFF — required for reliable playback after replace
+    hygiene_params: list[dict] = [
+        {"name_or_index": "Snap", "value": 0},
+    ]
+
+    # Step 3: smart defaults for warped loops
+    if _is_warped_loop(file_path):
+        hygiene_params.extend([
+            {"name_or_index": "S Start", "value": 0.0},
+            {"name_or_index": "S Length", "value": 1.0},
+            {"name_or_index": "S Loop On", "value": 1},
+        ])
+
+    try:
+        ableton.send_command("batch_set_parameters", {
+            "track_index": track_index,
+            "device_index": device_index,
+            "parameters": hygiene_params,
+        })
+    except Exception as exc:
+        logger.debug("_simpler_post_load_hygiene failed: %s", exc)
+        # non-fatal — verification already succeeded
+        pass
+
+    return {
+        "verified": True,
+        "device_name": actual_name,
+        "track_index": track_index,
+        "device_index": device_index,
+        "warped_loop_defaults_applied": _is_warped_loop(file_path),
+    }
+
 
 @mcp.tool()
 async def replace_simpler_sample(
@@ -292,6 +416,17 @@ async def replace_simpler_sample(
     manually first or use find_and_load_device to load a preset that already
     contains a sample.
 
+    **Prefer `load_browser_item(track, uri)` when possible** — see P0-1 in
+    docs/2026-04-14-bugs-discovered.md. The M4L bridge's replace path can
+    silently keep the bootstrap placeholder in some conditions; this tool
+    now verifies by reading back the device name and will return an error
+    if the replace didn't actually take effect.
+
+    Also auto-applies post-load hygiene:
+      - Sets Simpler Snap=0 (required for playback after replace)
+      - For warped loops (filename contains 'NNbpm'), sets S Start=0,
+        S Length=1, S Loop On=1
+
     Use get_clip_file_path to get the path of a resampled clip, then pass
     it here to load it into Simpler for slicing.
     Requires LivePilot Analyzer on master track.
@@ -299,6 +434,7 @@ async def replace_simpler_sample(
     cache = _get_spectral(ctx)
     _require_analyzer(cache)
     bridge = _get_m4l(ctx)
+    ableton = ctx.lifespan_context["ableton"]
     result = await bridge.send_command(
         "replace_simpler_sample", track_index, device_index, file_path
     )
@@ -312,6 +448,16 @@ async def replace_simpler_sample(
             "error": "Sample may not have loaded. Ensure the Simpler already "
             "has a sample loaded — replace_sample silently fails on empty Simplers."
         }
+
+    # Verify by reading back the device name — guards against the silent
+    # failure mode where the bridge reports success but keeps the placeholder.
+    hygiene = await _simpler_post_load_hygiene(
+        bridge, ableton, track_index, device_index, file_path
+    )
+    if not hygiene.get("verified"):
+        return hygiene
+
+    result.update(hygiene)
     return result
 
 
@@ -327,10 +473,18 @@ async def load_sample_to_simpler(
     This is the full workflow for programmatic sample loading:
     1. Loads a dummy sample via the browser (creates Simpler with a sample)
     2. Replaces the dummy with your audio file
-    3. Returns the Simpler ready for slicing/warping
+    3. Applies post-load hygiene (Snap=0, loop defaults for warped loops)
+    4. Verifies by reading back the device name — returns an error if
+       the Simpler still has the bootstrap placeholder (P0-1 guard)
 
     Use this instead of replace_simpler_sample when the track has no Simpler
     or the Simpler is empty. Works with any audio file path.
+
+    **For files that exist in Ableton's browser index** (Samples, User Library,
+    Packs), PREFER `load_browser_item(track, uri)` — it goes through Ableton's
+    native loading path and is more reliable. This tool is a workaround for
+    files that aren't browser-indexed.
+
     Requires LivePilot Analyzer on master track.
     """
     cache = _get_spectral(ctx)
@@ -380,6 +534,14 @@ async def load_sample_to_simpler(
     if not result.get("sample_loaded"):
         return {"error": "Sample replacement failed after bootstrap"}
 
+    # Step 4: Verify by reading back the device name (P0-1 guard)
+    hygiene = await _simpler_post_load_hygiene(
+        bridge, ableton, track_index, actual_device_index, file_path
+    )
+    if not hygiene.get("verified"):
+        return hygiene
+
+    result.update(hygiene)
     result["method"] = "bootstrap_and_replace"
     result["device_index"] = actual_device_index  # additive — for step-result binding
     result["track_index"] = track_index
@@ -457,7 +619,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 ──────────────────────────────────────────────
 
 
@@ -542,7 +703,6 @@ async def remove_warp_marker(
         "remove_warp_marker", track_index, clip_index, beat_time
     )
 
-
 # ── Phase 2: Clip & Display ────────────────────────────────────────────
 
 
@@ -600,7 +760,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 ─────────────────────────────────────────────
 
 
@@ -659,6 +818,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:
@@ -684,7 +844,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"]

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

package/mcp_server/tools/composition.py

@@ -14,6 +14,7 @@ These tools power the composition intelligence layer:
 from __future__ import annotations
 
 import json
+import logging
 from typing import Optional
 
 from fastmcp import Context
@@ -22,6 +23,8 @@ from ..server import mcp
 from ..memory.technique_store import TechniqueStore
 from . import _composition_engine as engine
 
+logger = logging.getLogger(__name__)
+
 _memory_store = TechniqueStore()
 
 
@@ -49,7 +52,8 @@ def _build_clip_matrix(ableton, scene_count: int, track_count: int) -> list[list
         matrix_data = ableton.send_command("get_scene_matrix")
         raw_matrix = matrix_data.get("matrix", [])
         return raw_matrix
-    except Exception:
+    except Exception as exc:
+        logger.warning("get_scene_matrix failed, using empty matrix: %s", exc)
         return [[] for _ in range(scene_count)]
 
 
@@ -95,8 +99,8 @@ def analyze_composition(ctx: Context) -> dict:
             clips = arr.get("clips", [])
             if clips:
                 arr_clips[track["index"]] = clips
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("arrangement_clips track=%s skipped: %s", track.get("index"), exc)
 
     if not sections and arr_clips:
         sections = engine.build_section_graph_from_arrangement(
@@ -111,7 +115,8 @@ def analyze_composition(ctx: Context) -> dict:
                 "track_index": track["index"]
             })
             track_data.append(ti)
-        except Exception:
+        except Exception as exc:
+            logger.debug("get_track_info track=%s fallback: %s", track.get("index"), exc)
             track_data.append({"index": track["index"], "name": track.get("name", ""),
                                "devices": []})
 
@@ -130,8 +135,8 @@ def analyze_composition(ctx: Context) -> dict:
                 })
                 notes = result.get("notes", [])
                 track_notes.extend(notes)
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.debug("get_notes t=%d s=%d skipped: %s", t_idx, s_idx, exc)
         all_notes_by_track[t_idx] = track_notes
 
     # Map notes to sections
@@ -244,7 +249,8 @@ def get_phrase_grid(
                 "clip_index": scene_idx,
             })
             notes_by_track[t_idx] = result.get("notes", [])
-        except Exception:
+        except Exception as exc:
+            logger.debug("get_notes t=%d s=%d empty: %s", t_idx, scene_idx, exc)
             notes_by_track[t_idx] = []
 
     phrases = engine.detect_phrases(section, notes_by_track)
@@ -464,8 +470,8 @@ def get_harmony_field(
                                     "pattern": pattern,
                                     "classification": classification,
                                 }
-                            except Exception:
-                                pass
+                            except Exception as exc:
+                                logger.warning("neo-Riemannian classify failed: %s", exc)
 
             # Populate voice_leading_info from chord groups
             if harmony_analysis and not voice_leading_info:
@@ -483,12 +489,13 @@ def get_harmony_field(
                             "issue_count": len(all_vl_issues),
                             "quality": "clean" if not all_vl_issues else "has_issues",
                         }
-                except Exception:
-                    pass
+                except Exception as exc:
+                    logger.warning("voice_leading analysis failed: %s", exc)
 
             if scale_info and harmony_analysis:
                 break
-        except Exception:
+        except Exception as exc:
+            logger.debug("harmony scan on track %d skipped: %s", t_idx, exc)
             continue
 
     hf = engine.build_harmony_field(
@@ -535,7 +542,8 @@ def get_transition_analysis(ctx: Context) -> dict:
         try:
             ti = ableton.send_command("get_track_info", {"track_index": t_idx})
             track_data.append(ti)
-        except Exception:
+        except Exception as exc:
+            logger.debug("get_track_info transition t=%d fallback: %s", t_idx, exc)
             track_data.append({"index": t_idx, "name": track.get("name", ""), "devices": []})
 
     for section in sections:
@@ -623,7 +631,8 @@ def get_section_outcomes(
         techniques = _memory_store.list_techniques(
             type_filter="composition_outcome", sort_by="updated_at", limit=limit,
         )
-    except Exception:
+    except Exception as exc:
+        logger.warning("list_techniques(composition_outcome) failed: %s", exc)
         techniques = []
 
     outcomes = []
@@ -633,8 +642,8 @@ def get_section_outcomes(
             payload = full.get("payload", {})
             if isinstance(payload, dict):
                 outcomes.append(payload)
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("technique %s payload read failed: %s", t.get("id"), exc)
 
     result = engine.analyze_section_outcomes(outcomes)
 

package/mcp_server/tools/devices.py

@@ -11,6 +11,10 @@ from typing import Any, Optional
 from fastmcp import Context
 
 from ..server import mcp, _identify_port_holder
+import logging
+
+logger = logging.getLogger(__name__)
+
 
 
 def _ensure_list(value: Any) -> list:
@@ -130,9 +134,9 @@ def _postflight_loaded_device(ctx: Context, result: dict) -> dict:
         track_info = _get_ableton(ctx).send_command("get_track_info", {
             "track_index": int(track_index),
         })
-    except Exception:
+    except Exception as exc:
+        logger.debug("_postflight_loaded_device failed: %s", exc)
         return annotated
-
     devices = track_info.get("devices", []) if isinstance(track_info, dict) else []
     if not isinstance(devices, list) or not devices:
         return annotated
@@ -156,9 +160,8 @@ def _postflight_loaded_device(ctx: Context, result: dict) -> dict:
                 "device_index": int(match["index"]),
             })
             param_count = full_info.get("parameter_count", 0)
-        except Exception:
-            pass
-
+        except Exception as exc:
+            logger.debug("_postflight_loaded_device failed: %s", exc)
     device_info = _annotate_device_info({
         "name": match.get("name"),
         "class_name": match.get("class_name"),
@@ -597,7 +600,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 []

package/mcp_server/tools/motif.py

@@ -11,6 +11,10 @@ from fastmcp import Context
 
 from ..server import mcp
 from . import _motif_engine as motif_engine
+import logging
+
+logger = logging.getLogger(__name__)
+
 
 
 def _get_ableton(ctx: Context):
@@ -46,8 +50,9 @@ def get_motif_graph(ctx: Context) -> dict:
                     "clip_index": clip_idx,
                 })
                 track_notes.extend(result.get("notes", []))
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.debug("get_motif_graph failed: %s", exc)
+
         if track_notes:
             notes_by_track[t_idx] = track_notes
 

package/mcp_server/tools/planner.py

@@ -17,6 +17,9 @@ from fastmcp import Context
 from ..server import mcp
 from . import _composition_engine as comp_engine
 from . import _planner_engine as planner_engine
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 def _get_ableton(ctx: Context):
@@ -67,7 +70,8 @@ def plan_arrangement(
         try:
             ti = ableton.send_command("get_track_info", {"track_index": t_idx})
             track_data.append(ti)
-        except Exception:
+        except Exception as exc:
+            logger.debug("plan_arrangement failed: %s", exc)
             track_data.append({"index": t_idx, "name": track.get("name", ""), "devices": []})
 
     for section in sections:
@@ -96,7 +100,6 @@ def plan_arrangement(
     result["available_styles"] = sorted(planner_engine.VALID_STYLES)
     return result
 
-
 # ── transform_section (Round 4) ─────────────────────────────────────
 
 
@@ -130,6 +133,7 @@ def transform_section(
     track_count = session.get("track_count", 0)
 
     from .composition import _build_clip_matrix
+
     clip_matrix = _build_clip_matrix(ableton, len(scenes), track_count)
     sections = comp_engine.build_section_graph_from_scenes(scenes, clip_matrix, track_count)
 

package/mcp_server/tools/research.py

@@ -17,6 +17,9 @@ from fastmcp import Context
 from ..server import mcp
 from ..memory.technique_store import TechniqueStore
 from . import _research_engine as research_engine
+import logging
+
+logger = logging.getLogger(__name__)
 
 _memory_store = TechniqueStore()
 
@@ -66,8 +69,8 @@ def research_technique(
                 if ref and not ref.get("error") and ref.get("count", 0) > 0:
                     device_atlas_results.append(ref)
                     break  # Found in this category, skip others
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.debug("research_technique failed: %s", exc)
 
     # 3. Search memory for related techniques (direct TechniqueStore)
     memory_results = []
@@ -75,16 +78,16 @@ def research_technique(
         memory_results.extend(
             _memory_store.list_techniques(type_filter="technique_card", sort_by="updated_at", limit=10)
         )
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("research_technique failed: %s", exc)
 
     try:
         # "research" is not a valid type in TechniqueStore — search broadly
         memory_results.extend(
             _memory_store.search(query=query, limit=5)
         )
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("research_technique failed: %s", exc)
 
     if scope == "targeted":
         result = research_engine.targeted_research(
@@ -159,7 +162,8 @@ def get_emotional_arc(ctx: Context) -> dict:
                     hf.mode = detected.get("mode", "")
                     hf.confidence = detected.get("confidence", 0.0)
                     break
-            except Exception:
+            except Exception as exc:
+                logger.debug("get_emotional_arc failed: %s", exc)
                 continue
         harmony_fields.append(hf)
 
@@ -186,7 +190,6 @@ def get_emotional_arc(ctx: Context) -> dict:
         "section_count": len(sections),
     }
 
-
 # ── get_style_tactics (Round 4) ─────────────────────────────────────
 
 
@@ -213,8 +216,8 @@ def get_style_tactics(
         memory_tactics = _memory_store.search(
             query=artist_or_genre, limit=10,
         )
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("get_style_tactics failed: %s", exc)
 
     tactics = research_engine.get_style_tactics(artist_or_genre, memory_tactics)
 

package/mcp_server/transition_engine/tools.py

@@ -14,6 +14,10 @@ from ..tools import _composition_engine as comp_engine
 from .archetypes import TRANSITION_ARCHETYPES, select_archetype
 from .critics import run_all_transition_critics
 from .models import TransitionBoundary, TransitionPlan, TransitionScore
+import logging
+
+logger = logging.getLogger(__name__)
+
 
 
 # ── Helpers ───────────────────────────────────────────────────────────
@@ -29,7 +33,8 @@ def _build_sections_from_ableton(ctx: Context) -> list[comp_engine.SectionNode]:
     try:
         matrix_data = ableton.send_command("get_scene_matrix")
         clip_matrix = matrix_data.get("matrix", [])
-    except Exception:
+    except Exception as exc:
+        logger.debug("_build_sections_from_ableton failed: %s", exc)
         clip_matrix = [[] for _ in range(len(scenes))]
 
     return comp_engine.build_section_graph_from_scenes(

package/mcp_server/translation_engine/tools.py

@@ -33,9 +33,8 @@ def _fetch_translation_data(ctx: Context) -> dict:
             spec_data = spectral.get("spectrum")
             if spec_data and isinstance(spec_data["value"], dict):
                 spectrum_bands = spec_data["value"]
-    except Exception:
-        pass
-
+    except Exception as exc:
+        logger.debug("_fetch_translation_data failed: %s", exc)
     # Estimate stereo width from track pans via session info
     stereo_width = 0.0
     center_strength = 0.5
@@ -61,9 +60,8 @@ def _fetch_translation_data(ctx: Context) -> dict:
 
             # Simple foreground detection: at least one unmuted, non-quiet track
             has_foreground = any(not t.get("muted", False) for t in tracks)
-    except Exception:
-        pass
-
+    except Exception as exc:
+        logger.debug("_get_pan failed: %s", exc)
     return {
         "stereo_width": stereo_width,
         "center_strength": center_strength,
@@ -99,6 +97,10 @@ def get_translation_issues(ctx: Context) -> dict:
 
     Lighter than check_translation — returns only detected issues
     from the 5 playback robustness critics.
+import logging
+
+logger = logging.getLogger(__name__)
+
     """
     mix_snapshot = _fetch_translation_data(ctx)
     issues = run_all_translation_critics(mix_snapshot)

package/mcp_server/wonder_mode/engine.py

@@ -9,9 +9,12 @@ from __future__ import annotations
 
 import hashlib
 import json
+import logging
 import math
 from typing import Optional
 
+logger = logging.getLogger(__name__)
+
 
 # ── Move discovery ───────────────────────────────────────────────
 
@@ -104,8 +107,9 @@ def discover_moves(
                 if validation["valid"]:
                     filtered.append(move)
             result = filtered
-        except Exception:
-            pass  # constraint filtering is optional
+        except Exception as exc:
+            # constraint filtering is optional — keep the unfiltered list
+            logger.warning("constraint filtering skipped: %s", exc)
 
     return result
 
@@ -212,7 +216,8 @@ def _compile_variant_plan(move_dict: dict, kernel: dict | None) -> dict | None:
     try:
         plan = sem_compile(move_obj, kernel)
         return plan.to_dict()
-    except Exception:
+    except Exception as exc:
+        logger.warning("sem_compile(%s) failed: %s", move_obj, exc)
         return None