livepilot 1.10.5 → 1.10.7

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

@@ -15,6 +15,9 @@ from fastmcp import Context
 
 from ..server import mcp
 from . import engine
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 def _get_ableton(ctx: Context):
@@ -39,10 +42,9 @@ def _find_wonder_session_by_preview(set_id: str):
     try:
         from ..wonder_mode.session import find_session_by_preview_set
         return find_session_by_preview_set(set_id)
-    except Exception:
+    except Exception as exc:
+        logger.debug("_find_wonder_session_by_preview failed: %s", exc)
         return None
-
-
 @mcp.tool()
 def create_preview_set(
     ctx: Context,
@@ -148,8 +150,8 @@ def create_preview_set(
         # Fallback: if no keyword match, take top 3 from full registry
         if not available_moves:
             available_moves = registry.list_moves()[:3]
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("create_preview_set failed: %s", exc)
 
     # Get song brain if available
     song_brain: dict = {}
@@ -177,8 +179,18 @@ def create_preview_set(
             persistent_store=persistent,
         )
         taste_graph = graph.to_dict()
-    except Exception:
-        pass
+    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,
@@ -187,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()
@@ -345,8 +358,8 @@ async def commit_preview_variant(
             )
             if ws.creative_thread_id:
                 resolve_thread(ws.creative_thread_id)
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("commit_preview_variant failed: %s", exc)
 
         # Update taste graph (with persistent backing)
         try:
@@ -373,8 +386,8 @@ async def commit_preview_variant(
                     family=family,
                     kept=True,
                 )
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("commit_preview_variant failed: %s", exc)
 
         result["wonder_session_id"] = ws.session_id
 
@@ -434,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
@@ -451,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,
@@ -487,8 +505,9 @@ async def render_preview_variant(
                     ableton.send_command("start_playback", {})
                     playback_started = True
 
-                    import time as _time
-                    _time.sleep(play_seconds)
+                    import asyncio as _asyncio
+
+                    await _asyncio.sleep(play_seconds)
 
                     spectral_after = cache.get_all()
 
@@ -496,7 +515,8 @@ async def render_preview_variant(
                     playback_started = False
 
                     preview_mode = "audible_preview"
-            except Exception:
+            except Exception as exc:
+                logger.debug("render_preview_variant failed: %s", exc)
                 # Spectral capture is best-effort; keep preview_mode as metadata_only
                 pass
 
@@ -507,12 +527,14 @@ async def render_preview_variant(
             if playback_started:
                 try:
                     ableton.send_command("stop_playback", {})
-                except Exception:
-                    pass
+                except Exception as exc:
+                    logger.debug("render_preview_variant failed: %s", exc)
+
             for _ in range(applied_count):
                 try:
                     ableton.send_command("undo")
-                except Exception:
+                except Exception as exc:
+                    logger.debug("render_preview_variant failed: %s", exc)
                     break
 
         variant.status = "rendered"

package/mcp_server/project_brain/automation_graph.py

@@ -11,8 +11,10 @@ from .models import AutomationGraph
 def build_automation_graph(
     track_infos: list[dict],
     sections: list[dict] | None = None,
+    clip_automation: list[dict] | None = None,
 ) -> AutomationGraph:
-    """Build an AutomationGraph by scanning track device info for automation.
+    """Build an AutomationGraph covering both device-parameter automation
+    hints and real clip envelopes (BUG-E2).
 
     Args:
         track_infos: list of per-track info dicts.  Each may contain:
@@ -20,18 +22,52 @@ def build_automation_graph(
             - name: track name
             - devices: [{name, class_name, parameters: [{name, value, is_automated, ...}]}]
         sections: optional list of section dicts (for density_by_section).
+        clip_automation: optional list of per-clip envelope descriptors:
+            [{section_id, track_index, track_name, clip_index,
+              parameter_name, parameter_type, device_name}].
+            This is the ground truth — `device.parameters[i].is_automated`
+            only reflects mapping state, not the presence of an envelope.
 
     Returns:
         AutomationGraph with automated_params and density_by_section.
     """
     graph = AutomationGraph()
 
-    if not track_infos:
+    if not track_infos and not clip_automation:
         return graph
 
-    automated_params = []
+    automated_params: list[dict] = []
+    # Track which (track_index, device_name, param_name) we've already seen
+    # so device-hint entries don't duplicate clip-envelope entries.
+    seen: set[tuple[int, str, str]] = set()
 
-    for track in track_infos:
+    # 1) Seed with real clip envelopes. These are the source of truth.
+    per_section_counts: dict[str, int] = {}
+    for env in clip_automation or []:
+        t_idx = int(env.get("track_index", 0))
+        dev = str(env.get("device_name") or env.get("parameter_type") or "")
+        name = str(env.get("parameter_name") or "")
+        key = (t_idx, dev, name)
+        if key in seen:
+            continue
+        seen.add(key)
+        automated_params.append({
+            "track_index": t_idx,
+            "track_name": env.get("track_name", ""),
+            "device_name": dev or None,
+            "param_name": name,
+            "parameter_type": env.get("parameter_type", ""),
+            "clip_index": env.get("clip_index"),
+            "section_id": env.get("section_id"),
+            "source": "clip_envelope",
+        })
+        sec = env.get("section_id")
+        if sec:
+            per_section_counts[sec] = per_section_counts.get(sec, 0) + 1
+
+    # 2) Add device-level hints (track-wide is_automated flags) that
+    # aren't already covered by an envelope entry.
+    for track in track_infos or []:
         t_idx = track.get("index", 0)
         t_name = track.get("name", "")
         devices = track.get("devices", [])
@@ -41,29 +77,45 @@ def build_automation_graph(
             parameters = device.get("parameters", [])
 
             for param in parameters:
-                if param.get("is_automated", False) or param.get("automation_state", 0) > 0:
-                    automated_params.append({
-                        "track_index": t_idx,
-                        "track_name": t_name,
-                        "device_name": device_name,
-                        "param_name": param.get("name", ""),
-                        "param_value": param.get("value"),
-                    })
+                is_flagged = (
+                    param.get("is_automated", False)
+                    or param.get("automation_state", 0) > 0
+                )
+                if not is_flagged:
+                    continue
+                p_name = param.get("name", "")
+                key = (t_idx, str(device_name), str(p_name))
+                if key in seen:
+                    continue
+                seen.add(key)
+                automated_params.append({
+                    "track_index": t_idx,
+                    "track_name": t_name,
+                    "device_name": device_name,
+                    "param_name": p_name,
+                    "param_value": param.get("value"),
+                    "source": "device_hint",
+                })
 
     graph.automated_params = automated_params
 
-    # Compute density_by_section if sections are provided
+    # Compute density_by_section.
     if sections:
         total_automated = len(automated_params)
         for sec in sections:
             section_id = sec.get("section_id", "")
-            # Without per-section automation data, distribute evenly
-            # and weight by section density (more active tracks = more automation)
-            sec_density = sec.get("density", 0.0)
-            # Automation density approximation: section density * param count ratio
-            if total_automated > 0:
+            if per_section_counts:
+                # Use real per-section counts when we have them.
+                count = per_section_counts.get(section_id, 0)
+                # Normalize by max(1, largest section count) so the
+                # densest section is 1.0 and others fall below.
+                max_ct = max(per_section_counts.values()) or 1
+                graph.density_by_section[section_id] = round(count / max_ct, 3)
+            elif total_automated > 0:
+                # Fallback: approximate from section density (old behavior)
+                sec_density = sec.get("density", 0.0)
                 graph.density_by_section[section_id] = round(
-                    sec_density * min(total_automated / max(len(track_infos), 1), 1.0),
+                    sec_density * min(total_automated / max(len(track_infos or []), 1), 1.0),
                     3,
                 )
             else:

package/mcp_server/project_brain/builder.py

@@ -23,6 +23,7 @@ def build_project_state_from_data(
     track_infos: Optional[list[dict]] = None,
     notes_map: Optional[dict[str, dict[int, list[dict]]]] = None,
     arrangement_clips: Optional[dict] = None,
+    clip_automation: Optional[list[dict]] = None,
     analyzer_ok: bool = False,
     flucoma_ok: bool = False,
     plugin_health: Optional[dict[str, Any]] = None,
@@ -105,6 +106,7 @@ def build_project_state_from_data(
     state.automation_graph = build_automation_graph(
         track_infos=track_infos or [],
         sections=section_dicts_for_auto,
+        clip_automation=clip_automation or [],
     )
     state.automation_graph.freshness.mark_fresh(state.revision)
 

package/mcp_server/project_brain/tools.py

@@ -11,6 +11,10 @@ from fastmcp import Context
 
 from ..server import mcp
 from .builder import build_project_state_from_data
+import logging
+
+logger = logging.getLogger(__name__)
+
 
 
 def _get_ableton(ctx: Context):
@@ -39,7 +43,8 @@ def build_project_brain(ctx: Context) -> dict:
     try:
         scenes_resp = ableton.send_command("get_scenes_info")
         scenes = scenes_resp.get("scenes", [])
-    except Exception:
+    except Exception as exc:
+        logger.debug("build_project_brain failed: %s", exc)
         scenes = session_info.get("scenes", [])
 
     # 3. Get clip matrix (scene_matrix)
@@ -47,8 +52,8 @@ def build_project_brain(ctx: Context) -> dict:
     try:
         matrix_resp = ableton.send_command("get_scene_matrix")
         clip_matrix = matrix_resp.get("matrix", [])
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("build_project_brain failed: %s", exc)
 
     # 4. Gather per-track info with devices
     track_infos = []
@@ -58,7 +63,8 @@ def build_project_brain(ctx: Context) -> dict:
                 "track_index": track["index"],
             })
             track_infos.append(info)
-        except Exception:
+        except Exception as exc:
+            logger.debug("build_project_brain failed: %s", exc)
             track_infos.append({
                 "index": track.get("index", 0),
                 "name": track.get("name", ""),
@@ -75,21 +81,27 @@ def build_project_brain(ctx: Context) -> dict:
             clips = arr.get("clips", [])
             if clips:
                 arrangement_clips[track["index"]] = clips
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("build_project_brain failed: %s", exc)
 
     # 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.
+    #
+    # BUG-E1: section_id must match what build_section_graph_from_scenes emits.
+    # The composition engine emits `sec_{i:02d}` using the RAW enumerate index
+    # of the scene — it skips unnamed scenes (gap-preserving), so e.g. scenes
+    # ["Intro", "", "Verse"] become sections sec_00 and sec_02, not sec_01.
+    # Our notes_map must mirror that or keys won't align.
     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}"
-            )
+            scene_name = str(scene.get("name", "")).strip()
+            if not scene_name:
+                continue  # mirror _ce_build_sections: unnamed scenes skipped
+            section_id = f"sec_{scene_idx:02d}"
+
             per_track: dict[int, list[dict]] = {}
             for track in tracks:
                 t_idx = track.get("index", 0)
@@ -102,15 +114,60 @@ def build_project_brain(ctx: Context) -> dict:
                         notes = notes_resp.get("notes", [])
                         if notes:
                             per_track[t_idx] = notes
-                except Exception:
+                except Exception as exc:
+                    logger.debug("build_project_brain failed: %s", exc)
                     # Individual note fetch failing is fine — continue with others
                     continue
             if per_track:
                 notes_map[section_id] = per_track
-    except Exception:
+    except Exception as exc:
+        logger.debug("build_project_brain failed: %s", exc)
         # Overall failure: empty map, degrade to "all tracks active" fallback
         notes_map = {}
 
+    # 5c. Scan clip automation across the session (BUG-E2).
+    # Device-parameter is_automated flags only reflect whether a parameter
+    # is mapped somewhere — they don't reveal clip envelopes. Ableton's
+    # automation actually lives on each clip (session + arrangement). We
+    # walk every clip slot that has a clip and ask get_clip_automation, then
+    # aggregate into a flat list keyed by section.
+    clip_automation: list[dict] = []
+    try:
+        # Iterate session scenes x tracks, plus arrangement clips we already have.
+        # Use the raw enumerate index for section_id so it stays aligned with
+        # arrangement_graph sections (which use the same scheme — see E1 fix).
+        for scene_idx, scene in enumerate(scenes or []):
+            scene_name = str(scene.get("name", "")).strip()
+            if not scene_name:
+                continue
+            section_id = f"sec_{scene_idx:02d}"
+            for track in tracks:
+                t_idx = track.get("index", 0)
+                try:
+                    auto_resp = ableton.send_command("get_clip_automation", {
+                        "track_index": t_idx,
+                        "clip_index": scene_idx,
+                    })
+                except Exception as exc:
+                    # No clip in slot, or remote script rejected — skip
+                    logger.debug("build_project_brain automation skip: %s", exc)
+                    continue
+                if not isinstance(auto_resp, dict):
+                    continue
+                envs = auto_resp.get("envelopes") or []
+                for env in envs:
+                    clip_automation.append({
+                        "section_id": section_id,
+                        "track_index": t_idx,
+                        "track_name": track.get("name", ""),
+                        "clip_index": scene_idx,
+                        "parameter_name": env.get("parameter_name", ""),
+                        "parameter_type": env.get("parameter_type", ""),
+                        "device_name": env.get("device_name"),
+                    })
+    except Exception as exc:
+        logger.debug("build_project_brain automation scan failed: %s", exc)
+
     # 6. Probe capabilities (direct SpectralCache access, not TCP)
     analyzer_ok = False
     analyzer_fresh = False
@@ -127,8 +184,8 @@ def build_project_brain(ctx: Context) -> dict:
                 if spectral.get(key) is not None:
                     flucoma_ok = True
                     break
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("build_project_brain failed: %s", exc)
 
     # 7. Build state
     state = build_project_state_from_data(
@@ -138,6 +195,7 @@ def build_project_brain(ctx: Context) -> dict:
         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,
+        clip_automation=clip_automation if clip_automation else None,
         analyzer_ok=analyzer_ok,
         flucoma_ok=flucoma_ok,
         session_ok=True,