livepilot 1.24.0 → 1.25.0

package/mcp_server/composer/framework/knowledge_pack.py

@@ -1,27 +1,51 @@
 """KnowledgePack — assembles the vocabulary fields each compose mode's brief carries.
 
-For full mode: rich (event_lexicon, genre_context, artist_context, atlas_candidates, manual_snippets).
-For fast mode: subset (no event_lexicon — fast mode is loop-sketch scope, doesn't design form).
+For full mode: rich (event_lexicon, genre_context, artist_context,
+atlas_anchors, atlas_candidates_per_role, manual_snippets).
+For fast mode: subset (no event_lexicon — fast mode is loop-sketch scope).
 For develop mode: subset overlapping with full.
+
+v1.25 adds `atlas_anchors` — cohort + role-anchored URIs from
+atlas_pack_aware_compose, populated when atlas + brief_text are provided.
+The agent uses `atlas_explore` / `atlas_audition` / `atlas_substitute`
+mid-design to dig past anchors when needed (hybrid knowledge surface).
 """
 
 from __future__ import annotations
-from typing import Any
+
+import logging
+from dataclasses import asdict
+from typing import Any, Optional
 
 from .event_lexicon import EVENT_LEXICON, get_event_lexicon
 from .genre_loader import load_genre_context
 from .artist_loader import load_artist_context
 
+logger = logging.getLogger(__name__)
+
 
 class KnowledgePack:
     """Central knowledge assembly for compose-mode briefs."""
 
-    def build(self, intent: dict, mode: str = "full") -> dict:
+    def build(
+        self,
+        intent: dict,
+        mode: str = "full",
+        *,
+        atlas: Any = None,
+        ableton: Any = None,
+        ctx: Any = None,
+        brief_text: str = "",
+    ) -> dict:
         """Build the knowledge fields for a brief.
 
         intent: parsed CompositionIntent dict with at least 'genre', possibly 'sub_genre'.
                 May also carry 'artists' (list of producer names).
         mode: 'fast' | 'full' | 'develop'
+        atlas: AtlasManager instance (optional — when None, atlas_anchors is None)
+        ableton: ableton client (optional — reserved for v1.25.x browser fallback)
+        ctx: lifespan context (optional — reserved for taste_profile / recent_uris)
+        brief_text: the original prompt string (required for atlas_anchors)
 
         Returns a dict — pass directly to brief.knowledge OR spread into brief top-level.
         """
@@ -33,11 +57,12 @@ class KnowledgePack:
         artist_names = intent.get("artists") or []
         artist_ctx = load_artist_context(artist_names)
 
-        knowledge = {
+        knowledge: dict[str, Any] = {
             "genre_context": genre_ctx,
             "artist_context": artist_ctx,
-            "atlas_candidates_per_role": {},  # populated by brief_builder via existing get_role_candidates
-            "manual_snippets": {},  # populated by brief_builder per likely device
+            "atlas_candidates_per_role": {},  # legacy field — empty in v1.25 (replaced by atlas_anchors)
+            "atlas_anchors": None,            # populated below for full mode when atlas available
+            "manual_snippets": {},
         }
 
         # Event lexicon — full mode only (loop sketch doesn't design form)
@@ -46,4 +71,70 @@ class KnowledgePack:
         else:
             knowledge["event_lexicon"] = []
 
+        # Atlas anchors — full mode only, requires atlas + brief_text. Best-effort:
+        # any failure path silently leaves anchors=None and the brief still works.
+        if mode == "full" and atlas is not None and brief_text:
+            try:
+                from .atlas_resolver import AtlasResolver
+                resolver = AtlasResolver(
+                    atlas=atlas,
+                    ableton=ableton,
+                    taste_profile=_safe_get_taste_profile(ctx),
+                    recent_uris=_safe_get_recent_uris(ctx),
+                )
+                mood = _extract_mood(intent)
+                anchors = resolver.resolve_anchors(
+                    brief_text=brief_text,
+                    genre=genre,
+                    mood=mood,
+                    artist_refs=artist_names,
+                )
+                knowledge["atlas_anchors"] = asdict(anchors)
+            except Exception as exc:
+                logger.debug("KnowledgePack.build: atlas_anchors unavailable: %s", exc)
+
         return knowledge
+
+
+# ── Helpers ─────────────────────────────────────────────────────────
+
+
+def _extract_mood(intent: dict) -> str:
+    """Derive a mood string from the parsed intent.
+
+    Combines mood + descriptors fields when present. Falls back to "" so
+    the resolver's mood-overlap boost simply doesn't fire (rather than
+    matching against junk).
+    """
+    parts: list[str] = []
+    for key in ("mood", "descriptors", "modifiers"):
+        val = intent.get(key)
+        if isinstance(val, str) and val:
+            parts.append(val)
+        elif isinstance(val, (list, tuple)):
+            parts.extend(str(v) for v in val if v)
+    return " ".join(parts).strip()
+
+
+def _safe_get_taste_profile(ctx: Any) -> Optional[dict]:
+    """Best-effort taste profile fetch. Returns None on any failure."""
+    if ctx is None:
+        return None
+    try:
+        # The taste graph tools live under mcp_server/tools/agent_os.py;
+        # importing here would create a cycle, so leave as None for now.
+        # v1.25.x will wire in get_taste_profile() once the cycle is broken.
+        return None
+    except Exception:
+        return None
+
+
+def _safe_get_recent_uris(ctx: Any) -> Optional[set[str]]:
+    """Best-effort recent-URIs fetch (§7 #2 anti-repeat). Returns None on failure."""
+    if ctx is None:
+        return None
+    try:
+        # Same cycle concern as _safe_get_taste_profile — defer to v1.25.x.
+        return None
+    except Exception:
+        return None

package/mcp_server/composer/full/brief_builder.py

@@ -46,12 +46,62 @@ _DESIGN_TARGETS = (
     "the song. Use the event_lexicon as a vocabulary of named structural "
     "moves to schedule at chosen phrase boundaries. For niche style references "
     "in research_hooks, run WebSearch to ground your form choices in the "
-    "actual conventions of that subgenre. Submit your design as a plan to "
-    "compose_full_apply with: per-track variant clips at chosen scene slots, "
-    "per-section arrangement_clip placements referencing those variants, "
-    "and structural events scheduled at phrase boundaries. The form is YOUR "
-    "creative product — vocabularies tell you what techno or BoC sound like, "
-    "they do not tell you the bar count of an intro."
+    "actual conventions of that subgenre.\n\n"
+    "INSTRUMENT SELECTION (v1.25 hybrid knowledge surface — MANDATED FOUR-SOURCE SEARCH):\n"
+    "The brief's `atlas_anchors` is ONE source. Before committing any role pick "
+    "you MUST also query the other three sources below. Factory-atlas-only picks "
+    "have repeatedly missed canonical user-curated instruments (e.g., the 808 Trap "
+    "Selector Rack from Trap Drums by Sound Oracle pack lives in the packs overlay, "
+    "not the factory tag index). Always union BEFORE deciding.\n\n"
+    "Source 1 — Factory atlas (already surfaced in atlas_anchors). Three tools:\n"
+    "  • atlas_audition(uri) — full sidecar dump for a chosen URI: character "
+    "tags, signature_techniques, producer-curated macro values, related demos. "
+    "Call this BEFORE committing to a candidate when its tags alone aren't "
+    "enough to know if it fits the section.\n"
+    "  • atlas_explore(role, mood, genre, artists?) — refined per-role query "
+    "when an anchor doesn't fit the section's purpose, or when you need siblings "
+    "of a role pick. Returns 3-5 ranked candidates with reasoning trails.\n"
+    "  • atlas_substitute(current_uri, anti_tag) — anti-tag-driven swap to use "
+    "AFTER analyze_sound_design or analyze_mix flags an issue (\"too bright\", "
+    "\"too aggressive\", \"too sparse\", \"muddy\", \"static\", \"generic\"). "
+    "Returns 3 alternatives that explicitly avoid the unwanted property.\n\n"
+    "Source 2 — User corpus (mandatory union — ~/.livepilot/atlas-overlays/):\n"
+    "  • extension_atlas_search(query=\"<role>\", limit=10) — searches all four "
+    "overlay namespaces: `packs` (Ableton factory packs with hidden_gems, "
+    "notable_presets, signature_workflows fields), `m4l-devices` (curated M4L "
+    "device knowledge), `user.*` (your scanned .amxd / plugin / preset library), "
+    "`elektron` (hardware-mirror chains). Producer-curated rack instruments "
+    "(808 Trap Selector Rack, Harmonic Drone Generator, etc.) live here, NOT "
+    "in the factory tag index. Always run this query alongside atlas_explore.\n"
+    "  • extension_atlas_search(query=\"<role-or-aesthetic>\", entity_type=\"demo_project\") — "
+    "GROUND-TRUTH ROLE→URI MAPPING. The packs namespace contains 100+ analyzed "
+    "demo .als project parses; each carries actual track-by-track instrument "
+    "URIs proven on real Ableton-shipped demos. For 808 bass, query "
+    "`demo_project` to find which pack-included .als demos use 808 bass and "
+    "what URI they loaded — the highest-confidence source for any role.\n"
+    "  • extension_atlas_get(namespace, entity_id) — full body of a chosen entry "
+    "including hidden_gems and signature_workflows fields the search summary trims.\n\n"
+    "Source 3 — Anthropic Ableton Knowledge MCP (mcp__Ableton_Knowledge__*):\n"
+    "  • search_transcripts(query) — Ableton's official tutorial video transcripts; "
+    "ground-truth pedagogy on how producers actually use the device.\n"
+    "  • search_live_manual(query) — live manual snippets for any device or feature.\n"
+    "  • search_knowledge_base(query) — broader Ableton knowledge base.\n"
+    "  • search_videos(query) — official tutorial video metadata.\n"
+    "  Run these for the ROLE term (e.g., \"808 bass\", \"sidechain compression\") "
+    "and for any artist/genre reference in the prompt to ground your design choices.\n\n"
+    "FOUR-SOURCE SEARCH PROTOCOL per role:\n"
+    "  1. Read atlas_anchors[role] (Source 1 starting point).\n"
+    "  2. Call atlas_explore(role, mood, genre, artists) (Source 1 ranked alts).\n"
+    "  3. Call extension_atlas_search(query=role) and extension_atlas_search(query=role, "
+    "entity_type=\"demo_project\") (Source 2 user corpus + ground-truth demos).\n"
+    "  4. Call mcp__Ableton_Knowledge__search_transcripts(query=role) for context (Source 3).\n"
+    "  5. Union results, score against brief's mood/aesthetic, then commit.\n\n"
+    "The framework's job was to surface the corpus. The picks are yours. "
+    "Submit your design as a plan to compose_full_apply with: per-track variant "
+    "clips at chosen scene slots, per-section arrangement_clip placements "
+    "referencing those variants, and structural events scheduled at phrase "
+    "boundaries. The form is YOUR creative product — vocabularies tell you "
+    "what techno or BoC sound like, they do not tell you the bar count of an intro."
 )
 
 
@@ -122,11 +172,21 @@ def build_full_brief(
     artist_refs = extract_artist_refs(prompt or "")
     research_hooks = detect_research_hooks(prompt or "")
 
-    # Build knowledge pack — populates genre_context, artist_context, event_lexicon
+    # Build knowledge pack — populates genre_context, artist_context, event_lexicon,
+    # AND v1.25 atlas_anchors when atlas + brief_text are available.
     if artist_refs:
         intent_dict["artists"] = artist_refs
     kp = KnowledgePack()
-    knowledge = kp.build(intent_dict, mode="full")
+    atlas_obj = _safe_get_atlas(ctx)
+    ableton_obj = _safe_get_ableton(ctx)
+    knowledge = kp.build(
+        intent_dict,
+        mode="full",
+        atlas=atlas_obj,
+        ableton=ableton_obj,
+        ctx=ctx,
+        brief_text=prompt or "",
+    )
 
     return {
         "mode": "full",
@@ -137,8 +197,31 @@ def build_full_brief(
         "artist_context": knowledge["artist_context"],
         "event_lexicon": knowledge["event_lexicon"],
         "atlas_candidates_per_role": knowledge["atlas_candidates_per_role"],
+        "atlas_anchors": knowledge.get("atlas_anchors"),
         "manual_snippets": knowledge["manual_snippets"],
         "seed_state": seed_state,
         "research_hooks": research_hooks,
         "design_targets": _DESIGN_TARGETS,
     }
+
+
+# ── Lifespan-context helpers ───────────────────────────────────────
+
+
+def _safe_get_atlas(ctx: Any) -> Optional[Any]:
+    """Best-effort atlas fetch. Returns None on any failure."""
+    try:
+        from ...atlas import get_atlas
+        return get_atlas()
+    except Exception:
+        return None
+
+
+def _safe_get_ableton(ctx: Any) -> Optional[Any]:
+    """Best-effort ableton-client fetch from lifespan_context. None on miss."""
+    try:
+        if ctx is not None and hasattr(ctx, "lifespan_context"):
+            return ctx.lifespan_context.get("ableton")
+    except Exception:
+        pass
+    return None

package/mcp_server/tools/_analyzer_engine/sample.py

@@ -258,12 +258,21 @@ async def _simpler_post_load_hygiene(
     # Step 4: auto-detect drum root note from filename (BUG-2026-04-22#18).
     # Only applied for one-shots — warped loops keep Live's default root
     # because their root note is irrelevant at loop playback speeds.
+    #
+    # 2026-05-02 — fixed param name: was "Sample Pitch Coarse" (doesn't exist
+    # on OriginalSimpler — silently failed). Correct param is "Transpose"
+    # (semitone offset from C3=60). Convert detected drum root → Transpose:
+    # Transpose = 60 - drum_root. Example: drum_root=36 (C1) → Transpose=+24,
+    # so triggering MIDI 36 plays the sample at original recorded pitch.
     drum_root = None
     if not is_loop:
         drum_root = _detect_drum_root_note(file_path)
         if drum_root is not None:
+            transpose_value = 60 - int(drum_root)
+            # Clamp to Simpler's Transpose range (-48..+48 semitones)
+            transpose_value = max(-48, min(48, transpose_value))
             hygiene_params.append(
-                {"name_or_index": "Sample Pitch Coarse", "value": drum_root}
+                {"name_or_index": "Transpose", "value": transpose_value}
             )
 
     try:

package/mcp_server/tools/browser.py

@@ -158,28 +158,57 @@ def search_browser(
     return _get_ableton(ctx).send_command("search_browser", params)
 
 
-# Role-aware Simpler defaults — BUG-2026-04-22 #17 + #18.
+# M4L instrument post-load hygiene — 2026-05-02.
+# Some Max-for-Live instruments load with defaults that immediately produce loud
+# unwanted output (Harmonic Drone Generator from Drone Lab is the canonical
+# example: Latch on + Density 80% + Volume −6 dB + all 8 voices active = a wall
+# of sustained drone the moment any MIDI note touches it). Apply tames here so
+# the device is workable on first load. Each entry maps a device-name match
+# (substring) to a list of (parameter_name, value) pairs.
+#
+# Detection runs UNCONDITIONALLY (not gated on `role` like _SIMPLER_ROLE_DEFAULTS)
+# because these M4L instruments are typically loaded without a role parameter.
+_M4L_INSTRUMENT_HYGIENE: dict[str, list[tuple[str, float]]] = {
+    "Harmonic Drone Generator": [
+        ("Latch", 0),       # Off — prevents indefinite note sustain after one trigger
+        ("Volume", -40),    # ≈ -20 dB display (default is -18 / -6 dB which is too loud)
+        ("Density", 40),    # 40% (default 80% is too dense for a background bed)
+    ],
+}
+
+
+# Role-aware Simpler defaults — BUG-2026-04-22 #17 + #18, plus 2026-05-02 fix.
 # Each role maps to a list of (parameter_name, value) pairs applied after
 # load via set_device_parameter. Trigger Mode polarity per BUG #9:
-# 0 = Trigger (one-shot), 1 = Gate (held). Volume in dB. Root in MIDI pitch.
+# 0 = Trigger (one-shot), 1 = Gate (held). Volume in dB. Transpose in semitones.
+#
+# 2026-05-02 — fixed pitch-shift bug:
+# Earlier versions used "Sample Pitch Coarse" param name, which DOES NOT EXIST
+# on OriginalSimpler — the call silently raised and was swallowed. Result: every
+# drum-role Simpler played 24 semitones below original pitch ("super low" sound)
+# because the Simpler's default sample root is C3 (60), but drum convention sends
+# MIDI 36 (C1). The correct parameter is "Transpose" (range -48..+48 semitones);
+# +24 compensates for the C3-vs-C1 mismatch so drum samples play at original
+# recorded pitch when MIDI 36 is sent. Melodic/texture roles use Transpose=0
+# because their default playback range centers on C3 (60) — no compensation needed.
 _SIMPLER_ROLE_DEFAULTS = {
     "drum": [
         ("Snap", 0),
         ("Volume", 0.0),
         ("Trigger Mode", 0),  # Trigger / one-shot
-        ("Sample Pitch Coarse", 36),  # C1, matches drum-pad convention
+        ("Transpose", 24),    # Compensate C3-default → C1-drum-convention root
     ],
     "melodic": [
         ("Snap", 1),
         ("Volume", 0.0),
         ("Trigger Mode", 1),  # Gate / held
-        ("Sample Pitch Coarse", 60),  # C3
+        ("Transpose", 0),     # C3 default — melodic input range
     ],
     "texture": [
         ("Snap", 0),
         ("Volume", -6.0),
         ("Trigger Mode", 1),  # Gate
-        ("Sample Pitch Coarse", 60),  # C3
+        ("Transpose", 0),     # C3 default — sustained-input range
     ],
 }
 
@@ -238,26 +267,80 @@ def load_browser_item(
         "uri": uri,
     })
 
-    # Post-load: apply role-aware defaults if the loaded device is a Simpler.
-    if role and isinstance(result, dict) and not result.get("error"):
-        device_index = result.get("device_index")
-        device_class = str(result.get("class_name") or result.get("device_name") or "")
-        if device_index is not None and "Simpler" in device_class:
-            applied = []
-            for name, value in _SIMPLER_ROLE_DEFAULTS[role]:
+    # Post-load: probe the loaded device once, then apply two layers of hygiene.
+    #
+    # 2026-05-02 — fixed device-detection bug. The TCP load_browser_item command
+    # returns {loaded, name, device_count} with NO device_index and NO class_name,
+    # so the previous detection (`result.get("device_index")` / `result.get("class_name")`)
+    # always failed and the role-defaults branch was never entered. Resolution:
+    # treat newly-loaded sample-on-empty-track as device_index=0 (Live places the
+    # instrument at chain head) and verify class + name via get_device_info.
+    #
+    # Layer 1 (gated on `role`): Simpler role-aware defaults — Snap/Volume/
+    # Trigger Mode/Transpose for drum/melodic/texture roles.
+    # Layer 2 (unconditional): M4L instrument hygiene — name-matched tames for
+    # known problem devices (Harmonic Drone Generator's Latch + loud defaults).
+    device_index_resolved: Optional[int] = None
+    device_class = ""
+    device_name_loaded = ""
+    if isinstance(result, dict) and result.get("loaded") and not result.get("error"):
+        device_index_resolved = result.get("device_index")
+        try:
+            probe = ableton.send_command("get_device_info", {
+                "track_index": track_index,
+                "device_index": 0,
+            })
+            device_class = str(probe.get("class_name", "") or "")
+            device_name_loaded = str(probe.get("name", "") or result.get("name", "") or "")
+            if device_index_resolved is None:
+                device_index_resolved = 0
+        except Exception:
+            pass
+
+    # Layer 1 — Simpler role-aware defaults
+    if role and device_index_resolved is not None and "Simpler" in device_class:
+        applied = []
+        for name, value in _SIMPLER_ROLE_DEFAULTS[role]:
+            try:
+                ableton.send_command("set_device_parameter", {
+                    "track_index": track_index,
+                    "device_index": int(device_index_resolved),
+                    "parameter_name": name,
+                    "value": value,
+                })
+                applied.append({"parameter": name, "value": value})
+            except Exception as exc:
+                # Don't fail the whole load if one default doesn't apply
+                # (parameter name might not exist on every Simpler variant).
+                applied.append({"parameter": name, "skipped": str(exc)})
+        result["role"] = role
+        result["role_defaults_applied"] = applied
+        result["device_class"] = device_class
+
+    # Layer 2 — M4L instrument hygiene (unconditional, name-matched).
+    # Detects Harmonic Drone Generator and other known problem M4L instruments
+    # by name substring, applies tame defaults to prevent loud-on-load surprises.
+    if device_index_resolved is not None and device_name_loaded:
+        for hygiene_name, params in _M4L_INSTRUMENT_HYGIENE.items():
+            if hygiene_name not in device_name_loaded:
+                continue
+            applied_hygiene = []
+            for name, value in params:
                 try:
                     ableton.send_command("set_device_parameter", {
                         "track_index": track_index,
-                        "device_index": int(device_index),
+                        "device_index": int(device_index_resolved),
                         "parameter_name": name,
                         "value": value,
                     })
-                    applied.append({"parameter": name, "value": value})
+                    applied_hygiene.append({"parameter": name, "value": value})
                 except Exception as exc:
-                    # Don't fail the whole load if one default doesn't apply
-                    # (parameter name might not exist on every Simpler variant).
-                    applied.append({"parameter": name, "skipped": str(exc)})
-            result["role"] = role
-            result["role_defaults_applied"] = applied
+                    applied_hygiene.append({"parameter": name, "skipped": str(exc)})
+            result["m4l_hygiene"] = {
+                "device_name": hygiene_name,
+                "applied": applied_hygiene,
+            }
+            result.setdefault("device_class", device_class)
+            break  # one hygiene match per load
 
     return result

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.24.0",
+  "version": "1.25.0",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 \u2014 459 tools, 54 domains, 44 semantic moves. Device atlas (5264 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, technique memory, 12 creative intelligence engines",
+  "description": "Agentic production system for Ableton Live 12 \u2014 462 tools, 55 domains, 44 semantic moves. Device atlas (5264 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, technique memory, 12 creative intelligence engines",
   "author": "Pilot Studio",
   "license": "BSL-1.1",
   "type": "commonjs",

package/remote_script/LivePilot/__init__.py

@@ -5,7 +5,7 @@ Entry point for the ControlSurface. Ableton calls create_instance(c_instance)
 when this script is selected in Preferences > Link, Tempo & MIDI.
 """
 
-__version__ = "1.24.0"
+__version__ = "1.25.0"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router

package/server.json

@@ -1,17 +1,17 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.dreamrec/livepilot",
-  "description": "459-tool agentic MCP production system for Ableton Live 12 \u2014 54 domains, 44 semantic moves, device atlas (5264 devices), Splice intelligence (gRPC + GraphQL), 9-band spectral perception auto-loaded, Creative Director skill, technique memory, 12 creative engines",
+  "description": "462-tool agentic MCP production system for Ableton Live 12 \u2014 55 domains, 44 semantic moves, device atlas (5264 devices), Splice intelligence (gRPC + GraphQL), 9-band spectral perception auto-loaded, Creative Director skill, technique memory, 12 creative engines",
   "repository": {
     "url": "https://github.com/dreamrec/LivePilot",
     "source": "github"
   },
-  "version": "1.24.0",
+  "version": "1.25.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "livepilot",
-      "version": "1.24.0",
+      "version": "1.25.0",
       "transport": {
         "type": "stdio"
       }