livepilot 1.9.24 → 1.10.1

package/mcp_server/wonder_mode/engine.py

@@ -25,11 +25,11 @@ def discover_moves(
     """Find semantic moves relevant to the request.
 
     Uses keyword scoring + optional taste reranking + constraint filtering.
-    Returns full move dicts including compile_plan (via registry.get_move).
+    Returns full move dicts including plan_template (via registry.get_move).
     """
     from ..semantic_moves import registry
 
-    all_moves = registry.list_moves()  # returns to_dict() — no compile_plan
+    all_moves = registry.list_moves()  # returns to_dict() — no plan_template
     if not all_moves:
         return []
 
@@ -77,7 +77,7 @@ def discover_moves(
 
     scored.sort(key=lambda x: -x[1])
 
-    # Enrich with full compile_plan via get_move()
+    # Enrich with full plan_template via get_move()
     result = []
     for move_dict, score in scored:
         full_move = registry.get_move(move_dict["move_id"])
@@ -98,7 +98,7 @@ def discover_moves(
             for move in result:
                 plan = {"steps": [
                     {"action": step.get("tool", ""), **step}
-                    for step in (move.get("compile_plan") or [])
+                    for step in (move.get("plan_template") or [])
                 ]}
                 validation = validate_plan_against_constraints(plan, active_constraints)
                 if validation["valid"]:
@@ -137,9 +137,9 @@ def _with_envelope(move: dict, tier: str) -> dict:
 # ── Distinctness selection ───────────────────────────────────────
 
 
-def _compile_plan_shape(move: dict) -> frozenset[str]:
-    """Extract the set of tool names from a move's compile_plan."""
-    plan = move.get("compile_plan") or []
+def _plan_template_shape(move: dict) -> frozenset[str]:
+    """Extract the set of tool names from a move's plan_template."""
+    plan = move.get("plan_template") or []
     return frozenset(step.get("tool", "") for step in plan if step.get("tool"))
 
 
@@ -147,7 +147,7 @@ def select_distinct_variants(scored_moves: list[dict]) -> list[dict]:
     """Select genuinely distinct moves for variant generation.
 
     Each selected move must differ from all previously selected moves by
-    at least one of: move_id, family, or compile_plan shape.
+    at least one of: move_id, family, or plan_template shape.
     Returns 0-3 moves.
     """
     if not scored_moves:
@@ -160,7 +160,7 @@ def select_distinct_variants(scored_moves: list[dict]) -> list[dict]:
     for move in scored_moves:
         mid = move.get("move_id", "")
         family = move.get("family", "")
-        shape = _compile_plan_shape(move)
+        shape = _plan_template_shape(move)
 
         # Skip duplicate move_ids
         if mid in used_ids:
@@ -190,14 +190,45 @@ _NOVELTY_LEVELS = {"safe": 0.25, "strong": 0.55, "unexpected": 0.85}
 _RISK_TO_EFFECT = {"low": "preserves", "medium": "evolves", "high": "contrasts"}
 
 
+def _compile_variant_plan(move_dict: dict, kernel: dict | None) -> dict | None:
+    """Compile a move through the semantic compiler if possible.
+
+    Returns CompiledPlan.to_dict() or None if no compiler is registered.
+    """
+    if kernel is None:
+        return None
+
+    move_id = move_dict.get("move_id", "")
+    from ..semantic_moves.compiler import compile as sem_compile, _COMPILERS
+    from ..semantic_moves import registry
+
+    if move_id not in _COMPILERS:
+        return None
+
+    move_obj = registry.get_move(move_id)
+    if move_obj is None:
+        return None
+
+    try:
+        plan = sem_compile(move_obj, kernel)
+        return plan.to_dict()
+    except Exception:
+        return None
+
+
 def build_variant(
     label: str,
     move_dict: dict,
     song_brain: Optional[dict] = None,
     novelty_level: float = 0.5,
     variant_id: str = "",
+    kernel: dict | None = None,
 ) -> dict:
-    """Build a variant dict from a real move + SongBrain context."""
+    """Build a variant dict from a real move + SongBrain context.
+
+    If kernel is provided, compiles the move through the semantic compiler
+    for an executable plan. Otherwise falls back to plan_template metadata.
+    """
     song_brain = song_brain or {}
     targets = move_dict.get("targets", {})
     protect = move_dict.get("protect", {})
@@ -226,6 +257,10 @@ def build_variant(
     if sacred and identity_effect == "preserves":
         why += f". Preserves {sacred[0].get('description', 'sacred elements')}"
 
+    # Compile through semantic compiler if kernel available
+    compiled = _compile_variant_plan(move_dict, kernel)
+    analytical = compiled is None
+
     return {
         "variant_id": variant_id,
         "label": label,
@@ -239,11 +274,11 @@ def build_variant(
         "novelty_level": novelty_level,
         "taste_fit": 0.5,
         "targets_snapshot": dict(targets),
-        "compiled_plan": move_dict.get("compile_plan"),
+        "compiled_plan": compiled,
         "score": 0.0,
         "rank": 0,
         "score_breakdown": {},
-        "analytical_only": False,
+        "analytical_only": analytical,
         "distinctness_reason": "",
     }
 
@@ -390,8 +425,86 @@ def _all_same_family(variants: list[dict]) -> bool:
     return len(families) <= 1 and len(variants) > 1
 
 
-# ── Pipeline orchestrator ────────────────────────────────────────
+# ── Corpus intelligence enrichment ──────────────────────────────
+
+
+def _get_corpus_hints(request_text: str, diagnosis: dict | None) -> dict | None:
+    """Query the corpus for creative hints relevant to the request.
+
+    Returns a dict with emotional_recipe, genre_chain, automation_density,
+    and technique_suggestions — or None if corpus is unavailable.
+    """
+    try:
+        from ..corpus import get_corpus
+    except ImportError:
+        return None
 
+    corpus = get_corpus()
+    if not corpus.emotional_recipes and not corpus.genre_chains:
+        return None
+
+    hints: dict = {}
+    request_lower = request_text.lower()
+
+    # Check for emotional keywords
+    _EMOTION_KEYWORDS = {
+        "warm": "warmth & comfort", "cold": "tension & anxiety",
+        "dark": "melancholy", "bright": "euphoria",
+        "aggressive": "danger", "soft": "warmth & comfort",
+        "anxious": "tension & anxiety", "nostalgic": "nostalgia",
+        "vast": "vastness", "ethereal": "vastness",
+        "sad": "melancholy", "happy": "euphoria",
+        "tension": "tension & anxiety", "release": "euphoria",
+    }
+    for keyword, emotion_key in _EMOTION_KEYWORDS.items():
+        if keyword in request_lower:
+            recipe = corpus.suggest_for_emotion(emotion_key)
+            if recipe:
+                hints["emotional_recipe"] = {
+                    "emotion": recipe.emotion,
+                    "technique_count": len(recipe.techniques),
+                    "first_techniques": [t[:100] for t in recipe.techniques[:3]],
+                }
+                break
+
+    # Check for genre keywords
+    _GENRE_KEYWORDS = ["dub", "techno", "minimal", "ambient", "idm", "trap",
+                       "sophie", "arca", "house", "trance", "drum and bass"]
+    for genre in _GENRE_KEYWORDS:
+        if genre in request_lower:
+            chain = corpus.get_genre_chain(genre)
+            if chain:
+                hints["genre_chain"] = {
+                    "genre": chain.genre,
+                    "devices": chain.devices[:5],
+                    "description": chain.description[:120],
+                }
+                break
+
+    # Check for physical model keywords
+    _MATERIAL_KEYWORDS = ["water", "metal", "glass", "breath", "fire", "electric"]
+    for material in _MATERIAL_KEYWORDS:
+        if material in request_lower:
+            model = corpus.suggest_for_material(material)
+            if model:
+                hints["physical_model"] = {
+                    "material": model.material,
+                    "devices": model.devices[:4],
+                }
+                break
+
+    # Automation density from diagnosis section type
+    if diagnosis:
+        problem_class = diagnosis.get("problem_class", "")
+        if "static" in problem_class or "flat" in problem_class:
+            hints["automation_density"] = corpus.get_automation_density_for_section("peak")
+        elif "breakdown" in problem_class:
+            hints["automation_density"] = corpus.get_automation_density_for_section("breakdown")
+
+    return hints if hints else None
+
+
+# ── Pipeline orchestrator ────────────────────────────────────────
 
 
 def generate_wonder_variants(
@@ -401,6 +514,8 @@ def generate_wonder_variants(
     song_brain: dict | None = None,
     taste_graph: object = None,
     active_constraints: object = None,
+    session_info: dict | None = None,
+    sample_context: dict | None = None,
 ) -> dict:
     """Full wonder mode pipeline: discover -> select distinct -> build -> taste -> rank."""
     song_brain = song_brain or {}
@@ -414,6 +529,17 @@ def generate_wonder_variants(
     labels = ["safe", "strong", "unexpected"]
     variants = []
 
+    # Load corpus intelligence for variant enrichment
+    corpus_hints = _get_corpus_hints(request_text, diagnosis)
+
+    # Build kernel for variant compilation
+    kernel = {
+        "session_info": session_info or {},
+        "mode": "improve",
+    }
+    if sample_context:
+        kernel.update(sample_context)
+
     # Build executable variants from distinct moves
     for i, move in enumerate(distinct):
         label = labels[i]
@@ -424,11 +550,15 @@ def generate_wonder_variants(
             song_brain=song_brain,
             novelty_level=_NOVELTY_LEVELS.get(label, 0.5),
             variant_id=f"{set_prefix}_{label}",
+            kernel=kernel,
         )
         if taste_graph is not None:
             # Score taste on envelope-adjusted move for consistency with targets_snapshot
             v["taste_fit"] = compute_taste_fit(move_with_envelope, taste_graph)
         v["distinctness_reason"] = _explain_distinctness(move, distinct, i)
+        # Enrich with corpus knowledge
+        if corpus_hints:
+            v["corpus_hints"] = corpus_hints
         variants.append(v)
 
     executable_count = len(variants)
@@ -483,7 +613,7 @@ def _explain_distinctness(move: dict, all_moves: list[dict], index: int) -> str:
 
     if family not in other_families:
         return f"Different family: {family}"
-    shape = _compile_plan_shape(move)
+    shape = _plan_template_shape(move)
     return f"Different approach: {', '.join(sorted(shape))}"
 
 

package/mcp_server/wonder_mode/tools.py

@@ -126,14 +126,46 @@ def enter_wonder_mode(
         action_ledger=action_ledger,
     )
 
+    # 1b. If diagnosis includes sample domains, search for candidates
+    sample_context = {}
+    diag_dict = diagnosis.to_dict()
+    candidate_domains = diag_dict.get("candidate_domains") or []
+    if "sample" in candidate_domains:
+        try:
+            from ..sample_engine.tools import get_sample_opportunities, search_samples
+            opportunities = get_sample_opportunities(ctx)
+            if opportunities.get("opportunities"):
+                opp = opportunities["opportunities"][0]
+                query = opp.get("search_query", opp.get("description", "sample"))
+                results = search_samples(ctx, query=query, max_results=3)
+                candidates = results.get("results", [])
+                if candidates:
+                    best = candidates[0]
+                    sample_context["sample_file_path"] = best.get("file_path", "")
+                    sample_context["sample_name"] = best.get("name", "")
+                    sample_context["material_type"] = best.get("material_type", "")
+        except Exception:
+            pass  # Graceful degradation — analytical variants still work
+
+    # 1c. Get session info for kernel
+    session_info = {}
+    try:
+        ableton = ctx.lifespan_context.get("ableton")
+        if ableton:
+            session_info = ableton.send_command("get_session_info", {})
+    except Exception:
+        pass
+
     # 2. Generate variants
     result = engine.generate_wonder_variants(
         request_text=request_text,
-        diagnosis=diagnosis.to_dict(),
+        diagnosis=diag_dict,
         kernel_id=kernel_id,
         song_brain=song_brain,
         taste_graph=taste_graph,
         active_constraints=active_constraints,
+        session_info=session_info,
+        sample_context=sample_context,
     )
 
     # 3. Create WonderSession (unique per invocation, not deterministic)

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "livepilot",
-  "version": "1.9.24",
+  "version": "1.10.1",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 293 tools, 39 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
+  "description": "Agentic production system for Ableton Live 12 — 317 tools, 43 domains. Device atlas (1305 devices), sample engine (Splice + browser + filesystem), auto-composition, spectral perception, technique memory, creative intelligence (12 engines)",
   "author": "Pilot Studio",
-  "license": "MIT",
+  "license": "BSL-1.1",
   "type": "commonjs",
   "bin": {
     "livepilot": "./bin/livepilot.js"
@@ -17,6 +17,12 @@
   "bugs": {
     "url": "https://github.com/dreamrec/LivePilot/issues"
   },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/dreamrec"
+    }
+  ],
   "keywords": [
     "mcp",
     "mcp-server",
@@ -29,7 +35,11 @@
     "ai",
     "sound-design",
     "mixing",
-    "arrangement"
+    "arrangement",
+    "splice",
+    "sample-engine",
+    "auto-composition",
+    "device-atlas"
   ],
   "engines": {
     "node": ">=18.0.0"

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.9.24"
+__version__ = "1.10.1"
 
 from _Framework.ControlSurface import ControlSurface
 from .server import LivePilotServer
@@ -20,6 +20,7 @@ from . import browser      # noqa: F401  — registers browser handlers
 from . import arrangement  # noqa: F401  — registers arrangement handlers
 from . import diagnostics       # noqa: F401  — registers diagnostics handler
 from . import clip_automation   # noqa: F401  — registers clip automation handlers
+from . import version_detect    # noqa: F401  — version detection
 
 
 def create_instance(c_instance):
@@ -36,6 +37,12 @@ class LivePilot(ControlSurface):
         self._server.start()
         self.log_message("LivePilot v%s starting..." % __version__)
         self.show_message("LivePilot v%s starting..." % __version__)
+        v = version_detect.version_string()
+        self.log_message("LivePilot detected Ableton Live %s" % v)
+        features = version_detect.get_api_features()
+        enabled = [k for k, flag in features.items() if flag]
+        if enabled:
+            self.log_message("  Enabled features: %s" % ", ".join(enabled))
 
     def disconnect(self):
         """Called by Ableton when the script is unloaded."""

package/remote_script/LivePilot/arrangement.py

@@ -169,6 +169,70 @@ def create_arrangement_clip(song, params):
     }
 
 
+@register("create_native_arrangement_clip")
+def create_native_arrangement_clip(song, params):
+    """Create an empty MIDI clip in arrangement using the native 12.1.10+ API.
+
+    Unlike create_arrangement_clip (which duplicates a session clip),
+    this creates a true native clip with full automation envelope support.
+
+    Required: track_index, start_time, length
+    Optional: name, color_index
+    """
+    from .version_detect import has_feature
+
+    if not has_feature("create_midi_clip_arrangement"):
+        raise RuntimeError(
+            "create_native_arrangement_clip requires Live 12.1.10+. "
+            "Use create_arrangement_clip (session clip duplication) instead."
+        )
+
+    track_index = int(params["track_index"])
+    start_time = float(params["start_time"])
+    length = float(params["length"])
+    if length <= 0:
+        raise ValueError("length must be > 0")
+    if start_time < 0:
+        raise ValueError("start_time must be >= 0")
+
+    track = get_track(song, track_index)
+    if not track.has_midi_input:
+        raise ValueError(
+            "Track %d is not a MIDI track — create_native_arrangement_clip "
+            "only works on MIDI tracks" % track_index
+        )
+
+    song.begin_undo_step()
+    try:
+        clip = track.create_midi_clip(start_time, length)
+
+        name = params.get("name")
+        if name:
+            clip.name = str(name)
+        color_index = params.get("color_index")
+        if color_index is not None:
+            clip.color_index = int(color_index)
+    finally:
+        song.end_undo_step()
+
+    # Find the clip index in arrangement_clips
+    clip_index = None
+    for i, c in enumerate(track.arrangement_clips):
+        if abs(c.start_time - start_time) < 0.01:
+            clip_index = i
+            break
+
+    return {
+        "track_index": track_index,
+        "clip_index": clip_index,
+        "start_time": start_time,
+        "length": length,
+        "name": clip.name,
+        "has_envelope_support": True,
+        "native": True,
+    }
+
+
 @register("add_arrangement_notes")
 def add_arrangement_notes(song, params):
     """Add MIDI notes to an arrangement clip (by index in arrangement_clips)."""
@@ -713,3 +777,53 @@ def back_to_arranger(song, params):
     """Switch playback from session clips back to the arrangement timeline."""
     song.back_to_arranger = True
     return {"back_to_arranger": True}
+
+
+@register("force_arrangement")
+def force_arrangement(song, params):
+    """Force ALL tracks to follow the arrangement timeline.
+
+    Stops all session clips, releases every track from session override,
+    sets back_to_arranger, and optionally jumps to a start position.
+
+    This is the atomic "play the arrangement from the top" command.
+    """
+    # 1. Stop playback
+    was_playing = song.is_playing
+    if was_playing:
+        song.stop_playing()
+
+    # 2. Stop playing clip slots individually to release session overrides
+    #    (track.stop_all_clips() throws STATE_ERROR when tracks have no clips)
+    for track in list(song.tracks) + list(song.return_tracks):
+        try:
+            for slot in track.clip_slots:
+                if slot.has_clip and slot.is_playing:
+                    slot.clip.stop()
+        except Exception:
+            pass
+
+    # 3. Global back-to-arranger
+    song.back_to_arranger = True
+
+    # 4. Jump to position (default: start)
+    beat_time = float(params.get("beat_time", 0))
+    song.current_song_time = max(0, beat_time)
+
+    # 5. Set loop if requested
+    if "loop_length" in params:
+        song.loop_start = float(params.get("loop_start", 0))
+        song.loop_length = float(params["loop_length"])
+        song.loop = True
+
+    # 6. Start playback if requested (default: yes)
+    play = params.get("play", True)
+    if play:
+        song.start_playing()
+
+    return {
+        "arrangement_active": True,
+        "position": song.current_song_time,
+        "is_playing": song.is_playing,
+        "loop": song.loop,
+    }

package/remote_script/LivePilot/browser.py

@@ -1,5 +1,5 @@
 """
-LivePilot - Browser domain handlers (5 commands).
+LivePilot - Browser domain handlers (6 commands).
 """
 
 import Live
@@ -386,6 +386,61 @@ def load_browser_item(song, params):
     )
 
 
+_SCAN_MAX_ITERATIONS = 100000
+
+
+def _scan_recursive(item, results, depth, max_depth, max_per_category,
+                    _counter=None):
+    """Recursively collect loadable browser items with iteration cap."""
+    if _counter is None:
+        _counter = [0]
+    if depth > max_depth or len(results) >= max_per_category:
+        return
+    for child in item.children:
+        _counter[0] += 1
+        if _counter[0] > _SCAN_MAX_ITERATIONS or len(results) >= max_per_category:
+            return
+        if child.is_loadable:
+            entry = {"name": child.name, "is_loadable": True}
+            try:
+                entry["uri"] = child.uri
+            except AttributeError:
+                entry["uri"] = None
+            results.append(entry)
+        if child.is_folder:
+            _scan_recursive(
+                child, results, depth + 1, max_depth, max_per_category,
+                _counter
+            )
+            if len(results) >= max_per_category:
+                return
+
+
+@register("scan_browser_deep")
+def scan_browser_deep(song, params):
+    """Walk the entire browser tree and return all loadable items by category.
+
+    Parameters
+    ----------
+    max_per_category : int, optional
+        Maximum items to collect per top-level category (default 1000).
+    max_depth : int, optional
+        Maximum recursion depth into the browser tree (default 4).
+    """
+    max_per_category = int(params.get("max_per_category", 1000))
+    max_depth = int(params.get("max_depth", 4))
+    browser = _get_browser()
+    categories = _get_categories(browser)
+
+    result = {}
+    for cat_name, cat_item in categories.items():
+        items = []
+        _scan_recursive(cat_item, items, 0, max_depth, max_per_category)
+        result[cat_name] = items
+
+    return {"categories": result}
+
+
 @register("get_device_presets")
 def get_device_presets(song, params):
     """List available presets for a device type by searching the browser.