livepilot 1.10.6 → 1.10.7

package/mcp_server/atlas/__init__.py

@@ -115,26 +115,70 @@ class AtlasManager:
         query_words = query_lower.split()
         results: List[Dict[str, Any]] = []
 
+        # BUG-B39: the real atlas scanner emits "instruments" /
+        # "audio_effects" but older callers and test fixtures sometimes
+        # pass the singular "instrument" / "effect". Build a tolerant
+        # category alias set so both forms work.
+        _CAT_ALIASES = {
+            "instrument": {"instrument", "instruments"},
+            "instruments": {"instrument", "instruments"},
+            "effect": {"effect", "effects", "audio_effects"},
+            "effects": {"effect", "effects", "audio_effects"},
+            "audio_effect": {"effect", "effects", "audio_effects",
+                             "audio_effect"},
+            "audio_effects": {"effect", "effects", "audio_effects",
+                              "audio_effect"},
+        }
+        allowed_cats = (
+            _CAT_ALIASES.get(category, {category})
+            if category != "all" else None
+        )
+
         for dev in self._devices:
             # Category filter
-            if category != "all" and dev.get("category", "") != category:
+            if allowed_cats is not None and dev.get("category", "") not in allowed_cats:
                 continue
 
             score = 0
             dev_name = dev.get("name", "")
             dev_name_lower = dev_name.lower()
 
-            # Name scoring: 100pts exact, 50pts substring
+            # Name scoring. BUG-B41 fix: dropped weight dramatically
+            # (was 100 exact / 50 substring) so a device literally
+            # named "Bass" no longer blows past character-tag matches
+            # for a sonic query like "warm analog bass". An exact name
+            # match is still the strongest single signal, but a device
+            # with 2+ matching character-tags now beats a name-only
+            # accident.
             if dev_name_lower == query_lower:
-                score += 100
+                score += 45  # was 100
             elif query_lower in dev_name_lower:
-                score += 50
-
-            # Tag scoring: 30pts per matching tag
-            dev_tags = [t.lower() for t in dev.get("tags", [])]
+                score += 20  # was 50
+            else:
+                # Partial: any query word present in name — small signal
+                for word in query_words:
+                    if len(word) >= 3 and word in dev_name_lower:
+                        score += 5
+
+            # Tag scoring — prefer enriched character_tags.
+            # BUG-B40 / B41: also read character_tags so enriched devices
+            # actually compete with name-based matches.
+            dev_tags = [
+                t.lower() for t in (
+                    dev.get("character_tags") or dev.get("tags", [])
+                )
+            ]
+            # BUG-B41: bumped to 35pts per tag so multi-tag matches beat
+            # a single substring-name match.
             for word in query_words:
                 if word in dev_tags:
-                    score += 30
+                    score += 35
+                # Partial tag match (word appears as substring in a tag)
+                else:
+                    for tag in dev_tags:
+                        if word in tag:
+                            score += 10
+                            break
 
             # Use case scoring: 25pts per match
             for use_case in dev.get("use_cases", []):
@@ -142,10 +186,11 @@ class AtlasManager:
                 for word in query_words:
                     if word in use_lower:
                         score += 25
-                        break  # one match per use_case
+                        break
 
-            # Genre scoring: 20pts primary, 10pts secondary
-            genres = dev.get("genres", {})
+            # Genre scoring: 20pts primary, 10pts secondary.
+            # BUG-B40: also read genre_affinity (enriched field).
+            genres = dev.get("genre_affinity") or dev.get("genres", {}) or {}
             for genre in genres.get("primary", []):
                 if query_lower in genre.lower() or genre.lower() in query_lower:
                     score += 20
@@ -153,8 +198,11 @@ class AtlasManager:
                 if query_lower in genre.lower() or genre.lower() in query_lower:
                     score += 10
 
-            # Description keyword scoring: 15pts
-            description = dev.get("description", "").lower()
+            # Description keyword scoring: 15pts.
+            # BUG-B40: prefer sonic_description when present.
+            description = (
+                dev.get("sonic_description") or dev.get("description", "")
+            ).lower()
             for word in query_words:
                 if len(word) >= 3 and word in description:
                     score += 15
@@ -224,7 +272,13 @@ class AtlasManager:
     def chain_suggest(
         self, role: str, genre: str = ""
     ) -> Dict[str, Any]:
-        """Suggest a device chain for a given role (e.g., 'bass', 'lead', 'pad')."""
+        """Suggest a device chain for a given role (e.g., 'bass', 'lead', 'pad').
+
+        BUG-B39 fix: the old code passed category="instrument" (singular)
+        and category="effect" to self.search(), but the atlas stores
+        devices with category="instruments" / "audio_effects" (plural).
+        Every filtered search missed and the chain came back empty.
+        """
         chain: List[Dict[str, Any]] = []
         position = 0
 
@@ -244,8 +298,8 @@ class AtlasManager:
         intent = instrument_intents.get(role_lower, role_lower)
         search_q = f"{intent} {genre}" if genre else intent
 
-        # Find instrument
-        instrument_candidates = self.search(search_q, category="instrument", limit=3)
+        # Find instrument — atlas category is "instruments" (plural)
+        instrument_candidates = self.search(search_q, category="instruments", limit=3)
         if instrument_candidates:
             best = instrument_candidates[0]["device"]
             chain.append({
@@ -255,7 +309,7 @@ class AtlasManager:
             })
             position += 1
 
-        # Stage 2: Effects
+        # Stage 2: Effects — atlas category is "audio_effects"
         effect_stages = [
             ("eq", f"Shape the {role} tone"),
             ("compression", f"Control {role} dynamics"),
@@ -264,7 +318,9 @@ class AtlasManager:
 
         for effect_type, reason in effect_stages:
             effect_q = f"{effect_type} {genre}" if genre else effect_type
-            effect_candidates = self.search(effect_q, category="effect", limit=2)
+            effect_candidates = self.search(
+                effect_q, category="audio_effects", limit=2,
+            )
             if effect_candidates:
                 best = effect_candidates[0]["device"]
                 chain.append({
@@ -295,37 +351,48 @@ class AtlasManager:
             return {"error": f"Device not found: {device_b}"}
 
         def _summarize(dev: Dict[str, Any]) -> Dict[str, Any]:
+            # BUG-B40 fix: enriched atlas entries use character_tags /
+            # sonic_description / genre_affinity — the old _summarize
+            # looked for "tags" / "description" / "genres" which are
+            # the UN-enriched raw scanner fields. We prefer enriched
+            # fields, fall back to raw when enrichment is absent.
             return {
                 "name": dev.get("name", ""),
                 "category": dev.get("category", ""),
-                "tags": dev.get("tags", []),
-                "genres": dev.get("genres", {}),
+                "tags": dev.get("character_tags") or dev.get("tags", []),
+                "genres": dev.get("genre_affinity") or dev.get("genres", {}),
                 "use_cases": dev.get("use_cases", []),
-                "description": dev.get("description", ""),
+                "description": (
+                    dev.get("sonic_description")
+                    or dev.get("description", "")
+                ),
                 "cpu_weight": dev.get("cpu_weight", "unknown"),
                 "sweet_spot": dev.get("sweet_spot", ""),
+                "enriched": dev.get("enriched", False),
             }
 
         summary_a = _summarize(dev_a)
         summary_b = _summarize(dev_b)
 
-        # Recommendation logic: score each for the role
+        # Recommendation logic: score each for the role.
+        # BUG-B40: scorer also reads the enriched field names.
         score_a = 0
         score_b = 0
         if role:
             role_lower = role.lower()
-            # Check use_cases
             for uc in dev_a.get("use_cases", []):
                 if role_lower in uc.lower():
                     score_a += 20
             for uc in dev_b.get("use_cases", []):
                 if role_lower in uc.lower():
                     score_b += 20
-            # Check tags
-            for tag in dev_a.get("tags", []):
+            # Tag scoring — prefer character_tags (enriched)
+            a_tags = dev_a.get("character_tags") or dev_a.get("tags", [])
+            b_tags = dev_b.get("character_tags") or dev_b.get("tags", [])
+            for tag in a_tags:
                 if role_lower in tag.lower():
                     score_a += 10
-            for tag in dev_b.get("tags", []):
+            for tag in b_tags:
                 if role_lower in tag.lower():
                     score_b += 10
 

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)