livepilot 1.23.6 → 1.25.0

package/mcp_server/composer/framework/event_lexicon.py

@@ -0,0 +1,71 @@
+"""42-event structural lexicon — vocabulary of named primitives the agent
+can schedule at phrase boundaries. Used by full + develop mode briefs.
+
+Categories: filter, drums, layer, riser, dynamics, harmonic, space.
+"""
+
+from __future__ import annotations
+from typing import Optional
+
+
+EVENT_LEXICON: list[dict] = [
+    # Filter gestures (5)
+    {"name": "hpf_sweep_up", "category": "filter", "description": "HPF rises 80 Hz → 1-2 kHz over 16-32 bars before drop"},
+    {"name": "lpf_close_slow", "category": "filter", "description": "LPF closes gradually over 64-128 bars (ambient texture removal)"},
+    {"name": "filter_open_snap", "category": "filter", "description": "Sudden filter opening on bar 1 of new section (drop arrival)"},
+    {"name": "band_pass_sweep", "category": "filter", "description": "Band-pass center sweeps up over 8 bars (microhouse)"},
+    {"name": "filter_wobble_increase", "category": "filter", "description": "LFO-driven filter mod depth increases over 8 bars"},
+    # Drum / Rhythm events (11)
+    {"name": "kick_dropout", "category": "drums", "description": "Kick muted for 8-16 bars before reintroduction"},
+    {"name": "kick_first_entry", "category": "drums", "description": "Kick appears for the first time after percussion-only intro"},
+    {"name": "snare_roll_final_bars", "category": "drums", "description": "Snare roll accelerating over bars 15-16 of 16-bar phrase"},
+    {"name": "hat_layer_entry", "category": "drums", "description": "Additional hat layer enters (closed → open, or second hat sample)"},
+    {"name": "perc_dropout", "category": "drums", "description": "All percussion except kick removed for 4-8 bars (tension)"},
+    {"name": "full_drum_dropout", "category": "drums", "description": "All drums including kick removed (breakdown)"},
+    {"name": "drum_reintroduction", "category": "drums", "description": "Drums return after full dropout at full energy"},
+    {"name": "clap_add", "category": "drums", "description": "Clap or snare enters where only kick existed before"},
+    {"name": "ghost_density_increase", "category": "drums", "description": "Ghost note velocity raised across all hats"},
+    {"name": "and_of_4_snare", "category": "drums", "description": "Extra snare hit on 'and of 4' on bar 16 (common fill marker)"},
+    {"name": "ride_cymbal_add", "category": "drums", "description": "Ride cymbal enters (jazz/DnB open feel)"},
+    # Layer entry / exit (9)
+    {"name": "layer_fade_in", "category": "layer", "description": "Track volume automation 0 → nominal over 4-8 bars"},
+    {"name": "layer_fade_out", "category": "layer", "description": "Track volume nominal → 0 over 8-16 bars"},
+    {"name": "layer_hard_cut_in", "category": "layer", "description": "Track unmutes on bar 1 of new section"},
+    {"name": "layer_hard_cut_out", "category": "layer", "description": "Track mutes on bar 1 of section change"},
+    {"name": "melody_first_entry", "category": "layer", "description": "Lead/melody track introduces for the first time"},
+    {"name": "texture_swell", "category": "layer", "description": "Atmosphere/pad rises from inaudible to audible over 32 bars"},
+    {"name": "sub_bass_entry", "category": "layer", "description": "Sub-bass track appears for first time"},
+    {"name": "pad_strip_to_silence", "category": "layer", "description": "Pad/harmonic layer removed for breakdown isolation"},
+    {"name": "vocal_chop_entry", "category": "layer", "description": "Vocal chop track enters"},
+    # Riser / Fall events (5)
+    {"name": "riser_swell", "category": "riser", "description": "Riser sample triggered at bar 13 of 16-bar phrase (arrives at bar 17)"},
+    {"name": "reverse_cymbal", "category": "riser", "description": "Reverse cymbal swell timed to arrive on bar 1 of next section"},
+    {"name": "noise_swell", "category": "riser", "description": "White noise volume −inf → 0 dB over 8 bars then cut on drop"},
+    {"name": "pitch_riser", "category": "riser", "description": "Sample or synth pitch automating upward over 4-8 bars"},
+    {"name": "downlifter", "category": "riser", "description": "Reverse riser / falling pitch for energy drop or breakdown arrival"},
+    # Sidechain / Dynamics (4)
+    {"name": "sidechain_activate", "category": "dynamics", "description": "Sidechain compressor (pad vs. kick) switches on at section start"},
+    {"name": "sidechain_deactivate", "category": "dynamics", "description": "Sidechain removed in breakdown, restoring pad sustain"},
+    {"name": "compressor_release_lengthen", "category": "dynamics", "description": "Compressor release extended for swelling effect"},
+    {"name": "drum_bus_saturation_increase", "category": "dynamics", "description": "Saturation drive increases during a build"},
+    # Harmonic / Melodic (5)
+    {"name": "chord_change", "category": "harmonic", "description": "Harmonic progression advances to next chord"},
+    {"name": "motif_restatement", "category": "harmonic", "description": "Primary hook returns after absence (ABAB form)"},
+    {"name": "motif_inversion", "category": "harmonic", "description": "Inverted motif (IDM/classical variation)"},
+    {"name": "motif_fragmentation", "category": "harmonic", "description": "Motif shortened to 1-2 notes, repeated (pre-climax)"},
+    {"name": "half_time_shift", "category": "harmonic", "description": "Note durations doubled (groove drops to half-time feel)"},
+    # Space / Reverb (3)
+    {"name": "reverb_send_increase", "category": "space", "description": "Send to reverb return increases over 4-8 bars"},
+    {"name": "dub_throw", "category": "space", "description": "Single 1-beat send spike to delay/reverb"},
+    {"name": "full_silence_bar", "category": "space", "description": "1-2 bars of total silence (highest-impact transition tool)"},
+]
+
+
+def get_event_lexicon(category: Optional[str] = None) -> list[dict]:
+    """Return the lexicon, optionally filtered by category.
+
+    category: 'filter', 'drums', 'layer', 'riser', 'dynamics', 'harmonic', 'space', or None for all.
+    """
+    if category is None:
+        return list(EVENT_LEXICON)
+    return [ev for ev in EVENT_LEXICON if ev["category"] == category]

package/mcp_server/composer/framework/genre_loader.py

@@ -0,0 +1,77 @@
+"""Markdown parser for livepilot/skills/livepilot-core/references/genre-vocabularies.md.
+
+Genre entries are demarcated by `## genre_name` headers. Each entry contains
+descriptive content (kick character, bass register, harmonic palette, etc.).
+We parse opportunistically — capture the raw markdown block per genre name,
+let the agent reason on the content rather than over-structuring it.
+"""
+
+from __future__ import annotations
+import re
+from pathlib import Path
+from typing import Optional
+
+
+_GENRE_CACHE: Optional[dict[str, dict]] = None
+
+
+def _genre_md_path() -> Optional[Path]:
+    """Locate genre-vocabularies.md by walking up from this file."""
+    here = Path(__file__).resolve()
+    for parent in here.parents:
+        candidate = parent / "livepilot" / "skills" / "livepilot-core" / "references" / "genre-vocabularies.md"
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def _load_genre_md() -> dict[str, dict]:
+    """Parse the markdown into {genre_name_lowered: {raw: text, ...}}.
+
+    Cached after first call.
+    """
+    global _GENRE_CACHE
+    if _GENRE_CACHE is not None:
+        return _GENRE_CACHE
+    path = _genre_md_path()
+    if path is None:
+        _GENRE_CACHE = {}
+        return _GENRE_CACHE
+
+    text = path.read_text(encoding="utf-8")
+    # Genres are demarcated by `## name` (or `### name`) — the structure
+    # may vary, so handle both. Use a regex split.
+    genres: dict[str, dict] = {}
+    sections = re.split(r"^##+\s+(.+?)\s*$", text, flags=re.MULTILINE)
+    # Re.split returns [pre, name1, body1, name2, body2, ...]
+    for i in range(1, len(sections), 2):
+        name = sections[i].strip()
+        if not name or name.lower() in ("vocabulary", "how to read this", "table of contents"):
+            continue
+        body = sections[i + 1] if i + 1 < len(sections) else ""
+        # Lowercase + underscore normalize the key
+        key = name.lower().replace(" ", "_").replace("-", "_")
+        genres[key] = {"name": name, "raw_md": body.strip()[:2000]}  # cap to keep brief size sane
+
+    _GENRE_CACHE = genres
+    return _GENRE_CACHE
+
+
+def load_genre_context(genre: str) -> dict:
+    """Load descriptive context for a parsed genre.
+
+    genre: parsed genre slug (techno, microhouse, ambient, etc.)
+
+    Returns a dict with content if found, or {"status": "no_match", ...} if not.
+    """
+    if not genre:
+        return {"status": "no_genre_provided"}
+    genres = _load_genre_md()
+    key = genre.lower().replace(" ", "_").replace("-", "_")
+    if key in genres:
+        return genres[key]
+    # Try fuzzy: genre might be sub-genre matching a key contained in entry names
+    for k, v in genres.items():
+        if key in k or k in key:
+            return v
+    return {"status": "no_match", "parsed_genre": genre}

package/mcp_server/composer/framework/intent_source.py

@@ -0,0 +1,137 @@
+"""Abstract source of CompositionIntent — prompt-derived, session-derived, or hybrid.
+
+PromptSource: parses a free-text prompt via prompt_parser.parse_prompt
+SessionSource: introspects the live Ableton session via the MCP tool layer
+HybridSource: combines both — session wins on tempo/key, prompt wins on genre/mood
+"""
+
+from __future__ import annotations
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class IntentSource(ABC):
+    """Abstract base — produces a CompositionIntent-shaped dict for any compose mode.
+
+    Returned dict shape (CompositionIntent fields):
+        {
+          "genre": str,
+          "mood": str,
+          "tempo": int,
+          "key": str,
+          "sub_genre": str,
+          "descriptors": list,
+          "explicit_elements": list,
+          "energy": float,
+          "layer_count": int,
+          "duration_bars": int,
+          # ... see prompt_parser.CompositionIntent for full list
+        }
+    """
+
+    @abstractmethod
+    def parse(self, ctx: Any) -> dict:
+        ...
+
+
+class PromptSource(IntentSource):
+    """Parses a free-text prompt via prompt_parser.parse_prompt."""
+
+    def __init__(self, prompt: str):
+        self.prompt = prompt
+
+    def parse(self, ctx: Any) -> dict:
+        # Lazy import to avoid circular deps at framework-package import time
+        from ..prompt_parser import parse_prompt
+        intent = parse_prompt(self.prompt)
+        # CompositionIntent has its own to_dict(); prefer it, else fall back to asdict
+        if hasattr(intent, "to_dict"):
+            return intent.to_dict()
+        if hasattr(intent, "__dataclass_fields__"):
+            from dataclasses import asdict
+            return asdict(intent)
+        if isinstance(intent, dict):
+            return intent
+        # Fallback for unexpected return type
+        return {"raw_intent": str(intent)}
+
+
+class SessionSource(IntentSource):
+    """Introspects the live Ableton session via MCP tools.
+
+    Reads session tempo, key, time signature, and per-track content.
+    Returns the same CompositionIntent shape as PromptSource so downstream
+    consumers don't care which source was used.
+    """
+
+    def __init__(self, scene_index: int = 0):
+        self.scene_index = scene_index
+
+    def parse(self, ctx: Any) -> dict:
+        ableton = ctx.lifespan_context.get("ableton") if hasattr(ctx, "lifespan_context") else None
+        if ableton is None:
+            logger.warning("SessionSource.parse: ableton client not in ctx — returning empty intent")
+            return {}
+
+        try:
+            session = ableton.send_command("get_session_info", {})
+        except Exception as exc:
+            logger.warning("SessionSource.parse: get_session_info failed: %s", exc)
+            return {}
+
+        intent: dict = {
+            "tempo": float(session.get("tempo", 120.0)),
+            "scene_index": self.scene_index,
+        }
+
+        # Time signature
+        sig_num = session.get("signature_numerator")
+        sig_den = session.get("signature_denominator")
+        if sig_num and sig_den:
+            intent["time_signature"] = f"{sig_num}/{sig_den}"
+
+        # Try to read song scale (Live 12.4 song-scale API)
+        try:
+            scale_result = ableton.send_command("get_song_scale", {})
+            if scale_result and not scale_result.get("error"):
+                intent["key"] = scale_result.get("root_note") or scale_result.get("key")
+                intent["scale_mode"] = scale_result.get("scale_name") or scale_result.get("mode")
+        except Exception as exc:
+            logger.debug("SessionSource.parse: get_song_scale unavailable: %s", exc)
+
+        return intent
+
+
+class HybridSource(IntentSource):
+    """Combines prompt + session intent.
+
+    Merge rule:
+    - tempo: session wins (live truth) if present, else prompt
+    - key/scale_mode: session wins if present, else prompt
+    - genre/mood: prompt wins (creative directive)
+    - other fields: prompt wins, session fills gaps
+    """
+
+    def __init__(self, prompt: str, scene_index: int = 0):
+        self.prompt = prompt
+        self.scene_index = scene_index
+
+    def parse(self, ctx: Any) -> dict:
+        prompt_intent = PromptSource(self.prompt).parse(ctx)
+        session_intent = SessionSource(self.scene_index).parse(ctx)
+
+        merged = dict(prompt_intent)  # start with prompt as base
+        # Session-wins overrides
+        for session_authoritative in ("tempo", "key", "scale_mode", "time_signature"):
+            session_val = session_intent.get(session_authoritative)
+            if session_val is not None:
+                merged[session_authoritative] = session_val
+        # Carry session-only fields the prompt doesn't have
+        for k, v in session_intent.items():
+            if k not in merged:
+                merged[k] = v
+        return merged

package/mcp_server/composer/framework/knowledge_pack.py

@@ -0,0 +1,140 @@
+"""KnowledgePack — assembles the vocabulary fields each compose mode's brief carries.
+
+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
+
+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",
+        *,
+        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.
+        """
+        # Genre context — descriptive vocabulary for the parsed style
+        genre = intent.get("sub_genre") or intent.get("genre") or ""
+        genre_ctx = load_genre_context(genre) if genre else {}
+
+        # Artist context — populated only if prompt mentioned producers
+        artist_names = intent.get("artists") or []
+        artist_ctx = load_artist_context(artist_names)
+
+        knowledge: dict[str, Any] = {
+            "genre_context": genre_ctx,
+            "artist_context": artist_ctx,
+            "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)
+        if mode in ("full", "develop"):
+            knowledge["event_lexicon"] = list(EVENT_LEXICON)
+        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/framework/plan_compiler.py

@@ -0,0 +1,10 @@
+"""PlanCompiler — turns a Brief-derived plan into a Remote Script step sequence."""
+from typing import Any
+
+
+class PlanCompiler:
+    """Phase 1 stub — full impl in Phase 2 onwards."""
+
+    def compile(self, brief: Any) -> list:
+        """Return list of step dicts. Stub returns empty."""
+        return []

package/mcp_server/composer/full/__init__.py

@@ -0,0 +1,10 @@
+"""Full compose mode — currently deterministic engine; will become two-phase
+LLM-creative in v1.24 Phase 3 (BUG-FULL-MODE-18 fix).
+
+Phase 1 of v1.24 just moves the existing code here without behavior change.
+"""
+from .engine import ComposerEngine, CompositionResult
+from .apply import apply_full_plan
+from .brief_builder import build_full_brief
+
+__all__ = ["ComposerEngine", "CompositionResult", "apply_full_plan", "build_full_brief"]