livepilot 1.10.6 → 1.10.8

package/mcp_server/atlas/__init__.py

@@ -115,26 +115,70 @@ class AtlasManager:
         query_words = query_lower.split()
         results: List[Dict[str, Any]] = []
 
+        # BUG-B39: the real atlas scanner emits "instruments" /
+        # "audio_effects" but older callers and test fixtures sometimes
+        # pass the singular "instrument" / "effect". Build a tolerant
+        # category alias set so both forms work.
+        _CAT_ALIASES = {
+            "instrument": {"instrument", "instruments"},
+            "instruments": {"instrument", "instruments"},
+            "effect": {"effect", "effects", "audio_effects"},
+            "effects": {"effect", "effects", "audio_effects"},
+            "audio_effect": {"effect", "effects", "audio_effects",
+                             "audio_effect"},
+            "audio_effects": {"effect", "effects", "audio_effects",
+                              "audio_effect"},
+        }
+        allowed_cats = (
+            _CAT_ALIASES.get(category, {category})
+            if category != "all" else None
+        )
+
         for dev in self._devices:
             # Category filter
-            if category != "all" and dev.get("category", "") != category:
+            if allowed_cats is not None and dev.get("category", "") not in allowed_cats:
                 continue
 
             score = 0
             dev_name = dev.get("name", "")
             dev_name_lower = dev_name.lower()
 
-            # Name scoring: 100pts exact, 50pts substring
+            # Name scoring. BUG-B41 fix: dropped weight dramatically
+            # (was 100 exact / 50 substring) so a device literally
+            # named "Bass" no longer blows past character-tag matches
+            # for a sonic query like "warm analog bass". An exact name
+            # match is still the strongest single signal, but a device
+            # with 2+ matching character-tags now beats a name-only
+            # accident.
             if dev_name_lower == query_lower:
-                score += 100
+                score += 45  # was 100
             elif query_lower in dev_name_lower:
-                score += 50
-
-            # Tag scoring: 30pts per matching tag
-            dev_tags = [t.lower() for t in dev.get("tags", [])]
+                score += 20  # was 50
+            else:
+                # Partial: any query word present in name — small signal
+                for word in query_words:
+                    if len(word) >= 3 and word in dev_name_lower:
+                        score += 5
+
+            # Tag scoring — prefer enriched character_tags.
+            # BUG-B40 / B41: also read character_tags so enriched devices
+            # actually compete with name-based matches.
+            dev_tags = [
+                t.lower() for t in (
+                    dev.get("character_tags") or dev.get("tags", [])
+                )
+            ]
+            # BUG-B41: bumped to 35pts per tag so multi-tag matches beat
+            # a single substring-name match.
             for word in query_words:
                 if word in dev_tags:
-                    score += 30
+                    score += 35
+                # Partial tag match (word appears as substring in a tag)
+                else:
+                    for tag in dev_tags:
+                        if word in tag:
+                            score += 10
+                            break
 
             # Use case scoring: 25pts per match
             for use_case in dev.get("use_cases", []):
@@ -142,10 +186,11 @@ class AtlasManager:
                 for word in query_words:
                     if word in use_lower:
                         score += 25
-                        break  # one match per use_case
+                        break
 
-            # Genre scoring: 20pts primary, 10pts secondary
-            genres = dev.get("genres", {})
+            # Genre scoring: 20pts primary, 10pts secondary.
+            # BUG-B40: also read genre_affinity (enriched field).
+            genres = dev.get("genre_affinity") or dev.get("genres", {}) or {}
             for genre in genres.get("primary", []):
                 if query_lower in genre.lower() or genre.lower() in query_lower:
                     score += 20
@@ -153,8 +198,11 @@ class AtlasManager:
                 if query_lower in genre.lower() or genre.lower() in query_lower:
                     score += 10
 
-            # Description keyword scoring: 15pts
-            description = dev.get("description", "").lower()
+            # Description keyword scoring: 15pts.
+            # BUG-B40: prefer sonic_description when present.
+            description = (
+                dev.get("sonic_description") or dev.get("description", "")
+            ).lower()
             for word in query_words:
                 if len(word) >= 3 and word in description:
                     score += 15
@@ -224,7 +272,13 @@ class AtlasManager:
     def chain_suggest(
         self, role: str, genre: str = ""
     ) -> Dict[str, Any]:
-        """Suggest a device chain for a given role (e.g., 'bass', 'lead', 'pad')."""
+        """Suggest a device chain for a given role (e.g., 'bass', 'lead', 'pad').
+
+        BUG-B39 fix: the old code passed category="instrument" (singular)
+        and category="effect" to self.search(), but the atlas stores
+        devices with category="instruments" / "audio_effects" (plural).
+        Every filtered search missed and the chain came back empty.
+        """
         chain: List[Dict[str, Any]] = []
         position = 0
 
@@ -244,8 +298,8 @@ class AtlasManager:
         intent = instrument_intents.get(role_lower, role_lower)
         search_q = f"{intent} {genre}" if genre else intent
 
-        # Find instrument
-        instrument_candidates = self.search(search_q, category="instrument", limit=3)
+        # Find instrument — atlas category is "instruments" (plural)
+        instrument_candidates = self.search(search_q, category="instruments", limit=3)
         if instrument_candidates:
             best = instrument_candidates[0]["device"]
             chain.append({
@@ -255,7 +309,7 @@ class AtlasManager:
             })
             position += 1
 
-        # Stage 2: Effects
+        # Stage 2: Effects — atlas category is "audio_effects"
         effect_stages = [
             ("eq", f"Shape the {role} tone"),
             ("compression", f"Control {role} dynamics"),
@@ -264,7 +318,9 @@ class AtlasManager:
 
         for effect_type, reason in effect_stages:
             effect_q = f"{effect_type} {genre}" if genre else effect_type
-            effect_candidates = self.search(effect_q, category="effect", limit=2)
+            effect_candidates = self.search(
+                effect_q, category="audio_effects", limit=2,
+            )
             if effect_candidates:
                 best = effect_candidates[0]["device"]
                 chain.append({
@@ -295,37 +351,48 @@ class AtlasManager:
             return {"error": f"Device not found: {device_b}"}
 
         def _summarize(dev: Dict[str, Any]) -> Dict[str, Any]:
+            # BUG-B40 fix: enriched atlas entries use character_tags /
+            # sonic_description / genre_affinity — the old _summarize
+            # looked for "tags" / "description" / "genres" which are
+            # the UN-enriched raw scanner fields. We prefer enriched
+            # fields, fall back to raw when enrichment is absent.
             return {
                 "name": dev.get("name", ""),
                 "category": dev.get("category", ""),
-                "tags": dev.get("tags", []),
-                "genres": dev.get("genres", {}),
+                "tags": dev.get("character_tags") or dev.get("tags", []),
+                "genres": dev.get("genre_affinity") or dev.get("genres", {}),
                 "use_cases": dev.get("use_cases", []),
-                "description": dev.get("description", ""),
+                "description": (
+                    dev.get("sonic_description")
+                    or dev.get("description", "")
+                ),
                 "cpu_weight": dev.get("cpu_weight", "unknown"),
                 "sweet_spot": dev.get("sweet_spot", ""),
+                "enriched": dev.get("enriched", False),
             }
 
         summary_a = _summarize(dev_a)
         summary_b = _summarize(dev_b)
 
-        # Recommendation logic: score each for the role
+        # Recommendation logic: score each for the role.
+        # BUG-B40: scorer also reads the enriched field names.
         score_a = 0
         score_b = 0
         if role:
             role_lower = role.lower()
-            # Check use_cases
             for uc in dev_a.get("use_cases", []):
                 if role_lower in uc.lower():
                     score_a += 20
             for uc in dev_b.get("use_cases", []):
                 if role_lower in uc.lower():
                     score_b += 20
-            # Check tags
-            for tag in dev_a.get("tags", []):
+            # Tag scoring — prefer character_tags (enriched)
+            a_tags = dev_a.get("character_tags") or dev_a.get("tags", [])
+            b_tags = dev_b.get("character_tags") or dev_b.get("tags", [])
+            for tag in a_tags:
                 if role_lower in tag.lower():
                     score_a += 10
-            for tag in dev_b.get("tags", []):
+            for tag in b_tags:
                 if role_lower in tag.lower():
                     score_b += 10
 
@@ -344,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