livepilot 1.10.5 → 1.10.7

package/mcp_server/tools/motif.py

@@ -11,6 +11,10 @@ from fastmcp import Context
 
 from ..server import mcp
 from . import _motif_engine as motif_engine
+import logging
+
+logger = logging.getLogger(__name__)
+
 
 
 def _get_ableton(ctx: Context):
@@ -18,7 +22,12 @@ def _get_ableton(ctx: Context):
 
 
 @mcp.tool()
-def get_motif_graph(ctx: Context) -> dict:
+def get_motif_graph(
+    ctx: Context,
+    limit: int = 50,
+    offset: int = 0,
+    summary_only: bool = False,
+) -> dict:
     """Detect recurring melodic and rhythmic patterns across all tracks.
 
     Scans note data from all session clips to find repeated interval
@@ -27,7 +36,27 @@ def get_motif_graph(ctx: Context) -> dict:
 
     Use this to understand what musical ideas are present and which
     ones need development or variation.
+
+    BUG-B7 fix: sessions with many clips produced 90 KB+ payloads that
+    exceeded inline-tool-response limits. Callers now page the list and
+    can opt into a compact summary view that drops per-motif occurrence
+    arrays and suggested_developments.
+
+    Args:
+        limit: maximum motifs returned per call (default 50, max 500).
+        offset: skip this many of the highest-salience motifs (for paging).
+        summary_only: return only motif_id + kind + salience + fatigue_risk
+                      + occurrence_count per motif, dropping occurrences
+                      and other lists. Use when you need a bird's-eye view.
     """
+    # Cheap input validation — these bounds match the tool contract the
+    # rest of the server relies on for inline responses.
+    if limit < 0:
+        raise ValueError("limit must be >= 0")
+    if offset < 0:
+        raise ValueError("offset must be >= 0")
+    limit = min(limit, 500)
+
     ableton = _get_ableton(ctx)
     session = ableton.send_command("get_session_info")
     tracks = session.get("tracks", [])
@@ -46,16 +75,38 @@ def get_motif_graph(ctx: Context) -> dict:
                     "clip_index": clip_idx,
                 })
                 track_notes.extend(result.get("notes", []))
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.debug("get_motif_graph failed: %s", exc)
+
         if track_notes:
             notes_by_track[t_idx] = track_notes
 
     motifs = motif_engine.detect_motifs(notes_by_track)
+    total = len(motifs)
+    page = motifs[offset:offset + limit] if limit > 0 else []
+
+    if summary_only:
+        # Compact per-motif record: keep identity + scoring signals, drop
+        # occurrences / developments / pitch/rhythm payloads that balloon
+        # the response on complex sessions.
+        motif_dicts = [{
+            "motif_id": m.motif_id,
+            "kind": m.kind,
+            "salience": m.salience,
+            "fatigue_risk": m.fatigue_risk,
+            "occurrence_count": len(m.occurrences),
+        } for m in page]
+    else:
+        motif_dicts = [m.to_dict() for m in page]
 
     return {
-        "motifs": [m.to_dict() for m in motifs],
-        "motif_count": len(motifs),
+        "motifs": motif_dicts,
+        "motif_count": len(motif_dicts),
+        "total_motifs": total,
+        "offset": offset,
+        "limit": limit,
+        "summary_only": summary_only,
+        "has_more": offset + len(motif_dicts) < total,
         "tracks_analyzed": len(notes_by_track),
     }
 

package/mcp_server/tools/planner.py

@@ -17,6 +17,9 @@ from fastmcp import Context
 from ..server import mcp
 from . import _composition_engine as comp_engine
 from . import _planner_engine as planner_engine
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 def _get_ableton(ctx: Context):
@@ -67,7 +70,8 @@ def plan_arrangement(
         try:
             ti = ableton.send_command("get_track_info", {"track_index": t_idx})
             track_data.append(ti)
-        except Exception:
+        except Exception as exc:
+            logger.debug("plan_arrangement failed: %s", exc)
             track_data.append({"index": t_idx, "name": track.get("name", ""), "devices": []})
 
     for section in sections:
@@ -96,7 +100,6 @@ def plan_arrangement(
     result["available_styles"] = sorted(planner_engine.VALID_STYLES)
     return result
 
-
 # ── transform_section (Round 4) ─────────────────────────────────────
 
 
@@ -130,6 +133,7 @@ def transform_section(
     track_count = session.get("track_count", 0)
 
     from .composition import _build_clip_matrix
+
     clip_matrix = _build_clip_matrix(ableton, len(scenes), track_count)
     sections = comp_engine.build_section_graph_from_scenes(scenes, clip_matrix, track_count)
 

package/mcp_server/tools/research.py

@@ -17,6 +17,9 @@ from fastmcp import Context
 from ..server import mcp
 from ..memory.technique_store import TechniqueStore
 from . import _research_engine as research_engine
+import logging
+
+logger = logging.getLogger(__name__)
 
 _memory_store = TechniqueStore()
 
@@ -66,8 +69,8 @@ def research_technique(
                 if ref and not ref.get("error") and ref.get("count", 0) > 0:
                     device_atlas_results.append(ref)
                     break  # Found in this category, skip others
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.debug("research_technique failed: %s", exc)
 
     # 3. Search memory for related techniques (direct TechniqueStore)
     memory_results = []
@@ -75,16 +78,16 @@ def research_technique(
         memory_results.extend(
             _memory_store.list_techniques(type_filter="technique_card", sort_by="updated_at", limit=10)
         )
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("research_technique failed: %s", exc)
 
     try:
         # "research" is not a valid type in TechniqueStore — search broadly
         memory_results.extend(
             _memory_store.search(query=query, limit=5)
         )
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("research_technique failed: %s", exc)
 
     if scope == "targeted":
         result = research_engine.targeted_research(
@@ -118,6 +121,30 @@ def get_emotional_arc(ctx: Context) -> dict:
     no resolution at the end, peak too early.
 
     Returns: tension curve and issues with recommended composition moves.
+
+    📌 On the `tension_curve` vs other energy metrics (BUG-B21 clarification):
+      LivePilot exposes THREE intentionally different "energy-like"
+      signals — they are NOT scaled versions of each other:
+
+        1. `get_section_graph.energy` / `get_performance_state.energy_level`
+           → density-based (active-track ratio per section). After the
+           Batch 6 cross-engine unification these two are identical.
+           Use when asking "how busy is this section?"
+
+        2. `get_emotional_arc.tension` (this tool)
+           → narrative-arc signal weighted by harmonic instability,
+           section placement, and payoff/contrast. Use when asking
+           "where does the song want to go emotionally?" — tension
+           can be HIGH in a sparse-but-anticipatory section (low
+           density) and LOW in a busy-but-resolved section (high
+           density).
+
+        3. `get_performance_state.energy_window.target_energy`
+           → forward-looking — next-scene target, not current state.
+
+      If the three readings disagree for the same section, that's the
+      DESIGN: density ≠ tension ≠ intended destination. Pick the one
+      that matches your question.
     """
     from . import _composition_engine as engine
 
@@ -159,7 +186,8 @@ def get_emotional_arc(ctx: Context) -> dict:
                     hf.mode = detected.get("mode", "")
                     hf.confidence = detected.get("confidence", 0.0)
                     break
-            except Exception:
+            except Exception as exc:
+                logger.debug("get_emotional_arc failed: %s", exc)
                 continue
         harmony_fields.append(hf)
 
@@ -186,7 +214,6 @@ def get_emotional_arc(ctx: Context) -> dict:
         "section_count": len(sections),
     }
 
-
 # ── get_style_tactics (Round 4) ─────────────────────────────────────
 
 
@@ -213,8 +240,8 @@ def get_style_tactics(
         memory_tactics = _memory_store.search(
             query=artist_or_genre, limit=10,
         )
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("get_style_tactics failed: %s", exc)
 
     tactics = research_engine.get_style_tactics(artist_or_genre, memory_tactics)
 

package/mcp_server/tools/theory.py

@@ -245,7 +245,15 @@ def suggest_next_chord(
                 candidates = style_map[k]
                 break
     if not candidates:
-        candidates = style_map.get("I", ["IV", "V"])
+        # BUG-B23: the old fallback hard-coded ["IV", "V"] — uppercase
+        # literals that lie about chord quality in a minor key (where
+        # both iv and v are minor triads). Pick the tonic key ("i" in
+        # minor, "I" in major) and let the style_map's own conventions
+        # populate a minor-appropriate default when available.
+        tonic_key = "i" if is_minor else "I"
+        candidates = style_map.get(tonic_key)
+        if not candidates:
+            candidates = ["iv", "v"] if is_minor else ["IV", "V"]
 
     # Build concrete suggestions with MIDI pitches
     suggestions = []
@@ -450,11 +458,24 @@ def harmonize_melody(
 ) -> dict:
     """Generate a multi-voice harmonization of a melody from a MIDI clip.
 
-    Finds diatonic chords containing each melody note and voices them
-    following basic voice leading rules (smooth bass motion, no crossing).
+    Hymn-style SATB convention: the original melody IS the soprano voice.
+    The algorithm finds diatonic chords containing each melody note and
+    voices them below the melody (bass + tenor + alto for 4-voice mode;
+    just bass for 2-voice mode).
 
     voices: 2 (melody + bass) or 4 (SATB). Default 4.
-    Returns note data ready for add_notes on new tracks.
+
+    Response keys:
+      - melody: the input melody as passed in (identical pitches to soprano)
+      - soprano: same as melody (hymn-style convention)
+      - alto / tenor: inner voices (4-voice only)
+      - bass: root-aware bass line — BUG-B26 fix prevents tonic pedal
+      - chord_sequence: the chord chosen per melody note (degree + name)
+
+    BUG-B27: `soprano` and `melody` are intentionally identical — the
+    tool's job is to add harmony UNDER an existing melody, not replace
+    it. Both fields are returned so callers can pipe whichever makes
+    their downstream code cleaner.
 
     Processing time: 2-5s.
     """
@@ -477,6 +498,39 @@ def harmonize_melody(
         result_voices["tenor"] = []
 
     prev_bass_midi = None
+    prev_degree: Optional[int] = None
+
+    # BUG-B26 fix: the old chord-selection walked scale degrees in a fixed
+    # preference order [I, IV, V, vi, ii, iii, vii] and picked the FIRST
+    # one containing the melody note — in practice this meant I (tonic)
+    # won whenever the melody hit a chord tone of I, so the bass pedaled
+    # on the tonic. We now build ALL candidate diatonic chords that
+    # contain the note, then score them to prefer harmonic motion:
+    #   - strong penalty for picking the same chord twice in a row
+    #     (breaks the pedal pattern)
+    #   - mild preference for functional moves (I→IV, IV→V, V→I etc)
+    #   - fallback to the original [I, IV, V, …] order on ties
+    _DEGREE_ORDER = [0, 3, 4, 5, 1, 2, 6]  # I, IV, V, vi, ii, iii, vii
+
+    def _score_chord(degree: int, prev: Optional[int]) -> float:
+        score = 10.0 - _DEGREE_ORDER.index(degree) * 0.5
+        if prev is None:
+            return score
+        if degree == prev:
+            # Avoid repeating the same chord — the big lever for B26
+            score -= 20.0
+        # Functional pair bonuses (classical/pop voice-leading)
+        functional_pairs = {
+            (0, 3), (0, 4), (0, 5),  # I → IV, V, vi
+            (3, 4), (3, 0), (3, 1),  # IV → V, I, ii
+            (4, 0), (4, 5),          # V → I, vi
+            (5, 1), (5, 3),          # vi → ii, IV
+            (1, 4), (1, 6),          # ii → V, vii°
+            (6, 0), (6, 2),          # vii° → I, iii
+        }
+        if (prev, degree) in functional_pairs:
+            score += 5.0
+        return score
 
     for n in melody:
         melody_pitch = n["pitch"]
@@ -484,16 +538,23 @@ def harmonize_melody(
         dur = n["duration"]
         mel_pc = melody_pitch % 12
 
-        # Find the best diatonic chord containing this pitch
-        best_chord = None
-        for degree in [0, 3, 4, 5, 1, 2, 6]:  # I, IV, V, vi, ii, iii, vii
+        # Collect every diatonic chord that contains this melody note
+        candidates: list[tuple[int, dict]] = []
+        for degree in _DEGREE_ORDER:
             chord = engine.build_chord(degree, tonic, mode)
             if mel_pc in chord["pitch_classes"]:
-                best_chord = chord
-                break
+                candidates.append((degree, chord))
 
-        if best_chord is None:
-            best_chord = engine.build_chord(0, tonic, mode)
+        if not candidates:
+            candidates = [(0, engine.build_chord(0, tonic, mode))]
+
+        # Pick the highest-scoring candidate — break ties by preference order
+        candidates.sort(
+            key=lambda pair: (-_score_chord(pair[0], prev_degree),
+                              _DEGREE_ORDER.index(pair[0]))
+        )
+        best_degree, best_chord = candidates[0]
+        prev_degree = best_degree
 
         # Build MIDI pitches for the chord
         chord_midis = sorted([
@@ -553,10 +614,13 @@ def harmonize_melody(
                 "duration": dur, "velocity": int(vel * 0.7),
             })
 
+    # BUG-B27: expose the input melody under `melody` (alias of soprano)
+    # so downstream code doesn't have to guess which field carries it.
     result = {
         "key": _key_display(key_info),
         "voices": voices,
         "melody_notes": len(melody),
+        "melody": list(result_voices["soprano"]),
     }
     for voice_name, voice_notes in result_voices.items():
         if voice_notes:
@@ -608,9 +672,15 @@ def generate_countermelody(
 
     # Consonant intervals (semitones mod 12): P1, m3, M3, P4, P5, m6, M6, P8
     consonant = {0, 3, 4, 5, 7, 8, 9}
+    # BUG-B28: "imperfect" consonances (thirds + sixths) are more
+    # colorful than perfect ones (unison, 4th, 5th, octave). Prefer them
+    # so the countermelody doesn't collapse onto a static pedal of 1/4/5/8s.
+    imperfect_consonant = {3, 4, 8, 9}  # m3, M3, m6, M6
 
     counter_notes = []
     prev_cp = None
+    # Track recently-used pitches to reward range exploration (B28)
+    recent_pitches: list[int] = []
 
     for i, n in enumerate(melody):
         mel_pitch = n["pitch"]
@@ -626,29 +696,47 @@ def generate_countermelody(
 
                 score = 0.0
 
-                # Contrary motion bonus
+                # Prefer imperfect consonances (thirds + sixths) — more
+                # colorful than unison/4th/5th/octave. Without this the
+                # counter collapses onto perfect intervals (B28).
+                if iv in imperfect_consonant:
+                    score += 4.0
+
+                # Contrary motion bonus (amplified for B28)
                 if prev_cp is not None and i > 0:
                     mel_dir = mel_pitch - melody[i - 1]["pitch"]
                     cp_dir = cp - prev_cp
                     if (mel_dir > 0 and cp_dir < 0) or (mel_dir < 0 and cp_dir > 0):
-                        score += 10
+                        score += 15  # was 10 — make contrary motion dominant
                     # Penalize parallel perfect intervals
                     prev_iv = abs(prev_cp - melody[i - 1]["pitch"]) % 12
                     if prev_iv == iv and iv in (0, 7):
                         score -= 50
 
-                # Stepwise motion bonus
+                # Stepwise motion bonus — but don't let it pin us to one pitch
                 if prev_cp is not None:
                     step = abs(cp - prev_cp)
-                    if step <= 2:
+                    if step == 0:
+                        # Penalize exact repetition (was implicit-neutral)
+                        score -= 6
+                    elif step <= 2:
                         score += 5
                     elif step <= 4:
-                        score += 2
+                        score += 3
                     elif step > 7:
                         score -= 3
                 else:
                     score += 3
 
+                # BUG-B28: range-exploration bonus. Penalize pitches used
+                # in the last 4 notes; this forces the counter to walk
+                # through the pool instead of hovering on 2-3 pitches.
+                if cp in recent_pitches:
+                    score -= 4
+                # Modest bonus for pitches we haven't visited recently
+                if cp not in set(recent_pitches):
+                    score += 1
+
                 score += random.uniform(0, 2)
                 scored.append((cp, score))
 
@@ -657,6 +745,10 @@ def generate_countermelody(
 
             scored.sort(key=lambda x: -x[1])
             chosen = scored[0][0]
+            # Maintain a sliding window of the last 4 counter pitches
+            recent_pitches.append(chosen)
+            if len(recent_pitches) > 4:
+                recent_pitches.pop(0)
 
             counter_notes.append({
                 "pitch": chosen,

package/mcp_server/transition_engine/critics.py

@@ -270,17 +270,24 @@ def run_gesture_fit_critic(
     boundary = plan.boundary
     archetype = plan.archetype
 
-    # Check if the section pair matches any of the archetype's use cases
-    pair_tags = {
-        f"{boundary.from_type}_to_{boundary.to_type}",
-        boundary.from_type,
-        boundary.to_type,
-    }
-    use_case_match = any(
-        tag in uc or uc in tag
-        for tag in pair_tags
-        for uc in archetype.use_cases
-    )
+    # Check if the section pair matches any of the archetype's use cases.
+    # BUG-B15: "any_section_change" is a wildcard that matches any transition —
+    # honor it explicitly so archetypes documented as universal don't get
+    # flagged as mismatched on specific pairs like intro→build.
+    WILDCARDS = {"any_section_change", "any"}
+    if any(uc in WILDCARDS for uc in archetype.use_cases):
+        use_case_match = True
+    else:
+        pair_tags = {
+            f"{boundary.from_type}_to_{boundary.to_type}",
+            boundary.from_type,
+            boundary.to_type,
+        }
+        use_case_match = any(
+            tag in uc or uc in tag
+            for tag in pair_tags
+            for uc in archetype.use_cases
+        )
 
     if not use_case_match:
         issues.append(TransitionIssue(

package/mcp_server/transition_engine/tools.py

@@ -14,6 +14,10 @@ from ..tools import _composition_engine as comp_engine
 from .archetypes import TRANSITION_ARCHETYPES, select_archetype
 from .critics import run_all_transition_critics
 from .models import TransitionBoundary, TransitionPlan, TransitionScore
+import logging
+
+logger = logging.getLogger(__name__)
+
 
 
 # ── Helpers ───────────────────────────────────────────────────────────
@@ -29,7 +33,8 @@ def _build_sections_from_ableton(ctx: Context) -> list[comp_engine.SectionNode]:
     try:
         matrix_data = ableton.send_command("get_scene_matrix")
         clip_matrix = matrix_data.get("matrix", [])
-    except Exception:
+    except Exception as exc:
+        logger.debug("_build_sections_from_ableton failed: %s", exc)
         clip_matrix = [[] for _ in range(len(scenes))]
 
     return comp_engine.build_section_graph_from_scenes(

package/mcp_server/translation_engine/tools.py

@@ -33,9 +33,8 @@ def _fetch_translation_data(ctx: Context) -> dict:
             spec_data = spectral.get("spectrum")
             if spec_data and isinstance(spec_data["value"], dict):
                 spectrum_bands = spec_data["value"]
-    except Exception:
-        pass
-
+    except Exception as exc:
+        logger.debug("_fetch_translation_data failed: %s", exc)
     # Estimate stereo width from track pans via session info
     stereo_width = 0.0
     center_strength = 0.5
@@ -61,9 +60,8 @@ def _fetch_translation_data(ctx: Context) -> dict:
 
             # Simple foreground detection: at least one unmuted, non-quiet track
             has_foreground = any(not t.get("muted", False) for t in tracks)
-    except Exception:
-        pass
-
+    except Exception as exc:
+        logger.debug("_get_pan failed: %s", exc)
     return {
         "stereo_width": stereo_width,
         "center_strength": center_strength,
@@ -99,6 +97,10 @@ def get_translation_issues(ctx: Context) -> dict:
 
     Lighter than check_translation — returns only detected issues
     from the 5 playback robustness critics.
+import logging
+
+logger = logging.getLogger(__name__)
+
     """
     mix_snapshot = _fetch_translation_data(ctx)
     issues = run_all_translation_critics(mix_snapshot)

package/mcp_server/wonder_mode/engine.py

@@ -9,9 +9,12 @@ from __future__ import annotations
 
 import hashlib
 import json
+import logging
 import math
 from typing import Optional
 
+logger = logging.getLogger(__name__)
+
 
 # ── Move discovery ───────────────────────────────────────────────
 
@@ -104,8 +107,9 @@ def discover_moves(
                 if validation["valid"]:
                     filtered.append(move)
             result = filtered
-        except Exception:
-            pass  # constraint filtering is optional
+        except Exception as exc:
+            # constraint filtering is optional — keep the unfiltered list
+            logger.warning("constraint filtering skipped: %s", exc)
 
     return result
 
@@ -212,7 +216,8 @@ def _compile_variant_plan(move_dict: dict, kernel: dict | None) -> dict | None:
     try:
         plan = sem_compile(move_obj, kernel)
         return plan.to_dict()
-    except Exception:
+    except Exception as exc:
+        logger.warning("sem_compile(%s) failed: %s", move_obj, exc)
         return None