livepilot 1.10.7 → 1.10.8

package/mcp_server/__init__.py

@@ -1,2 +1,2 @@
 """LivePilot MCP Server — bridges MCP protocol to Ableton Live."""
-__version__ = "1.10.7"
+__version__ = "1.10.8"

package/mcp_server/atlas/__init__.py

@@ -411,14 +411,46 @@ class AtlasManager:
 
 
 # ── Module-level lazy loader ───────────────────────────────────────
+#
+# Thread-safe via services.singletons.Singleton. The previous check-then-set
+# pattern raced under FastMCP concurrency (two handlers could both construct
+# AtlasManager) and never refreshed the in-memory index after a rebuild of
+# device_atlas.json on disk. The Singleton helper handles both.
+#
+# The ``_atlas_instance`` module attribute is preserved for backward
+# compatibility with call sites that read it directly (atlas/tools.py),
+# but new code should call ``get_atlas()`` / ``invalidate_atlas()`` instead.
 
-_atlas_instance: Optional[AtlasManager] = None
+from pathlib import Path
+from ..services.singletons import Singleton
 
+ATLAS_PATH = Path(__file__).parent / "device_atlas.json"
 
-def _load_atlas() -> AtlasManager:
-    """Lazy-load the atlas from device_atlas.json in the same directory."""
+_atlas_instance: Optional[AtlasManager] = None  # kept for legacy imports
+
+
+def _build_atlas() -> AtlasManager:
+    return AtlasManager(str(ATLAS_PATH))
+
+
+_atlas_holder = Singleton(_build_atlas)
+
+
+def get_atlas() -> AtlasManager:
+    """Thread-safe accessor. Re-reads device_atlas.json if its mtime advanced."""
     global _atlas_instance
-    if _atlas_instance is None:
-        atlas_path = os.path.join(os.path.dirname(__file__), "device_atlas.json")
-        _atlas_instance = AtlasManager(atlas_path)
-    return _atlas_instance
+    instance = _atlas_holder.get(reload_if_newer=ATLAS_PATH)
+    _atlas_instance = instance   # keep legacy attribute in sync
+    return instance
+
+
+def invalidate_atlas() -> None:
+    """Force the next get_atlas() to re-read device_atlas.json from disk."""
+    global _atlas_instance
+    _atlas_holder.invalidate()
+    _atlas_instance = None
+
+
+def _load_atlas() -> AtlasManager:
+    """Legacy shim — kept so atlas/tools.py still works. Prefer get_atlas()."""
+    return get_atlas()

package/mcp_server/atlas/tools.py

@@ -19,15 +19,17 @@ def _get_ableton(ctx: Context):
 
 
 def _get_atlas():
-    """Get the global AtlasManager instance, loading lazily if needed."""
-    from . import _atlas_instance, _load_atlas
-    if _atlas_instance is None:
-        try:
-            _load_atlas()
-        except FileNotFoundError:
-            return None
-    from . import _atlas_instance as inst
-    return inst
+    """Get the global AtlasManager instance, loading lazily if needed.
+
+    Uses the thread-safe singleton helper — concurrent FastMCP tool calls no
+    longer race on the check-then-set, and the atlas auto-reloads from disk
+    if device_atlas.json's mtime advanced (e.g. after scan_full_library).
+    """
+    from . import get_atlas
+    try:
+        return get_atlas()
+    except FileNotFoundError:
+        return None
 
 
 @mcp.tool()
@@ -197,23 +199,44 @@ def scan_full_library(ctx: Context, force: bool = False) -> dict:
         stats[cat] = stats.get(cat, 0) + 1
     stats["enriched_devices"] = sum(1 for d in devices if d.get("enriched"))
 
+    # Read the actual running Live version from the session rather than
+    # hardcoding "12.3.6" — the hardcoded string was baking last year's
+    # version into every new user's atlas until they forced a rescan.
+    try:
+        session_info = ableton.send_command("get_session_info", {}) or {}
+        live_version = session_info.get("live_version", "unknown")
+    except Exception:
+        live_version = "unknown"
+
     # Build atlas
     atlas_data = {
         "version": "2.0.0",
-        "live_version": "12.3.6",
+        "live_version": live_version,
         "scanned_at": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
         "stats": stats,
         "devices": devices,
         "packs": [],
     }
 
-    # Write
-    with open(atlas_path, "w") as f:
+    # Atomic write: tmp + rename. Same pattern as PersistentJsonStore. Previous
+    # version used open(atlas_path, "w") + json.dump with no fsync, so a crash
+    # mid-write produced a truncated JSON file that the next AtlasManager init
+    # silently read as empty-dict — devices vanished from memory.
+    tmp_path = atlas_path + ".tmp"
+    with open(tmp_path, "w") as f:
         json.dump(atlas_data, f, indent=2)
-
-    # Reload into global
+        f.flush()
+        try:
+            os.fsync(f.fileno())
+        except OSError:
+            # fsync may be unavailable on some filesystems/Windows paths —
+            # best-effort; the rename below is still atomic on POSIX.
+            pass
+    os.replace(tmp_path, atlas_path)
+
+    # Invalidate singleton so next get_atlas() picks up the new file.
     import mcp_server.atlas as atlas_mod
-    atlas_mod._atlas_instance = AtlasManager(atlas_path)
+    atlas_mod.invalidate_atlas()
 
     return {
         "status": "scanned",
@@ -222,3 +245,21 @@ def scan_full_library(ctx: Context, force: bool = False) -> dict:
         "stats": stats,
         "atlas_path": atlas_path,
     }
+
+
+@mcp.tool()
+def reload_atlas(ctx: Context) -> dict:
+    """Force the atlas to re-read device_atlas.json from disk.
+
+    Useful after an out-of-band rebuild (e.g. a manual edit to the JSON file,
+    or a scan that crashed before invalidating the cache). The next search /
+    suggest / compare call will see the fresh data. No-op if the atlas has
+    never been loaded — the first real call will load it fresh anyway.
+    """
+    from . import invalidate_atlas, get_atlas
+    invalidate_atlas()
+    atlas = get_atlas()
+    return {
+        "reloaded": True,
+        "device_count": atlas.device_count if atlas else 0,
+    }

package/mcp_server/composer/layer_planner.py

@@ -403,6 +403,33 @@ def plan_sections(intent: CompositionIntent) -> list[dict]:
         })
         current_bar += scaled_bars
 
+    # Clamp overshoot. Rounding each section up to the nearest 4 bars plus
+    # the min-of-4-bars floor means a short duration_bars (e.g. 16) against
+    # a 6-section template could produce 24+ bars of sections — a 50%
+    # overshoot that pushed arrangement clips into unexpected territory.
+    # Trim from the longest non-intro section until we fit.
+    total_placed = sum(s["bars"] for s in sections)
+    overshoot = total_placed - intent.duration_bars
+    if overshoot > 0 and sections:
+        # Sort indices by section length desc, skipping the first section
+        # (usually intro) which we'd rather preserve at its snapped length.
+        trimmable = sorted(
+            range(1, len(sections)),
+            key=lambda i: -sections[i]["bars"],
+        ) or [0]
+        i = 0
+        while overshoot > 0 and i < len(trimmable) * 4:
+            idx = trimmable[i % len(trimmable)]
+            if sections[idx]["bars"] > 4:
+                sections[idx]["bars"] -= 4
+                overshoot -= 4
+            i += 1
+        # Recompute start_bar values after any trim
+        running = 0
+        for s in sections:
+            s["start_bar"] = running
+            running += s["bars"]
+
     return sections
 
 

package/mcp_server/composer/prompt_parser.py

@@ -202,9 +202,15 @@ _ELEMENT_PATTERNS: list[tuple[str, str]] = [
 
 _TEMPO_RE = re.compile(r"\b(\d{2,3})\s*bpm\b", re.IGNORECASE)
 
-# Key patterns: C, Cm, C#, C# minor, Db, Dbm, F# minor, Bb major
+# Key patterns: must have either an accidental (C#, Db) OR an explicit
+# quality word (C minor, F major, Am). The previous regex made the
+# quality group optional AND allowed a bare letter — so "dark ambient"
+# matched D as a key root, silently overwriting any mood-inferred key.
 _KEY_RE = re.compile(
-    r"\b([A-Ga-g][#b]?)\s*(minor|major|min|maj|m)?\b"
+    # Case 1: root + quality word (explicit minor/major/min/maj/m suffix)
+    r"\b([A-Ga-g])\s*(minor|major|min|maj|m)\b"
+    # Case 2: root + accidental (optional quality)
+    r"|\b([A-Ga-g][#b])\s*(minor|major|min|maj|m)?\b"
 )
 
 
@@ -228,19 +234,22 @@ def parse_prompt(text: str) -> CompositionIntent:
         intent.tempo = int(tempo_match.group(1))
 
     # 2. Extract key (search original text to preserve case)
+    # Regex has TWO alternations (root+quality OR root-with-accidental
+    # +optional-quality). Take whichever branch matched.
     key_match = _KEY_RE.search(text)
     if key_match:
-        root = key_match.group(1)
-        # Normalize root: uppercase first letter
+        root = key_match.group(1) or key_match.group(3)
+        quality = key_match.group(2) or key_match.group(4) or ""
+        # Normalize root: uppercase first letter, preserve accidental
         root = root[0].upper() + root[1:] if len(root) > 1 else root.upper()
-        quality = key_match.group(2) or ""
         quality_lower = quality.lower()
         if quality_lower in ("minor", "min", "m"):
             intent.key = f"{root}m"
         elif quality_lower in ("major", "maj"):
             intent.key = root
         else:
-            # Standalone note — check if followed by 'm' in the original
+            # Only reached when Case 2 matched without quality — an
+            # accidental was present (C#, Db), so this IS a legit key root.
             intent.key = root
 
     # 3. Match genre (check aliases first, then canonical names)

package/mcp_server/connection.py

@@ -213,9 +213,17 @@ class AbletonConnection:
             # The single-client guard can briefly reject an immediate reconnect
             # after this process closes a previous socket. Retry once after a
             # short delay when the command was rejected before execution.
-            if fresh_connect and _is_single_client_state_error(response):
-                self.disconnect()
-                time.sleep(SINGLE_CLIENT_RETRY_DELAY)
+            #
+            # IMPORTANT: release the lock around the sleep so concurrent tool
+            # calls are not blocked on an idle timer. The previous version
+            # slept 250ms while holding the lock, which stalled every other
+            # async MCP handler in the server.
+            needs_retry = fresh_connect and _is_single_client_state_error(response)
+
+        if needs_retry:
+            self.disconnect()
+            time.sleep(SINGLE_CLIENT_RETRY_DELAY)
+            with self._lock:
                 self.connect()
                 response = self._send_raw(
                     command,

package/mcp_server/corpus/__init__.py

@@ -365,13 +365,23 @@ def load_corpus() -> Corpus:
 
 
 # ── Module-level lazy singleton ─────────────────────────────────────────
+#
+# Thread-safe via services.singletons.Singleton — concurrent FastMCP
+# handlers can no longer both trigger load_corpus() (which did heavy
+# filesystem I/O) on a cold start.
 
+from ..services.singletons import Singleton
+
+_corpus_holder = Singleton(load_corpus)
+
+# Preserved for backward compatibility with any code that reads the legacy
+# attribute directly.
 _corpus_instance: Optional[Corpus] = None
 
 
 def get_corpus() -> Corpus:
-    """Get the global corpus instance (lazy-loaded on first call)."""
+    """Get the global corpus instance (lazy-loaded, thread-safe)."""
     global _corpus_instance
-    if _corpus_instance is None:
-        _corpus_instance = load_corpus()
-    return _corpus_instance
+    instance = _corpus_holder.get()
+    _corpus_instance = instance
+    return instance

package/mcp_server/m4l_bridge.py

@@ -303,13 +303,43 @@ class SpectralReceiver(asyncio.DatagramProtocol):
             print(f"LivePilot: failed to decode bridge response: {exc}", file=sys.stderr)
 
     def _handle_chunk(self, index: int, total: int, encoded: str) -> None:
-        """Reassemble chunked responses."""
+        """Reassemble chunked responses.
+
+        The previous implementation incremented ``_chunk_id`` only when
+        ``index == 0`` and assumed the first chunk always arrived first.
+        Under UDP reordering (rare on loopback but possible under system
+        load), a chunk with ``index > 0`` arriving before ``index 0`` would
+        be dropped into the PREVIOUS sequence's bucket — silently corrupting
+        that earlier response's payload.
+
+        Until the wire protocol adds an explicit sequence id, the safer
+        behavior is: if we see an out-of-order first-chunk (``index > 0``
+        with no open bucket), start a fresh bucket but log a warning. That
+        way we never poison a prior sequence, and the problem surfaces in
+        logs if it happens.
+        """
         if index == 0:
             self._chunk_id += 1
-        key = str(self._chunk_id)
-        if key not in self._chunks:
+            key = str(self._chunk_id)
             self._chunks[key] = {"parts": {}, "total": total}
             self._chunk_times[key] = time.monotonic()
+        else:
+            key = str(self._chunk_id)
+            if key not in self._chunks:
+                # Out-of-order arrival. Start a new bucket rather than append
+                # to the previous sequence's parts — that's the corruption
+                # path. Log once so it's diagnosable.
+                import sys
+                print(
+                    f"LivePilot: chunk index={index}/{total} arrived before "
+                    f"index=0 — starting fresh bucket. UDP reordering on "
+                    f"loopback suggests system load.",
+                    file=sys.stderr,
+                )
+                self._chunk_id += 1
+                key = str(self._chunk_id)
+                self._chunks[key] = {"parts": {}, "total": total}
+                self._chunk_times[key] = time.monotonic()
 
         self._chunks[key]["parts"][index] = encoded
 
@@ -369,14 +399,26 @@ class M4LBridge:
         if not self.cache.is_connected:
             return {"error": "LivePilot Analyzer not connected. Drop it on the master track."}
 
+        # Fail fast if there is no receiver to correlate the response. The
+        # previous version sent the OSC packet anyway, dropped the reply
+        # inside _handle_response (no future registered), and waited out
+        # the full 5s timeout before returning a misleading "device may be
+        # busy or removed" error. The real cause was "no receiver wired",
+        # which the caller should see immediately.
+        if self.receiver is None:
+            return {
+                "error": "M4L bridge has no active receiver — the UDP 9880 "
+                         "listener did not start. Check server startup logs "
+                         "for a bind failure on port 9880."
+            }
+
         if self._cmd_lock is None:
             self._cmd_lock = asyncio.Lock()
         async with self._cmd_lock:
             # Create a future for the response
             loop = asyncio.get_running_loop()
             future = loop.create_future()
-            if self.receiver:
-                self.receiver.set_response_future(future)
+            self.receiver.set_response_future(future)
 
             # Build and send OSC message (no leading / — Max udpreceive
             # passes messagename with / intact to JS, breaking dispatch)
@@ -394,8 +436,7 @@ class M4LBridge:
                 # 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)
+                self.receiver.set_response_future(None)
 
     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/runtime/execution_router.py

@@ -326,8 +326,22 @@ async def execute_plan_steps_async(
         results.append(result)
 
         # Record successful step result for future bindings
-        if result.ok and step_id and isinstance(result.result, dict):
-            step_results[step_id] = result.result
+        if result.ok and step_id:
+            if isinstance(result.result, dict):
+                step_results[step_id] = result.result
+            else:
+                # Log but DO NOT silently drop the binding without telling
+                # anyone — the previous version let non-dict results slip
+                # past, which meant any downstream {"$from_step": step_id}
+                # reference blew up with a confusing "step_id not found"
+                # instead of the real "result wasn't a dict" cause.
+                import logging as _logging
+                _logging.getLogger(__name__).warning(
+                    "step_results: dropping non-dict result for "
+                    "step_id=%s tool=%s type=%s. Any $from_step refs to "
+                    "this step_id will fail with 'step_id not found'.",
+                    step_id, tool, type(result.result).__name__,
+                )
 
         if not result.ok and stop_on_failure:
             break

package/mcp_server/runtime/remote_commands.py

@@ -82,6 +82,12 @@ BRIDGE_COMMANDS: frozenset[str] = frozenset({
     "remove_warp_marker", "capture_audio", "capture_stop",
     "check_flucoma", "scrub_clip", "stop_scrub", "get_display_values",
     "get_plugin_params", "map_plugin_param", "get_plugin_presets",
+    # Deep-LOM writes that the Python Remote Script cannot reach (live on
+    # the sample child object or require device-selection semantics that
+    # only Max JS LiveAPI exposes). See mcp_server/tools/analyzer.py for
+    # the matching MCP tools that route through bridge.send_command.
+    "simpler_set_warp",
+    "compressor_set_sidechain",
     # NOTE: load_sample_to_simpler used to live here, but it's actually an
     # async Python MCP tool in mcp_server/tools/analyzer.py, not a bridge
     # command. It has no case in livepilot_bridge.js and no @register handler

package/mcp_server/sample_engine/models.py

@@ -139,11 +139,30 @@ class SampleFitReport:
 
     @property
     def overall_score(self) -> float:
+        """Average over AVAILABLE critics only.
+
+        BUG-B38 reshaped frequency_fit to report ``-1.0`` with
+        ``available=False`` when no mix snapshot is present. The previous
+        aggregator mean-folded that sentinel into the overall score,
+        dropping it by ~17 points (one critic out of six). The fix is to
+        respect the ``available`` flag — same contract every other caller
+        uses.
+        """
         if not self.critics:
             return 0.0
-        scores = [c.score if isinstance(c, CriticResult) else c.get("score", 0)
-                  for c in self.critics.values()]
-        return sum(scores) / len(scores) if scores else 0.0
+        available_scores = []
+        for c in self.critics.values():
+            if isinstance(c, CriticResult):
+                if c.available is False:
+                    continue
+                available_scores.append(c.score)
+            else:  # legacy dict shape
+                if c.get("available") is False:
+                    continue
+                available_scores.append(c.get("score", 0))
+        if not available_scores:
+            return 0.0
+        return sum(available_scores) / len(available_scores)
 
     def to_dict(self) -> dict:
         return {

package/mcp_server/semantic_moves/__init__.py

@@ -14,3 +14,4 @@ from . import transition_compilers  # noqa: F401
 from . import sound_design_compilers  # noqa: F401
 from . import performance_compilers  # noqa: F401
 from . import sample_compilers  # noqa: F401
+from . import device_creation_compilers  # noqa: F401

package/mcp_server/semantic_moves/compiler.py

@@ -24,14 +24,22 @@ class CompiledStep:
     params: dict                 # Concrete params, e.g. {"track_index": 0, "volume": 0.72}
     description: str             # Human-readable, e.g. "Push Drums from 0.65 → 0.72"
     verify_after: bool = True    # Whether to check meters after this step
+    # Optional explicit backend. If set, the execution router uses it verbatim
+    # and skips classify_step(). Leave None to let the router auto-classify at
+    # dispatch time — safe because test_move_annotations enforces every
+    # registered move's steps map to a known backend.
+    backend: Optional[str] = None
 
     def to_dict(self) -> dict:
-        return {
+        d = {
             "tool": self.tool,
             "params": self.params,
             "description": self.description,
             "verify_after": self.verify_after,
         }
+        if self.backend:
+            d["backend"] = self.backend
+        return d
 
 
 @dataclass

package/mcp_server/semantic_moves/device_creation_compilers.py

@@ -0,0 +1,47 @@
+"""Family compiler for device-creation semantic moves.
+
+Device-creation moves generate custom M4L devices via the Device Forge
+(``generate_m4l_effect``). Unlike mix/sound-design moves — where the
+compiler inspects the kernel's track topology — device-creation moves
+are parametric: the plan_template already contains the tool call and
+concrete arguments.
+
+We therefore use a single family-level compiler that just maps
+``plan_template`` → ``CompiledStep`` objects. This keeps the registry
+honest (every move is either compilable or analytical_only) without
+duplicating templates into per-move compilers.
+"""
+from __future__ import annotations
+
+from .compiler import CompiledPlan, CompiledStep, register_family_compiler
+from .models import SemanticMove
+
+
+def _compile_device_creation(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Map plan_template steps straight to CompiledStep.
+
+    plan_template is trusted for this family: each step already has
+    ``tool``, ``params``, ``description``, and ``backend`` annotated.
+    """
+    steps: list[CompiledStep] = []
+    for step in move.plan_template:
+        steps.append(CompiledStep(
+            tool=step.get("tool", ""),
+            params=step.get("params", {}),
+            description=step.get("description", ""),
+            verify_after=bool(step.get("verify_after", True)),
+            backend=step.get("backend"),
+        ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level=move.risk_level,
+        summary=move.intent,
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=[],
+    )
+
+
+register_family_compiler("device_creation", _compile_device_creation)