livepilot 1.27.0 → 1.27.2

package/mcp_server/atlas/__init__.py

@@ -7,9 +7,12 @@ suggestion, chain building, and device comparison.
 from __future__ import annotations
 
 import json
+import logging
 import os
 from typing import Any, Dict, List, Optional
 
+logger = logging.getLogger(__name__)
+
 
 class AtlasManager:
     """In-memory device atlas with indexed lookups."""
@@ -47,10 +50,26 @@ class AtlasManager:
             dev_category = dev.get("category", "")
 
             if dev_id:
+                if dev_id in self._by_id and self._by_id[dev_id] is not dev:
+                    logger.warning(
+                        "atlas: duplicate device id %r shadows a prior entry "
+                        "(name=%r); last-wins", dev_id, dev_name,
+                    )
                 self._by_id[dev_id] = dev
             if dev_name:
-                self._by_name[dev_name.lower()] = dev
+                name_key = dev_name.lower()
+                if name_key in self._by_name and self._by_name[name_key] is not dev:
+                    logger.warning(
+                        "atlas: duplicate device name %r shadows a prior entry "
+                        "(id=%r); last-wins", dev_name, dev_id,
+                    )
+                self._by_name[name_key] = dev
             if dev_uri:
+                if dev_uri in self._by_uri and self._by_uri[dev_uri] is not dev:
+                    logger.warning(
+                        "atlas: duplicate device uri %r shadows a prior entry "
+                        "(id=%r); last-wins", dev_uri, dev_id,
+                    )
                 self._by_uri[dev_uri] = dev
 
             # Category index

package/mcp_server/atlas/tools.py

@@ -109,11 +109,14 @@ def atlas_search(ctx: Context, query: str, category: str = "all", limit: int = 1
     try:
         from .overlays import get_overlay_index
         idx = get_overlay_index()
-        # Search all non-`packs` namespaces; `packs` is already in the bundled atlas
-        for ns in idx.list_namespaces():
-            if ns == "packs":
-                continue
-            overlay_results.extend(idx.search(query, namespace=ns, limit=limit))
+        # Single pass over the overlay index (namespace=None scans all
+        # namespaces at once), then drop `packs` client-side — `packs` is
+        # already covered by the bundled atlas. Avoids re-scanning the whole
+        # index once per namespace.
+        overlay_results = [
+            e for e in idx.search(query, namespace=None, limit=limit * 2)
+            if e.namespace != "packs"
+        ]
     except Exception:  # noqa: BLE001 — never fail atlas_search over an overlay glitch
         pass
 
@@ -177,10 +180,13 @@ def atlas_search(ctx: Context, query: str, category: str = "all", limit: int = 1
 
 
 @mcp.tool()
-def atlas_device_info(ctx: Context, device_id: str) -> dict:
+def atlas_device_info(ctx: Context, device_id: str, verbose: bool = True) -> dict:
     """Get complete atlas knowledge about a device — parameters, recipes, pairings, gotchas.
 
     device_id: the atlas ID or device name (e.g., "drift", "Compressor", "808_core_kit")
+    verbose:   when True (default) return the full raw atlas record. Set False for a
+               compact summary (capped description, tag/technique counts) — useful
+               when you only need to identify the device, not read every recipe.
     """
     atlas = _get_atlas()
     if atlas is None:
@@ -189,7 +195,29 @@ def atlas_device_info(ctx: Context, device_id: str) -> dict:
     entry = atlas.lookup(device_id)
     if entry is None:
         return {"error": f"Device '{device_id}' not found in atlas", "suggestion": "Use atlas_search to find devices"}
-    return entry
+    if verbose:
+        return entry
+    # Compact mode: the common case doesn't need the full multi-KB record.
+    # Truncate the longest free-text fields the way atlas_search already caps
+    # sonic_description, and report counts for list-heavy fields so the caller
+    # knows to re-request verbose for the full detail.
+    summary: dict = {
+        "id": entry.get("id", ""),
+        "name": entry.get("name", ""),
+        "uri": entry.get("uri", ""),
+        "category": entry.get("category", ""),
+        "enriched": bool(entry.get("enriched", False)),
+        "sonic_description": (
+            entry.get("sonic_description") or entry.get("description", "")
+        )[:_ATLAS_SEARCH_DESCRIPTION_CHAR_CAP],
+        "character_tags": (
+            entry.get("character_tags") or entry.get("tags", [])
+        )[:8],
+        "sweet_spot": str(entry.get("sweet_spot", ""))[:_ATLAS_SEARCH_DESCRIPTION_CHAR_CAP],
+    }
+    summary.update(_surface_enriched_fields(entry))
+    summary["verbose_available"] = True
+    return summary
 
 
 @mcp.tool()
@@ -258,20 +286,20 @@ def atlas_chain_suggest(ctx: Context, role: str, genre: str = "") -> dict:
             query_parts.append(genre)
         query = " ".join(query_parts)
 
-        for ns in idx.list_namespaces():
-            if ns == "packs":
-                continue
-            hits = idx.search(query, namespace=ns, limit=5)
-            for entry in hits:
-                overlay_suggestions.append({
+        hits = [
+            e for e in idx.search(query, namespace=None, limit=10)
+            if e.namespace != "packs"
+        ]
+        for entry in hits:
+            overlay_suggestions.append({
                     "namespace": entry.namespace,
                     "entity_id": entry.entity_id,
                     "name": entry.name,
                     "description": (entry.description or "")[:120],
                     "tags": list(entry.tags)[:5],
-                    "source": f"user_overlay:{entry.namespace}",
-                    "note": "Load via search_browser or extension_atlas_get; no Live URI.",
-                })
+                "source": f"user_overlay:{entry.namespace}",
+                "note": "Load via search_browser or extension_atlas_get; no Live URI.",
+            })
     except Exception:  # noqa: BLE001 — never fail chain_suggest over an overlay glitch
         pass
 
@@ -662,14 +690,17 @@ def scan_full_library(
     if not force and os.path.exists(atlas_path):
         age = time.time() - os.path.getmtime(atlas_path)
         if age < 86400:
-            # Reload if not already loaded
-            import mcp_server.atlas as atlas_mod
-            if atlas_mod._atlas_instance is None:
-                atlas_mod._atlas_instance = AtlasManager(atlas_path)
+            # Use the public, thread-safe loader rather than poking the
+            # legacy `_atlas_instance` cell directly: get_atlas() loads
+            # lazily via the Singleton holder and is the only path the rest
+            # of the module actually reads back from. The old direct
+            # AtlasManager(atlas_path) construction wrote a cell get_atlas()
+            # never consults.
+            from . import get_atlas
             return {
                 "status": "already_exists",
                 "age_hours": round(age / 3600, 1),
-                "device_count": atlas_mod._atlas_instance.device_count,
+                "device_count": get_atlas().device_count,
                 "message": "Atlas is recent. Use force=True to rescan.",
             }
 
@@ -796,6 +827,34 @@ def _serialize_overlay_entry(entry) -> dict:
     }
 
 
+_OVERLAY_DESCRIPTION_PREVIEW = 240
+
+
+def _serialize_overlay_entry_lite(entry) -> dict:
+    """Lightweight search-result serializer: drops the full YAML `body`.
+
+    The `body` of an overlay entry can be ~17 KB; inlining it for every one of
+    up to `limit` matches makes a single extension_atlas_search return hundreds
+    of KB. The search path only needs identity + a description preview so the
+    caller can decide which entry to fetch in full via extension_atlas_get.
+    """
+    description = entry.description or ""
+    truncated = len(description) > _OVERLAY_DESCRIPTION_PREVIEW
+    return {
+        "namespace": entry.namespace,
+        "entity_type": entry.entity_type,
+        "entity_id": entry.entity_id,
+        "name": entry.name,
+        "description": (
+            description[:_OVERLAY_DESCRIPTION_PREVIEW] + "…"
+            if truncated else description
+        ),
+        "tags": entry.tags,
+        "artists": entry.artists,
+        "requires_box": entry.requires_box,
+    }
+
+
 @mcp.tool()
 def extension_atlas_search(ctx: Context, query: str,
                            namespace: str = "",
@@ -822,7 +881,9 @@ def extension_atlas_search(ctx: Context, query: str,
         "namespace": namespace or None,
         "entity_type": entity_type or None,
         "count": len(matches),
-        "results": [_serialize_overlay_entry(e) for e in matches],
+        "results": [_serialize_overlay_entry_lite(e) for e in matches],
+        "note": "Search results omit the full YAML body; call "
+                "extension_atlas_get(namespace, entity_id) for the complete entry.",
     }
 
 

package/mcp_server/composer/fast/brief_builder.py

@@ -1402,8 +1402,12 @@ def build_creative_brief(
             "   — those are filtered out before the brief reaches you.\n"
             "5. **TIER-1: Fire each search in `recommended_searches` BEFORE designing\n"
             "   that role.** Each entry gives you a (tool, query) pair — call the named\n"
-            "   Ableton Knowledge MCP tool. Most queries hit the Live manual or video\n"
-            "   tutorials; capture 1 useful snippet per role and apply it.\n"
+            "   Ableton Knowledge MCP tool with the `mcp__Ableton_Knowledge__` prefix\n"
+            "   (e.g. search_live_manual → mcp__Ableton_Knowledge__search_live_manual).\n"
+            "   Most queries hit the Live manual or video tutorials; capture 1 useful\n"
+            "   snippet per role and apply it. The Ableton Knowledge MCP is OPTIONAL —\n"
+            "   if any mcp__Ableton_Knowledge__* tool is unavailable or returns nothing,\n"
+            "   skip it and proceed using the creative guidance alone.\n"
             "6. **TIER-2: If `reference_artist` is set**, also fire each search in\n"
             "   `reference_searches` and design USING that artist's signature techniques.\n"
             "7. For each layer: pick ONE uri from instruments_by_role[role], design\n"

package/mcp_server/composer/full/apply.py

@@ -719,6 +719,15 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
                 continue
         else:
             track_index = int(track_index)
+            # BUG-FIX (P2 zombie-cleanup): a reused/existing track must also be
+            # registered as "applied". Otherwise the postflight zombie-cleanup
+            # (which excludes only applied_track_indices) sees a reused track
+            # that currently has no session clips / instrument — e.g. one given
+            # only arrangement clips — as an empty leftover and DELETES it.
+            # Reused tracks must never be eligible for cleanup, and postflight
+            # monitoring must be restored on them too.
+            if track_index >= 0 and track_index not in applied_track_indices:
+                applied_track_indices.append(track_index)
 
         # Optional instrument load
         instrument = track_spec.get("instrument") or {}

package/mcp_server/composer/full/layer_planner.py

@@ -408,12 +408,22 @@ def plan_sections(
     Returns a list of dicts: {name, bars, layers, start_bar}.
     """
     if section_template is None:
-        raise ValueError(
-            "plan_sections() requires explicit section_template in v1.24+. "
-            "SECTION_TEMPLATES was removed — the LLM provides form, not the "
-            "framework. Pass a section_template list or use the v1.24 full-mode "
-            "compose flow which is LLM-creative."
-        )
+        # v1.24 removed the built-in SECTION_TEMPLATES registry (form is the
+        # LLM's job, not the framework's). But the deterministic scaffolding
+        # tools (augment_with_samples, get_composition_plan,
+        # propose_composer_branches) and wonder_mode still call this without a
+        # template. Degrade to a SINGLE full-length section containing every
+        # selected role — this is NOT a form template (no genre-keyed
+        # multi-section sequence, no module-level bar-count registry), it just
+        # lets those tools emit a working skeleton. Callers that want real form
+        # pass an explicit section_template.
+        roles = _select_roles(intent)
+        return [{
+            "name": "Full",
+            "bars": max(4, int(intent.duration_bars or 64)),
+            "layers": list(roles),
+            "start_bar": 0,
+        }]
 
     template = section_template
 

package/mcp_server/composer/tools.py

@@ -378,12 +378,18 @@ def consult_ableton_knowledge(
     template, and surfaces sources alongside the answer.
 
     Examples:
-      consult_ableton_knowledge("how do I make my kick punchier?")
-        → plan: [search_live_manual("Saturator"), search_transcripts("kick punch"),
-                 search_videos("kick design tutorial")] + synthesis template
-      consult_ableton_knowledge("what's the difference between Operator and Wavetable?")
-        → plan: [search_live_manual("Operator"), search_live_manual("Wavetable"),
-                 search_transcripts("Operator vs Wavetable")]
+      consult_ableton_knowledge("what does the Saturator Drive knob do?")
+        → intent: device
+        → plan: [search_live_manual("what does the Saturator Drive knob do?"),
+                 search_videos("what does the Saturator Drive knob do?"),
+                 search_transcripts("what does the Saturator Drive knob do?")]
+                 + synthesis template
+      consult_ableton_knowledge("how do I make my kick punchier?", {"current_genre": "techno"})
+        → intent: sound_design
+        → plan: [search_transcripts("techno how do I make my kick punchier?"),
+                 search_videos("techno how do I make my kick punchier? tutorial"),
+                 search_knowledge_base("how do I make my kick punchier?")]
+                 + synthesis template
 
     session_context (optional): {
         "current_genre": "techno",

package/mcp_server/connection.py

@@ -258,7 +258,8 @@ class AbletonConnection:
             needs_retry = fresh_connect and _is_single_client_state_error(response)
 
         if needs_retry:
-            self.disconnect()
+            with self._lock:
+                self.disconnect()
             time.sleep(SINGLE_CLIENT_RETRY_DELAY)
             with self._lock:
                 self.connect()

package/mcp_server/creative_constraints/engine.py

@@ -72,9 +72,28 @@ def validate_plan_against_constraints(
     session_info = session_info or {}
     violations: list[str] = []
     warnings: list[str] = []
+    unenforced: list[str] = []
 
     steps = plan.get("steps", [])
 
+    # Modes that carry no structural step-level rule (taste/heuristic only).
+    # They were previously skipped silently — surface them as warnings so a
+    # caller can't mistake "no violations" for "validated against this mode".
+    advisory_modes = {
+        "mood_shift_without_new_fx": (
+            "shift the mood with existing tools — adding effects is discouraged "
+            "but not auto-detected here"
+        ),
+        "make_it_stranger_but_keep_the_hook": (
+            "push novelty while preserving the hook — not enforceable from plan "
+            "steps alone"
+        ),
+        "club_translation_safe": (
+            "keep changes club/DJ-friendly — judged by mix/tempo character, not "
+            "individual steps"
+        ),
+    }
+
     for constraint in constraint_set.constraints:
         if constraint == "no_new_tracks":
             for step in steps:
@@ -96,10 +115,37 @@ def validate_plan_against_constraints(
                 if step.get("action", "") in mix_actions:
                     violations.append(f"Step modifies mix ({step['action']}) — violates arrangement_only")
 
+        elif constraint == "use_loaded_devices_only":
+            load_actions = {"load_browser_item", "insert_device", "find_and_load_device",
+                           "load_device_by_uri", "load_sample_to_simpler",
+                           "replace_simpler_sample", "insert_rack_chain"}
+            for step in steps:
+                if step.get("action", "") in load_actions:
+                    violations.append(
+                        f"Step loads a new device ({step['action']}) — violates use_loaded_devices_only"
+                    )
+
+        elif constraint == "performance_safe_creative":
+            unsafe_actions = {"create_midi_track", "create_audio_track", "create_return_track",
+                             "delete_track", "delete_device", "delete_clip", "delete_scene"}
+            for step in steps:
+                if step.get("action", "") in unsafe_actions:
+                    violations.append(
+                        f"Step is unsafe during live performance ({step['action']}) — "
+                        f"violates performance_safe_creative"
+                    )
+
+        elif constraint in advisory_modes:
+            unenforced.append(constraint)
+            warnings.append(
+                f"{constraint} is advisory: {advisory_modes[constraint]}"
+            )
+
     return {
         "valid": len(violations) == 0,
         "violations": violations,
         "warnings": warnings,
+        "unenforced_constraints": unenforced,
         "constraint_count": len(constraint_set.constraints),
     }
 

package/mcp_server/experiment/engine.py

@@ -244,12 +244,19 @@ async def run_branch_async(
     ]
 
     steps_executed = sum(1 for r in exec_results if r.ok)
+    # Only remote_command steps land on Ableton's linear undo stack. Bridge
+    # (M4L/OSC) and mcp_tool mutations do NOT, so issuing one `undo` per
+    # successful step over-undoes and walks back unrelated prior user edits.
+    # Count undos from remote_command successes alone.
+    undo_count = sum(
+        1 for r in exec_results if r.ok and r.backend == "remote_command"
+    )
     branch.executed_at_ms = int(time.time() * 1000)
     branch.after_snapshot = capture_fn()
 
-    # Undo all successful steps back to checkpoint. Undo is a remote_command,
-    # route it through the normal ableton.send_command path for simplicity.
-    for _ in range(steps_executed):
+    # Undo only the remote_command steps back to checkpoint. Undo is itself a
+    # remote_command, routed through the normal ableton.send_command path.
+    for _ in range(undo_count):
         try:
             ableton.send_command("undo", {})
         except Exception as exc:

package/mcp_server/grader/client.py

@@ -17,11 +17,14 @@ session state, returning the same shape used by `mcp_server/audit/checks.py`:
 
 from __future__ import annotations
 
+import logging
 from typing import Any, Callable, Iterable
 
 from mcp_server.audit import checks as audit_checks
 from mcp_server.audit.checks import infer_role
 
+_logger = logging.getLogger(__name__)
+
 
 _TRACK_COUNT_WARN = 8
 _TRACK_COUNT_FAIL = 12
@@ -441,11 +444,21 @@ def _aggregate_per_track(
         try:
             result = check_fn(*args)
         except Exception as exc:
+            _logger.warning(
+                "grader check %s failed for criterion %r track %r (%s): %s",
+                getattr(check_fn, "__name__", repr(check_fn)),
+                criterion_id,
+                t.get("index"),
+                t.get("name"),
+                exc,
+                exc_info=True,
+            )
             per_track.append({
                 "track_index": t.get("index"),
                 "name": t.get("name"),
                 "role": role,
                 "severity": "n/a",
+                "errored": True,
                 "summary": f"check failed: {type(exc).__name__}",
                 "issues": [],
                 "evidence": {},
@@ -459,15 +472,30 @@ def _aggregate_per_track(
         })
 
     actionable = [r for r in per_track if r["severity"] != "n/a"]
+    n_errored = sum(1 for r in per_track if r.get("errored"))
 
     if not actionable:
+        if n_errored:
+            # Every checkable track raised — do NOT masquerade an all-error
+            # sweep as a benign no-op pass. Surface it as a failure.
+            return {
+                "id": criterion_id,
+                "passed": False,
+                "severity": "fail",
+                "summary": (
+                    f"{n_errored} track(s) errored during check; no track "
+                    "produced a usable result"
+                ),
+                "issues": [],
+                "evidence": {"per_track": per_track, "errored": n_errored},
+            }
         return {
             "id": criterion_id,
             "passed": True,
             "severity": "n/a",
             "summary": "No checkable tracks (data missing or no applicable role)",
             "issues": [],
-            "evidence": {"per_track": per_track},
+            "evidence": {"per_track": per_track, "errored": n_errored},
         }
 
     has_fail = any(r["severity"] == "fail" for r in actionable)
@@ -505,7 +533,7 @@ def _aggregate_per_track(
         "severity": rubric_severity,
         "summary": summary,
         "issues": issues,
-        "evidence": {"per_track": per_track},
+        "evidence": {"per_track": per_track, "errored": n_errored},
     }
 
 

package/mcp_server/grader/tools.py

@@ -64,9 +64,15 @@ def _build_light_state(ctx: Context) -> dict[str, Any]:
         info = _safe_call(ableton, "get_track_info", {"track_index": idx})
         if not info:
             continue
-        if info.get("is_foldable") and info.get("is_master"):
+        # Skip master/return tracks (real Remote Script field names are
+        # is_master_track / is_return_track, not is_master / is_return).
+        if info.get("is_master_track") or info.get("is_return_track"):
             continue
-        if info.get("is_return"):
+        # Skip group containers — foldable group tracks hold no clips or
+        # devices of their own, so they inflate the §7.3 track count and
+        # (having a mixer volume but no role/ghost tag) trip the
+        # buried-track check. Only count real, content-bearing layers.
+        if info.get("is_foldable"):
             continue
         tracks.append({
             "index": idx,

package/mcp_server/hook_hunter/analyzer.py

@@ -108,8 +108,21 @@ def find_hook_candidates(
     for c in candidates:
         # Check if hook is present in payoff sections (via motif locations)
         if c.hook_type == "melodic" and motif_data:
-            for motif in motif_data.get("motifs", []):
-                if motif.get("name", "") in c.hook_id:
+            for idx, motif in enumerate(motif_data.get("motifs", [])):
+                # BUG-B61 fix: the old test `motif.get("name", "") in c.hook_id`
+                # was always True for real motif data, because the engine emits
+                # `motif_id` (not `name`) so .get("name","") returned "", and
+                # `"" in c.hook_id` is True for every candidate. That boosted
+                # every melodic candidate by every motif's recurrence. Rebuild
+                # the source motif's hook_id exactly as it was constructed above
+                # (motif_id -> name -> idxN fallback) and require an exact match
+                # so each candidate is boosted only by its own source motif.
+                identifier = (
+                    motif.get("motif_id")
+                    or motif.get("name")
+                    or f"idx{idx}"
+                )
+                if f"motif_{identifier}" == c.hook_id:
                     # Motif with high recurrence across sections = stronger hook
                     c.memorability = min(1.0, c.memorability + motif.get("recurrence", 0) * 0.2)