livepilot 1.10.0 → 1.10.2

package/mcp_server/composer/sample_resolver.py

@@ -0,0 +1,153 @@
+"""Local-first sample resolution for composer plans.
+
+Moves sample resolution from execution time (where the old pseudo-tool
+_agent_pick_best_sample was supposed to "figure it out") to plan time.
+
+Async because splice_remote downloads real samples over gRPC. Filesystem-only
+callers still work synchronously from an async perspective — the function
+only awaits when it actually has to hit the network.
+
+Returns (local_path, source) where source is one of:
+  'filesystem'    — hit in a provided search_root directory (no network)
+  'splice_local'  — Splice catalog hit that's already downloaded (no credit spend)
+  'splice_remote' — Splice catalog hit that required download (1 credit)
+  'browser'       — Ableton browser match with a local path
+  'unresolved'    — no match; caller drops the layer from the plan and warns
+
+Preference order is fixed: filesystem > splice_local > splice_remote > browser.
+Filesystem wins even if Splice has a faster hit — local files are free.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional, Tuple
+
+from .layer_planner import LayerSpec
+
+
+_AUDIO_EXTENSIONS = (".wav", ".aif", ".aiff", ".flac")
+
+
+def _query_tokens(query: str) -> list[str]:
+    """Return lowercase query tokens meaningful for matching (len > 2)."""
+    return [t.lower() for t in query.split() if len(t) > 2]
+
+
+def _iter_candidates(root: Path):
+    """Yield all audio-format files beneath root."""
+    if not root.exists():
+        return
+    for ext in _AUDIO_EXTENSIONS:
+        yield from root.rglob(f"*{ext}")
+
+
+def _filesystem_match(layer: LayerSpec, search_roots: list[Path]) -> Optional[str]:
+    """First filename-substring match on role or any query token.
+
+    Sync helper — no network, no async needed.
+    """
+    tokens = _query_tokens(layer.search_query)
+    role = layer.role.lower()
+    for root in search_roots:
+        for path in _iter_candidates(Path(root)):
+            name = path.name.lower()
+            if role and role in name:
+                return str(path)
+            if any(tok in name for tok in tokens):
+                return str(path)
+    return None
+
+
+async def _splice_resolve(
+    layer: LayerSpec,
+    splice_client: object,
+    credit_budget: int,
+) -> Tuple[Optional[str], str]:
+    """Query Splice for the layer. Returns (path, source) or (None, 'unresolved').
+
+    Tries local hits first (free), then remote downloads (1 credit each,
+    respecting the hard floor). Stops on first success.
+    """
+    if splice_client is None or not getattr(splice_client, "connected", False):
+        return None, "unresolved"
+
+    try:
+        result = await splice_client.search_samples(
+            query=layer.search_query,
+            per_page=5,
+        )
+    except Exception:
+        return None, "unresolved"
+
+    samples = list(result.samples) if result and hasattr(result, "samples") else []
+    if not samples:
+        return None, "unresolved"
+
+    # 1. Prefer already-local Splice hits (zero credit spend)
+    for sample in samples:
+        lp = getattr(sample, "local_path", "") or ""
+        if lp and Path(lp).exists():
+            return lp, "splice_local"
+
+    # 2. Remote download — respect the credit hard floor
+    for sample in samples:
+        if getattr(sample, "local_path", ""):
+            continue  # already handled above
+        file_hash = getattr(sample, "file_hash", "")
+        if not file_hash:
+            continue
+        try:
+            can, _remaining = await splice_client.can_afford(1, credit_budget)
+            if not can:
+                break  # credit floor hit — stop trying, don't try next sample
+            downloaded = await splice_client.download_sample(file_hash)
+            if downloaded and Path(downloaded).exists():
+                return downloaded, "splice_remote"
+        except Exception:
+            continue  # try next hit
+
+    return None, "unresolved"
+
+
+async def resolve_sample_for_layer(
+    layer: LayerSpec,
+    search_roots: Optional[list] = None,
+    splice_client: object = None,
+    browser_client: object = None,
+    credit_budget: int = 1,
+) -> Tuple[Optional[str], str]:
+    """Resolve a layer's sample to a concrete local file path.
+
+    Preference order: filesystem > splice_local > splice_remote > browser.
+    Unresolved layers return (None, 'unresolved'); callers drop them from
+    the plan and surface a warning.
+
+    search_roots accepts Path or str entries. Missing dirs are silently
+    skipped. None entries are filtered out.
+    """
+    roots = [Path(r) for r in (search_roots or []) if r]
+
+    # 1. Filesystem — always try first, no network
+    fs_hit = _filesystem_match(layer, roots)
+    if fs_hit:
+        return fs_hit, "filesystem"
+
+    # 2 & 3. Splice (local hits + remote download)
+    path, source = await _splice_resolve(layer, splice_client, credit_budget)
+    if path is not None:
+        return path, source
+
+    # 4. Browser (sync, optional)
+    if browser_client is not None:
+        try:
+            search = getattr(browser_client, "search", None)
+            hits = search(layer.search_query, limit=5) if callable(search) else []
+            for hit in hits or []:
+                lp = hit.get("file_path") if isinstance(hit, dict) else None
+                if lp and Path(lp).exists():
+                    return lp, "browser"
+        except Exception:
+            pass
+
+    return None, "unresolved"

package/mcp_server/composer/tools.py

@@ -20,6 +20,61 @@ from .engine import ComposerEngine
 _engine = ComposerEngine()
 
 
+def _get_search_roots(ctx: Context) -> list:
+    """Pull sample-search roots from ctx (if the server wired any) plus
+    environment fallbacks.
+    """
+    roots = []
+    try:
+        cfg = ctx.lifespan_context.get("sample_search_roots") if hasattr(ctx, "lifespan_context") else None
+        if cfg:
+            roots.extend(cfg)
+    except Exception:
+        pass
+    return roots
+
+
+async def _credit_safety_prelude(splice_client, max_credits: int) -> tuple[int, int | None, list[str]]:
+    """Apply the hard floor / budget trimming rules upfront.
+
+    Returns (adjusted_max_credits, credits_remaining_or_None, warnings).
+    """
+    warnings: list[str] = []
+    credits_remaining: int | None = None
+
+    if splice_client is None or not getattr(splice_client, "connected", False):
+        warnings.append(
+            "Splice not connected. Plan will use browser/filesystem fallback "
+            "for sample search."
+        )
+        return max_credits, None, warnings
+
+    try:
+        info = await splice_client.get_credits()
+        credits_remaining = getattr(info, "credits", None)
+    except Exception:
+        credits_remaining = None
+
+    if credits_remaining is None:
+        return max_credits, None, warnings
+
+    if credits_remaining <= 5:
+        warnings.append(
+            f"Splice credits critically low ({credits_remaining}). "
+            f"Using downloaded samples only."
+        )
+        max_credits = 0
+    elif max_credits > credits_remaining - 5:
+        safe_budget = max(0, credits_remaining - 5)
+        warnings.append(
+            f"Budget capped at {safe_budget} credits "
+            f"(remaining: {credits_remaining}, floor: 5)."
+        )
+        max_credits = safe_budget
+
+    return max_credits, credits_remaining, warnings
+
+
 @mcp.tool()
 async def compose(
     ctx: Context,
@@ -27,61 +82,33 @@ async def compose(
     max_credits: int = 50,
     dry_run: bool = False,
 ) -> dict:
-    """Create a full multi-layer composition from a text prompt.
+    """Plan a full multi-layer composition from a text prompt.
 
-    Searches Splice's catalog, selects matching samples with critic scoring,
-    downloads them, loads into Ableton, applies processing techniques, and
-    arranges into genre-appropriate sections.
+    Parses the prompt into genre/mood/tempo/key, plans layers using role
+    templates, and compiles an executable plan of tool calls. Does NOT
+    execute — returns the plan for the agent to step through.
 
     prompt: "dark minimal techno 128bpm with industrial textures and ghostly vocals"
-    max_credits: maximum Splice credits to spend (default 50, 0 = use only downloaded)
-    dry_run: if True, return the plan without executing (same as get_composition_plan)
+    max_credits: maximum Splice credits budget for the plan (default 50, 0 = downloaded only)
+    dry_run: if True, return the plan without credit checks
 
-    Returns a compiled plan with all execution steps. When dry_run is False,
-    the plan is ready for step-by-step execution by the agent.
+    Returns a compiled plan with step-by-step tool calls. The agent
+    executes each step by calling the referenced tools in sequence.
     """
-    # Parse the prompt into structured intent
     intent = parse_prompt(prompt)
 
-    # Credit safety check
-    splice_client = None
-    credits_remaining = None
-    try:
-        lifespan = ctx.lifespan_context
-        if lifespan and "splice" in lifespan:
-            splice_client = lifespan["splice"]
-            if splice_client and splice_client.connected:
-                credits_remaining = await splice_client.get_credits_remaining()
-    except Exception:
-        pass
-
-    warnings: list[str] = []
-
-    if credits_remaining is not None:
-        if credits_remaining <= 5:
-            warnings.append(
-                f"Splice credits critically low ({credits_remaining}). "
-                f"Using downloaded samples only."
-            )
-            max_credits = 0
-        elif max_credits > credits_remaining - 5:
-            safe_budget = max(0, credits_remaining - 5)
-            warnings.append(
-                f"Budget capped at {safe_budget} credits "
-                f"(remaining: {credits_remaining}, floor: 5)."
-            )
-            max_credits = safe_budget
-
-    if splice_client is None or not getattr(splice_client, "connected", False):
-        warnings.append(
-            "Splice not connected. Plan will use browser/filesystem fallback "
-            "for sample search."
-        )
+    splice_client = ctx.lifespan_context.get("splice_client") if hasattr(ctx, "lifespan_context") else None
+    search_roots = _get_search_roots(ctx)
 
-    # Compose
-    result = _engine.compose(intent, dry_run=dry_run, max_credits=max_credits)
+    max_credits, credits_remaining, warnings = await _credit_safety_prelude(splice_client, max_credits)
 
-    # Merge warnings
+    result = await _engine.compose(
+        intent,
+        dry_run=dry_run,
+        max_credits=max_credits,
+        search_roots=search_roots,
+        splice_client=splice_client,
+    )
     result.warnings.extend(warnings)
 
     output = result.to_dict()
@@ -101,48 +128,24 @@ async def augment_with_samples(
     max_credits: int = 10,
     max_layers: int = 3,
 ) -> dict:
-    """Add sample-based layers to the existing session.
+    """Plan sample-based layers to add to the existing session.
 
-    Analyzes the request, searches Splice for complementary samples,
-    and creates a plan to add new tracks with appropriate processing.
+    Parses the request and builds a plan for new tracks with sample
+    search queries, processing techniques, and volume/pan settings.
+    Does NOT execute — returns the plan for the agent to step through.
 
     request: "add organic textures" or "layer a vocal chop over the verse"
-    max_credits: maximum Splice credits to spend (default 10)
-    max_layers: maximum number of new tracks to add (default 3)
+    max_credits: maximum Splice credits budget for the plan (default 10)
+    max_layers: maximum number of new tracks in the plan (default 3)
 
-    Returns a compiled plan for adding new layers to the session.
+    Returns a compiled plan with step-by-step tool calls.
     """
-    # Credit safety
-    splice_client = None
-    credits_remaining = None
-    try:
-        lifespan = ctx.lifespan_context
-        if lifespan and "splice" in lifespan:
-            splice_client = lifespan["splice"]
-            if splice_client and splice_client.connected:
-                credits_remaining = await splice_client.get_credits_remaining()
-    except Exception:
-        pass
+    splice_client = ctx.lifespan_context.get("splice_client") if hasattr(ctx, "lifespan_context") else None
+    search_roots = _get_search_roots(ctx)
 
-    warnings: list[str] = []
+    max_credits, credits_remaining, warnings = await _credit_safety_prelude(splice_client, max_credits)
 
-    if credits_remaining is not None:
-        if credits_remaining <= 5:
-            warnings.append(
-                f"Splice credits critically low ({credits_remaining}). "
-                f"Using downloaded samples only."
-            )
-            max_credits = 0
-        elif max_credits > credits_remaining - 5:
-            safe_budget = max(0, credits_remaining - 5)
-            max_credits = safe_budget
-
-    if splice_client is None or not getattr(splice_client, "connected", False):
-        warnings.append(
-            "Splice not connected. Will use browser/filesystem fallback."
-        )
-
-    # Get current session info for context
+    # Pull current session info for tempo context
     session_context: dict = {}
     try:
         ableton = ctx.lifespan_context.get("ableton")
@@ -153,14 +156,14 @@ async def augment_with_samples(
     except Exception:
         pass
 
-    # Augment
-    result = _engine.augment(
+    result = await _engine.augment(
         request=request,
         max_credits=max_credits,
         max_layers=max_layers,
+        search_roots=search_roots,
+        splice_client=splice_client,
     )
 
-    # Override tempo from session if available
     if session_context.get("tempo"):
         result.intent.tempo = int(session_context["tempo"])
 
@@ -192,10 +195,17 @@ async def get_composition_plan(
     prompt: "dark minimal techno 128bpm with industrial textures"
     """
     intent = parse_prompt(prompt)
-    plan = _engine.get_plan(intent)
+    splice_client = ctx.lifespan_context.get("splice_client") if hasattr(ctx, "lifespan_context") else None
+    search_roots = _get_search_roots(ctx)
+    plan = await _engine.get_plan(
+        intent,
+        search_roots=search_roots,
+        splice_client=splice_client,
+    )
     plan["prompt"] = prompt
     plan["note"] = (
-        "This is a dry run. No samples searched, downloaded, or loaded. "
-        "Use compose() to execute this plan."
+        "This is a dry run. No samples searched or loaded. "
+        "Use compose() to get the full plan with credit checks, "
+        "then step through each tool call in sequence."
     )
     return plan

package/mcp_server/memory/taste_accessors.py

@@ -0,0 +1,47 @@
+"""Shared accessors for reading from a taste-graph dict.
+
+Three shapes exist in the wild:
+  canonical:   {"dimension_weights": {"dim": 0.3, ...}, ...}   TasteGraph.to_dict()
+  legacy flat: {"dim": 0.3, ...}                               arbitrary caller dicts
+  legacy obj:  {"dim": {"value": 0.3, ...}}                    TasteDimension.to_dict()
+
+Every consumer that wants to read a dimension preference MUST route through
+get_dimension_pref so new callers standardize on the canonical path and
+pre-existing dicts keep working until fully migrated.
+
+Do not add new shapes. If you find yourself writing a fourth shape, fix the
+producer instead.
+"""
+
+from __future__ import annotations
+
+
+def get_dimension_pref(
+    taste_graph: object,
+    dimension: str,
+    default: float = 0.5,
+) -> float:
+    """Read a dimension preference from a taste graph dict, regardless of shape.
+
+    Returns default for non-dict input, missing dimensions, or non-numeric values.
+    """
+    if not isinstance(taste_graph, dict):
+        return default
+
+    # Canonical shape wins
+    dw = taste_graph.get("dimension_weights")
+    if isinstance(dw, dict) and dimension in dw:
+        val = dw[dimension]
+        if isinstance(val, (int, float)):
+            return float(val)
+
+    # Legacy flat shapes
+    val = taste_graph.get(dimension)
+    if isinstance(val, (int, float)):
+        return float(val)
+    if isinstance(val, dict):
+        v = val.get("value")
+        if isinstance(v, (int, float)):
+            return float(v)
+
+    return default

package/mcp_server/preview_studio/engine.py

@@ -121,7 +121,11 @@ def _build_triptych(
         compiled_plan = None
         if moves and i < len(moves):
             move_id = moves[i].get("move_id", "")
-            compiled_plan = moves[i].get("compile_plan")
+            # Compile through the semantic compiler — single source of truth
+            from ..wonder_mode.engine import _compile_variant_plan
+            kernel = {"session_info": {"tempo": 120, "tracks": []}, "mode": "improve"}
+            compiled_plan = _compile_variant_plan(moves[i], kernel)
+            # No fallback to plan_template — uncompilable moves stay analytical
 
         variants.append(PreviewVariant(
             variant_id=f"{set_id}_{profile['label']}",
@@ -264,7 +268,10 @@ def _compute_set_id(request_text: str, kernel_id: str) -> str:
 
 def _estimate_taste_fit(novelty: float, taste_graph: dict) -> float:
     """Estimate how well a novelty level fits user taste."""
-    boldness = taste_graph.get("transition_boldness", 0.5)
+    # Routes through the canonical accessor so dimension_weights.transition_boldness
+    # is honored. Previously read the top-level key directly and always got 0.5.
+    from ..memory.taste_accessors import get_dimension_pref
+    boldness = get_dimension_pref(taste_graph, "transition_boldness", default=0.5)
     # Users who like boldness prefer higher novelty
     fit = 1.0 - abs(novelty - boldness) * 0.5
     return round(max(0.0, min(1.0, fit)), 3)

package/mcp_server/preview_studio/tools.py

@@ -23,7 +23,15 @@ def _get_ableton(ctx: Context):
 
 def _should_refuse_analytical(compiled_plan, wonder_linked: bool) -> bool:
     """Check if an analytical variant should be refused in Wonder context."""
-    return compiled_plan is None and wonder_linked
+    if not wonder_linked:
+        return False
+    if compiled_plan is None:
+        return True
+    if isinstance(compiled_plan, dict):
+        return len(compiled_plan.get("steps", [])) == 0
+    if isinstance(compiled_plan, list):
+        return len(compiled_plan) == 0
+    return True
 
 
 def _find_wonder_session_by_preview(set_id: str):
@@ -308,7 +316,7 @@ def commit_preview_variant(
 
 
 @mcp.tool()
-def render_preview_variant(
+async def render_preview_variant(
     ctx: Context,
     set_id: str = "",
     variant_id: str = "",
@@ -352,7 +360,7 @@ def render_preview_variant(
             "analytical_only": True,
         }
 
-    # If the variant has a compiled plan, we could apply-capture-undo.
+    # If the variant has a compiled plan, apply -> capture audible -> undo.
     # Without a compiled plan, return the variant's analytical preview.
     if variant.compiled_plan:
         ableton = _get_ableton(ctx)
@@ -360,52 +368,87 @@ def render_preview_variant(
         plan = variant.compiled_plan
         steps = plan if isinstance(plan, list) else plan.get("steps", [])
 
-        from ..runtime.execution_router import execute_plan_steps
+        from ..runtime.execution_router import execute_plan_steps_async
 
         applied_count = 0
-        try:
-            # Capture before state
-            before_info = ableton.send_command("get_session_info", {})
+        playback_started = False
+        preview_mode = "metadata_only_preview"
+        spectral_before: Optional[dict] = None
+        spectral_after: Optional[dict] = None
+        before_info: dict = {}
+        after_info: dict = {}
+
+        bridge = ctx.lifespan_context.get("m4l")
+        mcp_registry = ctx.lifespan_context.get("mcp_dispatch", {})
 
-            # Execute through unified router
-            exec_results = execute_plan_steps(steps, ableton=ableton, ctx=ctx)
+        try:
+            # ── 1. Capture BEFORE metadata ──
+            before_info = ableton.send_command("get_session_info", {}) or {}
+
+            # ── 2. Apply the variant ──
+            exec_results = await execute_plan_steps_async(
+                steps,
+                ableton=ableton,
+                bridge=bridge,
+                mcp_registry=mcp_registry,
+                ctx=ctx,
+            )
             applied_count = sum(1 for r in exec_results if r.ok)
+            if applied_count == 0 and steps:
+                return {
+                    "error": "Variant failed to apply any steps",
+                    "variant_id": variant_id,
+                    "step_errors": [r.error for r in exec_results if not r.ok],
+                }
+
+            # ── 3. Capture AFTER metadata (variant is live) ──
+            after_info = ableton.send_command("get_session_info", {}) or {}
+
+            # ── 4. Audible capture WHILE variant is still applied ──
+            # This is the critical ordering fix: previously this block ran AFTER
+            # the finally's undo loop, so "audible_preview" captured pre-variant
+            # audio and lied about it. Now playback + spectrum sampling happens
+            # while the variant is actually in effect, then the finally undoes it.
+            try:
+                from ..m4l_bridge import SpectralCache
+                cache = ctx.lifespan_context.get("spectral")
+                if cache and isinstance(cache, SpectralCache) and cache.is_connected:
+                    spectral_before = cache.get_all()
+
+                    tempo = before_info.get("tempo", 120) or 120
+                    play_seconds = min(bars * (60.0 / tempo) * 4, 8.0)
+
+                    ableton.send_command("start_playback", {})
+                    playback_started = True
+
+                    import time as _time
+                    _time.sleep(play_seconds)
+
+                    spectral_after = cache.get_all()
+
+                    ableton.send_command("stop_playback", {})
+                    playback_started = False
+
+                    preview_mode = "audible_preview"
+            except Exception:
+                # Spectral capture is best-effort; keep preview_mode as metadata_only
+                pass
 
-            # Capture after state
-            after_info = ableton.send_command("get_session_info", {})
         except Exception as e:
             return {"error": f"Render failed: {e}", "variant_id": variant_id}
         finally:
-            # Undo all applied changes regardless of success/failure
+            # ── 5. Cleanup: stop playback if still running, then undo everything ──
+            if playback_started:
+                try:
+                    ableton.send_command("stop_playback", {})
+                except Exception:
+                    pass
             for _ in range(applied_count):
                 try:
                     ableton.send_command("undo")
                 except Exception:
                     break
 
-        # Determine preview mode: audible (M4L available) or metadata-only
-        preview_mode = "metadata_only_preview"
-        spectral_before = None
-        spectral_after = None
-
-        # Try audible preview — capture spectrum via M4L spectral cache
-        try:
-            from ..m4l_bridge import SpectralCache
-            cache = ctx.lifespan_context.get("spectral")
-            if cache and isinstance(cache, SpectralCache) and cache.is_connected:
-                spectral_before = cache.get_all()
-                # Play for the requested bar count
-                tempo = before_info.get("tempo", 120)
-                play_seconds = bars * (60.0 / tempo) * 4  # bars * beat_duration * 4 beats
-                ableton.send_command("start_playback", {})
-                import time as _time
-                _time.sleep(min(play_seconds, 8.0))  # cap at 8 seconds
-                spectral_after = cache.get_all()
-                ableton.send_command("stop_playback", {})
-                preview_mode = "audible_preview"
-        except Exception:
-            pass  # fall back to metadata_only
-
         variant.status = "rendered"
         variant.preview_mode = preview_mode
         variant.render_ref = f"render_{variant_id}_{bars}bars"

package/mcp_server/project_brain/tools.py

@@ -78,6 +78,39 @@ def build_project_brain(ctx: Context) -> dict:
         except Exception:
             pass
 
+    # 5b. Build notes_map for role inference.
+    # Shape: {section_id: {track_index: [notes]}}. Without this, role_graph
+    # falls back to "assume all tracks active in every section" which destroys
+    # section-scoped role confidence.
+    notes_map: dict[str, dict[int, list[dict]]] = {}
+    try:
+        for scene_idx, scene in enumerate(scenes or []):
+            section_id = str(
+                scene.get("section_id")
+                or scene.get("name")
+                or f"scene_{scene_idx}"
+            )
+            per_track: dict[int, list[dict]] = {}
+            for track in tracks:
+                t_idx = track.get("index", 0)
+                try:
+                    notes_resp = ableton.send_command("get_notes", {
+                        "track_index": t_idx,
+                        "clip_index": scene_idx,
+                    })
+                    if isinstance(notes_resp, dict):
+                        notes = notes_resp.get("notes", [])
+                        if notes:
+                            per_track[t_idx] = notes
+                except Exception:
+                    # Individual note fetch failing is fine — continue with others
+                    continue
+            if per_track:
+                notes_map[section_id] = per_track
+    except Exception:
+        # Overall failure: empty map, degrade to "all tracks active" fallback
+        notes_map = {}
+
     # 6. Probe capabilities (direct SpectralCache access, not TCP)
     analyzer_ok = False
     analyzer_fresh = False
@@ -103,6 +136,7 @@ def build_project_brain(ctx: Context) -> dict:
         scenes=scenes if scenes and clip_matrix else None,
         clip_matrix=clip_matrix if clip_matrix else None,
         track_infos=track_infos if track_infos else None,
+        notes_map=notes_map if notes_map else None,
         arrangement_clips=arrangement_clips if arrangement_clips else None,
         analyzer_ok=analyzer_ok,
         flucoma_ok=flucoma_ok,