livepilot 1.10.6 → 1.10.8

package/mcp_server/m4l_bridge.py

@@ -278,26 +278,68 @@ class SpectralReceiver(asyncio.DatagramProtocol):
             self._handle_chunk(int(args[0]), int(args[1]), str(args[2]))
 
     def _handle_response(self, encoded: str) -> None:
-        """Decode a single-packet base64 response."""
+        """Decode a single-packet base64 response.
+
+        Resolves _response_callback exactly once, then clears it. Without the
+        clear, a second late packet could overwrite a future belonging to a
+        different in-flight command. The protocol has no request id yet
+        (livepilot_bridge.js:666 emits bare /response), so correlation relies
+        on the single-command-in-flight invariant enforced by M4LBridge._cmd_lock
+        plus this one-shot clear.
+        """
         try:
             # URL-safe base64 decode (- and _ instead of + and /)
             padded = encoded + "=" * (-len(encoded) % 4)
             decoded = base64.urlsafe_b64decode(padded).decode('utf-8')
             result = _normalize_bridge_payload(json.loads(decoded))
-            if self._response_callback and not self._response_callback.done():
-                self._response_callback.set_result(result)
+            cb = self._response_callback
+            if cb and not cb.done():
+                cb.set_result(result)
+            # Clear regardless — either we consumed it, or it was already
+            # done/abandoned. Future packets with no owner get dropped.
+            self._response_callback = None
         except Exception as exc:
             import sys
             print(f"LivePilot: failed to decode bridge response: {exc}", file=sys.stderr)
 
     def _handle_chunk(self, index: int, total: int, encoded: str) -> None:
-        """Reassemble chunked responses."""
+        """Reassemble chunked responses.
+
+        The previous implementation incremented ``_chunk_id`` only when
+        ``index == 0`` and assumed the first chunk always arrived first.
+        Under UDP reordering (rare on loopback but possible under system
+        load), a chunk with ``index > 0`` arriving before ``index 0`` would
+        be dropped into the PREVIOUS sequence's bucket — silently corrupting
+        that earlier response's payload.
+
+        Until the wire protocol adds an explicit sequence id, the safer
+        behavior is: if we see an out-of-order first-chunk (``index > 0``
+        with no open bucket), start a fresh bucket but log a warning. That
+        way we never poison a prior sequence, and the problem surfaces in
+        logs if it happens.
+        """
         if index == 0:
             self._chunk_id += 1
-        key = str(self._chunk_id)
-        if key not in self._chunks:
+            key = str(self._chunk_id)
             self._chunks[key] = {"parts": {}, "total": total}
             self._chunk_times[key] = time.monotonic()
+        else:
+            key = str(self._chunk_id)
+            if key not in self._chunks:
+                # Out-of-order arrival. Start a new bucket rather than append
+                # to the previous sequence's parts — that's the corruption
+                # path. Log once so it's diagnosable.
+                import sys
+                print(
+                    f"LivePilot: chunk index={index}/{total} arrived before "
+                    f"index=0 — starting fresh bucket. UDP reordering on "
+                    f"loopback suggests system load.",
+                    file=sys.stderr,
+                )
+                self._chunk_id += 1
+                key = str(self._chunk_id)
+                self._chunks[key] = {"parts": {}, "total": total}
+                self._chunk_times[key] = time.monotonic()
 
         self._chunks[key]["parts"][index] = encoded
 
@@ -357,14 +399,26 @@ class M4LBridge:
         if not self.cache.is_connected:
             return {"error": "LivePilot Analyzer not connected. Drop it on the master track."}
 
+        # Fail fast if there is no receiver to correlate the response. The
+        # previous version sent the OSC packet anyway, dropped the reply
+        # inside _handle_response (no future registered), and waited out
+        # the full 5s timeout before returning a misleading "device may be
+        # busy or removed" error. The real cause was "no receiver wired",
+        # which the caller should see immediately.
+        if self.receiver is None:
+            return {
+                "error": "M4L bridge has no active receiver — the UDP 9880 "
+                         "listener did not start. Check server startup logs "
+                         "for a bind failure on port 9880."
+            }
+
         if self._cmd_lock is None:
             self._cmd_lock = asyncio.Lock()
         async with self._cmd_lock:
             # Create a future for the response
             loop = asyncio.get_running_loop()
             future = loop.create_future()
-            if self.receiver:
-                self.receiver.set_response_future(future)
+            self.receiver.set_response_future(future)
 
             # Build and send OSC message (no leading / — Max udpreceive
             # passes messagename with / intact to JS, breaking dispatch)
@@ -376,11 +430,13 @@ class M4LBridge:
                 result = await asyncio.wait_for(future, timeout=timeout)
                 return result
             except asyncio.TimeoutError:
-                # Clear the stale future so a delayed response doesn't resolve
-                # a future that no caller is waiting on
-                if self.receiver:
-                    self.receiver.set_response_future(None)
                 return {"error": "M4L bridge timeout — device may be busy or removed"}
+            finally:
+                # Always clear the future — on success the receiver has already
+                # cleared it inside _handle_response, but calling again is a
+                # no-op. On timeout this is what prevents a delayed packet from
+                # resolving a future belonging to the next command.
+                self.receiver.set_response_future(None)
 
     async def send_capture(self, command: str, *args: Any, timeout: float = 35.0) -> dict:
         """Send a capture command to the M4L device and wait for /capture_complete."""

package/mcp_server/musical_intelligence/detectors.py

@@ -208,11 +208,43 @@ def detect_role_conflicts(
                   "Layer drum parts into one Drum Rack or pan them apart"),
     }
 
+    # BUG-B1 fix: intentional drum + percussion layering is the core
+    # aesthetic in hip-hop / Dilla / lo-fi / beat-scene music, not a
+    # conflict. Heuristic to demote drum-role conflicts when the track
+    # names make that layering obvious (one "DRUMS" + one "PERC/CONGA/
+    # SHAKER" is distinct instruments, not a fight for the same role).
+    _PERC_NAMES = {
+        "perc", "percussion", "conga", "congas", "shaker",
+        "tambourine", "cowbell", "triangle", "bongo",
+        "djembe", "claves", "hi-hat", "hihat", "hat",
+    }
+
+    def _looks_like_layering(group: list[dict]) -> bool:
+        """True if at least one of the tracks has a percussion-specific
+        name (distinct from the main drum kit)."""
+        if len(group) < 2:
+            return False
+        perc_track_count = 0
+        for track in group:
+            name = str(track.get("name", "")).lower()
+            if any(tok in name for tok in _PERC_NAMES):
+                perc_track_count += 1
+        # Needs at least one main "drums" track AND one perc track
+        return 1 <= perc_track_count < len(group)
+
     conflicts = []
     for role, (desc, rec) in UNIQUE_ROLES.items():
         group = role_groups.get(role, [])
         if len(group) > 1:
             severity = min(0.9, 0.3 + (len(group) - 1) * 0.2)
+            if role == "drums" and _looks_like_layering(group):
+                # Demote severity — this looks intentional, not a conflict
+                severity = max(0.1, severity - 0.4)
+                rec = (
+                    "Drum + percussion layering detected — if this is "
+                    "intentional (hip-hop / Dilla / lo-fi), ignore. "
+                    "Otherwise: " + rec
+                )
             conflicts.append(RoleConflict(
                 role=role,
                 tracks=group,

package/mcp_server/performance_engine/tools.py

@@ -21,34 +21,59 @@ logger = logging.getLogger(__name__)
 # ── Helpers ─────────────────────────────────────────────────────────
 
 
-def _infer_role(name: str, index: int, scene_count: int) -> str:
-    """Infer a scene's role from its name or position."""
-    lower = name.lower()
-    for role in ("intro", "verse", "chorus", "build", "drop", "breakdown", "outro", "transition"):
-        if role in lower:
-            return role
-    # Positional fallback
+# BUG-E4 / E5 fix: performance_engine used to have its own _infer_role() keyword
+# list and _infer_energy() static {role → number} table. Those diverged from
+# _composition_engine's richer section classifier, which caused
+# get_performance_state and analyze_composition to label the same scenes
+# differently (Deep Flow: drop vs verse, Sun Peak: drop vs chorus) and to
+# report dissimilar energies (composition derived from active-track density,
+# performance looked up a hard-coded 0.2/0.4/0.7 table). Now performance
+# consumes composition's section graph as the source of truth and only keeps
+# a positional fallback for scenes without enough data.
+_POSITIONAL_FALLBACK_ROLES = {
+    "first": "intro",
+    "last": "outro",
+    "early": "intro",
+    "middle_low": "verse",
+    "middle_high": "chorus",
+    "late": "outro",
+    "default": "verse",
+}
+
+
+def _positional_fallback_role(index: int, scene_count: int) -> str:
+    """Map a scene index to a role when no composition data is available.
+
+    Kept only as a last-resort so we still produce a sensible answer for
+    unnamed scenes or when build_section_graph_from_scenes returns empty.
+    Callers should prefer the composition-engine result when it exists.
+    """
+    if scene_count <= 0:
+        return _POSITIONAL_FALLBACK_ROLES["default"]
     if index == 0:
-        return "intro"
+        return _POSITIONAL_FALLBACK_ROLES["first"]
     if index == scene_count - 1:
-        return "outro"
+        return _POSITIONAL_FALLBACK_ROLES["last"]
     if scene_count > 4:
-        quarter = scene_count / 4
+        quarter = scene_count / 4.0
         if index < quarter:
-            return "intro"
-        elif index < quarter * 2:
-            return "verse"
-        elif index < quarter * 3:
-            return "chorus"
-        else:
-            return "outro"
-    return "verse"
+            return _POSITIONAL_FALLBACK_ROLES["early"]
+        if index < quarter * 2:
+            return _POSITIONAL_FALLBACK_ROLES["middle_low"]
+        if index < quarter * 3:
+            return _POSITIONAL_FALLBACK_ROLES["middle_high"]
+        return _POSITIONAL_FALLBACK_ROLES["late"]
+    return _POSITIONAL_FALLBACK_ROLES["default"]
+
 
+def _positional_fallback_energy(role: str) -> float:
+    """Static energy map used only when density is unavailable.
 
-def _infer_energy(role: str) -> float:
-    """Infer energy level from scene role."""
-    energy_map = {
-        "intro": 0.2,
+    Kept tiny and explicit so the fallback path is obvious — the primary
+    source of energy is _composition_engine's density-based value.
+    """
+    return {
+        "intro": 0.3,
         "verse": 0.4,
         "build": 0.6,
         "chorus": 0.7,
@@ -56,23 +81,82 @@ def _infer_energy(role: str) -> float:
         "breakdown": 0.3,
         "transition": 0.5,
         "outro": 0.2,
-    }
-    return energy_map.get(role, 0.5)
+    }.get(role, 0.5)
 
 
 def _fetch_scene_data(ctx: Context) -> tuple[list[SceneRole], int]:
-    """Fetch scene info from Ableton and build SceneRole list."""
+    """Fetch scene info + composition graph from Ableton and build SceneRole list.
+
+    BUG-E4 / E5 fix: roles + energies now flow from composition_engine's
+    build_section_graph_from_scenes, which uses keyword matching + active-
+    track density for energy. Unnamed scenes fall back to the positional
+    heuristic. This keeps get_performance_state in sync with
+    get_section_graph / analyze_composition.
+    """
+    from ..tools._composition_engine import (
+        build_section_graph_from_scenes,
+        SectionNode as CESectionNode,
+    )
+
     ableton = ctx.lifespan_context["ableton"]
 
     scenes_info = ableton.send_command("get_scenes_info", {})
     scenes_list = scenes_info.get("scenes", [])
     scene_count = len(scenes_list)
 
+    # Pull session topology + clip matrix so composition engine can compute
+    # active-track density. If any of these fails we fall back to the
+    # positional heuristic — preserving the old behavior as a safety net.
+    track_count = 0
+    clip_matrix: list[list[dict]] = []
+    try:
+        session_info = ableton.send_command("get_session_info", {})
+        track_count = int(session_info.get("track_count", 0))
+    except Exception as exc:
+        logger.debug("_fetch_scene_data session_info failed: %s", exc)
+    try:
+        mtx = ableton.send_command("get_scene_matrix", {})
+        if isinstance(mtx, dict):
+            clip_matrix = mtx.get("matrix", []) or []
+    except Exception as exc:
+        logger.debug("_fetch_scene_data scene_matrix failed: %s", exc)
+
+    # Build the composition section graph. Each SectionNode has
+    # section_id = f"sec_{raw_enumerate_index:02d}" per BUG-E1 fix, so we
+    # can index by scene position directly.
+    ce_sections: list[CESectionNode] = []
+    try:
+        if scenes_list and clip_matrix and track_count > 0:
+            ce_sections = build_section_graph_from_scenes(
+                scenes_list, clip_matrix, track_count,
+            )
+    except Exception as exc:
+        logger.debug("_fetch_scene_data section graph failed: %s", exc)
+
+    ce_by_scene_idx: dict[int, CESectionNode] = {}
+    for sec in ce_sections:
+        # section_id format "sec_02" → scene index 2 (raw enumerate index)
+        sid = str(sec.section_id)
+        if sid.startswith("sec_"):
+            try:
+                ce_by_scene_idx[int(sid[4:])] = sec
+            except ValueError:
+                pass
+
     scene_roles: list[SceneRole] = []
     for i, scene_data in enumerate(scenes_list):
         name = scene_data.get("name", f"Scene {i}")
-        role = _infer_role(name, i, scene_count)
-        energy = _infer_energy(role)
+        ce_sec = ce_by_scene_idx.get(i)
+        if ce_sec is not None:
+            # SectionType is an enum; .value gives the string vocabulary
+            stype = ce_sec.section_type
+            role = stype.value if hasattr(stype, "value") else str(stype)
+            energy = float(ce_sec.energy)
+        else:
+            # Unnamed scene or build failed — positional fallback
+            role = _positional_fallback_role(i, scene_count)
+            energy = _positional_fallback_energy(role)
+
         scene_roles.append(SceneRole(
             scene_index=i,
             name=name,
@@ -85,14 +169,13 @@ def _fetch_scene_data(ctx: Context) -> tuple[list[SceneRole], int]:
     current_scene = 0
     try:
         session_info = ableton.send_command("get_session_info", {})
-        # Check if any scene is marked as triggered/playing
         session_scenes = session_info.get("scenes", [])
         for i, s in enumerate(session_scenes):
             if s.get("is_triggered", False):
                 current_scene = i
                 break
     except Exception as exc:
-        logger.debug("_fetch_scene_data failed: %s", exc)
+        logger.debug("_fetch_scene_data current_scene failed: %s", exc)
 
     return scene_roles, current_scene
 

package/mcp_server/preview_studio/engine.py

@@ -42,11 +42,17 @@ def create_preview_set(
     available_moves: Optional[list[dict]] = None,
     song_brain: Optional[dict] = None,
     taste_graph: Optional[dict] = None,
+    kernel: Optional[dict] = None,
 ) -> PreviewSet:
     """Create a preview set with variant slots.
 
     For creative_triptych, generates 3 variants: safe, strong, unexpected.
     Each variant gets a move_id from available_moves ranked by novelty.
+
+    kernel: the live session kernel (track topology + device chains). Compilers
+        resolve targets from it — without it, variants degrade into no-ops or
+        generic reads. Callers that have a `ctx` should fetch a real kernel
+        via runtime.tools.get_session_kernel(ctx).
     """
     set_id = _compute_set_id(request_text, kernel_id)
     now = int(time.time() * 1000)
@@ -56,11 +62,15 @@ def create_preview_set(
     taste_graph = taste_graph or {}
 
     if strategy == "creative_triptych":
-        variants = _build_triptych(request_text, moves, song_brain, taste_graph, set_id, now)
+        variants = _build_triptych(
+            request_text, moves, song_brain, taste_graph, set_id, now, kernel,
+        )
     elif strategy == "binary":
         variants = _build_binary(request_text, moves, song_brain, set_id, now)
     else:
-        variants = _build_triptych(request_text, moves, song_brain, taste_graph, set_id, now)
+        variants = _build_triptych(
+            request_text, moves, song_brain, taste_graph, set_id, now, kernel,
+        )
 
     ps = PreviewSet(
         set_id=set_id,
@@ -81,6 +91,7 @@ def _build_triptych(
     taste_graph: dict,
     set_id: str,
     now: int,
+    kernel: Optional[dict] = None,
 ) -> list[PreviewVariant]:
     """Build safe / strong / unexpected variants."""
     identity = song_brain.get("identity_core", "")
@@ -114,20 +125,34 @@ def _build_triptych(
         },
     ]
 
+    # Normalize kernel for the compiler. If the caller supplied a real kernel
+    # use it; otherwise fall back to an empty-but-valid shape so compilers
+    # degrade to no-op steps and emit warnings instead of crashing.
+    compile_kernel = kernel if kernel else {
+        "session_info": {"tempo": 120, "tracks": []},
+        "mode": "improve",
+    }
+
     variants = []
     for i, profile in enumerate(profiles):
         # Pick a move if available
         move_id = ""
         compiled_plan = None
-        if moves and i < len(moves):
-            move_id = moves[i].get("move_id", "")
+        move = moves[i] if moves and i < len(moves) else None
+        if move is not None:
+            move_id = move.get("move_id", "")
             # 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)
+            compiled_plan = _compile_variant_plan(move, compile_kernel)
             # No fallback to plan_template — uncompilable moves stay analytical
 
-        variants.append(PreviewVariant(
+        # BUG-B44 / B45: populate user-facing description fields and flag
+        # variants that lack a compiled_plan as not-executable (so callers
+        # don't commit shells).
+        description = _describe_variant(move, compiled_plan, profile)
+        executable = compiled_plan is not None and bool(move_id)
+
+        variant = PreviewVariant(
             variant_id=f"{set_id}_{profile['label']}",
             label=profile["label"],
             intent=profile["intent"],
@@ -139,11 +164,67 @@ def _build_triptych(
             compiled_plan=compiled_plan,
             taste_fit=_estimate_taste_fit(profile["novelty"], taste_graph),
             created_at_ms=now,
-        ))
+            what_changed=description["what_changed"],
+            summary=description["summary"],
+        )
+        # Non-executable variants get status='blocked' so callers know to
+        # skip preview/commit. Stored as status since executable/blocked_reason
+        # aren't modeled yet.
+        if not executable:
+            variant.status = "blocked"
+        variants.append(variant)
 
     return variants
 
 
+def _describe_variant(
+    move: Optional[dict],
+    compiled_plan: Optional[dict],
+    profile: dict,
+) -> dict:
+    """Build user-facing description fields for a variant (BUG-B45).
+
+    Priority order:
+      1. Move's `intent` or `description` — the authored one-liner
+      2. Compiled plan's step descriptions joined with " → "
+      3. The profile label + novelty level as a last-resort fallback
+
+    Returns {"what_changed": str, "summary": str}.
+    """
+    what_changed = ""
+    summary = ""
+    if move:
+        # Move-level narrative beats plan-level — captures intent, not execution
+        move_intent = str(move.get("intent") or move.get("description") or "")
+        if move_intent:
+            what_changed = move_intent
+            summary = move_intent[:120]
+
+    if not what_changed and compiled_plan:
+        steps = compiled_plan.get("steps") or []
+        step_descriptions = [
+            str(s.get("description") or s.get("summary") or s.get("intent") or "")
+            for s in steps
+        ]
+        step_descriptions = [d for d in step_descriptions if d]
+        if step_descriptions:
+            what_changed = " → ".join(step_descriptions[:4])
+            summary = (
+                step_descriptions[0][:120]
+                if step_descriptions else ""
+            )
+
+    if not what_changed:
+        # Final fallback — describe the profile so the UI has something
+        what_changed = (
+            f"{profile['label'].title()} variant at novelty "
+            f"{profile['novelty']:.1f} (no executable plan available)"
+        )
+        summary = what_changed
+
+    return {"what_changed": what_changed, "summary": summary}
+
+
 def _build_binary(
     request_text: str,
     moves: list[dict],

package/mcp_server/preview_studio/tools.py

@@ -182,6 +182,16 @@ def create_preview_set(
     except Exception as exc:
         logger.debug("create_preview_set failed: %s", exc)
 
+    # Fetch a real session kernel so compilers resolve targets from the live
+    # set instead of an empty placeholder. Degrades gracefully when Ableton
+    # is unreachable (unit tests, no-connection environments).
+    live_kernel: dict = {}
+    try:
+        from ..runtime.tools import get_session_kernel
+        live_kernel = get_session_kernel(ctx, request_text=request_text) or {}
+    except Exception as exc:
+        logger.debug("create_preview_set: could not fetch session kernel: %s", exc)
+
     ps = engine.create_preview_set(
         request_text=request_text,
         kernel_id=kernel_id,
@@ -189,6 +199,7 @@ def create_preview_set(
         available_moves=available_moves,
         song_brain=song_brain,
         taste_graph=taste_graph,
+        kernel=live_kernel,
     )
 
     return ps.to_dict()
@@ -436,7 +447,12 @@ async 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_async
+        from ..runtime.execution_router import execute_plan_steps_async, filter_apply_steps
+
+        # Read-only verification steps (meters/spectrum/info) don't create undo
+        # points in Ableton — counting them and then undoing walks back earlier
+        # user edits. Separate writes from reads before the apply pass.
+        apply_steps = filter_apply_steps(steps)
 
         applied_count = 0
         playback_started = False
@@ -453,16 +469,16 @@ async def render_preview_variant(
             # ── 1. Capture BEFORE metadata ──
             before_info = ableton.send_command("get_session_info", {}) or {}
 
-            # ── 2. Apply the variant ──
+            # ── 2. Apply the variant (write steps only) ──
             exec_results = await execute_plan_steps_async(
-                steps,
+                apply_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:
+            if applied_count == 0 and apply_steps:
                 return {
                     "error": "Variant failed to apply any steps",
                     "variant_id": variant_id,
@@ -489,9 +505,9 @@ async def render_preview_variant(
                     ableton.send_command("start_playback", {})
                     playback_started = True
 
-                    import time as _time
+                    import asyncio as _asyncio
 
-                    _time.sleep(play_seconds)
+                    await _asyncio.sleep(play_seconds)
 
                     spectral_after = cache.get_all()