livepilot 1.10.5 → 1.10.7

package/mcp_server/creative_constraints/tools.py

@@ -17,7 +17,9 @@ from fastmcp import Context
 from ..server import mcp
 from . import engine
 from .models import CONSTRAINT_MODES
+import logging
 
+logger = logging.getLogger(__name__)
 
 # Module-level cache for active constraints and distillations
 _active_constraints: Optional[engine.ConstraintSet] = None
@@ -92,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
@@ -110,20 +115,36 @@ def distill_reference_principles(
                     "groove_posture": tactics.get("groove_posture", {}),
                     "harmonic_character": tactics.get("harmonic_character", ""),
                 }
-        except Exception:
-            pass
+        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()
-        except Exception:
-            # Fallback: build from description keywords
-            reference_profile = _profile_from_description(reference_description)
+            reference_profile = profile.to_dict() if profile else {}
+        except Exception as exc:
+            logger.debug("distill_reference_principles failed: %s", exc)
+
+    # 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,
@@ -204,9 +225,8 @@ def generate_constrained_variants(
             taste_store = ctx.lifespan_context.setdefault("taste_memory", TasteMemoryStore())
             anti_store = ctx.lifespan_context.setdefault("anti_memory", AntiMemoryStore())
             taste_graph = build_taste_graph(taste_store=taste_store, anti_store=anti_store).to_dict()
-        except Exception:
-            pass
-
+        except Exception as exc:
+            logger.debug("generate_constrained_variants failed: %s", exc)
         ps = ps_engine.create_preview_set(
             request_text=f"[Constrained: {', '.join(active.constraints)}] {request_text}",
             kernel_id=kernel_id,
@@ -215,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}"}
@@ -255,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}. "
@@ -287,13 +369,14 @@ 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:
         return {"error": f"Failed to generate reference-inspired variants: {e}"}
 
-
 # ── Helpers ───────────────────────────────────────────────────────
 
 
@@ -305,37 +388,128 @@ def _get_song_brain_dict() -> dict:
     except Exception as _e:
         if __debug__:
             import sys
+
             print(f"LivePilot: SongBrain unavailable in creative_constraints: {_e}", file=sys.stderr)
     return {}
 
 
 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

@@ -22,7 +22,9 @@ import time
 from typing import Optional
 
 from .models import ExperimentSet, ExperimentBranch, BranchSnapshot
+import logging
 
+logger = logging.getLogger(__name__)
 
 # ── In-memory experiment store ───────────────────────────────────────────────
 
@@ -34,9 +36,9 @@ def _gen_id(prefix: str, seed: str) -> str:
     h = hashlib.sha256(f"{prefix}:{seed}:{time.time()}".encode()).hexdigest()[:8]
     return f"{prefix}_{h}"
 
-
 # ── Create experiments ───────────────────────────────────────────────────────
 
+
 def create_experiment(
     request_text: str,
     move_ids: list[str],
@@ -83,9 +85,9 @@ def list_experiments() -> list[dict]:
     """List all experiment sets."""
     return [exp.to_dict() for exp in _EXPERIMENTS.values()]
 
-
 # ── Run experiments (requires Ableton connection) ────────────────────────────
 
+
 def run_branch(
     branch: ExperimentBranch,
     ableton,  # AbletonConnection
@@ -120,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", []):
@@ -127,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)
@@ -143,7 +147,8 @@ def _run_branch_sync(branch, ableton, compiled_plan, capture_fn):
     for _ in range(steps_executed):
         try:
             ableton.send_command("undo", {})
-        except Exception:
+        except Exception as exc:
+            logger.debug("_run_branch_sync failed: %s", exc)
             break
 
     branch.status = "evaluated" if steps_executed > 0 else "failed"
@@ -170,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,
@@ -215,7 +216,8 @@ async def run_branch_async(
     for _ in range(steps_executed):
         try:
             ableton.send_command("undo", {})
-        except Exception:
+        except Exception as exc:
+            logger.debug("run_branch_async failed: %s", exc)
             break
 
     # A branch is "evaluated" only if it actually applied at least one step.
@@ -244,9 +246,9 @@ def evaluate_branch(
     branch.score = result.get("score", 0.0)
     return branch
 
-
 # ── Commit / discard ─────────────────────────────────────────────────────────
 
+
 async def commit_branch_async(
     experiment: ExperimentSet,
     branch_id: str,

package/mcp_server/experiment/tools.py

@@ -18,6 +18,9 @@ from fastmcp import Context
 from ..server import mcp
 from . import engine
 from .models import BranchSnapshot
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 def _get_ableton(ctx: Context):
@@ -35,25 +38,22 @@ def _capture_snapshot(ctx: Context) -> BranchSnapshot:
     try:
         meters = ableton.send_command("get_track_meters", {"include_stereo": True})
         snapshot.track_meters = meters.get("tracks", [])
-    except Exception:
-        pass
-
+    except Exception as exc:
+        logger.debug("_capture_snapshot failed: %s", exc)
     # Spectral data (requires M4L analyzer)
     if spectral and spectral.is_connected:
         try:
             spec = spectral.get("spectrum")
             if spec:
                 snapshot.spectrum = spec.get("value", {})
-        except Exception:
-            pass
-
+        except Exception as exc:
+            logger.debug("_capture_snapshot failed: %s", exc)
         try:
             rms_data = spectral.get("rms")
             if rms_data:
                 snapshot.rms = rms_data.get("value")
-        except Exception:
-            pass
-
+        except Exception as exc:
+            logger.debug("_capture_snapshot failed: %s", exc)
     return snapshot
 
 

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)