livepilot 1.27.1 → 1.27.3

package/mcp_server/tools/planner.py

@@ -26,11 +26,57 @@ def _get_ableton(ctx: Context):
     return ctx.lifespan_context["ableton"]
 
 
+def _resolve_section_template(sections):
+    """Build the (SectionType, energy, density, bars) template for the planner.
+
+    Honors a caller-supplied ``sections`` list (entries shaped as
+    ``[type, energy, density, bars]`` or the dict form); otherwise falls back
+    to a generic genre-neutral arc that starts INTRO and ends OUTRO. The v1.24
+    refactor removed the built-in per-genre STYLE_TEMPLATES
+    (vocabulary-not-form) — the framework supplies only a neutral default
+    skeleton so plan_arrangement always returns a plan instead of crashing on
+    the now-mandatory section_template argument.
+    """
+    ST = comp_engine.SectionType
+    if sections:
+        template = []
+        for entry in sections:
+            if isinstance(entry, dict):
+                stype = entry.get("type") or entry.get("section_type") or "verse"
+                energy = float(entry.get("energy", entry.get("energy_target", 0.5)))
+                density = float(entry.get("density", entry.get("density_target", 0.5)))
+                bars = max(1, int(entry.get("bars", 8)))
+            else:
+                stype, energy, density, bars = entry
+                # Clamp bars>=1: a 0/negative bar count makes the engine's
+                # template_bars sum 0 -> ZeroDivisionError on scale_factor.
+                energy, density, bars = float(energy), float(density), max(1, int(bars))
+            if not isinstance(stype, ST):
+                try:
+                    stype = ST(str(stype).lower())
+                except ValueError:
+                    stype = ST.VERSE
+            template.append((stype, energy, density, bars))
+        if template:
+            return template
+    # Generic genre-neutral default arc (INTRO … OUTRO).
+    return [
+        (ST.INTRO, 0.3, 0.3, 8),
+        (ST.BUILD, 0.6, 0.6, 8),
+        (ST.DROP, 1.0, 0.9, 16),
+        (ST.BREAKDOWN, 0.5, 0.4, 8),
+        (ST.BUILD, 0.7, 0.7, 8),
+        (ST.DROP, 1.0, 1.0, 16),
+        (ST.OUTRO, 0.3, 0.2, 8),
+    ]
+
+
 @mcp.tool()
 def plan_arrangement(
     ctx: Context,
     target_bars: int = 128,
     style: str = "electronic",
+    sections: Optional[list] = None,
 ) -> dict:
     """Transform the current loop/session into a full arrangement blueprint.
 
@@ -41,14 +87,22 @@ def plan_arrangement(
     - Orchestration plan (which tracks play in which sections)
 
     target_bars: desired total arrangement length (default: 128 bars)
-    style: electronic | hiphop | pop | ambient | techno
+    style: free-text style label (e.g. "electronic", "ambient") — recorded as a
+        hint on the result. The framework no longer hardcodes genre→form
+        templates (vocabulary-not-form, v1.24); supply explicit form via
+        `sections` if desired.
+    sections: optional explicit form — a list of
+        [section_type, energy_target, density_target, bars] entries (or the
+        dict form {"type","energy","density","bars"}). When omitted a generic
+        genre-neutral arc (INTRO…OUTRO) is used so the tool always returns a
+        plan.
 
     Returns: full ArrangementPlan with actionable section-by-section instructions.
     """
-    if style not in planner_engine.VALID_STYLES:
-        return {"error": f"Unknown style '{style}'. Valid: {sorted(planner_engine.VALID_STYLES)}"}
-
     ableton = _get_ableton(ctx)
+    # Capture the caller's requested form before the local `sections` (the
+    # built section graph) shadows the parameter name below.
+    requested_sections = sections
 
     # 1. Get session info
     session = ableton.send_command("get_session_info")
@@ -85,11 +139,19 @@ def plan_arrangement(
     # 5. Analyze loop identity
     loop_identity = planner_engine.analyze_loop_identity(roles, sections)
 
-    # 6. Plan arrangement
+    # 6. Plan arrangement. The v1.24 refactor made section_template mandatory
+    # (STYLE_TEMPLATES removed); supply the caller's form or a neutral default.
+    # Malformed `sections` (wrong arity, non-numeric energy/density) would raise
+    # a raw ValueError/TypeError; convert to the file's structured-error form.
+    try:
+        section_template = _resolve_section_template(requested_sections)
+    except (ValueError, TypeError) as exc:
+        return {"error": f"Invalid sections entry: {exc}", "code": "INVALID_PARAM"}
     plan = planner_engine.plan_arrangement_from_loop(
         loop_identity,
         target_duration_bars=target_bars,
         style=style,
+        section_template=section_template,
     )
 
     # Add section-level sample role hints
@@ -97,7 +159,7 @@ def plan_arrangement(
 
     result = plan.to_dict()
     result["loop_identity"] = loop_identity.to_dict()
-    result["available_styles"] = sorted(planner_engine.VALID_STYLES)
+    result["style"] = style
     return result
 
 # ── transform_section (Round 4) ─────────────────────────────────────

package/mcp_server/tools/research.py

@@ -132,8 +132,11 @@ def get_emotional_arc(ctx: Context) -> dict:
            Use when asking "how busy is this section?"
 
         2. `get_emotional_arc.tension` (this tool)
-           → narrative-arc signal weighted by harmonic instability,
-           section placement, and payoff/contrast. Use when asking
+           → narrative-arc signal weighted by harmonic instability
+           (derived per section from key-detection confidence — low
+           confidence reads as unstable — plus a bump when the mode
+           shifts from the previous section), section placement, and
+           payoff/contrast. Use when asking
            "where does the song want to go emotionally?" — tension
            can be HIGH in a sparse-but-anticipatory section (low
            density) and LOW in a busy-but-resolved section (high
@@ -191,6 +194,21 @@ def get_emotional_arc(ctx: Context) -> dict:
                 continue
         harmony_fields.append(hf)
 
+    # Derive a real instability signal per section — cheapest honest proxy
+    # available from what the loop above already computed:
+    #   1. Key-detection confidence: low confidence (weak/ambiguous tonal
+    #      center) reads as harmonically unstable. No key detected at all
+    #      (no notes found) falls back to a neutral 0.3, matching the
+    #      tension-curve fallback below.
+    #   2. Mode change vs the previous section: a shift from e.g. major to
+    #      minor (or vice versa) is itself a destabilizing event, so it adds
+    #      a bump on top of the confidence-derived base.
+    for hf in harmony_fields:
+        hf.instability = round(max(0.0, min(1.0, 1.0 - hf.confidence)), 3) if hf.key else 0.3
+    for prev_hf, curr_hf in zip(harmony_fields, harmony_fields[1:]):
+        if prev_hf.mode and curr_hf.mode and prev_hf.mode != curr_hf.mode:
+            curr_hf.instability = round(min(1.0, curr_hf.instability + 0.15), 3)
+
     issues = engine.run_emotional_arc_critic(sections, harmony_fields)
 
     # Build tension curve for visualization

package/mcp_server/tools/theory.py

@@ -75,7 +75,7 @@ def analyze_harmony(
     """
     notes = _get_clip_notes(ctx, track_index, clip_index)
     if not notes:
-        return {"error": "No notes in clip", "suggestion": "Add notes first"}
+        return {"error": "No notes in clip", "code": "STATE_ERROR", "suggestion": "Add notes first"}
 
     key_info = _detect_or_parse_key(notes, key_hint=key)
     tonic = key_info["tonic"]
@@ -146,7 +146,7 @@ def suggest_next_chord(
     """
     notes = _get_clip_notes(ctx, track_index, clip_index)
     if not notes:
-        return {"error": "No notes in clip"}
+        return {"error": "No notes in clip", "code": "STATE_ERROR"}
 
     key_info = _detect_or_parse_key(notes, key_hint=key)
     tonic = key_info["tonic"]
@@ -154,7 +154,7 @@ def suggest_next_chord(
 
     chord_groups = engine.chordify(notes)
     if not chord_groups:
-        return {"error": "No chords detected in clip"}
+        return {"error": "No chords detected in clip", "code": "STATE_ERROR"}
 
     # Analyze last chord
     last_group = chord_groups[-1]
@@ -298,7 +298,7 @@ def detect_theory_issues(
     """
     notes = _get_clip_notes(ctx, track_index, clip_index)
     if not notes:
-        return {"error": "No notes in clip"}
+        return {"error": "No notes in clip", "code": "STATE_ERROR"}
 
     key_info = _detect_or_parse_key(notes, key_hint=key)
     tonic = key_info["tonic"]
@@ -406,7 +406,7 @@ def identify_scale(
     """
     notes = _get_clip_notes(ctx, track_index, clip_index)
     if not notes:
-        return {"error": "No notes in clip"}
+        return {"error": "No notes in clip", "code": "STATE_ERROR"}
 
     detected = engine.detect_key(notes, mode_detection=True)
 
@@ -481,7 +481,7 @@ def harmonize_melody(
     """
     notes = _get_clip_notes(ctx, track_index, clip_index)
     if not notes:
-        return {"error": "No notes in clip"}
+        return {"error": "No notes in clip", "code": "STATE_ERROR"}
 
     melody = sorted(
         [n for n in notes if not n.get("mute", False)],
@@ -655,7 +655,7 @@ def generate_countermelody(
 
     notes = _get_clip_notes(ctx, track_index, clip_index)
     if not notes:
-        return {"error": "No notes in clip"}
+        return {"error": "No notes in clip", "code": "STATE_ERROR"}
 
     melody = sorted(
         [n for n in notes if not n.get("mute", False)],
@@ -668,7 +668,7 @@ def generate_countermelody(
     # Build pool of scale pitches in range
     pool = [p for p in range(range_low, range_high + 1) if p % 12 in scale_pcs]
     if not pool:
-        return {"error": "No scale pitches in given range"}
+        return {"error": "No scale pitches in given range", "code": "STATE_ERROR"}
 
     # Consonant intervals (semitones mod 12): P1, m3, M3, P4, P5, m6, M6, P8
     consonant = {0, 3, 4, 5, 7, 8, 9}
@@ -790,14 +790,14 @@ def transpose_smart(
     """
     notes = _get_clip_notes(ctx, track_index, clip_index)
     if not notes:
-        return {"error": "No notes in clip"}
+        return {"error": "No notes in clip", "code": "STATE_ERROR"}
 
     source_key = engine.detect_key(notes)
 
     try:
         target = engine.parse_key(target_key)
     except ValueError:
-        return {"error": f"Invalid target key: {target_key}"}
+        return {"error": f"Invalid target key: {target_key}", "code": "INVALID_PARAM"}
 
     source_tonic = source_key["tonic"]
     target_tonic = target["tonic"]

package/mcp_server/tools/transport.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import asyncio
 from typing import Optional
 
 from fastmcp import Context
@@ -142,7 +143,9 @@ async def get_session_diagnostics(ctx: Context, check_clip_keys: bool = False) -
         the bridge once per audio clip and can add noticeable latency on
         large sessions.
     """
-    result = _get_ableton(ctx).send_command("get_session_diagnostics")
+    result = await asyncio.to_thread(
+        _get_ableton(ctx).send_command, "get_session_diagnostics"
+    )
 
     if not check_clip_keys:
         return result
@@ -155,7 +158,9 @@ async def get_session_diagnostics(ctx: Context, check_clip_keys: bool = False) -
     from .clips import check_clip_key_consistency  # local import to avoid cycles
 
     audio_mismatches: list[dict] = []
-    session_info = _get_ableton(ctx).send_command("get_session_info")
+    session_info = await asyncio.to_thread(
+        _get_ableton(ctx).send_command, "get_session_info"
+    )
     tracks = (session_info or {}).get("tracks", []) if isinstance(session_info, dict) else []
     for track in tracks:
         t_idx = track.get("index")

package/mcp_server/transition_engine/critics.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 
 from dataclasses import asdict, dataclass, field
 
+from .archetypes import _SECTION_PAIR_PREFERENCES
 from .models import TransitionBoundary, TransitionPlan, TransitionScore
 
 
@@ -275,7 +276,18 @@ def run_gesture_fit_critic(
     # honor it explicitly so archetypes documented as universal don't get
     # flagged as mismatched on specific pairs like intro→build.
     WILDCARDS = {"any_section_change", "any"}
-    if any(uc in WILDCARDS for uc in archetype.use_cases):
+    pair = (boundary.from_type, boundary.to_type)
+    preferred_for_pair = _SECTION_PAIR_PREFERENCES.get(pair, [])
+    if archetype.name in preferred_for_pair:
+        # The engine deliberately selects archetypes from this preference list
+        # via select_archetype(). Several preferred archetypes describe their
+        # use_cases with semantic labels (e.g. harmonic_suspend ->
+        # "chord_progression_pivot") that share no substring with section-type
+        # names, so the substring heuristic below would otherwise flag the
+        # engine's own chosen archetype as a mismatch. Treat membership in the
+        # preference map as an authoritative match.
+        use_case_match = True
+    elif any(uc in WILDCARDS for uc in archetype.use_cases):
         use_case_match = True
     else:
         pair_tags = {

package/mcp_server/user_corpus/tools.py

@@ -733,11 +733,40 @@ def corpus_trim_plugin_identity(
     research_priority  : tag value: "low" / "medium" / "skip". Default "low".
     """
     if not plugin_id:
-        return {"error": "plugin_id is required", "status": "error"}
+        return {
+            "error": "plugin_id is required",
+            "code": "INVALID_PARAM",
+            "status": "error",
+        }
+    if not re.match(r"^[a-z0-9-]+$", plugin_id):
+        return {
+            "error": (
+                f"plugin_id '{plugin_id}' contains invalid characters; "
+                "must match ^[a-z0-9-]+$"
+            ),
+            "code": "INVALID_PARAM",
+            "status": "error",
+        }
+    inventory_path = DEFAULT_OUTPUT_ROOT / "plugins" / "_inventory.json"
+    if not inventory_path.exists():
+        return {
+            "error": "No inventory; run corpus_detect_plugins first.",
+            "code": "INVALID_PARAM",
+            "status": "error",
+        }
+    inventory = json.loads(inventory_path.read_text(encoding="utf-8"))
+    known_ids = {p.get("plugin_id") for p in inventory.get("plugins", [])}
+    if plugin_id not in known_ids:
+        return {
+            "error": f"plugin_id '{plugin_id}' not in inventory.",
+            "code": "INVALID_PARAM",
+            "status": "error",
+        }
     yaml_path = DEFAULT_OUTPUT_ROOT / "plugins" / plugin_id / "identity.yaml"
     if not yaml_path.exists():
         return {
             "error": f"No identity.yaml for plugin_id '{plugin_id}'",
+            "code": "NOT_FOUND",
             "status": "error",
         }
     import yaml as _yaml

package/mcp_server/wonder_mode/engine.py

@@ -271,9 +271,12 @@ 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
+    # Compile through semantic compiler if kernel available. A variant is
+    # analytical-only when it has no compiled plan OR the compiled plan is
+    # non-executable (0 steps / requires seed_args) — LIVE#9: previously a
+    # non-executable compiled plan was mislabeled analytical_only=False.
     compiled = _compile_variant_plan(move_dict, kernel)
-    analytical = compiled is None
+    analytical = compiled is None or not compiled.get("executable", False)
 
     return {
         "variant_id": variant_id,
@@ -597,6 +600,56 @@ def _get_corpus_hints(request_text: str, diagnosis: dict | None) -> dict | None:
 # ── Pipeline orchestrator ────────────────────────────────────────
 
 
+def _pick_recommended(ranked: list[dict]) -> str:
+    """Pick the recommended variant_id from a ranked list.
+
+    Prefer the highest-ranked EXECUTABLE variant (analytical_only is False) so
+    callers that auto-apply `recommended` never get handed a non-executable /
+    analytical-only shell when a real move exists (P2-30 / LIVE#9). Falls back
+    to the top-ranked variant when none are executable.
+    """
+    if not ranked:
+        return ""
+    for v in ranked:
+        if not v.get("analytical_only", False):
+            return v["variant_id"]
+    return ranked[0]["variant_id"]
+
+
+def _pick_boldest_executable(ranked: list[dict]) -> Optional[dict]:
+    """Pick the highest-novelty EXECUTABLE variant as a second recommendation.
+
+    `_pick_recommended` deliberately biases toward the top-ranked variant,
+    which is itself weighted toward taste/identity/coherence fit (see
+    `_select_weights`) — by construction the "recommended" slot is rarely
+    the boldest option, even for a request that explicitly asked to be
+    surprised (novelty only gets a minority weight in every weight
+    profile). This surfaces the boldest EXECUTABLE alternative alongside
+    it so a "surprise me" caller isn't structurally steered away from
+    genuine novelty. Analytical-only shells are excluded (nothing to run).
+    Ties on novelty_level are broken by rank (prefer the better-ranked of
+    equally-novel variants). Returns None when no executable variant exists
+    (e.g. an all-analytical cold-start set).
+    """
+    executable = [v for v in ranked if not v.get("analytical_only", False)]
+    if not executable:
+        return None
+    boldest = max(
+        executable,
+        key=lambda v: (v.get("novelty_level", 0.0), -v.get("rank", 10 ** 9)),
+    )
+    novelty = boldest.get("novelty_level", 0.0)
+    return {
+        "variant_id": boldest.get("variant_id", ""),
+        "why": (
+            f"Highest-novelty executable alternative (novelty {novelty:.2f}) "
+            f"— the top recommendation favors taste/identity fit over "
+            f"novelty by design, so this is the boldest option that can "
+            f"actually be run."
+        ),
+    }
+
+
 def generate_wonder_variants(
     request_text: str,
     diagnosis: dict | None = None,
@@ -651,7 +704,10 @@ def generate_wonder_variants(
             v["corpus_hints"] = corpus_hints
         variants.append(v)
 
-    executable_count = len(variants)
+    # move_based_count = how many real moves matched (pre-padding). Drives the
+    # padding gate AND variant_count_actual (move-match semantics callers/tests
+    # depend on). Executability is a SEPARATE axis computed after ranking.
+    move_based_count = len(variants)
 
     # v1.18.2 #10 fix: when NO executable moves matched, seed from the
     # cold-start distinct-starting-points set instead of padding with
@@ -663,7 +719,7 @@ def generate_wonder_variants(
     # the generic analytical fallback because we don't want to mix real
     # move-based variants with architecture-first seeds — that would
     # confuse the presentation.
-    if executable_count == 0:
+    if move_based_count == 0:
         while len(variants) < 3:
             idx = len(variants)
             seed = _COLD_START_SEEDS[idx]
@@ -698,8 +754,13 @@ def generate_wonder_variants(
         taste_evidence=taste_evidence,
     )
 
+    # LIVE#9 / P2-30: degraded_reason must reflect ACTUAL executability, not the
+    # move-match count. A move-based variant whose compiled plan is
+    # non-executable (0 steps / requires seed_args) is analytical_only=True and
+    # must NOT be presented as a full match.
+    real_executable = sum(1 for v in ranked if not v.get("analytical_only", False))
     degraded_reason = ""
-    if executable_count == 0:
+    if move_based_count == 0:
         # v1.18.2 #10: cold-start path — distinct starting-point seeds
         # rather than identical-generic padding.
         degraded_reason = (
@@ -707,18 +768,30 @@ def generate_wonder_variants(
             "from distinct starting-point families (device_creation × 2 "
             "+ mix-architecture-first)"
         )
-    elif executable_count == 1:
-        degraded_reason = "Only 1 distinct executable move found"
+    elif real_executable < 3:
+        # Partial/degraded: fewer than 3 variants are actually executable; the
+        # remainder are analytical/non-executable fallbacks. Surface it so a
+        # degraded set is not presented as a full match.
+        fallback_count = 3 - real_executable
+        degraded_reason = (
+            f"Only {real_executable} of 3 variants are executable; the "
+            f"remaining {fallback_count} are analytical/non-executable fallbacks"
+        )
 
     return {
         "mode": "wonder",
         "request": request_text,
         "variants": ranked,
-        "recommended": ranked[0]["variant_id"] if ranked else "",
+        "recommended": _pick_recommended(ranked),
+        # Additive second slot (does not change `recommended`'s semantics):
+        # the highest-novelty EXECUTABLE variant, surfaced alongside the
+        # safe/taste-weighted recommendation. See _pick_boldest_executable.
+        "boldest_executable": _pick_boldest_executable(ranked),
         "taste_evidence": taste_evidence,
         "identity_confidence": song_brain.get("identity_confidence", 0.0),
         "move_count_matched": len(moves),
-        "variant_count_actual": executable_count,
+        "variant_count_actual": move_based_count,
+        "executable_count": real_executable,
         "degraded_reason": degraded_reason,
     }
 

package/mcp_server/wonder_mode/session.py

@@ -9,6 +9,7 @@ SongBrain, action ledger, and creative threads.
 
 from __future__ import annotations
 
+import threading
 from dataclasses import asdict, dataclass, field
 from typing import Optional
 
@@ -63,6 +64,13 @@ class WonderSession:
 
     status: str = "diagnosing"  # diagnosing, variants_ready, previewing, resolved
 
+    # Session-identity guard — see preview_studio.models.compute_session_fingerprint.
+    # Stamped at enter_wonder_mode time from the session_info already fetched
+    # for diagnosis; carried onto any PreviewSet built from this session's
+    # variants so a later commit can detect a stale topology. Empty string
+    # means "no signal" (older sessions, or built without a live session).
+    session_fingerprint: str = ""
+
     # Valid state transitions
     _VALID_TRANSITIONS: dict = field(default_factory=lambda: {
         "diagnosing": {"variants_ready"},
@@ -87,28 +95,42 @@ class WonderSession:
 
 
 # ── In-memory store ───────────────────────────────────────────────
+#
+# _wonder_sessions is mutated from both threadpooled sync tools
+# (enter_wonder_mode) and event-loop async tools (commit_preview_variant,
+# via _find_wonder_session_by_preview) — without a lock, two concurrent
+# store_wonder_session calls can race in the check-then-evict loop below:
+# both read the same `oldest_key`, both pop it, and a naive `del` on the
+# second call raises KeyError. One module-level lock around the
+# get/store/find critical sections closes that race.
 
 _wonder_sessions: dict[str, WonderSession] = {}
+_wonder_sessions_lock = threading.Lock()
 
 
 def store_wonder_session(ws: WonderSession) -> None:
     """Store a WonderSession with FIFO eviction at capacity."""
-    _wonder_sessions[ws.session_id] = ws
-    while len(_wonder_sessions) > _MAX_WONDER_SESSIONS:
-        oldest_key = next(iter(_wonder_sessions))
-        evicted = _wonder_sessions.pop(oldest_key)
-        if evicted.outcome == "pending":
-            evicted.outcome = "abandoned"
+    with _wonder_sessions_lock:
+        _wonder_sessions[ws.session_id] = ws
+        while len(_wonder_sessions) > _MAX_WONDER_SESSIONS:
+            oldest_key = next(iter(_wonder_sessions), None)
+            if oldest_key is None:
+                break
+            evicted = _wonder_sessions.pop(oldest_key, None)
+            if evicted is not None and evicted.outcome == "pending":
+                evicted.outcome = "abandoned"
 
 
 def get_wonder_session(session_id: str) -> Optional[WonderSession]:
     """Retrieve a WonderSession by ID."""
-    return _wonder_sessions.get(session_id)
+    with _wonder_sessions_lock:
+        return _wonder_sessions.get(session_id)
 
 
 def find_session_by_preview_set(set_id: str) -> Optional[WonderSession]:
     """Find a WonderSession linked to a preview set ID."""
-    for ws in _wonder_sessions.values():
-        if ws.preview_set_id == set_id:
-            return ws
+    with _wonder_sessions_lock:
+        for ws in _wonder_sessions.values():
+            if ws.preview_set_id == set_id:
+                return ws
     return None

package/mcp_server/wonder_mode/tools.py

@@ -12,6 +12,7 @@ import logging
 from fastmcp import Context
 
 from ..server import mcp
+from ..preview_studio.models import compute_session_fingerprint
 from . import engine
 
 logger = logging.getLogger(__name__)
@@ -375,6 +376,11 @@ def enter_wonder_mode(
         variant_count_actual=result.get("variant_count_actual", 0),
         degraded_reason=result.get("degraded_reason", ""),
         status="diagnosing",  # will transition below
+        # Stamped from the session_info already fetched above for diagnosis —
+        # no extra round-trip. Lets a later commit_preview_variant detect
+        # that the session's track topology changed since these variants'
+        # compiled_plan indices were built.
+        session_fingerprint=compute_session_fingerprint(session_info),
     )
     ws.transition_to("variants_ready")
 
@@ -456,7 +462,14 @@ def rank_wonder_variants(
 
     return {
         "rankings": ranked,
-        "recommended": ranked[0]["variant_id"] if ranked else "",
+        # Prefer the highest-ranked EXECUTABLE variant (P2-30/LIVE#9) — the same
+        # rule as generate_wonder_variants; ranked[0] alone could hand back a
+        # non-executable/analytical-only shell.
+        "recommended": engine._pick_recommended(ranked),
+        # Additive second slot: the highest-novelty EXECUTABLE variant, for
+        # callers who invoked Wonder Mode wanting genuine surprise rather
+        # than the safest taste-weighted pick.
+        "boldest_executable": engine._pick_boldest_executable(ranked),
     }
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.27.1",
+  "version": "1.27.3",
   "mcpName": "io.github.dreamrec/livepilot",
   "description": "Agentic production system for Ableton Live 12 — 467 tools, 56 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",