livepilot 1.10.6 → 1.10.8

package/mcp_server/creative_constraints/tools.py

@@ -94,10 +94,13 @@ def distill_reference_principles(
     if not reference_description.strip() and not style_name.strip():
         return {"error": "Provide reference_description or style_name"}
 
-    # Build a reference profile from available data
+    # BUG-B17 fix: collect profile fragments from all sources and MERGE.
+    # The old flow stopped at the first non-empty source, so if
+    # get_style_tactics returned a half-filled profile the text-keyword
+    # fallback never ran and the description's rich content was lost.
+    # Now we always run the text fallback too and fill missing fields.
     reference_profile: dict = {}
 
-    # Try to get style tactics if style_name is provided
     if style_name:
         try:
             from ..tools._research_engine import get_style_tactics
@@ -114,18 +117,34 @@ def distill_reference_principles(
                 }
         except Exception as exc:
             logger.debug("distill_reference_principles failed: %s", exc)
-    # Try to get a reference profile from the reference engine
+
+    # Try the built-in style profile builder
     if not reference_profile:
         try:
             from ..reference_engine.profile_builder import build_style_reference_profile
             profile = build_style_reference_profile(
                 style_name or reference_description
             )
-            reference_profile = profile.to_dict()
+            reference_profile = profile.to_dict() if profile else {}
         except Exception as exc:
             logger.debug("distill_reference_principles failed: %s", exc)
-            # Fallback: build from description keywords
-            reference_profile = _profile_from_description(reference_description)
+
+    # Text-keyword fallback ALWAYS merges in. Style tactics + profile
+    # builder typically leave some fields empty; the description's
+    # keywords fill those gaps. This is the B17 fix that makes the
+    # Dabrye reproducer produce non-empty principles.
+    if reference_description.strip():
+        text_profile = _profile_from_description(reference_description)
+        for key, value in text_profile.items():
+            existing = reference_profile.get(key)
+            is_empty = (
+                existing is None
+                or existing == ""
+                or existing == []
+                or existing == {}
+            )
+            if is_empty and value:
+                reference_profile[key] = value
 
     distillation = engine.distill_reference_principles(
         reference_profile=reference_profile,
@@ -216,23 +235,65 @@ def generate_constrained_variants(
             taste_graph=taste_graph,
         )
 
-        # Validate each variant's compiled_plan against constraints
+        # Validate each variant's compiled_plan against constraints.
+        # BUG-B46: two problems in the old code —
+        #   1) iterating `for step in v.compiled_plan` yields dict KEYS
+        #      (compiled_plan is {'move_id': ..., 'steps': [...]}), so
+        #      the validation ran on strings and silently passed.
+        #   2) when a variant was filtered, we only blanked compiled_plan
+        #      and left status='pending' — callers had no way to tell
+        #      which variants became shells.
+        # Now we iterate .get("steps", []) correctly, flip filtered
+        # variants to status='blocked', and count blocked_count in the
+        # response so callers can detect the "all variants filtered" case.
+        blocked_count = 0
         for v in ps.variants:
-            v.what_preserved = f"{v.what_preserved} | Constraints: {', '.join(active.constraints)}"
+            v.what_preserved = (
+                f"{v.what_preserved} | Constraints: "
+                f"{', '.join(active.constraints)}"
+            )
             if v.compiled_plan:
-                plan = {"steps": [
-                    {"action": step.get("tool", ""), **step}
-                    for step in v.compiled_plan
-                ]}
-                validation = engine.validate_plan_against_constraints(plan, active)
+                steps = v.compiled_plan.get("steps", []) if isinstance(
+                    v.compiled_plan, dict
+                ) else []
+                plan = {
+                    "steps": [
+                        {"action": step.get("tool", ""), **step}
+                        for step in steps
+                    ]
+                }
+                validation = engine.validate_plan_against_constraints(
+                    plan, active,
+                )
                 if not validation["valid"]:
                     v.compiled_plan = None
-                    v.what_changed = f"[FILTERED] {v.what_changed} — violates {', '.join(active.constraints)}"
+                    v.status = "blocked"
+                    v.what_changed = (
+                        f"[FILTERED] {v.what_changed} — violates "
+                        f"{', '.join(active.constraints)}"
+                    )
+                    blocked_count += 1
+            elif v.status == "blocked":
+                # Already blocked upstream (no compilable move)
+                blocked_count += 1
+
+        note = (
+            f"Variants with violating plans have been filtered "
+            f"({blocked_count}/{len(ps.variants)} blocked)"
+        )
+        if blocked_count == len(ps.variants) and ps.variants:
+            note = (
+                f"All {blocked_count} variants violate constraints "
+                f"{active.constraints!r}. Try loosening constraints or a "
+                f"different request."
+            )
 
         return {
             "preview_set": ps.to_dict(),
             "constraints_applied": active.constraints,
-            "note": "Variants with violating plans have been filtered",
+            "blocked_count": blocked_count,
+            "executable_count": len(ps.variants) - blocked_count,
+            "note": note,
         }
     except Exception as e:
         return {"error": f"Failed to generate constrained variants: {e}"}
@@ -256,9 +317,29 @@ def generate_reference_inspired_variants(
     if _cached_distillation is None:
         return {"error": "No reference distilled yet — call distill_reference_principles first"}
 
+    # BUG-B54: the reference-engine chain (distill → map → generate_variants)
+    # used to silently degrade when distill_reference_principles returned
+    # empty principles (BUG-B17). Callers got 3 shell variants branded
+    # "reference-inspired" with no reference material driving them.
+    # Refuse to run when principles are empty — the user should fix the
+    # distillation step first.
+    principles_list = list(_cached_distillation.principles or [])
+    if not principles_list:
+        return {
+            "error": (
+                "distill_reference_principles returned no principles — "
+                "reference-inspired variant generation refuses to run on "
+                "empty input (would produce meaningless 'reference-inspired' "
+                "shell variants). Try a more specific reference description "
+                "or pick a reference covered by the built-in style corpus."
+            ),
+            "reference": _cached_distillation.reference_description,
+            "principles_applied": [],
+        }
+
     # Build request text from reference principles
     principles_text = ", ".join(
-        p.principle for p in _cached_distillation.principles[:3]
+        p.principle for p in principles_list[:3]
     )
     full_request = (
         f"Inspired by: {_cached_distillation.reference_description}. "
@@ -288,7 +369,9 @@ def generate_reference_inspired_variants(
         return {
             "preview_set": ps.to_dict(),
             "reference": _cached_distillation.reference_description,
-            "principles_applied": [p.to_dict() for p in _cached_distillation.principles[:5]],
+            "principles_applied": [
+                p.to_dict() for p in principles_list[:5]
+            ],
             "note": "Variants are shaped by reference principles, not surface imitation",
         }
     except Exception as e:
@@ -311,32 +394,122 @@ def _get_song_brain_dict() -> dict:
 
 
 def _profile_from_description(description: str) -> dict:
-    """Build a rough reference profile from text description."""
+    """Build a rough reference profile from a free-text description.
+
+    BUG-B17 fix: the old version only mapped 8 emotion keywords and
+    left every other field empty, so distill_reference_principles
+    returned empty principles for any description that didn't include
+    exactly one of those 8 words. We now scan for a rich keyword set
+    across emotional / spectral / width / groove / harmonic / density
+    dimensions so a description like "cold 90s hip-hop with ghostly
+    vocal chops and dusty drums" actually produces principles.
+    """
     desc_lower = description.lower()
 
+    # Emotional stance
     emotional_map = {
-        "dark": "tense",
-        "bright": "euphoric",
-        "sad": "melancholic",
-        "aggressive": "aggressive",
-        "dreamy": "dreamy",
-        "chill": "relaxed",
-        "intense": "aggressive",
-        "minimal": "restrained",
+        "dark": "tense", "cold": "tense", "ominous": "tense", "eerie": "tense",
+        "bright": "euphoric", "warm": "warm", "sunny": "euphoric",
+        "sad": "melancholic", "longing": "melancholic", "wistful": "melancholic",
+        "nostalgic": "nostalgic", "dust": "nostalgic", "dusty": "nostalgic",
+        "aggressive": "aggressive", "violent": "aggressive", "intense": "aggressive",
+        "dreamy": "dreamy", "dream": "dreamy", "floaty": "dreamy",
+        "chill": "relaxed", "meditative": "relaxed",
+        "minimal": "restrained", "restrained": "restrained",
+        "ghostly": "haunted", "haunted": "haunted", "ghost": "haunted",
+        "euphoric": "euphoric", "ecstatic": "euphoric",
     }
-
     emotional = ""
     for keyword, stance in emotional_map.items():
         if keyword in desc_lower:
             emotional = stance
             break
 
+    # Spectral contour — from brightness / color keywords
+    spectral_contour: dict = {}
+    if any(k in desc_lower for k in ("dark", "muddy", "lo-fi", "lofi",
+                                      "dusty", "cold", "underwater",
+                                      "warm", "vintage")):
+        spectral_contour = {
+            "band_balance": {"sub": 0.4, "low": 0.5, "mid": 0.35,
+                             "high_mid": 0.2, "high": 0.1},
+            "centroid_hint": "dark / roll-off near 4kHz",
+        }
+    elif any(k in desc_lower for k in ("bright", "crisp", "shiny", "airy",
+                                        "glittery", "sparkly", "cinematic")):
+        spectral_contour = {
+            "band_balance": {"sub": 0.25, "low": 0.3, "mid": 0.4,
+                             "high_mid": 0.55, "high": 0.6},
+            "centroid_hint": "bright / open high shelf",
+        }
+
+    # Width / depth — mono vs wide vs deep
+    width_depth: dict = {}
+    if any(k in desc_lower for k in ("narrow", "mono", "focused", "tight",
+                                      "centered")):
+        width_depth = {"stereo_width": 0.25, "depth_hint": "close, upfront"}
+    elif any(k in desc_lower for k in ("wide", "spacious", "spatial",
+                                        "ambient", "washy", "drifting")):
+        width_depth = {"stereo_width": 0.85, "depth_hint": "deep, spatial"}
+    elif any(k in desc_lower for k in ("intimate", "dry")):
+        width_depth = {"stereo_width": 0.4, "depth_hint": "dry, intimate"}
+
+    # Groove posture — rhythm keywords
+    groove_posture: dict = {}
+    if any(k in desc_lower for k in ("swing", "shuffle", "dilla", "slouchy")):
+        groove_posture = {"feel": "swung", "stiffness": 0.25}
+    elif any(k in desc_lower for k in ("tight", "clean", "quantized",
+                                        "precise", "crispy")):
+        groove_posture = {"feel": "straight", "stiffness": 0.9}
+    elif any(k in desc_lower for k in ("loose", "sloppy", "drunk",
+                                        "organic", "human")):
+        groove_posture = {"feel": "humanized", "stiffness": 0.3}
+    elif any(k in desc_lower for k in ("driving", "motorik", "pulsing",
+                                        "throbbing", "hypnotic")):
+        groove_posture = {"feel": "driving", "stiffness": 0.8}
+
+    # Density motion — when the user hints at pacing
+    density_arc: list[float] = []
+    if any(k in desc_lower for k in ("slow burn", "patient", "gradually",
+                                      "builds", "buildup")):
+        density_arc = [0.2, 0.3, 0.5, 0.7, 0.9]
+    elif any(k in desc_lower for k in ("explodes", "immediate", "front-loaded",
+                                        "hits from the start")):
+        density_arc = [0.9, 0.85, 0.8, 0.5, 0.3]
+    elif any(k in desc_lower for k in ("dual drop", "return", "second wind")):
+        density_arc = [0.4, 0.8, 0.5, 0.3, 0.9]
+
+    # Harmonic character
+    harmonic = ""
+    if any(k in desc_lower for k in ("minor", "dorian", "phrygian",
+                                      "melancholic", "tense")):
+        harmonic = "minor_modal"
+    elif any(k in desc_lower for k in ("major", "ionian", "lydian",
+                                        "euphoric", "triumphant")):
+        harmonic = "major_modal"
+    elif any(k in desc_lower for k in ("dissonant", "dense", "clusters",
+                                        "microtonal")):
+        harmonic = "dissonant_clustered"
+    elif any(k in desc_lower for k in ("ambient", "drone", "pad",
+                                        "atmospheric", "washy")):
+        harmonic = "atmospheric_filtered"
+
+    # Payoff / section pacing
+    section_pacing: list[dict] = []
+    if any(k in desc_lower for k in ("sparse intro", "sparse", "slow start")):
+        section_pacing.append({"label": "sparse_intro", "bars": 16})
+    if any(k in desc_lower for k in ("buildup", "builds", "growing")):
+        section_pacing.append({"label": "gradual_buildup", "bars": 16})
+    if any(k in desc_lower for k in ("drop", "peak", "payoff",
+                                      "strip back", "pulled out")):
+        section_pacing.append({"label": "strip_back_payoff", "bars": 16})
+
     return {
         "emotional_stance": emotional,
-        "density_arc": [],
-        "section_pacing": [],
-        "width_depth": {},
-        "spectral_contour": {},
-        "groove_posture": {},
-        "harmonic_character": "",
+        "density_arc": density_arc,
+        "section_pacing": section_pacing,
+        "width_depth": width_depth,
+        "spectral_contour": spectral_contour,
+        "groove_posture": groove_posture,
+        "harmonic_character": harmonic,
     }

package/mcp_server/experiment/engine.py

@@ -122,6 +122,8 @@ def _run_branch_sync(branch, ableton, compiled_plan, capture_fn):
     branch.compiled_plan = compiled_plan
     branch.before_snapshot = capture_fn()
 
+    from ..runtime.execution_router import READ_ONLY_TOOLS
+
     steps_executed = 0
     log = []
     for step in compiled_plan.get("steps", []):
@@ -129,7 +131,7 @@ def _run_branch_sync(branch, ableton, compiled_plan, capture_fn):
         params = step.get("params", {})
         if not tool:
             continue
-        if tool in ("get_track_meters", "get_master_spectrum", "analyze_mix"):
+        if tool in READ_ONLY_TOOLS:
             continue
         try:
             result = ableton.send_command(tool, params)
@@ -173,21 +175,17 @@ async def run_branch_async(
     analyze_mix) are skipped in the apply pass — they're used for snapshot
     capture separately.
     """
-    from ..runtime.execution_router import execute_plan_steps_async
+    from ..runtime.execution_router import execute_plan_steps_async, filter_apply_steps
 
     branch.status = "running"
     branch.compiled_plan = compiled_plan
 
     branch.before_snapshot = capture_fn()
 
-    # Filter out read-only verification steps from the apply pass
+    # Filter out read-only verification steps from the apply pass (canonical
+    # list lives in execution_router.READ_ONLY_TOOLS).
     all_steps = compiled_plan.get("steps", []) or []
-    apply_steps = [
-        s for s in all_steps
-        if s.get("tool") and s.get("tool") not in (
-            "get_track_meters", "get_master_spectrum", "analyze_mix",
-        )
-    ]
+    apply_steps = filter_apply_steps(all_steps)
 
     exec_results = await execute_plan_steps_async(
         apply_steps,

package/mcp_server/hook_hunter/analyzer.py

@@ -33,14 +33,30 @@ def find_hook_candidates(
     candidates: list[HookCandidate] = []
 
     # 1. Motif-based hooks
-    for motif in motif_data.get("motifs", []):
+    #
+    # BUG-B8 fix: the old code used motif.get('name', 'unknown'); the motif
+    # engine emits `motif_id` (not `name`), so every candidate collapsed
+    # onto hook_id="motif_unknown" and rank_hook_candidates returned 4+
+    # duplicate rows with empty location strings. We now prefer motif_id,
+    # then name, then a per-iteration index fallback to guarantee uniqueness.
+    # A final post-filter dedupes by (hook_id, hook_type, description) in
+    # case another producer slips a duplicate in.
+    for idx, motif in enumerate(motif_data.get("motifs", [])):
         salience = motif.get("salience", 0)
         recurrence = motif.get("recurrence", 0)
         if salience > 0.2 or recurrence > 0.3:
+            identifier = (
+                motif.get("motif_id")
+                or motif.get("name")
+                or f"idx{idx}"
+            )
             candidates.append(HookCandidate(
-                hook_id=f"motif_{motif.get('name', 'unknown')}",
+                hook_id=f"motif_{identifier}",
                 hook_type="melodic",
-                description=motif.get("description", motif.get("name", "motif")),
+                description=motif.get(
+                    "description",
+                    motif.get("name") or motif.get("motif_id") or f"motif #{idx}",
+                ),
                 location=motif.get("location", ""),
                 memorability=min(1.0, salience * 1.2),
                 recurrence=recurrence,
@@ -109,6 +125,20 @@ def find_hook_candidates(
         if "groove" in c.hook_id:
             c.evidence_sources.append("clip_reuse")
 
+    # BUG-B8: post-filter dedupe. Even after the motif_id fix above, other
+    # producers (track-name, groove-pattern) could collide on the same
+    # hook_id if session conventions repeat (e.g. two tracks named "Lead").
+    # Keep the first occurrence (sorted by salience below picks the winner
+    # among the originals), drop later duplicates by hook_id.
+    seen_ids: set[str] = set()
+    unique_candidates: list[HookCandidate] = []
+    for c in candidates:
+        if c.hook_id in seen_ids:
+            continue
+        seen_ids.add(c.hook_id)
+        unique_candidates.append(c)
+    candidates = unique_candidates
+
     # Sort by salience
     candidates.sort(key=lambda c: c.salience, reverse=True)
     return candidates
@@ -154,17 +184,40 @@ def score_phrase_impact(
     # Anticipation: was there a dip before?
     anticipation = min(1.0, max(0.0, (0.5 - prev_energy) * 2)) if prev_energy < 0.5 else 0.2
 
-    # Contrast: density or energy change
-    contrast = min(1.0, abs(density - prev_density) + abs(energy_delta))
+    # BUG-B51: note-content signals differentiate sections with
+    # identical energy/density. Without these, compare_phrase_impact
+    # emitted identical scores for every pair of same-density sections.
+    pitch_classes = int(section_data.get("unique_pitch_classes", 0) or 0)
+    note_count = int(section_data.get("note_count", 0) or 0)
+    velocity_variance = float(section_data.get("velocity_variance", 0) or 0)
+    # Pitch-class diversity → contrast lift: 0 classes = 0, 7+ = +0.3
+    pc_contrast_bonus = min(0.3, pitch_classes * 0.04)
+    # Note-density signal: more notes = richer content
+    note_density_signal = min(1.0, note_count / 50.0)
+    # Velocity variance → dynamic interest
+    dynamic_interest = min(1.0, velocity_variance / 200.0)
+
+    # Contrast: density / energy change + pitch-class diversity
+    contrast = min(
+        1.0,
+        abs(density - prev_density) + abs(energy_delta) + pc_contrast_bonus,
+    )
 
-    # Repetition fatigue: high density with no change = fatiguing
-    fatigue = max(0.0, 1.0 - contrast) * 0.5
+    # Repetition fatigue: high density + low dynamic variance = fatiguing
+    base_fatigue = max(0.0, 1.0 - contrast) * 0.5
+    # Flat velocity → more fatigue; dynamic variation → less
+    fatigue = round(max(0.0, base_fatigue - dynamic_interest * 0.15), 3)
 
-    # Section clarity: does it have a clear role?
-    clarity = 0.7 if section_data.get("label") else 0.3
+    # Section clarity: does it have a clear role + content to back it up?
+    label_clarity = 0.7 if section_data.get("label") else 0.3
+    content_clarity = 0.1 * min(1.0, note_count / 20.0)
+    clarity = min(1.0, label_clarity + content_clarity)
 
     # Groove continuity: rhythm present
     groove = 0.7 if section_data.get("has_drums", True) else 0.3
+    # Boost groove continuity when the section has genuine rhythmic
+    # activity (note_density_signal nudges it up, flat sections down)
+    groove = min(1.0, groove + note_density_signal * 0.1)
 
     # Payoff balance
     payoff = min(1.0, (arrival + anticipation) / 2)

package/mcp_server/hook_hunter/tools.py

@@ -135,7 +135,18 @@ def develop_hook(
     # Look up the actual hook to adapt strategies by type
     hook_type = "melodic"  # default
     hook_description = "the hook"
-    if hook_id:
+    # BUG-B31: when no hook_id is provided, default to the session's primary
+    # hook. Previously the tool emitted generic advice even though
+    # find_primary_hook was already available — users had to manually chain
+    # find_primary_hook → develop_hook to get type-specific tactics.
+    if not hook_id:
+        tracks, scenes, motif_data = _fetch_tracks_and_scenes(ctx)
+        primary = analyzer.find_primary_hook(tracks, motif_data, scenes)
+        if primary is not None:
+            hook_id = primary.hook_id
+            hook_type = primary.hook_type
+            hook_description = primary.description
+    elif hook_id:
         tracks, scenes, motif_data = _fetch_tracks_and_scenes(ctx)
         candidates = analyzer.find_hook_candidates(tracks, motif_data, scenes)
         match = [c for c in candidates if c.hook_id == hook_id]
@@ -333,7 +344,14 @@ def suggest_payoff_repair(ctx: Context) -> dict:
 
 
 def _get_section_data(ableton) -> list[dict]:
-    """Build section data from Ableton scenes with real energy/density/has_drums."""
+    """Build section data from Ableton scenes with real energy/density/has_drums.
+
+    BUG-B51 fix: also fetches per-section note signals (unique pitch
+    count, note count, velocity-variance) so compare_phrase_impact can
+    differentiate two sections that share energy/density but have
+    different clip contents. Without these, the old comparator emitted
+    identical scores for every pair of same-density sections.
+    """
     sections: list[dict] = []
     try:
         matrix = ableton.send_command("get_scene_matrix")
@@ -342,11 +360,6 @@ def _get_section_data(ableton) -> list[dict]:
 
         # Detect drum track indices by name
         drum_keywords = {"drum", "beat", "kick", "hat", "perc", "snare"}
-        track_names = []
-        # tracks may be in matrix metadata or session_info
-        for ti, row_entry in enumerate(matrix_rows[0] if matrix_rows else []):
-            track_names.append("")  # placeholder — we'll use scenes_list tracks if available
-        # Use scene matrix track info if available
         track_info = matrix.get("tracks", [])
         drum_indices = set()
         for ti, track in enumerate(track_info):
@@ -361,16 +374,49 @@ def _get_section_data(ableton) -> list[dict]:
             clip_count = sum(1 for c in row if c)
             total_tracks = max(len(row), 1)
 
-            # has_drums: check if any drum track has a clip in this scene
             has_drums = any(
                 di < len(row) and row[di]
                 for di in drum_indices
             ) if drum_indices else False
 
             density = min(1.0, clip_count / total_tracks)
-            # energy: density + drum bonus
             energy = min(1.0, density + (0.1 if has_drums else 0.0))
 
+            # BUG-B51: cheap per-section note signals. Sample up to 3
+            # non-drum tracks in this scene for a flavor of the
+            # section's harmonic/rhythmic content. Keeps the call
+            # count bounded so compare_phrase_impact doesn't explode.
+            unique_pitches: set = set()
+            note_count = 0
+            velocity_variance = 0.0
+            sampled = 0
+            for t_idx, cell in enumerate(row):
+                if sampled >= 3 or not cell:
+                    continue
+                if t_idx in drum_indices:
+                    continue
+                try:
+                    notes_resp = ableton.send_command("get_notes", {
+                        "track_index": t_idx, "clip_index": i,
+                    })
+                except Exception:
+                    continue
+                notes = notes_resp.get("notes", []) if isinstance(
+                    notes_resp, dict
+                ) else []
+                if not notes:
+                    continue
+                sampled += 1
+                note_count += len(notes)
+                for n in notes:
+                    unique_pitches.add(int(n.get("pitch", 0)) % 12)
+                vels = [int(n.get("velocity", 0)) for n in notes]
+                if len(vels) >= 2:
+                    mean_v = sum(vels) / len(vels)
+                    velocity_variance += sum(
+                        (v - mean_v) ** 2 for v in vels
+                    ) / len(vels)
+
             sections.append({
                 "id": f"scene_{i}",
                 "name": scene.get("name", f"Scene {i}"),
@@ -378,6 +424,11 @@ def _get_section_data(ableton) -> list[dict]:
                 "energy": round(energy, 3),
                 "density": round(density, 3),
                 "has_drums": has_drums,
+                # BUG-B51: these three differentiate otherwise-identical
+                # sections. Downstream phrase scorer reads them.
+                "unique_pitch_classes": len(unique_pitches),
+                "note_count": note_count,
+                "velocity_variance": round(velocity_variance, 3),
             })
     except Exception as exc:
         logger.debug("_get_section_data failed: %s", exc)