livepilot 1.10.8 → 1.12.2

package/mcp_server/project_brain/models.py

@@ -205,16 +205,35 @@ class RoleGraph:
 
 @dataclass
 class AutomationGraph:
-    """Automation presence and gesture density."""
+    """Automation presence and gesture density.
+
+    ``coverage_pct`` is the fraction of scanned clips that have at least
+    one automation envelope (0.0–1.0). Introduced in v1.10.9 to close
+    BUG-D2's "is this session missing automation?" signal — downstream
+    engines (Wonder Mode, Sound Design, etc.) can branch on a low
+    coverage value to recommend filter sweeps, volume crescendos, and
+    dub-style handoffs that the producer hasn't written yet.
+
+    ``clip_envelope_count`` is the raw total of per-clip envelopes
+    discovered; distinguishes "no automation in the project at all"
+    (count=0) from "automation exists but is lightly used" (count>0 but
+    coverage_pct<0.2).
+    """
 
     automated_params: list[dict] = field(default_factory=list)
     density_by_section: dict[str, float] = field(default_factory=dict)
+    coverage_pct: float = 0.0
+    clip_envelope_count: int = 0
+    clips_scanned: int = 0
     freshness: FreshnessInfo = field(default_factory=FreshnessInfo)
 
     def to_dict(self) -> dict:
         return {
             "automated_params": list(self.automated_params),
             "density_by_section": dict(self.density_by_section),
+            "coverage_pct": round(self.coverage_pct, 3),
+            "clip_envelope_count": self.clip_envelope_count,
+            "clips_scanned": self.clips_scanned,
             "freshness": self.freshness.to_dict(),
         }
 

package/mcp_server/project_brain/tools.py

@@ -131,11 +131,15 @@ def build_project_brain(ctx: Context) -> dict:
     # 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.
+    #
+    # clips_scanned is the denominator for coverage_pct (BUG-D2) — it
+    # counts how many (track, scene) slots we probed, regardless of
+    # whether an envelope came back. Without this, a session with zero
+    # automation would be indistinguishable from a session where we
+    # failed to probe, which is exactly the ambiguity BUG-D2 flagged.
     clip_automation: list[dict] = []
+    clips_scanned = 0
     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:
@@ -143,6 +147,7 @@ def build_project_brain(ctx: Context) -> dict:
             section_id = f"sec_{scene_idx:02d}"
             for track in tracks:
                 t_idx = track.get("index", 0)
+                clips_scanned += 1
                 try:
                     auto_resp = ableton.send_command("get_clip_automation", {
                         "track_index": t_idx,
@@ -196,6 +201,7 @@ def build_project_brain(ctx: Context) -> dict:
         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,
+        clips_scanned=clips_scanned,
         analyzer_ok=analyzer_ok,
         flucoma_ok=flucoma_ok,
         session_ok=True,
@@ -230,6 +236,7 @@ def get_project_brain_summary(ctx: Context) -> dict:
         "section_count": len(state.arrangement_graph.sections),
         "role_count": len(state.role_graph.roles),
         "automated_param_count": len(state.automation_graph.automated_params),
+        "automation_coverage_pct": round(state.automation_graph.coverage_pct, 3),
         "tempo": state.session_graph.tempo,
         "time_signature": state.session_graph.time_signature,
         "is_stale": state.is_stale(),

package/mcp_server/runtime/execution_router.py

@@ -47,6 +47,13 @@ MCP_TOOLS: frozenset[str] = frozenset({
     "generate_m4l_effect",
     "install_m4l_device",
     "list_genexpr_templates",
+    # MIDI Tool bridge (v1.12.0+) — these run entirely in the MCP server:
+    # config dispatch via OSC to m4l_bridge, cache state reads, filesystem
+    # copy. No TCP remote command, no bridge TCP round-trip.
+    "install_miditool_device",
+    "set_miditool_target",
+    "get_miditool_context",
+    "list_miditool_generators",
 })
 
 

package/mcp_server/runtime/mcp_dispatch.py

@@ -95,6 +95,33 @@ async def _list_genexpr_templates(params: dict, ctx: Any = None) -> dict:
     return await _call(list_genexpr_templates, ctx, params)
 
 
+# ── MIDI Tool bridge (v1.12.0+) ───────────────────────────────────────────
+#
+# These four run entirely in-process: install_miditool_device copies .amxd
+# files, set_miditool_target writes to MidiToolCache + OSC-sends config,
+# get_miditool_context reads the cache, list_miditool_generators reads the
+# GENERATOR_METADATA dict. None of them need TCP or bridge round-trips.
+
+async def _install_miditool_device(params: dict, ctx: Any = None) -> dict:
+    from ..tools.miditool import install_miditool_device
+    return await _call(install_miditool_device, ctx, params)
+
+
+async def _set_miditool_target(params: dict, ctx: Any = None) -> dict:
+    from ..tools.miditool import set_miditool_target
+    return await _call(set_miditool_target, ctx, params)
+
+
+async def _get_miditool_context(params: dict, ctx: Any = None) -> dict:
+    from ..tools.miditool import get_miditool_context
+    return await _call(get_miditool_context, ctx, params)
+
+
+async def _list_miditool_generators(params: dict, ctx: Any = None) -> dict:
+    from ..tools.miditool import list_miditool_generators
+    return await _call(list_miditool_generators, ctx, params)
+
+
 def build_mcp_dispatch_registry() -> dict[str, Callable]:
     """Return the canonical registry of MCP-only tools for plan execution.
 
@@ -115,4 +142,9 @@ def build_mcp_dispatch_registry() -> dict[str, Callable]:
         "generate_m4l_effect": _generate_m4l_effect,
         "install_m4l_device": _install_m4l_device,
         "list_genexpr_templates": _list_genexpr_templates,
+        # v1.12.0 MIDI Tool bridge
+        "install_miditool_device": _install_miditool_device,
+        "set_miditool_target": _set_miditool_target,
+        "get_miditool_context": _get_miditool_context,
+        "list_miditool_generators": _list_miditool_generators,
     }

package/mcp_server/runtime/remote_commands.py

@@ -48,6 +48,21 @@ REMOTE_COMMANDS: frozenset[str] = frozenset({
     "insert_device",           # 12.3+ native device insertion
     "insert_rack_chain",       # 12.3+ rack chain insertion
     "set_drum_chain_note",     # 12.3+ drum chain note assignment
+    # rack variations + macro CRUD (Live 11+)
+    "get_rack_variations", "store_rack_variation",
+    "recall_rack_variation", "delete_rack_variation",
+    "randomize_rack_macros", "add_rack_macro",
+    "remove_rack_macro", "set_rack_visible_macros",
+    # simpler slice CRUD (Live 11+)
+    "insert_simpler_slice", "move_simpler_slice",
+    "remove_simpler_slice", "clear_simpler_slices",
+    "reset_simpler_slices", "import_slices_from_onsets",
+    # wavetable modulation matrix (Live 11+)
+    "get_wavetable_mod_targets", "add_wavetable_mod_route",
+    "set_wavetable_mod_amount", "get_wavetable_mod_amount",
+    "get_wavetable_mod_matrix",
+    # device A/B compare (Live 12.3+)
+    "get_device_ab_state", "toggle_device_ab", "copy_device_state",
     # clip_automation (3)
     "get_clip_automation", "set_clip_automation", "clear_clip_automation",
     # browser (6)
@@ -65,8 +80,39 @@ REMOTE_COMMANDS: frozenset[str] = frozenset({
     "capture_midi", "start_recording", "stop_recording",
     "get_cue_points", "jump_to_cue", "toggle_cue_point",
     "back_to_arranger", "force_arrangement",
+    # scales — Song + per-clip scale awareness (Live 12.0+)
+    "get_song_scale", "set_song_scale", "set_song_scale_mode",
+    "list_available_scales",
+    "get_clip_scale", "set_clip_scale", "set_clip_scale_mode",
+    # tuning system (Live 12.1+)
+    "get_tuning_system", "set_tuning_reference_pitch",
+    "set_tuning_note", "reset_tuning_system",
+    # follow actions — clip (Live 12.0 revamp) + scene (Live 12.2+)
+    "get_clip_follow_action", "set_clip_follow_action",
+    "clear_clip_follow_action", "list_follow_action_types",
+    "apply_follow_action_preset",
+    "get_scene_follow_action", "set_scene_follow_action",
+    "clear_scene_follow_action",
+    # groove pool (Live 11+)
+    "list_grooves", "get_groove_info", "set_groove_params",
+    "assign_clip_groove", "get_clip_groove",
+    "get_song_groove_amount", "set_song_groove_amount",
+    # take lanes (Live 12.0 UI / 12.2 API)
+    "get_take_lanes", "create_take_lane", "set_take_lane_name",
+    "create_audio_clip_on_take_lane", "create_midi_clip_on_take_lane",
+    "get_take_lane_clips",
     # diagnostics (1)
     "get_session_diagnostics",
+    # control surfaces (diagnostic)
+    "list_control_surfaces", "get_control_surface_info",
+    # song primitives — transport/link
+    "tap_tempo", "nudge_tempo",
+    "set_exclusive_arm", "set_exclusive_solo",
+    "capture_and_insert_scene", "set_count_in_duration",
+    "get_link_state", "set_link_enabled", "force_link_beat_time",
+    # track primitives
+    "jump_in_session_clip", "get_track_performance_impact",
+    "get_appointed_device",
     # ping (built-in)
     "ping",
 })
@@ -92,6 +138,14 @@ BRIDGE_COMMANDS: frozenset[str] = frozenset({
     # async Python MCP tool in mcp_server/tools/analyzer.py, not a bridge
     # command. It has no case in livepilot_bridge.js and no @register handler
     # in remote_script. See mcp_server/runtime/execution_router.MCP_TOOLS.
+    # NOTE: MIDI Tool bridge commands (Live 12.0+ MIDI Generators /
+    # Transformations, requires LivePilot_MIDITool.amxd) do NOT belong in
+    # this set. They ride OSC prefixes /miditool/request, /miditool/ready
+    # (bridge→server) and miditool/config, miditool/response (server→bridge),
+    # dispatched through m4l_device/miditool_bridge.js (a separate JS, not
+    # livepilot_bridge.js) and pushed directly via M4LBridge.send_miditool_*
+    # helpers rather than through send_command. BRIDGE_COMMANDS is reserved
+    # for send_command targets that dispatch inside livepilot_bridge.js.
 })
 
 # Combined: all valid send_command targets

package/mcp_server/sample_engine/slice_classifier.py

@@ -0,0 +1,169 @@
+"""Spectral classification of Simpler-slice drum break segments.
+
+Lessons from the 2026-04-18 creative session that drove this module:
+
+- Never assume slice 0 is a kick. Slice content depends on transient
+  detection order in the source audio, not drum-rack convention.
+- Snares ALWAYS have 20-35% mid-frequency energy (drum body resonance).
+  Hi-hats / cymbals have <25% mid (they're thin metal discs with no
+  resonant body). This mid-content threshold is the critical separator
+  that tripped up the first classification pass.
+- Ghosts are defined by low peak amplitude (<0.35) regardless of spectrum.
+
+Thresholds validated against "Break Ghosts 90 bpm" (Ableton Core Library)
+in the session. See ``feedback_analyze_slices_before_programming`` memory
+entry for the full story and the specific slice map for that sample.
+
+This module is pure Python (numpy only). No LivePilot / Ableton /
+FastMCP dependencies — testable and runnable in isolation.
+"""
+from __future__ import annotations
+
+from typing import List, Literal, Sequence, TypedDict
+
+import numpy as np
+
+
+Label = Literal["KICK", "SNARE", "HAT", "ghost"]
+
+
+class SliceFeatures(TypedDict):
+    """Per-slice classification result plus the features that drove the decision."""
+
+    index: int
+    label: Label
+    peak: float
+    rms: float
+    sub_pct: float
+    low_pct: float
+    mid_pct: float
+    high_pct: float
+
+
+# ---------------------------------------------------------------------------
+# Band boundaries (Hz). Tuned against the 2026-04-18 session's working set.
+# ---------------------------------------------------------------------------
+
+_SUB_MAX = 100.0    # sub-bass (kick fundamentals live here)
+_LOW_MAX = 300.0    # body / low-mid (kick "thud" + bass fundamentals)
+_MID_MAX = 3000.0   # presence / drum body / vocals
+# Everything above _MID_MAX is "high" (sizzle / air / cymbal).
+
+
+# ---------------------------------------------------------------------------
+# Classification thresholds. DO NOT loosen these without re-validating on a
+# real break — the 2026-04-18 session proved that relaxing the HAT mid-cap
+# to 32% misclassifies loud snares as hats.
+# ---------------------------------------------------------------------------
+
+_GHOST_PEAK = 0.35        # Below this peak → ghost regardless of spectrum
+_KICK_SUB_LOW_MIN = 0.45  # sub + low must be this dominant
+_KICK_HIGH_MAX = 0.40     # kicks never have >40% high
+_SNARE_MID_MIN = 0.25     # snares HAVE a drum body (mid content)
+_SNARE_HIGH_MIN = 0.40    # + sizzle
+_SNARE_PEAK_MIN = 0.60    # + loud enough to not be a ghost
+_HAT_HIGH_MIN = 0.70      # hats are thin metal — overwhelmingly high
+_HAT_MID_MAX = 0.25       # hats have almost no drum body
+
+
+def _band_energy(segment: np.ndarray, sr: int) -> tuple[float, float, float, float]:
+    """Return (sub, low, mid, high) energy fractions that sum to ~1.0.
+
+    Uses an rFFT. If the segment is empty or silent, returns equal quarters
+    so downstream logic doesn't have to handle zero-sum edge cases (the
+    caller still sees silence via the peak/rms fields).
+    """
+    if len(segment) < 2:
+        return 0.25, 0.25, 0.25, 0.25
+    spec = np.abs(np.fft.rfft(segment))
+    total = float(spec.sum())
+    if total <= 0:
+        return 0.25, 0.25, 0.25, 0.25
+    freqs = np.fft.rfftfreq(len(segment), 1.0 / sr)
+    sub = float(spec[freqs < _SUB_MAX].sum() / total)
+    low = float(spec[(freqs >= _SUB_MAX) & (freqs < _LOW_MAX)].sum() / total)
+    mid = float(spec[(freqs >= _LOW_MAX) & (freqs < _MID_MAX)].sum() / total)
+    high = float(spec[freqs >= _MID_MAX].sum() / total)
+    return sub, low, mid, high
+
+
+def classify_segment(segment: np.ndarray, sr: int) -> Label:
+    """Classify a single audio segment as KICK / SNARE / HAT / ghost.
+
+    Returns the label string. See module docstring for the reasoning behind
+    each threshold.
+    """
+    if len(segment) < 2:
+        return "ghost"
+    peak = float(np.max(np.abs(segment)))
+    if peak < _GHOST_PEAK:
+        return "ghost"
+
+    sub, low, mid, high = _band_energy(segment, sr)
+
+    # KICK: sub+low dominance with limited high content.
+    if (sub + low) >= _KICK_SUB_LOW_MIN and high < _KICK_HIGH_MAX:
+        return "KICK"
+
+    # HAT: overwhelmingly high-freq, almost no drum-body mid content.
+    if high >= _HAT_HIGH_MIN and mid <= _HAT_MID_MAX:
+        return "HAT"
+
+    # SNARE: broadband (mid body + high sizzle) AND loud.
+    if (
+        mid >= _SNARE_MID_MIN
+        and high >= _SNARE_HIGH_MIN
+        and peak >= _SNARE_PEAK_MIN
+    ):
+        return "SNARE"
+
+    # Fallback for ambiguous mid/high dominant loud hits — usually
+    # snares with unusual spectrum (e.g., rim-shots, piccolo snare).
+    if peak >= _SNARE_PEAK_MIN and (mid + high) >= 0.70:
+        return "SNARE"
+
+    # If nothing else matched but there's real energy, call it a hat
+    # rather than a ghost (ghost is reserved for quiet hits).
+    return "HAT"
+
+
+def classify_slices(
+    audio: np.ndarray,
+    sr: int,
+    frame_boundaries: Sequence[int],
+) -> List[SliceFeatures]:
+    """Classify every slice defined by ``frame_boundaries``.
+
+    ``frame_boundaries`` is a list of N+1 frame positions defining N slices.
+    For a sample with slices starting at frames [0, 1000, 3000, 5000] and
+    total length 10000 frames, pass [0, 1000, 3000, 5000, 10000].
+
+    Stereo input is auto-downmixed (mean of the two channels).
+
+    Returns a list of ``SliceFeatures`` in slice-index order.
+    """
+    if audio.ndim > 1:
+        audio = audio.mean(axis=1)
+
+    results: List[SliceFeatures] = []
+    for i in range(len(frame_boundaries) - 1):
+        start = int(frame_boundaries[i])
+        end = int(frame_boundaries[i + 1])
+        segment = audio[start:end]
+        label = classify_segment(segment, sr)
+        peak = float(np.max(np.abs(segment))) if len(segment) else 0.0
+        rms = float(np.sqrt(np.mean(segment ** 2))) if len(segment) else 0.0
+        sub, low, mid, high = _band_energy(segment, sr)
+        results.append(
+            SliceFeatures(
+                index=i,
+                label=label,
+                peak=peak,
+                rms=rms,
+                sub_pct=sub,
+                low_pct=low,
+                mid_pct=mid,
+                high_pct=high,
+            )
+        )
+    return results

package/mcp_server/semantic_moves/tools.py

@@ -107,16 +107,137 @@ def preview_semantic_move(
     return result
 
 
+def _build_taste_context(ctx: Context) -> dict:
+    """Pull the active taste graph for ranking, with defensive fallbacks.
+
+    Returns a dict with ``dimension_weights``, ``dimension_avoidances``,
+    ``move_family_scores`` (family → score), and ``evidence_count``.
+    Empty dicts when no taste has been recorded yet — the ranker then
+    collapses to pure keyword matching, which is the correct behavior for
+    a cold-start user with no history.
+    """
+    try:
+        from ..memory.taste_graph import build_taste_graph
+        from ..memory.taste_memory import TasteMemoryStore
+        from ..memory.anti_memory import AntiMemoryStore
+
+        taste_store = ctx.lifespan_context.setdefault("taste_memory", TasteMemoryStore())
+        anti_store = ctx.lifespan_context.setdefault("anti_memory", AntiMemoryStore())
+        graph = build_taste_graph(taste_store=taste_store, anti_store=anti_store)
+
+        move_family_scores: dict[str, float] = {}
+        for family, entry in getattr(graph, "move_family_scores", {}).items():
+            score = getattr(entry, "score", None)
+            if isinstance(score, (int, float)):
+                move_family_scores[family] = float(score)
+
+        return {
+            "dimension_weights": dict(getattr(graph, "dimension_weights", {}) or {}),
+            "dimension_avoidances": dict(getattr(graph, "dimension_avoidances", {}) or {}),
+            "move_family_scores": move_family_scores,
+            "evidence_count": int(getattr(graph, "evidence_count", 0) or 0),
+        }
+    except Exception as exc:
+        logger.debug("_build_taste_context failed: %s", exc)
+        return {
+            "dimension_weights": {},
+            "dimension_avoidances": {},
+            "move_family_scores": {},
+            "evidence_count": 0,
+        }
+
+
+def _score_move_for_request(move, request_lower: str, request_words: set, taste: dict) -> tuple[float, dict]:
+    """Compute the composite score for a single move.
+
+    Composition:
+        0.55 × keyword overlap (intent + move_id + targets)
+        0.30 × taste alignment (from taste_graph.dimension_weights on move.targets)
+        0.15 × (1 - anti avoidance penalty) (from dimension_avoidances)
+
+        ± up to 0.10 family bonus/penalty from move_family_scores[family].
+
+    When the user has no recorded taste (evidence_count == 0), the taste
+    and anti-penalty components collapse to neutral 0.5 so cold-start
+    behavior stays identical to the old keyword-only ranker.
+    """
+    # ── Keyword overlap component (0..1) ──────────────────────────────
+    intent_lower = move.intent.lower()
+    move_words = set(move.move_id.replace("_", " ").split())
+    intent_words = set(intent_lower.split())
+
+    overlap = request_words & (move_words | intent_words)
+    keyword_score = min(1.0, len(overlap) * 0.3)
+
+    for dim in move.targets:
+        if dim.lower() in request_lower:
+            keyword_score = min(1.0, keyword_score + 0.2)
+
+    if move.move_id.replace("_", " ") in request_lower:
+        keyword_score = 1.0
+
+    # ── Taste alignment component (0..1) ──────────────────────────────
+    evidence_count = taste["evidence_count"]
+    dim_weights = taste["dimension_weights"]
+    dim_avoid = taste["dimension_avoidances"]
+
+    if evidence_count > 0 and move.targets:
+        # Average dimension_weights for this move's targets; weights are
+        # -1..1 with 0 meaning unknown. Remap to 0..1 so "neutral" is 0.5.
+        raw_taste = [
+            dim_weights.get(dim, 0.0) for dim in move.targets
+        ]
+        taste_alignment = sum((w + 1.0) / 2.0 for w in raw_taste) / len(raw_taste)
+        avoidance = sum(
+            dim_avoid.get(dim, 0.0) for dim in move.targets
+        ) / len(move.targets)
+        avoidance = max(0.0, min(1.0, avoidance))
+    else:
+        taste_alignment = 0.5
+        avoidance = 0.0
+
+    composite = (
+        0.55 * keyword_score
+        + 0.30 * taste_alignment
+        + 0.15 * (1.0 - avoidance)
+    )
+
+    # ── Family bonus/penalty (±0.1) ────────────────────────────────────
+    family_bonus = 0.0
+    family_score = taste["move_family_scores"].get(move.family)
+    if family_score is not None:
+        # family score is 0..1 with 0.5 neutral; remap to -0.1..+0.1
+        family_bonus = (family_score - 0.5) * 0.2
+        composite += family_bonus
+
+    composite = max(0.0, min(1.0, composite))
+
+    breakdown = {
+        "keyword_score": round(keyword_score, 3),
+        "taste_alignment": round(taste_alignment, 3),
+        "avoidance_penalty": round(avoidance, 3),
+        "family_bonus": round(family_bonus, 3),
+        "evidence_count": evidence_count,
+    }
+    return composite, breakdown
+
+
 @mcp.tool()
 def propose_next_best_move(
     ctx: Context,
     request_text: str,
     limit: int = 3,
 ) -> dict:
-    """Propose the best semantic moves for a natural language request.
+    """Propose the best semantic moves for a natural language request, ranked
+    by keyword fit AND the active taste graph.
 
-    Analyzes the request text and ranks available semantic moves by
-    relevance. Returns up to `limit` suggestions with confidence scores.
+    Shipped in v1.10.9: ranking is no longer pure keyword overlap — it now
+    blends keyword match with taste alignment (``dimension_weights`` on each
+    move's targets), an anti-preference penalty (``dimension_avoidances``),
+    and a small family bonus from ``move_family_scores``. Cold-start users
+    with zero recorded evidence get the same ranking as before; users with
+    history see recommendations pulled toward dimensions they've kept and
+    away from ones they've undone.
 
     request_text: what the user wants (e.g., "make this punchier",
                   "tighten the low end", "reduce repetition")
@@ -125,50 +246,37 @@ def propose_next_best_move(
     if not request_text.strip():
         return {"error": "request_text cannot be empty"}
 
-    # Simple keyword matching for now — will be replaced by conductor
-    # routing + taste ranking in V2 Step 7
     request_lower = request_text.lower()
+    request_words = set(request_lower.split())
+    taste = _build_taste_context(ctx)
     all_moves = list(registry._REGISTRY.values())
 
-    scored = []
+    scored: list[tuple[object, float, dict]] = []
     for move in all_moves:
-        score = 0.0
-        # Match keywords from intent and move_id
-        intent_lower = move.intent.lower()
-        move_words = set(move.move_id.replace("_", " ").split())
-        intent_words = set(intent_lower.split())
-        request_words = set(request_lower.split())
-
-        # Word overlap scoring
-        overlap = request_words & (move_words | intent_words)
-        score += len(overlap) * 0.3
-
-        # Dimension matching
-        for dim in move.targets:
-            if dim in request_lower:
-                score += 0.2
-
-        # Boost exact intent matches
-        if move.move_id.replace("_", " ") in request_lower:
-            score += 1.0
-
-        if score > 0:
-            scored.append((move, min(score, 1.0)))
-
-    # Sort by score descending
+        score, breakdown = _score_move_for_request(
+            move, request_lower, request_words, taste,
+        )
+        # Keep only moves that had any keyword signal or strong taste pull —
+        # a move with zero keyword overlap AND neutral taste would be noise.
+        if breakdown["keyword_score"] > 0 or taste["evidence_count"] >= 5:
+            scored.append((move, score, breakdown))
+
     scored.sort(key=lambda x: -x[1])
     top = scored[:limit]
 
     suggestions = []
-    for move, score in top:
+    for move, score, breakdown in top:
         d = move.to_dict()
         d["match_score"] = round(score, 3)
+        d["score_breakdown"] = breakdown
         suggestions.append(d)
 
     return {
         "request": request_text,
         "suggestions": suggestions,
         "count": len(suggestions),
+        "taste_active": taste["evidence_count"] > 0,
+        "taste_evidence_count": taste["evidence_count"],
     }